> For the complete documentation index, see [llms.txt](https://ksaar.gitbook.io/ksaar-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ksaar.gitbook.io/ksaar-documentation/les-elements/les-formules/fonctions-de-liste.md).
# Fonctions de liste
{% hint style="success" %}
Les fonctions sur les formules sont disponibles dans chacune des sous-pages dédiées :
* [Opérateurs](/ksaar-documentation/les-elements/les-formules/operateurs.md)
* [Fonctions de texte](/ksaar-documentation/les-elements/les-formules/fonctions-de-texte.md)
* [Fonctions mathématiques](/ksaar-documentation/les-elements/les-formules/fonctions-mathematiques.md)
* [Fonctions de date](/ksaar-documentation/les-elements/les-formules/fonctions-de-date.md)
* [Fonctions de formatage](/ksaar-documentation/les-elements/les-formules/fonctions-de-formatage.md)
* [Fonctions de liste](/ksaar-documentation/les-elements/les-formules/fonctions-de-liste.md)
* [Fonctions sur des champs Ksaar](/ksaar-documentation/les-elements/les-formules/fonctions-sur-des-champs-ksaar.md)
* [Fonctions de Logique et autres](/ksaar-documentation/les-elements/les-formules/fonctions-de-logique-et-autres.md)
Des exemples de formules prêtes à l'emploi se trouvent ici : [Bibliothèque de formules classiques](/ksaar-documentation/les-elements/les-formules/bibliotheque-de-formules-classiques.md)
{% endhint %}
COUNTIF
#### Résumé
La fonction `COUNTIF` compte le nombre d'éléments dans une liste qui correspondent à un critère donné.
#### Syntaxe
* `COUNTIF(liste, lambda)`
#### Exemple
* `COUNTIF([1, 2, 3, 4, 5], x => x > 2)` → `3`
* `COUNTIF(["pomme", "banane", "cerise"], LAMBDA(x, x == "banane"))` -> `1`
EVERY
#### Résumé
La fonction `EVERY` vérifie si tous les éléments d'une liste répondent à une condition spécifiée.
#### Syntaxe
* `EVERY(liste, lambda)`
#### Exemple
* `EVERY([1, 2, 3], x => x > 0)` → `true`
* `EVERY(["pomme", "banane", "cerise"], LAMBDA(x, x !== ""))` -> `true`
FILL
#### Résumé
La fonction `FILL` remplace une partie d'une liste, spécifiée par un numéro de début inclut et un numéro de fin non inclut, par une valeur donnée.
#### Syntaxe
* `FILL(liste, valeur, début, fin)`
#### Exemple
* `FILL([0, 0, 0, 0], 10, 2, 4)` → `[0, 10, 10, 0]`
* `FILL(["pomme", "banane", "cerise"], "fruit", 2, 4)` → `["pomme", "fruit", "fruit"]`
FILTER
#### Résumé
La fonction `FILTER` filtre les éléments d'une liste pour conserver ceux qui répondent à condition spécifiée.
#### Syntaxe
* `FILTER(liste, lambda)`
#### Exemple
* `FILTER([1, 2, 3, 4], x => x % 2 == 0)` → `[2, 4]`
* `FILTER(["a", "b", "c"], x => x != "b")` `["a", "c"]`
#### Remarque
Il est possible de filtrer les éléments d'une liste avec des lambda fonctions. L'exemple suivant permet de filtrer une liste de contacts par ceux ont 20 ans :
```javascript
FILTER(contact, (x,i)=> INDEX(age,i+1)=20)
```
FIND
**Résumé**
La fonction `FIND` permet de chercher un élément dans une liste et de retourner la position de la première occurence. La fonction permet aussi de chercher une chaîne de caractères à l'intérieur d'une autre. Contrairement à `SEARCH`, cette fonction est sensible à la casse.
**Syntaxe**
* `FIND(liste, recherche, positionDébut = 1)`
**Exemple**
* `FIND("b", ["a","b","c","a","b","c"])` → `2`
* `FIND("world", "Hello world")` → `7`
* `FIND("WORLD", "Hello world")` → `0`
FLATTEN
#### Résumé
La fonction `FLATTEN` transforme une liste imbriquée en une liste à une dimension.
#### Syntaxe
* `FLATTEN(liste)`
#### Exemple
* `FLATTEN([[1, 2], [3, 4]])` → `[1, 2, 3, 4]`
* `FLATTEN([["pomme"], ["banane", "cerise"]])` -> `["pomme", "banane", "cerise"]`
INCLUDES
#### Résumé
La fonction `INCLUDES` détermine si une liste contient un élément spécifié.
#### Syntaxe
* `INCLUDES(liste, élément)`
#### Exemple
* `INCLUDES([1, 2, 3], 2)` → `true`
**Remarque**
Pour appliquer la formule includes sur une chaîne de caractères il faut d'abord séparer la chaîne en liste : `INCLUDES(SPLIT("Hello", ""), "H")` → `true`
INDEX
#### Résumé
La fonction `INDEX` renvoie l'élément à un indice donné dans un tableau.
#### Syntaxe
* `INDEX(liste, indice1, indice2, ...)`
#### Exemple
* `INDEX([1, 2, 3], 2)` → `2`
* `INDEX([[1, 2], [3, 4]], 2, 1)` → `3`
**Remarque**
Une version simplifiée de cette fonction existe. Attention, les indices commencent à 0 au lieu de 1 dans cette version.
`[1, 2, 3][1]` → `2`
`[[1, 2], [3, 4]][1][0]` → 3
LEN
#### Résumé
La fonction `LEN` renvoie le nombre d'éléments dans une liste ou liaison multiple (ou le nombre de caractères dans une chaîne de caractères)
#### Syntaxe
* `LEN(liste)`
* `LEN(texte)`
#### Exemple
* `LEN([4, 5, 6])` → `3`
* `LEN({liaison multiple})` → *nombre d'éléments dans la liaison multiple*
* `LEN("Hello")` → `5`
MAP
#### Résumé
La fonction `MAP` applique une fonction à chaque élément d'une liste.
#### Syntaxe
* `MAP(liste, lambda)`
#### Exemple
* `MAP([1, 2, 3], x => x * 2)` → `[2, 4, 6]`
REDUCE
#### Résumé
La fonction `REDUCE` applique une fonction contre un accumulateur et chaque élément du tableau (de gauche à droite) pour le réduire à une seule valeur.
#### Syntaxe
* `REDUCE(initial, liste, lambda)`
#### Exemple
* `REDUCE(0, [1, 2, 3, 4], (acc, x) => acc + x)` → `10`
* `REDUCE(10, [1, 2, 3], (acc, val) => acc * val)` -> `60`
REVERSE
#### Résumé
La fonction `REVERSE` inverse l'ordre des éléments d'une liste.
#### Syntaxe
* `REVERSE(liste)`
#### Exemple
* `REVERSE([1, 2, 3])` → `[3, 2, 1]`
SLICE
#### Résumé
La fonction `SLICE` extrait une partie d'une liste spécifiée par un numéro de début inclut et un numéro de fin non inclut.
#### Syntaxe
* `SLICE(liste, début, fin)`
#### Exemple
* `SLICE([1, 2, 3, 4, 5], 2, 4)` → `[2, 3]`
SOME
#### Résumé
La fonction `SOME` teste si au moins un élément d'une liste répond à la condition fournie.
#### Syntaxe
* `SOME(liste, lambda)`
#### Exemple
* `SOME([0, 1, 2], LAMBDA(x, x > 0))` → `true`
* `SOME([0, 0, 0], LAMBDA(x, x > 0))` → `false`
SORT
#### Résumé
La fonction `SORT` trie les éléments d'une liste par ordre croissant par défaut. Vous pouvez également définir votre propre fonction de comparaison pour faire le tri.
#### Syntaxe
* `SORT(liste)`
* `SORT(liste, fonctionComparaison)`
#### Exemple
* `SORT([3, 1, 4, 2])` → `[1, 2, 3, 4]`
* `SORT([3, 1, 4, 2], (a, b) => (b-a))` → `[4, 3, 2, 1]`
* `SORT(["pomme", "banane", "cerise"])` → `["banane", "cerise", "pomme"]`
**Remarque**
Cette formule trie les dates des éléments liés par ordre décroissant, puis sélectionne la plus récente. Elle permet ainsi d’identifier la date la plus récente dans la liaison multiple.
**Formule de type : Date**
```javascript
INDEX(SORT({Liaisons multiples -> Date}, (a,b) => DATE_DIFF(b,a)), 1)
```
SPLICE
#### Résumé
La fonction `SPLICE` change le contenu d'une liste en retirant, remplaçant ou ajoutant de nouveaux éléments. Il faut choisir un indice de début à partir duquel commencer les modifications, puis préciser le nombre d'éléments à supprimer, et enfin choisir les éléments à ajouter.
#### Syntaxe
* `SPLICE(liste, début, nbrSuppression, élément1, [élément2, ...])`
#### Exemple
* `SPLICE([1, 2, 3, 4], 2, 0, 'a', 'b')` → `[1, 'a', 'b', 2, 3, 4]`
* `SPLICE(["pomme", "banane", "cerise"], 3, 1, "fraise")` -> `["pomme", "banane", "fraise"]`
SUMIF
#### Résumé
La fonction `SUMIF` additionne les valeurs de la liste `liste_sum` dont les éléments correspondant dans `liste` répondent à une condition spécifiée.
#### Syntaxe
* `SUMIF(liste, lambda, liste_sum = liste)`
#### Exemple
* `SUMIF([1, 2, 3, 4], x => x > 2)` → `7`
* `SUMIF([1, 2, 3, 4], x => x % 2 === 0, [10, 20, 30, 40])` → `60`
#### Remarque
Il est possible d’utiliser une condition plus avancée dans SUMIF en utilisant une fonction lambda.\
Dans l’exemple ci-dessous, on additionne uniquement les absences dont le motif est "Justifiée".\
On utilise l'index `i` pour vérifier dans la liste *Motif* quel est le motif associé à chaque absence.
```javascript
SUMIF(Absences, (x,i)⇒ INDEX(Motif, i+1)=”Justifiée”)
```
**Exemple :**
`SUMIF([2, 2, 4], (x,i)⇒ INDEX(["Justifiée", "Non justifié", "Justifiée"], i+1)=”Justifiée”)`→ `6`
Cette forme de SUMIF est utile lorsque la condition dépend d’une autre liste (motifs, catégories, types, ...) et pas seulement de la valeur testée.
SUMPRODUCT
#### Résumé
La fonction `SUMPRODUCT` renvoie la somme des produits des éléments de deux listes.
#### Syntaxe
* `SUMPRODUCT(liste1, liste2)`
#### Exemple
* `SUMPRODUCT([1, 2, 3], [4, 5, 6])` → `32`
SUMPRODUCTIF
#### Résumé
La fonction `SUMPRODUCTIF` calcule la somme des produits des éléments de deux liste dont les éléments correspondant dans une première liste répondent à une condition spécifiée.
#### Syntaxe
* `SUMPRODUCTIF(liste, lambda, liste1, liste2)`
#### Exemple
* `SUMPRODUCTIF([2, 4, 6], x => x > 3, [1, 2, 3], [4, 5, 6])` → `28`
UNIQUE
#### Résumé
La fonction `UNIQUE` supprime les doublons dans une liste donnée.
#### Syntaxe
* `UNIQUE(liste)`
#### Exemple
* `UNIQUE([1, 2, 2, 3, 3, 3, 4])` → `[1, 2, 3, 4]`
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://ksaar.gitbook.io/ksaar-documentation/les-elements/les-formules/fonctions-de-liste.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.