Puoi usare una virgola finale in un oggetto JSON?

Quando si genera manualmente un oggetto o un array JSON, è spesso più facile lasciare una virgola finale sull'ultimo elemento nell'oggetto o nell'array. Ad esempio, il codice per l'output da una matrice di stringhe potrebbe apparire (in uno pseudocodice come C ++):

s.append("[");
for (i = 0; i < 5; ++i) {
    s.appendF("\"%d\",", i);
}
s.append("]");

dandoti una stringa come

[0,1,2,3,4,5,]

È permesso?

Purtroppo la specifica JSON non consente una virgola finale. Ci sono alcuni browser che lo permetteranno, ma generalmente devi preoccuparti di tutti i browser.

In generale, provo a risolvere il problema e aggiungo la virgola prima del valore effettivo, quindi si finisce con un codice simile al seguente:

s.append("[");
for (i = 0; i < 5; ++i) {
  if (i) s.append(","); // add the comma only if this isn't the first entry
  s.appendF("\"%d\"", i);
}
s.append("]");

Quella riga di codice in più nel tuo ciclo for non è quasi costosa ...

Un'altra alternativa che ho usato quando ho emesso una struttura su JSON da un dizionario di qualche forma è quella di aggiungere sempre una virgola dopo ogni voce (come stai facendo sopra) e quindi aggiungere una voce fittizia alla fine che non ha virgola finale (ma che è solo pigro; ->).

Purtroppo non funziona bene con un array.

No. Le specifiche JSON, come mantenute su http://json.org , non consentono le virgole finali. Da quello che ho visto, alcuni parser potrebbero permetterli silenziosamente durante la lettura di una stringa JSON, mentre altri genereranno errori. Per l'interoperabilità, non dovresti includerlo.

Il codice sopra potrebbe essere ristrutturato, sia per rimuovere la virgola finale quando si aggiunge il terminatore di matrice o per aggiungere la virgola prima degli elementi, saltando quella per la prima.

Semplice, economico, facile da leggere e funziona sempre indipendentemente dalle specifiche.

$delimiter = '';
for ....  {
    print $delimiter.$whatever
    $delimiter = ',';
}

L'assegnazione ridondante a $ delim è un prezzo molto piccolo da pagare. Funziona altrettanto bene se non esiste un ciclo esplicito ma frammenti di codice separati.

Le virgole finali sono consentite in JavaScript, ma non funzionano in IE. Le specifiche JSON senza versione di Douglas Crockford non le consentivano, e poiché era senza versione questo non avrebbe dovuto cambiare. Le specifiche JSON ES5 le consentivano come estensione, ma RFC 4627 di Crockford non lo fece e ES5 tornò a non consentirle. Firefox ha seguito l'esempio. Internet Explorer è il motivo per cui non possiamo avere cose carine.

