Annexe : Structure de données et GREL

Note : à améliorer. Pour l’instant inclusion de la page Memo_GREL.html

modifier type données

Contenu téléchargeable en .DOCX : Memo_GREL.docx


Mémo : Programmer dans Openrefine avec GREL

Auteur : Mathieu Saby

Licence CC-BY-v4

 

Historique

V3

12/11/2018

Ajout des fonctions manquantes, corrections, séparation en plusieurs documents

V2.2

31/05/2018

Correction typo + terminologie (enregistrement -> entrée)

V2.1

27/05/2018

Précisions sur l’accès aux éléments des tableaux et des chaînes

V2.0

23/05/2018

Ajout de passages sur Python, précisions sur le modèle de données

V1.0

01/11/2017

Création

 

Les transformations et facettes personnalisées sont basées sur des « expressions », équivalent des formules dans Excel. Les expressions peuvent être écrites en langage GREL (Google Refine Expression Language, ou General Refine Expression Language) spécifique d’Openrefine, en Jython (implémentation de Python en langage Java) ou en Clojure. GREL est utilisé plus souvent que Jython et Clojure, en général réservés à des cas complexes.

Ce document présente le modèle de données propre à Openrefine, la syntaxe de GREL et toutes les fonctions utilisables.

La version d’Openrefine décrite est la 3.1.

 

Pour plus d’informations voir la documentation officielle https://github.com/OpenRefine/OpenRefine/wiki/General-Refine-Expression-Language

Table des matières

1.        Syntaxe générale.. 4

2.        Types de données.. 4

2.1.          Types de données utilisables dans la grille de données. 4

2.2.          Remarques sur null et blank.. 5

2.3.          Type de données utilisables uniquement dans les formules.. 5

3.        Structure des chaînes et tableaux.. 5

4.        Variables internes.. 6

5.        Liste de toutes les fonctions GREL.. 7

5.1.           Fonctions générales. 8

5.1.1.       Détection et conversion de types. 8

Type (e). 8

toDate (e, [b1 ou s1,s2…]). 8

toString (e, [s1]). 8

toNumber (e). 8

isBlank (e), isNonBlank (e), isNull (e), isNotNull (e), isNumeric (e), isError (e). 8

coalesce (e1,[e2,e3…]). 8

5.1.2.       Choix.. 8

if (e, x, y). 8

forNonBlank (e,val,x,y). 8

5.1.3.       Enchaînement d’expressions.. 9

with (e1,val,e2). 9

5.1.4.       Opérateurs booléens. 9

and (b1, b2, b3…). 9

or (b1, b2, b3…). 9

xor (b1, b2, b3…). 9

not (b1). 9

5.1.5.       Facettes.. 9

facetCount (e, s1, s2). 9

5.1.6.       Croisement de données. 9

cross (c, s1, s2). 9

5.2.          Manipulation de chaînes.. 10

5.2.1.       Encodage de caractères.. 10

escape (s1,s2). 10

unescape (s1,s2). 10

reinterpret (s1, s2, [s3]). 10

5.2.2.       Fonction utilisées pour la clusterisation.. 10

ngram (s1,n1). 10

ngramFingerprint (s1,n1). 10

phonetic (s1,[s2]). 11

fingerprint (s1). 11

md5 (s1). 11

sha1 (s1). 11

unicode (s1). 11

unicodeType (s1). 11

5.2.3.       Tests sur les chaînes.. 11

startsWith (s1,s2). 11

endsWith (s1,s2). 11

contains (s1,s2). 11

5.2.4.       Modifications globales et troncature.. 11

chomp (s1, s2). 11

trim (s). 11

toUppercase (s). 12

toLowercase (s1). 12

toTitlecase (s1). 12

5.2.5.       Comparaisons, découpage, remplacement. 12

indexOf (s1,s2). 12

diff (s1,s2). 12

find (s1,m1) ou (s1,s2). 12

lastIndexOf (s1,s2). 12

length (s1). 12

match (s1,m1). 12

partition (s1,s2,[omitFragment]). 13

rpartition (s1,s2,[omitFragment]). 13

smartSplit (s1,[s2]). 13

split (s1,s2,[preserveAllTokens]). 13

splitByLengths (s1,n1,n2,…). 13

splitByChartype (s1). 13

substring (s, n1[,n2]). 14

replace (s1, s2,s3). 14

replaceChars (s1,s2,s3). 14

5.3.          Manipulation de tableaux.. 14

range (n1,[n2,[n3]]) ou (s1,[s2,[s3]]). 14

length (a1). 14

slice (a1,n1,[n2]). 14

join (a1,s1). 14

sort (a1). 15

reverse (a1). 15

uniques (a1). 15

5.4.          Fonctions mathématiques. 15

5.4.1.       Arrondis. 15

abs (n1). 15

round (n1). 15

ceil (n1). 15

floor (n1). 15

even (n1). 15

odd (n1). 15

mod (n1,n2). 15

quotient (n1,n2). 15

max (n1,n2). 15

min (n1,n2). 15

log (n1). 15

ln (n1). 15

pow (n1,n2). 16

exp (n1). 16

sum (t1). 16

fact (n1). 16

fact (n1,2). 16

combin (n1,n2). 16

degrees (n1). 16

radians (n1). 16

gcd (n1,n2). 16

lcm (n1,n2). 16

multinomial (n1,n2...). 16

5.4.2.       Fonctions trigonométriques. 16

5.5.          Manipulation de dates. 16

datePart (d1,s1). 16

now (). 16

inc (d1,n1,s1). 16

diff (d1,d2,s1). 17

5.6.          Itérations et filtres.. 17

forEach (a1,val,f). 17

forEachIndex (a1,index,val,f). 17

forRange (n1,n2,n3,val,f). 17

filter (a1,val,f). 17

5.7.           Récupération et manipulation de données HTML, XML ou JSON.. 17

parseJson (s1). 17

hasField (o,s1). 17

get (o,s1). 17

jsonize (o). 18

parseHtml (s1). 18

select (o). 18

toString (o). 18

innerHtml (o). 18

htmlAttr (o,s1). 18

htmlText (o). 18

ownText (o). 18

 

 


 

1.   Syntaxe générale

Les expressions en GREL ne doivent pas être précédées d’un signe = pour être évaluées (contrairement aux formules Excel).

Le contenu de chaque cellule de la colonne en cours est accessible par le mot-clé value.

Le contenu des cellules des autres colonnes est accessible par le mot-clé cells suivi du nom de la colonne (deux syntaxes : cells['nom_colonne'] ou cells.nom_colonne)

 

Plusieurs valeurs peuvent être concaténées avec le signe + si au moins une des valeurs est de type textuel.

     Ex: "a"+"b" -> "ab"

     Ex: "a"+1 -> "a1"

     Ex: value +"c"

     Ex: value+" ;"+cells.colonne1 +" ;"+ cells.colonne2

Les valeurs numériques peuvent être additionnées, soustraites, multipliées, divisées avec les opérateurs +, -, *, /

     Ex : 1+2 -> 3

