Passa al contenuto principale

2.5. Segments (Segmenti)

2.5. Segments (Segmenti)​

Per ciascun nodo in una nodelist di input, i segmenti applicano uno o più selettori al nodo e concatenano i risultati di ciascun selettore in nodelist per nodo di input, che sono poi concatenate nell'ordine della nodelist di input per formare una singola nodelist risultante del segmento.

Risulta che più segmenti ci sono in un'interrogazione, maggiore è la profondità nel valore di input dei nodi della nodelist risultante:

  • Un'interrogazione con N segmenti, dove N >= 0, produce una nodelist

costituita da nodi a profondità nel valore di input di N o maggiore.

  • Un'interrogazione con N segmenti, dove N >= 0, tutti child segment

(Sezione 2.5.1), produce una nodelist costituita da nodi precisamente a profondità N nel valore di input.

Ci sono due tipi di segmenti: child segment e descendant segment.

segment             = child-segment / descendant-segment

La sintassi e la semantica di ciascun tipo di segmento sono definite di seguito.

2.5.1. Child Segment (Segmento figlio)​

2.5.1.1. Syntax (Sintassi)​

Il child segment consiste in una sequenza non vuota, separata da virgole, di selettori racchiusa tra parentesi quadre.

Sono fornite anche notazioni abbreviate quando c'è un singolo selettore jolly o per nome.

child-segment       = bracketed-selection /
                      ("."
                       (wildcard-selector /
                        member-name-shorthand))

bracketed-selection = "[" S selector *(S "," S selector) S "]"

member-name-shorthand = name-first *name-char
name-first          = ALPHA /
                      "_"   /
                      %x80-D7FF /
                         ; skip surrogate code points
                      %xE000-10FFFF
name-char           = name-first / DIGIT
DIGIT               = %x30-39              ; 0-9
ALPHA               = %x41-5A / %x61-7A    ; A-Z / a-z

., un child segment costruito direttamente da un wildcard-selector, è abbreviazione per [].

.<member-name>, un child segment costruito da member-name-shorthand, è abbreviazione per ['<member-name>']. Nota: ciò può essere usato solo con nomi di membro composti da certi caratteri, come specificato nella regola ABNF member-name-shorthand. Così, ad esempio, $.foo.bar è abbreviazione per $['foo']['bar'] (ma non per $['foo.bar']).

2.5.1.2. Semantics (Semantica)​

Un child segment contiene una sequenza di selettori, ciascuno dei quali seleziona zero o più figli del valore di input.

Selettori di tipi diversi possono essere combinati in un singolo child segment.

Per ciascun nodo nella nodelist di input, la nodelist risultante di un child segment è la concatenazione delle nodelist da ciascuno dei suoi selettori nell'ordine in cui i selettori compaiono nella lista. Nota: qualsiasi nodo abbinato da più di un selettore è mantenuto tante volte nella nodelist.

Dove un selettore può produrre una nodelist in più di un ordine possibile, ciascuna occorrenza del selettore nel child segment può produrre una nodelist in un ordine distinto.

In sintesi, un child segment scende di un ulteriore livello nella struttura del valore di input.

2.5.1.3. Examples (Esempi)​

JSON:

["a", "b", "c", "d", "e", "f", "g"]

Interrogazioni:

QueryRisultatoPercorsiCommento
risultato
$[0,"a"$[0]Indici
3]"d"$[3]
$[0:2,"a"$[0]Fetta e
5]"b"$[1]indice
"f"$[5]
$[0,"a"$[0]Voci
0]"a"$[0]duplicate

Tabella 15: Esempi di child segment

2.5.2. Descendant Segment (Segmento discendente)​

2.5.2.1. Syntax (Sintassi)​

Il descendant segment consiste in un doppio punto .. seguito da un child segment (usando la notazione con parentesi quadre).

Sono fornite anche notazioni abbreviate che corrispondono alle forme abbreviate del child segment.

descendant-segment  = ".." (bracketed-selection /
                            wildcard-selector /
                            member-name-shorthand)

.., il descendant segment costruito direttamente da un wildcard-selector, è abbreviazione per ..[].

..<member-name>, un descendant segment costruito da member-name-shorthand, è abbreviazione per ..['<member-name>']. Nota: come con l'abbreviazione simile di un child segment, ciò può essere usato solo con nomi di membro composti da certi caratteri, come specificato nella regola ABNF member-name-shorthand.

