❤
npm
Sign UpSign In

@ezs/analytics

2.3.2 • Public • Published

analytics

Présentation

Ce plugin est propose une série d'instructions pour croiser, compter, trier, agréger des flux d’objets Javascript

installation

npm install @ezs/analytics

usage

Table of Contents

aggregate

Aggregate by id and count

[{
         { id: 'x', value: 2 },
         { id: 't', value: 2 },
         { id: 'x', value: 3 },
         { id: 'x', value: 5 },
}]

Script:

[use]
plugin = analytics

[aggregate]
path = id

Output:

[
         { id: 'x', value: [ 2, 3, 5] },
         { id: 't', value: [ 2 ]  },
]

Parameters

  • path String path to use for id (optional, default id)
  • value String path to use for value (if not found 1 is the default value) (optional, default value)

Returns Object

count

Take Object and throw special Object like {id, value} if key(s) was found id is the key, value is equal to 1 (if found)

[
 {
      "a": "nancy",
      "b": "lucy",
      "c": "geny",
  },
  {
      "a": "lorem",
      "b": "loret",
  },
  {
      "a": "fred",
  }
]

Script:

[use]
plugin = analytics

[count]
path = a
path = b
path = c

[aggregate]
[summing]

Output:

[{
   "id": "a",
   "value": 3
},
{
   "id": "b",
   "value": 2
},
{
   "id": "c",
   "value": 1
}]

Parameters

Returns Object

distance

To compare 2 fields with 2 id and compute a distance

  • for arrays, the distance is calculated according to the number of element in common
[{
           {
              id_of_a: 1,
              id_of_b: 2,
              a: ['x', 'y'],
              b: ['x', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 3,
              a: ['x', 'y'],
              b: ['y', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 4,
              a: ['x', 'y'],
              b: ['z'],
          },
          {
              id_of_a: 1,
              id_of_b: 5,
              a: ['x', 'y'],
              b: ['x', 'y', 'z'],
          },
          {
              id_of_a: 1,
              id_of_b: 6,
              a: ['x', 'y'],
              b: ['x', 'y'],
          },
}]

Script:

[use]
plugin = analytics

[distance]
id = id_of_a
id = id_of_b
value = a
value = b

Output:

[
    { id: [ 1, 2 ], value: 0.5 },
    { id: [ 1, 3 ], value: 0.5 },
    { id: [ 1, 4 ], value: 0 },
    { id: [ 1, 5 ], value: 0.8 },
    { id: [ 1, 6 ], value: 1 }
  ]

]

Parameters

  • path String path (optional, default value)

Returns Object

distinct

Take Object object getting some fields with json path, and do ...

[{
          { a: 'x', b: 'z' },
          { a: 't', b: 'z' },
          { a: 't', b: 'z' },
          { a: 'x', b: 'z' },
          { a: 'x', b: 'z' },
}]

Script:

[use]
plugin = analytics

[distinct]
path = a

Output:

[
          { id: 'x', value: 1 },
          { id: 't', value: 1 },
          { id: 't', value: 1 },
          { id: 'x', value: 1 },
          { id: 'x', value: 1 },
]

Parameters

  • path String path (optional, default "id")

Returns Object

distribute

Take Object like { id, value } and throw a serie of number value

[
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]

Script:

[use]
plugin = analytics

[distribute]

Output:

[
      { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2002, "value": 0 },
     { "id": 2003, "value": 3 },
     { "id": 2004, "value": 0 },
     { "id": 2005, "value": 4 },
     { "id": 2006, "value": 0 },
     { "id": 2007, "value": 5 },
     { "id": 2008, "value": 0 },
     { "id": 2009, "value": 6 },
     { "id": 2010, "value": 0 },
     { "id": 2011, "value": 7 },
     { "id": 2012, "value": 0 },
     { "id": 2013, "value": 8 }
]

Parameters

  • id String path to use for id (optional, default "id")
  • value String path to use for value (optional, default "value")
  • step String step between each value (optional, default 1)
  • start Number first value to throw (optional, default minvalueinthestream)
  • size Number size of the distribution (optional, default (maxvalue-minvalue)inthestream)
  • default Number default value for missing object (optional, default 0)

Returns Object

drop

Take Object and throw the same object only if there the value of the select field is not equals than a value

[
  {
   "departure": "nancy",
   "arrival": "paris",
 },
 {
   "departure": "nancy",
   "arrival": "toul",
 },
 {
   "departure": "paris",
   "arrival": "londre",
 }
]

Script:

[use]
plugin = analytics

[drop]

Output:

[{
  "departure": "nancy",
  "arrival": "paris"
},
{
   "departure": "nancy",
  "arrival": "toul"
}]

Parameters

  • path String path of the field to compare (optional, default "value")
  • if Number value to compare (optional, default "")

Returns Object

exploding

Take Object and take values with [value] path (must be an array) and throw object of each value. The new object is build with [id] and eac value.

[
 { departure: ['tokyo', 'nancy'], arrival: 'toul' },
 { departure: ['paris', 'nancy'], arrival: 'toul' },
 { departure: ['london', 'berlin'], arrival: 'toul' },
}]

