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
• count
• distance
• distinct
• distribute
• drop
• exploding
• filter
• graph
• greater
• groupingByEquality
• groupingByHamming
• groupingByLevenshtein
• groupingByModulo
• keys
• less
• maximizing
• merging
• minimizing
• multiply
• output
• pair
• pluck
• reducing
• segment
• slice
• sort
• statistics
• summing
• tune
• value

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

• path String

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:

```ini
[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:

```ini
[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

• path String

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
• meta String? element from the input to put it in the meta object

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

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

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
• value String path of the element who will be merge into an array

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
• aggregate Boolean aggregate all values for all paths (or not)aggregate all segmented value in one element (work if you have multiple path)
• identifier String path of the element who will be put in value field (if not set, fallback to 1)

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
• size Number the size of the specified portion of the stream

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
• reverse boolean sort in ascending or descending order

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
• target String path of the statistics in the returned object

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
• value String path of the element to be summed

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
• method ("natural" | "levenshtein" | "numerical") method used to create the unified identifier

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

Returns Object