Deux valeurs peuvent être comparées avec les opérateurs ==, != (pour les nombres, chaînes, dates, booléens) et <, >, <=, >= (pour les nombres uniquement).

     Ex : "a"== "A" -> false

 

La manipulation des données se fait à l’aide de fonctions dont le nom est sensible aux majuscules et qui sont toujours suivies de parenthèses () même si elles ne demandent aucun paramètre.

Stricto sensu, le GREL distingue les « fonctions » et les « contrôles », qui peuvent être considérés comme un type particulier de fonctions servant à réaliser des tests (if, with, filter, forEach, forEachIndex, forRange, isBlank, isNonBlank, isNull, isNotNull, isNumeric, isError, forNonBlank) :

·      Les fonctions peuvent s’écrire de deux manières :

-       paramètre1.nom_de_la_fonction (paramètre2, paramètre3…). Ex: value.replace ("a","")

ou

-       nom_de_la_fonction (paramètres). Ex: trim (value, "a","")

·      Les contrôles ne peuvent s’écrire que sous la forme contrôle (paramètres). Ex : if (value == 1, "valeur vaut 1")

 

Pour construire des expressions complexes, la solution la plus simple consiste à passer le résultat d’une fonction en premier argument d’une autre fonction, en les chaînant avec des points :

     Ex: "a|b|a|c|b".split("|").uniques().sort(),join("/") -> "a/b/c" (découpe l’expression en utilisant un séparateur "|", supprime les doublons, trie par ordre alphabétique, rejoint le résultat en utilisant un séparateur "/")

