Tableaux

sort, reverse et distinct préservent le type d'entrée : sort(scores) sur un number[] infère number[].

Pour transformer ou filtrer élément par élément, utiliser les constructions du langage — la projection -> et les filtres [predicate] — plutôt que les lambdas $map/$filter de JSONata.

countMesure

count(items: unknown[]): number

Nombre d'éléments.

joinCombinaison

join(items: string[], separator?: string): string

Concatène les chaînes avec un séparateur (`""` par défaut).

appendCombinaison

append(first: unknown[], second: unknown[]): unknown[]

Concatène deux tableaux.

zipCombinaison

zip(first: unknown[], second: unknown[]): unknown[][]

Apparie les éléments par indice, tronqué au tableau le plus court.

sortRéordonnancement

sort(items: string[] | number[]): string[] | number[]

Trie en ordre naturel croissant ; le résultat conserve le type d'entrée.

reverseRéordonnancement

reverse(items: unknown[]): unknown[]

Inverse l'ordre ; le résultat conserve le type d'entrée.

shuffleRéordonnancement

shuffle(items: unknown[]): unknown[]

Permutation aléatoire ; conserve le type d'entrée.

distinctDéduplication

distinct(items: unknown[]): unknown[]

Supprime les doublons (égalité profonde pour les objets) ; conserve le type d'entrée.

Mesure

count

count(items: unknown[]): number

Nombre d'éléments.

total: count(order.items)

Combinaison

join

join(items: string[], separator?: string): string

Concatène les chaînes avec un séparateur ("" par défaut).

csv: join(user.tags, ", ")

append

append(first: unknown[], second: unknown[]): unknown[]

Concatène deux tableaux.

all: append(data.names, data.scores)

zip

zip(first: unknown[], second: unknown[]): unknown[][]

Apparie les éléments par indice, tronqué au tableau le plus court.

paired: zip(data.names, data.scores)

Réordonnancement

sort

sort(items: string[] | number[]): string[] | number[]

Trie en ordre naturel croissant ; le résultat conserve le type d'entrée.

ranked: sort(data.scores)

reverse

reverse(items: unknown[]): unknown[]

Inverse l'ordre ; le résultat conserve le type d'entrée.

latestFirst: reverse(data.scores)

shuffle

shuffle(items: unknown[]): unknown[]

Permutation aléatoire ; conserve le type d'entrée.

deckOrder: shuffle(deck.cards)

Déduplication

distinct

distinct(items: unknown[]): unknown[]

Supprime les doublons (égalité profonde pour les objets) ; conserve le type d'entrée.

unique: distinct(data.names)

Playground

Mapping✔Playground ↗

input data: { scores: number[], names: string[] }

map {
  ranked: reverse(sort(data.scores)),
  unique: distinct(data.names),
  merged: append(data.names, data.scores),
  paired: zip(data.names, data.scores),
  csv: join(data.names, ", "),
}

input data: { scores: number[], names: string[] } map { ranked: reverse(sort(data.scores)), unique: distinct(data.names), merged: append(data.names, data.scores), paired: zip(data.names, data.scores), csv: join(data.names, ", "), }

JSON d'entrée

{ "scores": [12, 3, 12, 7], "names": ["ada", "alan", "ada"] }

{ "scores": [12, 3, 12, 7], "names": ["ada", "alan", "ada"] }

Sortie

{
  "ranked": [
    12,
    12,
    7,
    3
  ],
  "unique": [
    "ada",
    "alan"
  ],
  "merged": [
    "ada",
    "alan",
    "ada",
    12,
    3,
    12,
    7
  ],
  "paired": [
    [
      "ada",
      12
    ],
    [
      "alan",
      3
    ],
    [
      "ada",
      12
    ]
  ],
  "csv": "ada, alan, ada"
}

type inféré{ ranked: number[]; unique: string[]; merged: (string | number)[]; paired: (string | number)[][]; csv: string; }