Script:

[use]
plugin = analytics

[exploding]

Output:

[
   { "id": "toul", "value": "tokyo" },
   { "id": "toul", "value": "nancy" },
   { "id": "toul", "value": "paris" },
   { "id": "toul", "value": "nancy" },
   { "id": "toul", "value": "london" },
   { "id": "toul", "value": "berlin" }
]

Parameters

  • id String path to use for id (optional, default "id")
  • value String path to use for value (optional, default "value")

Returns Object

filter

Take Object and throw the same object only if there the value of the select field is equals than a value

  • [
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2003, value: 3 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]

    Script:

    [use]
plugin = analytics

[filter]
path = id
if = 2003
if = 2013

Output:

 [
          { id: 2003, value: 3 },
          { id: 2003, value: 3 },
          { id: 2013, value: 8 },
 ]

Parameters

  • path String path of the field to compare (optional, default "value")
  • if Number value to compare (optional, default "")

Returns Object

graph

Take Object and throw a new special object (id, value) for each combination of values

[
 { cities: ['berlin', 'nancy', 'toul'] },
 { cities: ['paris', 'nancy', 'toul']},
 { cities: ['paris', 'berlin', 'toul'] },
}]

Script:

[use]
plugin = analytics

[graph]
path = cities

Output:

[
  { "id": [ "berlin", "nancy" ], "value": 1 },
  { "id": [ "berlin", "toul" ], "value": 2 },
  { "id": [ "nancy", "toul" ], "value": 2 },
  { "id": [ "nancy", "paris" ], "value": 1 },
  { "id": [ "paris", "toul" ], "value": 2 },
  { "id": [ "berlin", "paris" ], "value": 1 }
]

Parameters

  • path String
  • identifier String path to use to set value result field (if not set or not exists, 1 is use as a default value) (optional, default false)

Returns Object

greater

Take Object and throw the same object only if the value of the selected field is greater (or equal) than a value

[
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]

Script:

[use]
plugin = analytics

[greater]
than = 3
strict = true

Output:

[
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
]

Parameters

  • path String path of the field to compare (optional, default "value")
  • than Number value to compare (optional, default 0)
  • strict Boolean greater than but not equal (optional, default false)

Returns Object

groupingByEquality

Take Object like { id, value } and reduce all values with the same id in a single object

[
   { "id": "lorem", "value": 1 },
   { "id": "Lorem", "value": 1 },
   { "id": "loren", "value": 1 },
   { "id": "korem", "value": 1 },
   { "id": "olrem", "value": 1 },
   { "id": "toto", "value": 1 },
   { "id": "titi", "value": 1 },
   { "id": "lorem", "value": 1 }
]

Script:

[use]
plugin = analytics

[groupingByEquality]

[summing]

Output:

[
  { "id": [ "lorem" ], "value": 2 },
  { "id": [ "Lorem" ], "value": 1 },
  { "id": [ "loren" ], "value": 1 },
  { "id": [ "korem" ], "value": 1 },
  { "id": [ "olrem" ], "value": 1 },
  { "id": [ "toto" ], "value": 1 },
  { "id": [ "titi" ], "value": 1 }
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)

Returns Object

groupingByHamming

Take Object like { id, value } and reduce all value with id which have the same Hamming distance in a single object

  • [
   { "id": "lorem", "value": 1 },
   { "id": "Lorem", "value": 1 },
   { "id": "loren", "value": 1 },
   { "id": "korem", "value": 1 },
   { "id": "olrem", "value": 1 },
   { "id": "toto", "value": 1 },
   { "id": "titi", "value": 1 },
   { "id": "lorem", "value": 1 }
]

    Script:

    [use]