Une autre solution consiste à enchâsser les fonctions les unes dans les autres. C’est la seule possibilité permise par les contrôles.

     Ex: join(sort(uniques(split("a|b|a|c|b","|"),"/") -> même résultat que plus haut

     Ex : if(length("ab") == 2, "ok", "ko")

 

2.   Types de données

2.1. Types de données utilisables dans la grille de données

La grille de données peut contenir six types de données, dont deux spéciaux.

Les quatre types de données ordinaires peuvent être créés lors d’un import ou par une expression, ou saisis manuellement :

·      chaîne de caractères (string) ; affiché en noir.

·      nombre (number) ; affiché en vert.

·      date (date) ; affiché en vert.

·      booléen (boolean): false / true ; affiché en vert.

Le type null peut être créé lors d’un import ou par une expression, mais pas saisi manuellement. Il désigne une absence de valeur (sur le même principe que NA en R). Par défaut les valeurs null sont invisibles et donc indissociables des chaînes vides, mais l’option Toutes > Aperçu > Afficher/masquer les valeurs nulles permet de les rendre visibles en gris : null (à partir d’OR 3.0).

 

Le type error est utilisé pour stocker un message d’erreur après une opération, uniquement si l’option « conserver l’erreur » est cochée dans l’éditeur de formule. L’erreur est affichée en rouge.

2.2. Remarques sur null et blank

Le type null est à distinguer de la valeur blank :

·      null est un type de donnée désignant l’absence de toute valeur.

·      blank est un mot-clé pouvant désigner une valeur de type null ou bien une chaîne de caractère vide "" (valeur de type string).

Dans une expression GREL, isBlank("") renverra true, isNull("") renverra false, isBlank(null) renverra true, isNull(null) renverra true. Dans les facettes la valeur (blank) correspond donc à la fois à des chaînes vides et à la valeur null. 

Le type null peut être utilisé dans une expression. Certaines opérations remplissent des cellules avec la valeur null : « Vider les cellules » et « Vider les valeurs répétées ».

Lors de l’import d’un fichier csv, une valeur absente (,,) sera analysée comme une cellule de type null. Le traitement d’une chaîne vide (,"",) dépendra de l’option « Analyser les cellules vides comme nulles ». Si l’option est activée (choix par défaut), la chaîne vide sera analysée comme une cellule de type null, sinon comme une cellule de type chaîne contenant une chaîne vide.

 

Le résultat d’une opération impliquant une valeur null sera null

Ex (si colnulle ne contient que des valeurs null) : 5+cells.colnulle.value -> null

Ex : "a"+cells.colnulle.value -> null

Il est possible d’utiliser les contrôles GREL isNull et isNonNull pour éviter ce comportement, par exemple en transformant la valeur null en une valeur exploitable (par ex. une chaîne vide).

Ex : "a" +if(isNull(cells.colnulle.value),v,"",v) -> "a"

Les contrôles isBlank, isNonBlank et forNonBlank (combinaison de if et de isNonBlank) fonctionnent de la même manière mais peuvent également servir à contourner la présence de chaînes vides.

Ex : "a" +if(isBlank(cells.colnulle.value),v,"VIDE",v) -> "aVIDE"

 

Depuis OR 3.0, la fonction coalesce() renvoie le premier de ses arguments non null.

Ex : coalesce(cells.colnulle.value,"a") -> "a"

Ex : coalesce(cells.colnonnulle.value,"a") -> contenu de colnonnulle

Ex : coalesce(cells.col1.value, cells.col2.value,cells.col1.value) -> contenu de col1, col2 ou col3 en fonction de leur contenu.

 

2.3. Type de données utilisables uniquement dans les formules

Le type tableau (array) peut être utilisé dans une formule, mais la grille de données ne peut pas stocker de tableau.

Dans l’éditeur de formule, les tableaux sont saisis sous forme de valeurs entre crochets séparées par de virgules.

     Ex : [7,3,5] -> 3 éléments : 7, 0 et 5.

Attention, confusion possible : une chaîne de caractère peut ressembler à un tableau si elle commence et se termine par des crochets.

3.   Structure des chaînes et tableaux

La structure interne des chaînes et des tableaux comporte des similarités : les caractères des chaînes peuvent être manipulés avec la même syntaxe que les éléments des tableaux.

Les caractères des chaînes et les éléments des tableaux sont numérotés à partir de 0. Ils peuvent être récupérés en utilisant la syntaxe variable[index].

     Ex : "abcd"[0] -> "a" (1er caractère, à l’index 0)

     Ex : "abcd"[2] -> "c" (3er caractère, à l’index 2)

     Ex : [7,3,5][0] -> 7 (1er élément du tableau, à l’index 0)

     Ex : [7,3,5][2] -> 5 (3e élément du tableau, à l’index 2)

Le dernier caractère ou le dernier élément est accessible à l’index -1.

     Ex : "abcd"[-1] -> "d" (dernier caractère, à l’index -1)

     Ex : [7,3,5][-1] -> 5 (dernier élément du tableau, à l’index -1)

Il est possible de récupérer un caractère ou un élément en comptant à l’envers à partir de l’élément -1.

     Ex : "abcd"[-2] -> "c" (avant-dernier caractère, à l’index -2)

     Ex : [7,3,5][-2] -> 3 (avant-dernier élément du tableau, à l’index -2)

 

Une sous-partie d’une chaîne ou d’un tableau peut être extraite en utilisant la syntaxe variable[index1,index2] (du caractère index1 au caractère précédent l’élément index2), ou à la fonction slice(), ou à la fonction substring() pour les chaînes. Pour extraire une sous-partie d’une chaîne ou d’un tableau allant d’un élément donné jusqu’au dernier élément (sans indiquer son index), il est nécessaire d’utiliser slice() ou substring() avec un argument unique.

     Ex : "abcd"[0,2] -> "ab" ; équivaut à "abcd".slice(0,2) et à "abcd".substring(0,2) : du caractère 0 à celui précédant le caractère 2, donc du caractère 0 au caractère 1

     Ex : "abcd"[0,4] -> "abcd" ; équivaut à "abcd".slice(0,4) et à "abcd".substring(0,4) : du caractère 0 à celui précédant le caractère 4, donc du caractère 0 au caractère 3

     Ex : "abcd"[1,-1] -> "bc" ; équivaut à "abcd".slice(1,-1) et à "abcd".substring(1,-1) : du caractère 1 à celui précédant le caractère -1, donc du caractère 1 à l’avant dernier caractère

     Ex : "abcd"[-2,-1] -> "c" ; équivaut à "abcd".slice(-2,-1) et à "abcd".substring(-2,-1) : de l’avant-dernier caractère à celui précédant le dernier caractère, donc isole l’avant-dernier caractère.

     Ex : [7,3,5][0,2] -> [7,3] ; équivaut à [7,3,5].slice(0,2) : de l’élément 0 à celui précédant l’élément 2, donc de l’index 0 à l’index 1

     Ex : [7,3,5][0,3] -> [7,3,5] ; équivaut à [7,3,5].slice(0,3) : de l’élément 0 à celui précédant l’élément 3, donc de l’index 0 à l’index 2

     Ex : [7,3,5][0,-1] -> [7,3] ; équivaut à [7,3,5].slice(0,-1) : de l’élément 0 à celui précédant le dernier élément, donc de l’index 0 à l’index 1

     Ex : [7,3,5][-2,-1] -> [3] ; équivaut à [7,3,5].slice(-2,-1) : de l’avant-dernier élément à celui précédant le dernier élément, donc isole l’avant-dernier élément.

     Ex : "abcd".slice(1) -> "bcd" (du caractère 1 au dernier caractère)

     Ex : "abcd".slice(-2) -> "bcd" (de l’avant-dernier au dernier caractère)

     Ex : [7,3,5].slice(1) -> [3,5] (de l’élément 1 au dernier élément)

     Ex : [7,3,5].slice(-2) -> [3,5] (de l’avant-dernier élément au dernier élément)

 

 

Les éléments d’un tableau peuvent être concaténés et convertis en chaîne avec la fonction join () :

     Ex : [a,3,5].join (‘/')-> "a/3/5"

Les éléments d’une chaîne peuvent être éclatées en tableau avec la fonction split () :

     Ex : "a/3/5".split(‘/’) -> [a,3,5]

4.   Variables internes

Des variables spéciales permettent d’accéder aux données d’un projet.

Cf. pour le détail https://github.com/OpenRefine/OpenRefine/wiki/Variables

Ces variables sont organisées hiérarchiquement. L’accès à une variables dépendant d’une variable d’un niveau supérieur se fait en utilisant la syntaxe niveau1.niveau2.niveau3. Mais dans certains cas des raccourcis permettent d’utiliser niveau2 ou niveau3 directement.

 

Schéma

 

·      La structure de base est la ligne (row). Un projet comprend 1 à N lignes ordonnées. Dans une formule, row désigne la ligne de la cellule à laquelle la formule est appliquée.

·      Chaque ligne est doté d’un numéro (row.index) et d’un contenu (row.cells abrégé en cells) composé d’une une suite horizontale de cellules réparties dans des colonnes dotées d’un nom.  Une cellule spécifique peut être retrouvée avec 'cells.nom_de_la_colonne' lorsque nom_de_la_colonne est un mot unique et avec 'cells.["nom de la colonne"]' s’il contient des espaces.

 

Exemple :

Données                                                                      Formules possibles

Auteur

Titre

Proust

A la recherche du temps perdu

Baudelaire

Les fleurs du mal

null

Le spleen de Paris

 

·      Une ou plusieurs lignes consécutives forment une « entrée » (record). Le regroupement de lignes dans une entrée est déclenché par la présence une valeur vide dans la 1re colonne (null ou chaîne vide). Dans une formule, row.record désigne l’entrée de la cellule à laquelle la formule est appliquée. Chaque entrée est dotée d’un numéro (index), d’un contenu (cells), et deux index délicats à manipuler (fromRowIndex et toRowIndex)

·      La formule row.record.cells permet d’accéder pour chaque colonne à un tableau contenant le contenu des cellules des lignes regroupées dans une même entrée. Chaque tableau peut être retrouvée avec 'row.record.cells.nom_de_la_colonne' lorsque nom_de_la_colonne est un mot unique et avec 'row.record.cells.["nom de la colonne"]' dans les autres cas.

 

Exemple :

Données                                                                      Formules possibles

Auteur

Titre

Proust

A la recherche du temps perdu

Baudelaire

Les fleurs du mal

null

Le spleen de Paris

 

·      fromRowIndex  indique la ligne du projet correspondant à la première ligne de l’entrée.  toRowIndex  indique la ligne du projet suivant la dernière ligne de l’entrée. La formule row.record.toRowIndex - row.record.fromRowIndex donne donc le nombre de lignes de l’entrée.

 

Exemple :

Données                                                                      Formules possibles

Auteur

Titre

Proust

A la recherche du temps perdu

Baudelaire

Les fleurs du mal

null

Le spleen de Paris

 

·      Chaque cellule (cell) est dotée d’une valeur (cell.value, abrégé en value) et d’informations de réconciliation (cell.recon). Dans une formule, cell désigne la cellule à laquelle la formule est appliquée.

·      Les informations de réconciliation recon comprennent 5 champs :’judgment', ‘match', ‘best', 'features', 'candidates'. match comprend notamment un champ id contenant l’identifiant de l’entité dans le référentiel utilisé, et un champ name contenant son nom. L’identifiant est donc récupérable avec la formule cells.recon.match.id.

5.   Liste de toutes les fonctions GREL

Convention : pour chaque fonction les paramètres possibles sont indiqués par une combinaison de lettre et de chiffres : s… désigne un paramètre de type chaîne (string), n… de type nombre (number), d… de type date, a… de type tableau (array), m… de type expression régulière.

Objets complexes : o ; éléments :e

s1, n1, d1 ou a1 désignent le premier paramètre, qui peut être utilisé sous la forme s1.fonction() ou fonction(s1). Les paramètres suivants s’ils sont possibles sont désignés par s2, n2, d2, a2, etc. Les paramètres facultatifs sont encadrés de crochets carrés [].

Certaines fonctions sont utilisables avec plusieurs types de paramètres. Pour clarifier la présentation, elles sont mentionnées plusieurs fois même s’il s’agit d’une fonction unique (ex : length).

 

5.1. Fonctions générales

5.1.1.     Détection et conversion de types

Type (e)

Renvoie le type de l’expression e : string, number, date, array, undefined (pour null), types spéciaux pour les objets JSON et HTML et les variables internes.

Ex : "a".type() ->        string

toDate (e, [b1 ou s1,s2…])

Renvoie l’expression e (chaîne) convertie en date.  L’option b1 vaut true si e contient le mois avant le jour (valeur par défaut), et false sinon. Les options s1, s2 etc. permettent de définir une syntaxe plus complexe en suivant http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html.

     Ex : "1802-01-02".toDate()                   ->   [date 1802-01-02T00:00:00Z]

     Ex : "1802-01-02".toDate(false)             ->   [date 1802-02-01T00:00:00Z]

     Ex : "20379". toDate("dMMyy")             ->   [date 1979-03-02T00:00:00Z]

toString (e, [s1])

Renvoie l’expression e (nombre, date, objet JSON, objet HTML, mais pas tableau) convertie en chaîne.  s1 peut contenir des options de formatage

     Ex : 1.toString()                                 ->   "1"

     Ex : toDate(1802).toString("yyyy")         ->   "1801" (pour 1801-12-31)

 

toNumber (e)

Renvoie l’expression e (chaîne) convertie en nombre.

     Ex : "09".toNumber                             ->   9

 

isBlank (e), isNonBlank (e), isNull (e), isNotNull (e), isNumeric (e), isError (e)

Renvoie un booléen en fonction du type du paramètre e.

     Ex: isBlank("")                                   ->   true

     Ex: isNull("")                                     ->   false

     Ex: isNumeric(2)                                ->   true

     Ex: isError(1 / 0)-> true

"Blank" désigne à la fois la valeur Null et les chaînes de caractères vides.

coalesce (e1,[e2,e3…])

Renvoie le premier de ses arguments non null.

     coalesce(value,"a")                            ->   "a" si value vaut null, sinon value

5.1.2.     Choix

if (e, x, y)

Renvoie la valeur x si l’expression e est vraie, sinon renvoie y

     Ex : if (value.length > 10, "long", "court") ->   "long" si value fait plus de 10 caractères, sinon "court"

forNonBlank (e,val,x,y)

combine if() et isNonBlank() : teste si l’expression e renvoie une valeur vide ; si ce n’est pas le cas, copie le résultat de e dans la variable v, et renvoie l’expression x ; sinon renvoie l’expression y.

     forNonBlank("", val, "1re variable :"+val, "1re variable vide")     ->         "1re variable vide"

     forNonBlank([], val, "1re variable :"+val, "1re variable vide")      ->         "1re variable vide"

5.1.3.     Enchaînement d’expressions

with (e1,val,e2)

Renvoie le résultat de l’expression e2, qui peut exploiter le résultat de l’expression e1 en utilisant la variable val. Utile si les syntaxes e1.e2() ou e2(e1) ne sont pas suffisantes.

     with ("ab", val, length(val))                   2    (équivaut à "ab".length())

     with ("ab", val, length(val+val))              4

5.1.4.     Opérateurs booléens

and (b1, b2, b3…) 

ET entre plusieurs expressions renvoyant une valeur booléenne

     Ex : and (1 < 3, 1 > 0)                         ->   true (les 2 expressions sont vraies)

or (b1, b2, b3…)

OU entre plusieurs expressions renvoyant une valeur booléenne

     Ex : or (1 < 3, 1 < 0)                           ->   true (la 1re expression est vraie)

xor (b1, b2, b3…) 

OU exclusif entre plusieurs expressions renvoyant une valeur booléenne

     Ex : or (1 < 3, 1 < 2)                           ->   false (plus d’une expression est vraie)

not (b1)

NON sur une expression renvoyant une valeur booléenne

     Ex : not (1 < 3)                                  ->   false

5.1.5.     Facettes

facetCount (e, s1, s2)

Renvoie le nombre d’occurrence correspondant à l’évaluation de l’expression e dans la colonne s2 s1 doit contenir e entre "". Si e vaut value, compte les occurrences de chaque valeur de s2 (équivalent de COUNTIF dans Excel).

 

Exemple :

col

Formule :

facetCount (value,"value","col")

Formule :

facetCount(value.length(),"value.length()","col")

 

a

2

3

b

1

3

a

2

3

bb

1

2

cc

1

2

 

5.1.6.     Croisement de données

cross (c, s1, s2)

Permet de croiser deux projets : renvoie un tableau de 0, 1 ou plus objets de type row du projet s1 pour lesquelles les cellules de la colonne s2 correspondent à la valeur c. c est soit un objet de type cell soit une chaîne. Renvoie null si la valeur cherchée est null, ou si elle n’a pas d’équivalent dans la colonne s2 du projet s1.

 

Exemple :

Projet « personnes »

Nom

prenom

naissance

De Staël

Nicolas

1913

Delacroix

Eugène

1798

Null

 

Inconnu

De Staël

Germaine

1766

 

Projet « oeuvres »

oeuvre

auteur

Formule

cells.auteur.value.cross("personnes","nom").cells. naissance.value

ou

cells.auteur.cross("personnes","nom").cells. naissance.value

Formule

"Delacroix".cross("personnes","nom").cells. naissance.value

 

De l’Allemagne

De Stael

[1913,1766]

[1798]

La liberté guidant le peuple

Delacroix

[1798]

[1798]

Les footballeurs

De Stael

[1913,1766]

[1798]

Les fleurs du mal

Baudelaire

null

[1798]

Titre anonyme

null

null

[1798]

 

5.2. Manipulation de chaînes

5.2.1.     Encodage de caractères

escape (s1,s2)

Renvoie s1 après remplacement des caractères interdits dans la syntaxe définie par s2 (‘xml’, ‘html’, ‘url’, ‘csv’, ‘javascript’) par des caractères spéciaux. Utilisé notamment pour encoder les paramètres avant une requête en remplaçant les caractères interdits dans les URL.

     Ex: escape("le paramètre", 'url’)            ->   le+param%C3%A8tre

     Ex: escape("le paramètre", ‘html’)          ->   le%20param&egrave;tre

     Ex: escape("le paramètre", ‘javascript’)   ->   le param\u00E8tre

unescape (s1,s2)

Renvoie s1 après remplacement des caractères spéciaux définis par s2 (‘xml’, ‘html’, ‘url’, ‘csv’, ‘javascript’) par des caractères ordinaires. Utilisé notamment pour transformer en chaîne ordinaire du contenu HTML.

     Ex: unescape("le%20param%C3%A8tre", 'url’)          ->         le paramètre

     Ex: unescape("le%20param&egrave;tre ", ‘html’)        ->         le paramètre

     Ex: unescape("le param\u00E8tre", ‘javascript’)         ->         le paramètre

      

reinterpret (s1, s2, [s3])

Renvoie la chaîne s1 décodée selon l’encodage de caractères s3 et réencodée avec l’encodage s2. Si s3 est absent, l’encodage par défaut du projet est utilisé.

     Ex : "é".reinterpret("utf8","iso-8859-1") ->   "é"

     Ex : "€".reinterpret("iso-8859-1","iso-8859-15") -> ¤

5.2.2.     Fonction utilisées pour la clusterisation

La plupart de ces fonctions sont très rarement utilisées manuellement dans des formules.

ngram (s1,n1)

Renvoie un tableau comprenant des suites de n1 mots extraits de s1.

     Ex : ngram("lundi Mardi mercredi jeudi",1)     ->         [ "lundi", "Mardi", "mercredi", "jeudi" ]

     Ex : ngram("lundi Mardi mercredi jeudi",2)     ->         [ "lundi Mardi", "mardi mercredi", "mercredi jeudi" ]

     Ex : ngram("lundi Mardi mercredi jeudi",3)     ->         [ "lundi Mardi mercredi", "mardi mercredi jeudi" ]

     Ex : ngram("lundi Mardi mercredi jeudi",4)     ->         [ "lundi  Mardi mercredi jeudi" ]

ngramFingerprint (s1,n1)

Renvoie une chaîne comprenant des chaînes de n1 caractères extraits de s1, ordonnées alphabétiquement, normalisées et concaténées.

     Ex : ngramFingerprint("ab aBa cba",1)   ->   "abc"

     Ex : ngramFingerprint("ab aBa cba",2)   ->   "abacbacb"

phonetic (s1,[s2])

Renvoie un représentation phonétique simplifiée de la chaîne s1 en utilisant l’algorithme s2 (metaphone, metaphone2, metaphone3 – par défaut –, cologne, soundex)

     Ex: "school".phonetic()                        ->   "SKL"

fingerprint (s1)

Renvoie l’ « empreinte » de s1 : suppression de la ponctuation > simplification des espaces > tri > suppression des redondances.

     Ex: fingerprint("b a.a a     d. b B B, d â")  ->   "a aa b d"

md5 (s1)

Renvoie la checksum de s1 selon l’algorithme MD5.

     Ex: "ab".md5()                                   ->   187ef4436122d1cc2f40dc2b92f0eba0

sha1 (s1)

Renvoie la checksum de s1 selon l’algorithme SHA1.

     Ex: "ab".sha1()                                  ->   da23614e02469a0d7c7bd1bdab5c9c474b1904dc

unicode (s1)

Renvoie un tableau indiquant le codepoint Unicode de chaque caractère de la chaîne s1.

     Ex: "Aé€".unicode()                            ->   [65,233,8364]

unicodeType (s1)

Renvoie un tableau indiquant le type de symbole Unicode de chaque caractère de la chaîne s1.

     Ex: "Aé€".unicodeType()                     ->   [ "uppercase letter", "lowercase letter", "currency symbol" ]

 

5.2.3.     Tests sur les chaînes

startsWith (s1,s2)

Renvoie une valeur booléenne indiquant si la chaîne s1 commence par la chaîne s2. Sensible à la casse et aux accents. Si s2 est vide, renvoie true.

     Ex: "école".startWith("le")                    ->   false

     Ex: "école".startWith("éc")                    ->   true

endsWith (s1,s2)

Renvoie une valeur booléenne indiquant si la chaîne s1 se termine par la chaîne s2. Sensible à la casse et aux accents. Si s2 est vide, renvoie true.

     Ex: "école".endsWith("le")                    ->   true

     Ex: "école".endsWith("éc")                   ->   false

contains (s1,s2)

Renvoie une valeur booléenne indiquant si la chaîne s1 contient la chaîne s2. Sensible à la casse et aux accents. Si s2 est vide, renvoie true.

     Ex: "école".contains("co")                    ->   true

5.2.4.     Modifications globales et troncature

chomp (s1, s2)

Si la chaîne s1 se termine par la chaîne s2, renvoie la partie de s1 tronquée de s2. Sinon renvoie s1.

     Ex: "école".chomp("le")                       ->   "éco"

     Ex: "école".chomp("les")                      ->   "école"

trim (s)

Renvoie la chaîne s sans les éventuels espaces initiaux et finaux.

     Ex: " école     ".trim()                           ->   "école"

toUppercase (s)

Renvoie la chaîne s en majuscules (y compris les lettres accentuées).

     Ex: "école".toUppercase()                    ->   "ÉCOLE"

toLowercase (s1)

Renvoie la chaîne s en minuscules (y compris les lettres accentuées).

     Ex: "ÉCOLE".toLowercase ()                ->   "école"

toTitlecase (s1)

Renvoie la chaîne s en minuscules mais avec la première lettre de chaque mot en majuscule.

     Ex: "éCole".toLowercase ()                  ->   "École"

5.2.5.     Comparaisons, découpage, remplacement

indexOf (s1,s2)

Renvoie la position de la 1re occurrence de la chaîne s2 dans la chaîne s1 ; renvoie -1 si s1 ne contient pas s2. (Attention, la numérotation commence à 0)

     Ex: "abab".indexOf ("ab")                     ->   0

     Ex: "abab".indexOf ("b")                      ->   1

     Ex: "abab".indexOf ("ac")                     ->   -1

diff (s1,s2)

Renvoie la portion de la chaîne s2 commençant au premier caractère de s2 différent du caractère s1 de même position.

     Ex: "azerty".indexOf ("azErtyuiop")        ->   "Ertyuiop"

     Ex: "azerty".indexOf ("azertyuiop")         ->   "uiop"

     Ex: "azerty".indexOf ("azerty")              ->   ""

     Ex: "azerty".indexOf ("az")                   ->   ""

find (s1,m1) ou (s1,s2)

Renvoie un tableau contenant les parties de la chaîne s1 correspondant à toutes les occurrences du motif d’expression régulière m1 ou de la chaîne s2 dans s1. Renvoie un tableau vide si aucune partie de s ne correspond à m1 ou s2.

Le motif n’a pas besoin de correspondre à l’ensemble de la chaîne, contrairement à match().

     Ex: find("test1 1234 ou test2 56 _test3",/\b(test.|\d{2})\b/)         ->         [ "test1", "test2", "56" ]

lastIndexOf (s1,s2)

Renvoie la position de la dernière occurrence de la chaîne s2 dans la chaîne s1 ; renvoie -1 si s1 ne contient pas s2. (Attention, la numérotation commence à 0)

     Ex: "abab".lastIndexOf ("ab")                ->   2

     Ex: "abab".lastIndexOf ("b")                 ->   3

     Ex: "abab".lastIndexOf ("ac")                ->   -1

length (s1)

Renvoie la longueur de la chaîne s1.

     Ex: "école".length()                             ->   5

match (s1,m1)

Renvoie un tableau contenant les parties de la chaîne s1 correspondant au motif d’expression régulière m1. Renvoie null si aucune partie de s ne correspond au motif.

Le motif doit contenir des parenthèses () pour définir le(s) groupe(s) à capturer, sinon match renvoie un tableau vide. Le motif doit correspondre à l’ensemble de la chaîne s1, sans troncature implicite à droite ni à gauche.

     Ex : match("abc", /(a.c)/)                      ->   ["abc"]

     Ex : match("azc", /(a.c)/)                      ->   ["azc"]

     Ex : match("x123x456x", /.*?([0-9]{3}).*/) ->   ["123"]

     Ex : match("x123x456x", /.*?([0-9]{3}).*?([0-9]{3}).*/)   ->         ["123","456"]

partition (s1,s2,[omitFragment])

Décompose la chaîne s1 en en un tableau de 3 chaînes, en utilisant la chaîne s2 comme séparateur. Le 1er élément sera la partie de s1 précédant la 1re occurrence du séparateur, le 2e sera le séparateur, le 3e sera la partie de s1 suivant le séparateur. s2 peut être une chaîne ou une expression régulière. L’option omitFragment est un booléen et vaut false par défaut. Si elle vaut true, le séparateur n’est pas retourné dans le tableau, qui ne comportera que 2 chaînes.

     Ex :  partition("ab--cd--ef","--")              ->   ["ab","--","cd--ef"]

     Ex :  partition("ab--cd--ef ","--",true)        ->   ["ab","cd--ef"]

     Ex :  partition("ab--cd--ef",/[-_]+/)           ->   ["ab","--","cd--ef"]

rpartition (s1,s2,[omitFragment])

Décompose la chaîne s1 en un tableau de 3 chaînes, en utilisant la chaîne s2 comme séparateur. Le 1er élément sera la partie de s1 précédant la dernière occurrence du séparateur, le 2e sera le séparateur, le 3e sera la partie de s1 suivant le séparateur. s2 peut être une chaîne ou une expression régulière. L’option omitFragment est un booléen et vaut false par défaut. Si elle vaut true, le séparateur n’est pas retourné dans le tableau, qui ne comportera que 2 chaînes.

     Ex :  rpartition("ab--cd--ef","--")             ->   ["ab--cd","--","ef"]

     Ex :  rpartition("ab--cd--ef ","--",true)       ->   ["ab--cd","ef"]

     Ex :  rpartition("ab--cd--ef",/[-_]+/)          ->   ["ab--cd","--","ef"]

smartSplit (s1,[s2])

Renvoie un tableau de chaînes obtenu en découpant la chaîne s1 avec le séparateur s2. s2 doit être une chaîne et non une expression régulière. Si s2 est omis et que s1 contient des tabulations, les tabulations sont utilisées comme séparateurs, sinon les virgules. Les guillemets sont gérés comme lors de la lecture d’un fichier CSV.

     Ex : "01,02,03,04".smartSplit()              ->   [ "01", "02", "03", "04" ]

     Ex : ",01,02,03,04,".smartSplit()            ->   [ "", "01", "02", "03", "04","" ]

     Ex : ‘01,"02,03",04".smartSplit()            ->   [ "01", "02,03", "04" ]

split (s1,s2,[preserveAllTokens])

Renvoie un tableau de chaînes obtenu en découpant la chaîne s1 avec le séparateur s2. s2 peut être une chaîne ou une expression régulière. L’option preserveAllTokens est un booléen qui vaut false par défaut. Elle ne fonctionne que si s2 est une chaîne ordinaire et non une expression régulière. Si elle vaut true, les chaînes vides sont préservées dans le tableau final, sinon elles sont supprimées.

Remarques : Si s2 est une expression régulière vide //, split renvoie un tableau comprenant tous les caractères de s1. split supprime également s2 si s2 est présent au début ou à la fin de s1. Dans ce cas,

Si s2 est présente au début ou à la fin de s1, split tronque s1 de s2 à gauche ou à droite, et ajoute une chaîne vide au début ou à la fin du tableau (uniquement au début si s2 est une expression régulière).

     Ex : "01-12-2015".split("-")[2]                ->   "2015" (3er élément du tableau ["01","12","2015"])

     Ex : "01-12-2015".split(/[12]-/)               ->   [ "0", "1", "2015" ]

     Ex : "01-12-2015".split(//)                     ->   [ "0", "1", "-", "1", "2", "-", "2", "0", "1", "5" ]

     Ex : "0--1".split("-")                             ->   [ "0",  "1" ]

     Ex : "0--1".split("-",true)                       ->   [ "0", "","1" ]

     Ex : "-ab--cde-".split("-")                      ->   ["ab","cde",""]

     Ex : "-ab--cde-".split("-",true)                ->   ["","ab","","cde",""]

     Ex : "-ab--cde-".split(/-/)                       ->   ["", "ab", "", "cde" ]

splitByLengths (s1,n1,n2,…)

Renvoie un tableau de chaînes issues de la décomposition de la chaîne s1 en segments de longueur n1, n2, n3…

     Ex : "01/12/2015".splitByLengths(2,3,5)  ->   ['01','/12','/2015']

splitByChartype (s1)

Renvoie un tableau de chaînes issues de la décomposition de la chaîne s1 en segments de caractères partageant le même type unicode (majuscules latines, minuscules latines, ponctuation....).

     Ex "aztéèAZÔ$€£+-`/:.!;@'?,&*%").splitByCharType -> [ "aztéè", "AZÔ", "$\u20ac£", "+", "-", "`", "/:.!;@'?,&*%" ]

substring (s, n1[,n2])

Equivalent de slice(s,n1[,n2]) ou bien directement de s[n1,n2].

Extrait les caractères de la chaîne s entre les positions n1 et n2 (Attention, la numérotation commence à 0 et la position n2 est exclue). Si n2 est absent, extrait les éléments de n1 jusqu’au dernier.

     Ex: "bleu".substring(1,3)                      ->   "le" (du caractère 1 au caractère 2 inclus)

     Ex : "bleu"[1,3]                                  ->   idem

     Ex : "bleu".substring(1)                        ->   "leu" (du caractère 1 au dernier caractère inclus)

replace (s1, s2,s3)

Dans la chaîne s1, remplace la chaîne s2 par la chaîne s3. s2 peut être une expression régulière. Si s2 est une chaîne, deux valeurs spéciales sont utilisables : \n (saut de ligne) et \t (tabulation), et les \ doivent être doublés en \\ (sous peine d’erreur). Si s2 est une expression régulière et contient des groupes capturés avec (), les groupes peuvent être utilisés dans s3 avec $0, $1, $2...

     Ex : "abCDab".replace ("ab","X")           ->   "XCDX"

     Ex : "ab\CDab".replace ("ab\\","X")        ->   "XCDab"

     Ex : "ab[tab]CDab".replace ("ab\t","X")   ->   "XCDab"

     Ex : "abCDab".replace (/[ba]{2}/,"X")      ->   "XCDX"

     Ex : "-bc1-bc2-de3-".replace(/.*(bc.).*(de.).*/,"")          -> ""

     Ex : "-bc1-bc2-de3-".replace(/.*(bc.).*(de.).*/,"$0")      -> "-bc1-bc2-de3-"

     Ex : "-bc1-bc2-de3-".replace(/.*(bc.).*(de.).*/,"$1+$2") -> "bc2+bc2" (dernière occurrence du motif 1)

     Ex : "-bc1-bc2-de3-".replace(/.*(bc.).*(de.).*/,"$2+$2") -> "de3+de3" (occurrence du motif 2)

 

replaceChars (s1,s2,s3)

Dans la chaîne s1, remplace chaque caractère contenu dans s2 par le caractère occupant la même position dans s3. Si des caractères de s2 n’ont pas d’équivalent dans s3, ils sont supprimés.

     Ex : "abCbDab".replaceChars ("ab","op") ->   ""opCpDop"

     Ex : "abCbDab".replaceChars ("ab","o")  ->   ""oCDo"

 

5.3. Manipulation de tableaux

range (n1,[n2,[n3]]) ou (s1,[s2,[s3]])

Renvoie un tableau comprenant une suite d’entiers. Si n2 est absent, la suite va de 0 à n1 inclus. Sinon, elle va de n1 à n2 (exclu), avec un incrément de n3 entre chaque nombre. Par défaut n3 vaut 1.

Le fonctionnement est identique si les entiers sont remplacés par des chaînes ou par une chaîne unique avec une virgule séparant chaque chiffre.

     Ex : range(4,40,10)                            ->   [4,14,24,34]

     Ex : range(4,10)                                ->   [4,5,6,7,8,9]

     Ex : range(4)                                     ->   [0,1,2,4]

     Ex : range("4,40,10")                          ->   [4,14,24,34]

     Ex : range("4","10")                            ->   [4,5,6,7,8,9]

     Ex : range("4")                                   ->   [0,1,2,4]

length (a1)

Renvoie le nombre d’éléments du tableau a1

     Ex : [7,3,5,2].length()                          ->   4

slice (a1,n1,[n2])

Renvoie tableau comprenant les éléments du tableau a1 entre les positions n1 et n2 (Attention, la numérotation commence à 0 et la position n2 est exclue). Si n2 est absent, extrait les éléments de n1 jusqu’au dernier.

     Ex : [7,3,5,4].splice(1,3)                      ->   [3,5] (de l’élément 1 à l’élément 2 inclus)

     Ex : [7,3,5,4].splice(1)                         ->   [3,5,4] (de l’élément 1 au dernier élément inclus)

join (a1,s1)

Renvoie une chaîne concaténant les éléments du tableau a1 en utilisant la chaîne s1 comme séparateur

     Ex : join (["01","12","2015"], ":")             ->   "01:12:2015"

sort (a1)

Renvoie le tableau a1 trié par ordre croissant. Les éléments doivent être de même type : nombre, texte, date.

     Ex : sort ([2,3,0])                                ->   [0,2,3]

     Ex : sort (["c","z","a","", "é"])                 ->   ["","a","b","c","é"]

reverse (a1)

Renvoie le tableau a1 en inversant l’ordre des éléments.

     Ex : reverse([2,3,"a"])                          ->   ["a",3,2]

uniques (a1)

Renvoie un tableau contenant les valeurs distinctes (non triées) du tableau a1.

     Ex : uniques([ 2, 1, "a",2, 0, 2,"a"])         ->   [2,"a", 0]

 

5.4. Fonctions mathématiques

Ces fonctions sont très peu utilisées.

5.4.1.     Arrondis

abs (n1)

Renvoie la valeur absolue du nombre n1.

round (n1)

Renvoie le nombre entier le plus proche de n1 (avec 0.5 arrondi à 1).

ceil (n1)

Renvoie le nombre entier inférieur à n1.

floor (n1)

Renvoie le nombre entier supérieur à n1.

even (n1)

Si n1 est entier et pair, renvoie n1, sinon renvoie le nombre pair immédiatement supérieur.

odd (n1)

Si n1 est entier et impair, renvoie n1, sinon renvoie le nombre impair immédiatement supérieur.

mod (n1,n2)

Renvoie le reste de la division de n1 par n2.

quotient (n1,n2)

Renvoie la partie exacte de la division de n1 par n2.

max (n1,n2)

Renvoie le plus grand de deux nombres n1 et n2.

min (n1,n2)

Renvoie le plus petit de deux nombres n1 et n2.

log (n1)

Renvoie le logarithme décimal de n1.

ln (n1)

Renvoie le logarithme néperien de n1.

pow (n1,n2)

Renvoie le n1 à la puissance n2.

exp (n1)

Renvoie l’exponentielle de n1 (en1)

sum (t1)

Renvoie la somme d’un tableau de nombres.

     Ex : [10,0,-10,55]                               ->   55

fact (n1)

Renvoie la factorielle de n1 (jusqu’à 20!).

fact (n1,2)

Renvoie la multifactorielle de n1 avec un pas de n2.

combin (n1,n2)

Renvoie le nombre de combinaisons (sans répétition) de n2 éléments dans un ensemble de n1 éléments.

degrees (n1)

Renvoie le un angle n1 converti de radians en degrés.

radians (n1)

Renvoie le un angle n1 converti de degrés en radians.

gcd (n1,n2)

Renvoie le plus grand diviseur commun de deux nombres.

lcm (n1,n2)

Renvoie le plus petit multiple commun de deux nombres.

multinomial (n1,n2...)

Renvoie la factorielle de la somme d’une série de nombre divisée par le produit des factorielles de chaque nombre.

5.4.2.     Fonctions trigonométriques

cos, sin, tan, cosh, sinh, tanh, acos, asin, atan, atan2

5.5. Manipulation de dates

datePart (d1,s1)

Renvoie u nombre correspondant à la composante de la date d1 définie par s1 (« hours », « minutes », « seconds », « years », « months », « days »)

     Ex : datePart(2018-11-04T1406:59Z,1,"years")          ->         2018

now ()

Renvoie un objet de type date contenant la date et l’heure d’exécution. now() est la seule fonction GREL à ne prendre aucun argument.

     Ex : now()                                        ->   2018-11-04T1406:59Z

inc (d1,n1,s1)

Renvoie un objet date correspondant à la date d1 modifiée de n1 unités de temps définies par s1 (« hours » par défaut ; « minutes », « seconds », « years », « months », « days »)

     Ex : inc(2018-11-04T1406:59Z,1,"years")      ->         2019-11-04T1406:59Z

     Ex : inc(2018-11-04T1406:59Z,-2,"months")  ->         2018-09-04T1406:59Z

diff (d1,d2,s1)

Renvoie la différence entre deux dates d1 et d2 dans une unité de temps.

     Ex: diff(now(),inc(now(),1,"days"),"hours")     ->         -24

5.6. Itérations et filtres

Remarque : index et val sont employé ici par convention. N’importe quel nom de variable pourrait être utilisé.

forEach (a1,val,f)

Applique une fonction f à chaque élément du tableau a1, et renvoie le résultat sous forme d’un nouveau tableau. La valeur de chaque élément est utilisable par f au moyen de val.

     Ex : forEach(["01","12","2015"], val, val)  ->   [ "01", "12", "2015" ]

     Ex : forEach(["01","12","2015"], val, length(val))         ->         [2,2,4]

forEachIndex (a1,index,val,f)

Applique une fonction f à chaque élément e du tableau a1, et renvoie le résultat sous forme d’un nouveau tableau. La valeur de chaque élément et son indice sont utilisables par f au moyen de val et index.

     Ex : forEachIndex(["01","12","2015"], index, val, val)   ->         [ "01", "12", "2015" ]

     Ex : forEachIndex(["01","12","2015"], index, val, index) ->         [ 0, 1, 2]

     Ex : forEachIndex(["01","12","2015"], index, val, index+":"+val)  ->         [ "0:01", "1:01", "2:2015"]

forRange (n1,n2,n3,val,f) 

Construit une suite de nombre allant de n1 à n2 (exclu) avec un pas de n3, applique la fonction f à chaque élément val de la suite, et renvoie le résultat dans un tableau. Combinaison de range() et forEach().

     Ex : forRange(1,8,2,val,val)                  ->   [ 1, 3, 5, 7 ]

     Ex : forRange(1,8,2,val,toString(val*10)) ->   [ "10", "30", "50", "70" ]

filter (a1,val,f)

Applique une fonction f à chaque élément val du tableau a1, évalue le résultat, et ajoute val dans un nouveau tableau si le résultat de f vaut true.

     Ex: filter([3, 4, 8, 7, 9] , val, mod(val, 2) == 0) ->          [ 4, 8 ]

     Ex: filter(["abc","def"] , val, length(val) >3)     ->          [ ]

 

5.7. Récupération et manipulation de données HTML, XML ou JSON

parseJson (s1) 

analyse la chaîne s1 contenant des données JSON et renvoie un objet manipulable avec get() ou la syntaxe [clé].

     Ex : '{"a":10, "b":["x","y"], "c":{"d":20}}'.parseJson()         ->         {"a":10, "b":["x","y"],"c":{"d":20}}}

     Ex : '{"a":10, "b":["x","y"], "c":{"d":20}}'.parseJson()["c"]["d"]          ->         20

     Ex : '{"a":10, "b":["x","y"], "c":{"d":20}}'.parseJson().get("c").get("d")            ->         20

hasField (o,s1)

Si o est un objet comprenant des champs (objet JSON ou variable interne à Openrefine) et disposant d’un champ s1, renvoie true, sinon false.

     Ex : '{"a":10}'.parseJson().hasField("a")    ->   true

     Ex : '{"a":10}'.parseJson().hasField("b")    ->   false

     Ex : 'x’.hasField("b")                            ->   false

     Ex : row.hasField("cells")                      ->   true

get (o,s1)

Si o est un objet comprenant des champs (objet JSON ou variable interne à Openrefine), et disposant d’un champ s1, renvoie la valeur du champ s1. Sinon renvoie null.

     Ex : '{"a":10}'.parseJson().get("a")           ->   10

     Ex : row.get("cells")                             ->   [object CellTuple]

jsonize (o)

Renvoie une chaîne interprétable comme une valeur JSON littérale, à partir d’une variable o pouvant être une chaîne, un nombre, un booléen, un tableau, un objet JSON.

     Ex : "a"'. jsonize()                                                  ->     ""a""

     Ex : '{a:10, b:["x","y"],c:{d:20}}'.parseJson().jsonize()              ->              '{"a":10, "b":["x","y"],"c":{"d":20}}'

parseHtml (s1)

Analyse la chaîne s1 contenant des données HTML ou XML et renvoie un objet spécial manipulable avec les fonctions spécialisées dans le traitement du HTML. Le nom des balises est passé en minuscules ; les balises fermantes manquantes sont rajoutées ; les caractères spéciaux sont remplacés par des entités HTML. Si la chaîne n’est pas un document HTML valide, des balises html, head et body sont ajoutées. Ce traitement est également réalisé sur les documents XML.

     Ex: "<P>abc éàçèù§&<>".parseHtml()    ->   <html> <head></head><body><p>abc &eacute;&agrave;&ccedil;&egrave;&ugrave;&sect;&amp;&lt;&gt;</p></body></html>

     Ex : "<book><title>titre</title></book>".parseHtml() -> <html> <head></head> <body> <p>p1</p> <div> <p>p2</p> <p>p3</p> </div> </body> </html>

select (o)

Opère une sélection sur un objet HTML ou XML renvoyé par parseHtml, en utilisant la syntaxe des sélecteurs jsoup, et renvoie un tableau contenant des objets HTML ou XML.

     Ex: "<p>p1</p><div><p>p2</p><p>p3</p></div>".parseHtml().select("div p")      ->         [<p>p2</p>,<p>p3</p>]

     Ex: "<book><title>titre1</title></book>"<book><title>titre2</title></book>".parseHtml().select("book title ")    ->         [<title>titre1</title>,<title>titre2</title>]

toString (o)

Renvoie un objet HTML ou XML transformé en chaîne. Ne peut s’appliquer qu’à un élément et non à un tableau.

     Ex: "<a href=lien.fr>lien</a>".parseHtml().select("a")[0].toString()           ->              "<a href=lien.fr>lien</a>"

innerHtml (o)

Renvoie l’intérieur d’un objet HTML ou XML (texte ou éléments enfants). Ne peut s’appliquer qu’à un élément et non à un tableau.

     Ex: "<a href=lien.fr>lien</a>".parseHtml().select("a")[0].innerHtml()         ->              "lien"

     Ex : "<p><a href=lien.fr>lien</a><p>".parseHtml().select("p")[0].innerHtml()          ->         "<a href=lien.fr>lien</a>"

htmlAttr (o,s1)

Renvoie la valeur de l’attribut s1 d’un objet HTML ou XML. Ne peut s’appliquer qu’à un élément et non à un tableau.

     Ex : "<a href=lien.fr>lien</a>".parseHtml().select("a")[0].htmlAttr("href")   ->         "lien.fr"

htmlText (o)

Renvoie le texte contenu dans un objet HTML ou XML, en incluant ses éléments enfants. Ne peut s’appliquer qu’à un élément et non à un tableau.

     Ex : "<p><a href=lien.fr>lien</a><p>".parseHtml().select("p")[0].htmlText()           ->         "lien"

ownText (o)

Renvoie le texte contenu dans un objet HTML ou XML, sans inclure ses éléments enfants. Ne peut s’appliquer qu’à un élément et non à un tableau.

     Ex : "<p><a href=lien.fr>lien</a><p>".parseHtml().select("p")[0].ownText()           ->         ""

     Ex : "<p><a href=lien.fr>lien</a><p>".parseHtml().select("a")[0].ownText()           ->         "lien"