Corretto schema JSON per una serie di elementi di diverso tipo

Question

Ho una serie non ordinata di elementi JSON. Secondo la specifica http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5, lo schema json qui sotto si convaliderà solo se gli oggetti nella matrice compaiono IN QUESTO ORDINE. Non voglio specificare un ordine, semplicemente convalidare gli oggetti all'interno dell'array, indipendentemente dall'ordine o dal numero di oggetti. Dalle specifiche non riesco a capire come questo sia fatto.

"transactions" : { 
    "type" : "array", 
    "items" : [ 
     { 
      "type" : "object", 
      "properties" : { 
       "type" : { 
        "type" : "string", 
        "enum" : ["BUILD", "REASSIGN"] 
       } 
      } 
     }, 
     { 
      "type" : "object", 
      "properties" : { 
       "type" : { 
        "type" : "string", 
        "enum" : ["BREAK"] 
       } 
      } 
     } 
    ] 
} 

Answer 1

Ho fatto questa stessa domanda sul gruppo google dello schema JSON e mi è stato risposto rapidamente. fge utente ha chiesto che vi posto qui la sua risposta:

Ciao,

La specifica corrente è progetto v4, non si tratta v3. Più particolare, la specifica convalida è qui:

http://tools.ietf.org/html/draft-fge-json-schema-validation-00

sito Il web non è aggiornata, non so perché ... io invio un tiro richiesta.

Con progetto v4 è possibile utilizzare questo:

{ 
    "type": "array", 
    "items": { 
     "oneOf": [ 
      {"first": [ "schema", "here" ] }, 
      {"other": [ "schema": "here" ] } 
     ] 
    } 
} 

Per esempio, questo è uno schema per un array in cui gli elementi possono essere sia stringhe o interi (può essere scritto in modo più modo semplice però):

{ 
    "type": "array", 
    "items": { 
     "oneOf": [ 
      {"type": "string"}, 
      {"type": "integer"} 
     ] 
    } 
} 

Questa è la risposta corretta. Il mio schema corretto ora include:

"transactions" : { 
    "type" : "array", 
    "items" : { 
     "oneOf" : [ 
      { 
       "type" : "object", 
       "properties" : { 
        "type" : { 
         "type" : "string", 
         "enum" : ["BUILD", "REASSIGN"] 
        } 
       } 
      }, 
      { 
       "type" : "object", 
       "properties" : { 
       "type" : { 
        "type" : "string", 
        "enum" : ["BREAK"] 
        } 
       } 
      } 
     ] 
    } 
} 

Answer 2

Ho esaminato questo per un po 'troppo. Ma non sono stato in grado di trovare una soluzione funzionante. Funziona bene se si dispone di un solo schema es.

"transactions" : { 
      "type" : "array", 
      "items" : 
      { 
      "type" : "object", 
      "properties" : { 
       "type" : { 
       "type" : "string", 
       "enum" : ["BREAK"] 
       }, 
      } 
} 

Quindi saltare le parentesi di matrice e utilizzare un oggetto. Tuttavia, se vuoi fare ciò che stai facendo, sembra che non ci sia una risposta solida. Questa è l'unica cosa che ho trovato finora: http://the-long-dark-tech-time.blogspot.se/2012/12/using-json-schema-with-array-of-mixed.html

Answer 3

Per chiunque bloccato con lo schema progetto 3. C'è una parola chiave "Tipo" che è equivalente al "anyof" nel progetto 4:

in modo da poter usare

{ 
    "fooBar" : { 
     "type" : "array", 
     "items" : { 
      "type" : [{ 
        "type" : "object", 
        "properties" : { 
         "foo" : {       
          "type" : "string" 
         } 
        } 
       }, { 
        "type" : "object", 
        "properties" : { 
         "bar" : { 
          "type" : "string" 
         } 
        } 
       } 
      ] 
     } 
    } 
} 

Answer 4

In risposta a utente VDEX: questo non è equivalente, ciò che si scritto significa che gli elementi dell'array si verificano in questo particolare ordine all'interno dell'array.

Soggetto a un'implementazione corretta, se si utilizza this schema validator.

Con questo schema:

{ 
    "$schema": "http://json-schema.org/draft-04/schema#", 
    "type": "array", 
    "items": [ 
    { 
     "type": "boolean" 
    }, 
    { 
     "type": "number" 
    }, 
    { 
     "type": "string" 
    } 
    ] 
} 

Questa JSON sarà convalidata:

[ 
    true, 
    5, 
    "a", 
    "6", 
    "a", 
    5.2 
] 

ma non questo:

[ 
    5, 
    true, 
    "a", 
    "6", 
    "a", 
    5.2 
] 

Così, l'obiettivo è totalmente diverso da parole chiave come "uno di".