plugin = analytics

[groupingByHamming]
distance = 1

[summing]

Output:

[
   { "id": [ "lorem", "Lorem", "loren", "korem" ], "value": 5 },
   { "id": [ "olrem" ], "value": 1 },
   { "id": [ "toto", "titi" ], "value": 2 }
]

Parameters

  • id String path to use for id (optional, default "id")
  • value String path to use for value (optional, default "value")

Returns Object

groupingByLevenshtein

Take Object like { id, value } and reduce all values with id which have the same Levenshtein distance in a single object

[
   { "id": "lorem", "value": 1 },
   { "id": "Lorem", "value": 1 },
   { "id": "loren", "value": 1 },
   { "id": "korem", "value": 1 },
   { "id": "olrem", "value": 1 },
   { "id": "toto", "value": 1 },
   { "id": "titi", "value": 1 },
   { "id": "lorem", "value": 1 }
]

Script:

[use]
plugin = analytics

[groupingByLevenshtein]
distance = 2

[summing]

Output:

[
   { "id": [ "lorem", "Lorem", "loren", "korem", "olrem" ], "value": 6 },
   { "id": [ "toto", "titi" ], "value": 2 }
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)
  • distance Number minimal levenshtein distance to have a same id (optional, default 1)

Returns Object

groupingByModulo

Take Object like { id, value } and reduce all values with the same modulo computation in a ansingle object

[{
}]

Script:

[use]
plugin = analytics

[groupingByModulo]

Output:

[
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)

Returns Object

keys

Take Object and throws all its keys

[
 { city: 'tokyo', year: 2000, count: 1 },
 { city: 'paris', year: 2001, count: 2 },
 { city: 'london', year: 2003, count: 3 },
 { city: 'nancy', year: 2005, count: 4 },
 { city: 'berlin', year: 2007, count: 5 },
 { city: 'madrid', year: 2009, count: 6 },
 { city: 'stockholm', year: 2011, count: 7 },
 { city: 'bruxelles', year: 2013, count: 8 },
]

Script:

[use]
plugin = analytics

[keys]
[aggregate]
[summing]

Output:

[
{
   "id": "city",
   "value": 8
},
{
  "id": "year",
  "value": 8
},
{
   "id": "count",
   "value": 8
}⏎
]

Parameters

Returns Object

less

Take Object and throw the same object only if the value of the selected field is less (or equal) than a value

[{
          { id: 2000, value: 1 },
          { id: 2001, value: 2 },
          { id: 2003, value: 3 },
          { id: 2005, value: 4 },
          { id: 2007, value: 5 },
          { id: 2009, value: 6 },
          { id: 2011, value: 7 },
          { id: 2013, value: 8 },
}]

Script:

[use]
plugin = analytics

[less]
path = value
than = 4

Output:

[{
   "id": 2000,
   "value": 1
},
{
   "id": 2001,
  "value": 2
},
{
   "id": 2003,
   "value": 3
},
{
   "id": 2005,
   "value": 4
}]

Parameters

  • path String path of the field to compare (optional, default value)
  • than Number value to compare (optional, default 0)
  • strict Boolean less than but not equal (optional, default false)

Returns Object

maximizing

Take special Object like {id, value} and replace value with the max of values

[
  { id: 'toul', value: [1, 2, 3] },
  { id: 'nancy', value: [2, 3, 4] },
  { id: 'neufchateau', value: [3, 4, 5] },
]

Script:

[use]
plugin = analytics

[maximizing]

Output:

[
   { "id": "toul", "value": 3 },
   { "id": "nancy", "value": 4 },
   { "id": "neufchateau", "value": 5 }
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)

Returns Object

merging

Take special Object like {id, value} and replace value with the merge of values

[{
}]

Script:

[use]
plugin = analytics

[merging]

Output:

[
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)

Returns Object

minimizing

Take special Object like {id, value} and replace value with the min of values

[{
}]

Script:

[use]
plugin = analytics

[drop]

Output:

[
]

Parameters

  • id String path to use for id (optional, default id)
  • value String path to use for value (optional, default value)

Returns Object

multiply

Take Object and throw the same object only if there the value of the select field is equals than a value Input file:

[{
   a: 1,
   b: 2,
}]

Script:

[use]
plugin = analytics

[multiply]
path = factor
value = X
value = Y
value = Z