Nota: da solo, .. non è un segmento valido.

2.5.2.2. Semantics (Semantica)​

Un descendant segment produce zero o più discendenti di un valore di input.

Per ciascun nodo nella nodelist di input, un selettore discendente visita il nodo di input e ciascuno dei suoi discendenti in modo tale che:

  • i nodi di qualsiasi array sono visitati in ordine di array, e

  • i nodi sono visitati prima dei loro discendenti.

L'ordine in cui i figli di un oggetto sono visitati non è prescritto, poiché gli oggetti JSON sono non ordinati.

Supponiamo che il descendant segment sia della forma ..[<selectors>] (dopo aver convertito qualsiasi forma abbreviata in notazione con parentesi quadre), e i nodi, nell'ordine visitato, siano D1, ..., Dn (dove n >= 1). Nota: D1 è il valore di input.

Per ciascun i tale che 1 <= i <= n, la nodelist Ri è definita come risultato dell'applicazione del child segment [<selectors>] al nodo Di.

Per ciascun nodo nella nodelist di input, il risultato del descendant segment è la concatenazione di R1, ..., Rn (in quell'ordine). Questi risultati sono poi concatenati nell'ordine della nodelist di input per formare il risultato del segmento.

In sintesi, un descendant segment scende di uno o più livelli nella struttura di ciascun valore di input.

2.5.2.3. Examples (Esempi)​

JSON:

{
  "o": {"j": 1, "k": 2},
  "a": [5, 3, [{"j": 4}, {"k": 6}]]
}

Interrogazioni:

(Nota che il quarto esempio può essere espresso in due interrogazioni equivalenti, mostrate nella Tabella 16 in una riga di tabella invece di due righe quasi identiche.)

QueryRisultatoPercorsi risultatoCommento
$..j1$['o']['j']Valori di oggetto
4$['a'][2][0]['j']
$..j4$['a'][2][0]['j']Risultato
1$['o']['j']alternativo
$..[0]5$['a'][0]Valori di array
{"j": 4}$['a'][2][0]
$..[*]{"j": 1,$['o']Tutti i valori
o"k": 2}$['a']
$..*[5, 3,$['o']['j']
[{"j": 4},$['o']['k']
{"k": 6}]]$['a'][0]
1$['a'][1]
2$['a'][2]
5$['a'][2][0]
3$['a'][2][1]
[{"j": 4},$['a'][2][0]['j']
{"k": 6}]$['a'][2][1]['k']
{"j": 4}
{"k": 6}
4
6
$..o{"j": 1,$['o']Il valore di input è
"k": 2}visitato
$.o..[*,1$['o']['j']Ordinamento
*]2$['o']['k']non deterministico
2$['o']['k']
1$['o']['j']
$.a..[0,5$['a'][0]Segmenti multipli
1]3$['a'][1]
{"j": 4}$['a'][2][0]
{"k": 6}$['a'][2][1]

Tabella 16: Esempi di descendant segment

Nota: l'ordinamento dei risultati per gli esempi $..[] e $.. qui sopra non è garantito, eccetto che:

  • {"j": 1, "k": 2} deve comparire prima di 1 e 2,

  • [5, 3, [{"j": 4}, {"k": 6}]] deve comparire prima di 5, 3, e [{"j":

4}, {"k": 6}],

  • 5 deve comparire prima di 3, che deve comparire prima di [{"j": 4}, {"k":

6}],

  • 5 e 3 devono comparire prima di {"j": 4}, 4, {"k": 6}, e 6,

  • [{"j": 4}, {"k": 6}] deve comparire prima di {"j": 4} e {"k": 6},

  • {"j": 4} deve comparire prima di {"k": 6},

  • {"k": 6} deve comparire prima di 4, e

  • 4 deve comparire prima di 6.

L'esempio qui sopra con l'interrogazione $.o..[*, *] mostra che un selettore può produrre nodelist in ordini distinti ogni volta che compare nel descendant segment.

L'esempio qui sopra con l'interrogazione $.a..[0, 1] mostra che il child segment [0, 1] è applicato a ciascun nodo a turno (piuttosto che i nodi essere visitati una volta per selettore, come avviene per alcune implementazioni JSONPath non conformi a questa specifica).

Ultimo aggiornamento il