Come è già stato detto, le specifiche JSON (basate su ECMAScript 3) non consentono la virgola finale. ES> = 5 lo consente, quindi puoi effettivamente usare quella notazione in JS puro. È stato discusso e alcuni parser lo hanno supportato ( http://bolinfest.com/essays/json.html , http://whereswalden.com/2010/09/08/spidermonkey-json-change-trailing-commas- non più accettato / ), ma è il fatto specifico (come mostrato su http://json.org/ ) che esso dovrebbe funzionare in JSON. Quella cosa ha detto ...

... Mi chiedo perché nessuno abbia sottolineato che puoi effettivamente dividere il ciclo alla 0a iterazione e utilizzare principale virgola invece di ultimi uno a sbarazzarsi del codice di confronto odore e qualsiasi sovraccarico delle prestazioni effettive nel circuito, con conseguente un codice che in realtà è più breve, più semplice e più veloce (a causa della mancanza di diramazioni / condizionali nel loop) rispetto ad altre soluzioni proposte.

Ad esempio (in uno pseudocodice in stile C simile al codice proposto dall'OP):

s.append("[");
// MAX == 5 here. if it's constant, you can inline it below and get rid of the comparison
if ( MAX > 0 ) {
    s.appendF("\"%d\"", 0); // 0-th iteration
    for( int i = 1; i < MAX; ++i ) {
        s.appendF(",\"%d\"", i); // i-th iteration
    }
}
s.append("]");

I programmatori PHP potrebbero voler dare un'occhiata implode () . Questo richiede un array che lo unisce usando una stringa.

Dai documenti ...

$array = array('lastname', 'email', 'phone');
echo implode(",", $array); // lastname,email,phone

È interessante notare che sia C & C ++ (e credo C #, ma non ne sono sicuro) consentono specificamente la virgola finale - esattamente per il motivo indicato: Rende molto più semplice la generazione programmatica di liste. Non sono sicuro del motivo per cui JavaScript non ha seguito il loro esempio.

Usa JSON5. Non usare JSON.

• Gli oggetti e le matrici possono avere virgole finali
• Le chiavi oggetto possono essere non quotate se sono identificatori validi
• Le stringhe possono essere a virgoletta singola
• Le stringhe possono essere suddivise su più righe
• I numeri possono essere esadecimali (base 16)
• I numeri possono iniziare o terminare con un punto decimale (iniziale o finale).
• I numeri possono includere Infinito e -Infinito.
• I numeri possono iniziare con un segno più (+) esplicito.
• Sono consentiti commenti sia inline (a riga singola) sia a blocchi (a più righe).

http://json5.org/

https://github.com/aseemk/json5

C'è un modo possibile per evitare un if-branch nel loop.

s.append("[ "); // there is a space after the left bracket
for (i = 0; i < 5; ++i) {
  s.appendF("\"%d\",", i); // always add comma
}
s.back() = ']'; // modify last comma (or the space) to right bracket

Secondo le specifiche della classe JSONArray :

• Un extra, (virgola) può apparire poco prima della parentesi di chiusura.
• Il valore null verrà inserito quando c'è, (virgola) elision.

Quindi, a quanto ho capito, dovrebbe essere permesso di scrivere:

[0,1,2,3,4,5,]

Ma potrebbe accadere che alcuni parser restituiscano il 7 come numero di oggetti (come IE8 come ha sottolineato Daniel Earwicker) invece dei 6 previsti.

Modificato:

Ho trovato questo JSON Validator che convalida una stringa JSON su RFC 4627 (il tipo di supporto application / json per Notazione oggetto JavaScript) e contro la specifica del linguaggio JavaScript. In realtà qui un array con una virgola finale è considerato valido solo per JavaScript e non per la specifica RFC 4627.

Tuttavia, nella specifica RFC 4627 si afferma che:

2.3. Array

Una struttura di matrice è rappresentata da parentesi quadre che circondano zero o più valori (o elementi). Gli elementi sono separati da virgole.

array = begin-array [ value *( value-separator value ) ] end-array

Per me questo è di nuovo un problema di interpretazione. Se scrivi che gli elementi sono separati da virgole (senza indicare qualcosa su casi speciali, come l'ultimo elemento), potrebbe essere compreso in entrambi i modi.

PS RFC 4627 non è uno standard (come esplicitamente dichiarato) ed è già obsoleto da RFC 7159 (che è uno standard proposto) RFC 7159

Dalla mia esperienza passata, ho scoperto che diversi browser gestiscono le virgole finali in JSON in modo diverso.

Sia Firefox che Chrome lo gestiscono bene. Ma IE (Tutte le versioni) sembra rompersi. Intendo davvero interrompere e smettere di leggere il resto della sceneggiatura.

Tenendo presente questo, e anche il fatto che è sempre bello scrivere codice conforme, suggerisco di dedicare lo sforzo extra di assicurarsi che non ci siano virgole finali.

:)

Conservo un conteggio corrente e lo confronto con un conteggio totale. Se il conteggio corrente è inferiore al conteggio totale, visualizzo la virgola.

Potrebbe non funzionare se non si dispone di un conteggio totale prima di eseguire la generazione JSON.

Inoltre, se utilizzi PHP 5.2.0 o versioni successive, puoi semplicemente formattare la tua risposta utilizzando l'API JSON integrata.

Con Relaxed JSON, puoi avere le virgole finali o semplicemente lasciarle fuori . Sono opzionali

Non è necessario che siano presenti virgole per analizzare un documento simile a JSON.

Dai un'occhiata alle specifiche JSON rilassate e vedrai quanto sono rumorose le specifiche JSON originali. Troppe virgole e virgolette ...

http://www.relaxedjson.org

Puoi anche provare il tuo esempio usando questo parser RJSON online e vederlo analizzare correttamente.

http://www.relaxedjson.org/docs/converter.html?source=%5B0%2C1%2C2%2C3%2C4%2C5%2C%5D

Di solito cerco sull'array e allego una virgola dopo ogni voce nella stringa. Dopo il ciclo, cancello di nuovo l'ultima virgola.

Forse non è il modo migliore, ma meno costoso di controllare ogni volta se è l'ultimo oggetto nel ciclo immagino.

Non è raccomandato, ma puoi comunque fare qualcosa del genere per analizzarlo.

jsonStr = '[0,1,2,3,4,5,]';
let data;
eval('data = ' + jsonStr);
console.log(data)

Poiché un ciclo for viene utilizzato per iterare su un array o una struttura dati iterabile simile, possiamo usare la lunghezza dell'array come mostrato,

awk -v header="FirstName,LastName,DOB" '
  BEGIN {
    FS = ",";
    print("[");
    columns = split(header, column_names, ",");
  }
  { print("  {");
    for (i = 1; i < columns; i++) {
      printf("    \"%s\":\"%s\",\n", column_names[i], $(i));
    }
    printf("    \"%s\":\"%s\"\n", column_names[i], $(i));
    print("  }");
  }
  END { print("]"); } ' datafile.txt

Con datafile.txt contenente,

 Angela,Baker,2010-05-23
 Betty,Crockett,1990-12-07
 David,Done,2003-10-31

Come detto non è permesso. Ma in JavaScript questo è:

var a = Array()
for(let i=1; i<=5; i++) {
    a.push(i)
}
var s = "[" + a.join(",") + "]"

(funziona bene su Firefox, Chrome, Edge, IE11 e senza let in IE9, 8, 7, 5)