Output:

[{
   a: 1,
   b: 2,
   factor: X
},
{
   a: 1,
   b: 2,
   factor: Y
},
{
   a: 1,
   b: 2,
   factor: Z
},
]

Parameters

  • path String path of the field to add (optional, default "factor")
  • value String value(s) to set factor field (optional, default "")

Returns Object

output

Create an output string containing all incoming elements in a data array. with given meta extracted into an object called meta.

Créer une sortie en chain de caratere avec les element entrent mise dans un tableau nommé data eyent les donnée meta extrais et mises dans un objet appelé meta.

Script / Scénario
ini
; Import analytics plugin required to use "output"
; Importation du plugin analytique nécessaire pour utiliser "output"
[use]
plugin = analytics

; Using "output" with 'indent' as true and 'meta' as total
; Utilisation de "output" avec 'indent' à vrai et total comme paramètres de 'meta'
[output]
indent = true
meta = total
Input / Entrée
 [
     { "_id": 1, "value": 2, "total": 2 },
     { "_id": 2, "value": 4, "total": 2 }
 ]
Output / Sortie

!!! Attention: This is an output function that can only be used at the end of an EZS script. !!! !!! The output is a string and can't be used with other EZS functions. !!!

!!! Attention : Ceci est une fonction de sortie, Elle peut uniquement etre utilisé à la fin d'un script ezs !!! !!! Cette sortie est une chaine de carater et ne peut pas etre utilisé avec d'autre fonction ezs !!!

 {
     "data": [
         { "_id": 1, "value": 2 },
         { "_id": 2, "value": 4 }
     ],
     "meta": {
         "total": 2
     }
 }

Parameters

  • indent Boolean
    • indent the output json
    • indenté le json de sortie
    (optional, default `false`)
  • meta String?
    • element from the input to put it in the meta object
    • élément a extraire de l'entrée et a mettre dans l'objet `meta`

Returns String

pair

Create a pair with 'id' containing a pair of the given 'path's and 'value' set to 1.

Créer un couple 'id' contenent un couple des 'path's donnée et 'value' mise à 1.

Script / Scénario
; Import analytics plugin required to use "pair"
; Importation du plugin analytique nécessaire pour utiliser "pair"
[use]
plugin = analytics

; Using "pair" with 'departure' and 'arrival' as paths setttings
; Utilisation de "pair" avec 'departure' et 'arrival' comme paramètres de paths
[pair]
path = departure
path = arrival
Input / Entrée
 [
     { "departure": ["tokyo", "nancy"], "arrival": "toul" },
     { "departure": ["paris", "nancy"], "arrival": "toul" },
     { "departure": ["london", "berlin"], "arrival": "toul" }
 ]
Output / Sortie
 [
     { "id": ["tokyo", "toul"], "value": 1 },
     { "id": ["nancy", "toul"], "value": 1 },
     { "id": ["paris", "toul"], "value": 1 },
     { "id": ["nancy", "toul"], "value": 1 },
     { "id": ["london", "toul"], "value": 1 },
     { "id": ["berlin", "toul"], "value": 1 }
 ]

Parameters

  • identifier String path to use to set value result field (if not set or not exists, 1 is use as a default value) (optional, default false)
  • null String
    • path of the element who will be use to create the pair
    • chemin de l'élément qui vas etre utilisé pour créer le couple

Returns {id: Array<String>, value: 1}

pluck

Extract the value of a given path and create a pair with the path as the id and path value as the value.

Extrais la valeur d'un path donnée et créer un couple avec pour identifient le path et comme value la valeur du path.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "pluck"
; Importation du plugin analytique nécessaire pour utiliser "pluck"
[use]
plugin = analytics

; Using "pluck" with 'year' as path setttings instead of 'id' how is the default value
; Utilisation de "pluck" avec 'year' comme paramètres de path au lieux de la valeur par defaut qui et 'id'
[pluck]
path = year
Input / Entrée
 [
     { "city": "tokyo", "year": 2000, "count": 1 },
     { "city": "paris", "year": 2001, "count": 2 },
     { "city": "london", "year": 2003, "count": 3 },
     { "city": "nancy", "year": 2005, "count": 4 },
     { "city": "berlin", "year": 2007, "count": 5 },
     { "city": "madrid", "year": 2009, "count": 6 },
     { "city": "stockholm", "year": 2011, "count": 7 },
     { "city": "bruxelles", "year": 2013, "count": 8 }
 ]
Output / Sortie
 [
     { "id": "year", "value": 2000 },
     { "id": "year", "value": 2001 },
     { "id": "year", "value": 2003 },
     { "id": "year", "value": 2005 },
     { "id": "year", "value": 2007 },
     { "id": "year", "value": 2009 },
     { "id": "year", "value": 2011 },
     { "id": "year", "value": 2013 }
 ]

Parameters

  • path String
    • path of the element who need to be extrated
    • chemin de l'élément qui doit être extrais
    (optional, default `id`)

Returns {id: String, value: Object}

reducing

Merges the id, value pairs into a new pair, associating the identifier with the values.

Fusionne les couple id, value, en un nouveau couple associent l'identifient au valeurs.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "reducing"
; Importation du plugin analytique nécessaire pour utiliser "reducing"
[use]
plugin = analytics

; Using "reducing" with default settings
; Utilisation de "reducing" avec les paramètres par défaut
[reducing]
; id = id
; value = value
Input / Entrée
 [
     { "id": "x", "value": 2 },
     { "id": "t", "value": 2 },
     { "id": "x", "value": 3 },
     { "id": "x", "value": 5 }
 ]
Output / Sortie
 [
     { "id": "x", "value": [2, 3, 5] },
     { "id": "t", "value": [2] }
 ]

Parameters

  • id String
    • path of the element who will be use as the key
    • chemin de l'élément qui vas être utilisé comme clé
    (optional, default `id`)
  • value String
    • path of the element who will be merge into an array
    • chemin de l'élément qui vas être fussioné en un tableau
    (optional, default `value`)

Returns {id: String, value: Array<Object>}

segment

Returns an object containing a segmentation of the input.

  • [a,b,c] will be returned as [a,b], [b,c]

Renvoie un objet contenant une segmentation de l'entrée.

  • [a,b,c] sera retourné sous la forme [a,b], [b,c]

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "segment"
; Importation du plugin analytique nécessaire pour utiliser "segment"
[use]
plugin = analytics

; Using "segment" with default settings
; Utilisation de "segment" avec les paramètres par défaut
[segment]
; aggregate = true
; identifier = false
; path = value
Input / Entrée
 [
     {
         "id": "doc#1",
         "value": [
             1,
             2,
             3,
             4
         ]
     },
     {
         "id": "doc#2",
         "value": [
             4,
             5,
             6
         ]
     },
     {
         "id": "doc#3",
         "value": [
             6,
             7
         ]
     },
     {
         "id": "doc#4",
         "value": [
             1,
             2,
             3,
             4,
             5,
             6,
             7
         ]
     }
 ]
Output / Sortie
 [
     { "id": [ 1, 2 ], "value": 1 },
     { "id": [ 2, 3 ], "value": 1 },
     { "id": [ 3, 4 ], "value": 1 },
     { "id": [ 4, 5 ], "value": 1 },
     { "id": [ 5, 6 ], "value": 1 },
     { "id": [ 6, 7 ], "value": 1 },
     { "id": [ 1, 2 ], "value": 1 },
     { "id": [ 2, 3 ], "value": 1 },
     { "id": [ 3, 4 ], "value": 1 },
     { "id": [ 4, 5 ], "value": 1 },
     { "id": [ 5, 6 ], "value": 1 },
     { "id": [ 6, 7 ], "value": 1 }
 ]

Parameters

  • path String
    • path of the element who need to be segmented
    • chemin de l'élément qui doit être segmentés
    (optional, default `value`)
  • aggregate Boolean aggregate all values for all paths (or not)
    • aggregate all segmented value in one element (work if you have multiple path)
    • agréger toutes les valeurs segmentées en un seul élément (fonctionne si vous avez plusieurs chemins)
    (optional, default `true`)
  • identifier String
    • path of the element who will be put in value field (if not set, fallback to 1)
    • chemin de l'élément qui sera mis dans le champ valeur (si non défini, fallback à `1`)
    (optional, default `false`)

Returns {id: Array<Number>, value: Object}

slice

Returns a copy of a section of a stream.

Renvoie une copie d'une section d'un flux.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "slice"
; Importation du plugin analytique nécessaire pour utiliser "slice"
[use]
plugin = analytics

; Using "slice" with default settings
; Utilisation de "slice" avec les paramètres par défaut
[slice]
; start = 1
; size = 10
Input / Entrée
 [
     { "id": 2023, "value": 12 },
     { "id": 2021, "value": 11 },
     { "id": 2019, "value": 10 },
     { "id": 2017, "value": 9 },
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 },
     { "id": 2001, "value": 2 },
     { "id": 2000, "value": 1 }
 ]
Output / Sortie
 [
     { "id": 2023, "value": 12 },
     { "id": 2021, "value": 11 },
     { "id": 2019, "value": 10 },
     { "id": 2017, "value": 9 },
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 }
 ]

Parameters

  • start Number
    • the beginning index of the specified portion of the stream
    • l'indice de début de la partie spécifiée du flux
    (optional, default `1`)
  • size Number
    • the size of the specified portion of the stream
    • la taille de début de la partie spécifiée du flux
    (optional, default `10`)

Returns Object

sort

Sort incomming objects based on the value of the given path.

Trie les objets entrants en fonction de la valeur du champ donné par path.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "sort"
; Importation du plugin analytique nécessaire pour utiliser "sort"
[use]
plugin = analytics

; Using "sort" with default settings
; Utilisation de "sort" avec les paramètres par défaut
[sort]
; path = id
; reverse = false
Input / Entrée
 [
     { "id": 2013, "value": 8 },
     { "id": 2011, "value": 7 },
     { "id": 2009, "value": 6 },
     { "id": 2007, "value": 5 },
     { "id": 2005, "value": 4 },
     { "id": 2003, "value": 3 },
     { "id": 2001, "value": 2 },
     { "id": 2000, "value": 1 }
 ]
Output / Sortie
 [
     { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2003, "value": 3 },
     { "id": 2005, "value": 4 },
     { "id": 2007, "value": 5 },
     { "id": 2009, "value": 6 },
     { "id": 2011, "value": 7 },
     { "id": 2013, "value": 8 }
 ]

Parameters

  • path String
    • path of the element used to as reference for the sort
    • chemin de l'élément utilisé comme référence pour le tri
    (optional, default `id`)
  • reverse boolean
    • sort in ascending or descending order
    • trier par ordre croissant ou décroissant
    (optional, default `false`)

Returns Object

statistics

Analyse and create statistics from given fields.

Analyse et crée des statistiques à partir des champs donnés.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "statistics"
; Importation du plugin analytique nécessaire pour utiliser "statistics"
[use]
plugin = analytics

; Using "statistics" with default settings
; Utilisation de "statistics" avec les paramètres par défaut
[statistics]
; path = value
; target = _statistics
Input / Entrée
 [
     { "value": 1 },
     { "value": 1 },
     { "value": 2 },
     { "value": 3 },
     { "value": 3 },
     { "value": 3 }
 ]
Output / Sortie
 [
     {
         "value": 1,
         "_statistics": {
             "value": {
                 "sample": 2,
                 "frequency": 1,
                 "percentage": 25,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     },
     {
         "value": 1,
         "_statistics": {
             "value": {
                 "sample": 2,
                 "frequency": 1,
                 "percentage": 25,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     },
     {
         "value": 2,
         "_statistics": {
             "value": {
                 "sample": 1,
                 "frequency": 0.5,
                 "percentage": 50,
                 "sum": 4,
                 "count": 3,
                 "min": 1,
                 "max": 2,
                 "mean": 1.3333333333333333,
                 "range": 1,
                 "midrange": 0.5,
                 "variance": 0.2222222222222222,
                 "deviation": 0.4714045207910317,
                 "population": 2
             }
         }
     }
 ]

Parameters

  • path String
    • path of the element used to create the statistics
    • chemin de l'élément utilisé pour créer les statistiques
    (optional, default `value`)
  • target String
    • path of the statistics in the returned object
    • chemin des stastistiques dans l'objet retourné
    (optional, default `_statistics`)

Returns Object

summing

Create an id, value pair from two given paths and apply a sum to the value.

Créer un couple id, value à partir de chemins et applique une somme sur value.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "summing"
; Importation du plugin analytique nécessaire pour utiliser "summing"
[use]
plugin = analytics

; Using "summing" with default settings
; Utilisation de "summing" avec les paramètres par défaut
[summing]
; id = id
; value = value
Input / Entrée
 [
     {
         "id": 1,
         "value": [1, 1, 1],
         "hello": "world"
     },
     {
         "id": 2,
         "value": [2, 2, 2],
         "hello": "world"
     }
 ]
Output / Sortie
[
    {
        "id": 1,
        "value": 3
    },
    {
        "id": 2,
        "value": 6
    }
]

Parameters

  • id String
    • path of the element used to create the new identifier
    • chemin de l'élément utilisé pour créer le nouvel identifiant
    (optional, default `id`)
  • value String
    • path of the element to be summed
    • chemin de l'élément qui doit être sommé
    (optional, default `value`)

Returns {id: String, value: Object}

tune

Create and replace the id with a unified id that can be used with sort.

Créer et remplacer l'identifiant par un identifiant unifié qui peut être utilisé avec sort.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "tune"
; Importation du plugin analytique nécessaire pour utiliser "tune"
[use]
plugin = analytics

; Using "tune" with default settings
; Utilisation de "tune" avec les paramètres par défaut
[tune]
; path = id
; method = natural
Input / Entrée
 [
     {
         "id": 1,
         "value": 1
     },
     {
         "id": 2,
         "value": 2
     }
 ]
Output / Sortie
 [
     {
         "id": "0000000000000000001.00000000000000000000",
         "value": {
             "id": 1,
             "value": 1,
             "label": "static value"
         }
     },
     {
         "id": "0000000000000000002.00000000000000000000",
         "value": {
             "id": 2,
             "value": 2,
             "label": "static value"
         }
     }
 ]

Parameters

  • path String
    • path of the element used to create the unified identifier
    • chemin de l'élément utilisé pour créer l'identifiant unifié
    (optional, default `id`)
  • method ("natural" | "levenshtein" | "numerical")
    • method used to create the unified identifier
      • natural - Create a normalised identifier that is set to a fixed length
      • levenshtein - Create an identifier based on the Levenshtein algorithm
      • numerical - Create an identifier based on a numeric value
    • méthode utilisée pour créer l'identifiant unifié
      • natural - Crée un identifiant normalisé de longueur fixe
      • levenshtein - Crée un identifiant basé sur l'algorithme de Levenshtein
      • numerical - Crée un identifiant basé sur une valeur numérique
    (optional, default `natural`)

Returns {id: String, value: Object}

value

Create a new object from the value of the given path.

Créer un nouvel objet à partir du chemin donné dans path.

Example / Exemple

Script / Scénario
; Import analytics plugin required to use "value"
; Importation du plugin analytique nécessaire pour utiliser "value"
[use]
plugin = analytics

; Using "value" with default settings
; Utilisation de "tune" avec les paramètres par défaut
[value]
; path = value
Input / Entrée
Dataset 1 / Jeu de données 1
 [
     { "id": 2000, "value": 1 },
     { "id": 2001, "value": 2 },
     { "id": 2003, "value": 3 },
     { "id": 2005, "value": 4 },
     { "id": 2007, "value": 5 },
     { "id": 2009, "value": 6 },
     { "id": 2011, "value": 7 },
     { "id": 2013, "value": 8 }
 ]
Dataset 2 / Jeu de données 2
 [
     {
         "id": 1,
         "value": {
             "hello": "world"
         }
     },
     {
         "id": 2,
         "value": {
             "hello": "ezs"
         }
     },
     {
         "id": 3,
         "value": {
             "hello": "lodex"
         }
     }
 ]
Output / Sortie
Dataset 1 / Jeu de données 1
 [
     1,
     2,
     3,
     4,
     5,
     6,
     7,
     8
 ]
Dataset 2 / Jeu de données 2
 [
     {
         "hello": "world"
     },
     {
         "hello": "ezs"
     },
     {
         "hello": "lodex"
     }
 ]

Parameters

  • path String
    • path of the element used to create the new object
    • chemin de l'élément utilisé pour créer le nouvel objet
    (optional, default `value`)

Returns Object

/@ezs/analytics/

    Package Sidebar

    Install

    npm i @ezs/analytics

    Repository

    github.com/Inist-CNRS/ezs

    Homepage

    github.com/Inist-CNRS/ezs/tree/master/packages/analytics#readme

    Weekly Downloads

    19

    Version

    2.3.2

    License

    MIT

    Unpacked Size

    155 kB

    Total Files

    49

    Last publish

    Collaborators

    • parmentf
    • touv
    • jj618
    Try on RunKit
    Report malware