Comparteix via

ParseJSON funció

S'aplica a: Aplicacions de llenç Copilot Studio Aplicacions basades en models CLI del Power Platform Funcions del Dataverse Power Pages

Interpreta una cadena JSON i retorna un valor dinàmic o un valor de tipus específic si es proporciona un tipus.

Important

Descripció

La ParseJSON funció analitza una cadena JSON vàlida i retorna un valor Dynamic que representa l'estructura JSON.

Opcionalment, utilitzeu el segon argument per convertir el JSON en un objecte escrit que es pugui utilitzar directament en Power Fx fórmules. Això fa que el resultat sigui més fàcil de consumir, ja que les conversions i coaccions en el punt d'ús ja no són necessàries. El JSON sense tipus s'assigna al tipus amb aquestes regles:

  • Les columnes del tipus que no estan presents al JSON s'omplen amb espais en blanc.
  • Les columnes del JSON que no estan presents en el tipus s'ignoren.
  • Columnes que es troben tant en el tipus com en JSON, el valor JSON ha de ser coercible al tipus.

La ParseJSON funció pot retornar errors si el text no és JSON vàlid segons el format JavaScript Object Notation (JSON) descrit a ECMA-404 i IETF RFC 8259.

Sintaxi

ParseJSON( JSONString [ , Tipus ] )

  • JSONString – Obligatori. L'estructura JSON representada com a text.
  • Tipus : opcional. La Power Fx definició de tipus per a l'estructura JSON. Sense aquest argument, ParseJSON retorna un valor dinàmic; amb ell la funció retorna un valor escrit específic.

Conversió de valors dinàmics

Sense el segon argument, ParseJSON retorna un valor Dynamic que requereix la conversió explícita dels valors de camp en els tipus de dades admesos. A la taula següent s'enumeren els tipus de dades del Power Apps i un tipus de dades JSON corresponent i com convertir-les.

Tipus de dades Exemples JSON Descripció Exemple de conversió
booleà { "bool": true } El booleà és un tipus explícit en JSON i es pot convertir directament. Boolean( ParseJSON("{ "bool"": true }").bool )
Color { "color": "#102030" }
{ "r": 255, "g": 128, "b": 0, "a": 0.5 }		 No hi ha cap tipus de color al JSON. Els valors de color es poden crear a partir d'enters d'RGBA o cadenes hexadecimals. ColorValue( ParseJSON( "{ ""color"": ""#102030"" }" ).color )
With( { uo: ParseJSON( "{ ""r"": 255, ""g"": 128, ""b"": 0, ""a""": 0.5 }" ) }, RGBA( Value( uo.r ), Value( uo.g ), Value( uo.a ) ) )
Divisa, número { "numbervalue": 123.5 } Els nombres es representen directament en JSON amb un punt (.) com a separador de decimals. Value( ParseJSON("{ "numbervalue"": 123.5 }").numbervalue )
Data, Data, Hora, Hora { "start": "2022-05-10" }
{ "start": "23:12:49.000" }		 JSON no té un tipus de data o hora, així que només pot representar les dates i les hores com a cadenes. Un valor dinàmic es pot convertir directament d'una cadena en format ISO 8601 a una data, hora o data. Per a la resta de formats, convertiu primer el camp JSON en text utilitzant la funció Text() i després utilitzeu la funció DateValue(), TimeValue() o DateTimeValue(), que per defecte utilitzarà el llenguatge de la configuració de l'usuari actual. DateValue( ParseJSON("{ ""cita"": ""2022-05-10"" }").cita )
DateValue( Text( ParseJSON("{ "cita"": ""5 de maig de 2022"" }").cita ) )
GUID { "id": "123e4567-e89b-12d3-a456-426655440000" } JSON no té un tipus de dades per als GUID, per la qual cosa només es poden representar com a cadenes. GUID( ParseJSON("{ "id"": ""123e4567-e89b-12d3-a456-426655440000"" }").id )
Hiperenllaç, imatge, contingut multimèdia { "URI": "https://northwindtraders.com/logo.jpg" } Aquests tipus de dades són tipus de dades de text i es poden convertir en text i després utilitzar-se al Power Apps. Text( ParseJSON("{ "URI"": ""https://northwindtraders.com/logo.jpg"" }"). URI )
Elecció { "status": 1 }
{ "status": "Closed" }		 Les opcions es presenten com a cadenes loicalitzades, amb el suport d'un número. La funció JSON() serialitza l'opció al número de suport. No hi ha cap conversió directa de número o cadena a una opció, però les funcions Switch() o If() es poden utilitzar en el valor del text o el valor numèric. Switch( Value( ParseJSON( "{ ""status"": 1 }" ).status ), 0, Status.Open, 1, Status.Closed )
Enregistra { "field": "value" } No hi ha cap conversió directa d'un objecte JSON a una estructura de registres, però es poden recuperar camps individuals del valor Dynamic per formar un registre. { camp: Text( ParseJSON( "{ ""camp"": "valor"" }" ).camp ) }
Referència de registre n/d Les referències de registre són úniques als orígens de dades i no es poden serialitzar ni no desserialitzar. Els valors de camp que representen claus úniques es poden utilitzar al JSON per identificar registres que després es poden cercar. n/d
Table [ { "id": 1, "name": "one" }, { "id": 2, "name": "two" } ]
[1, 2, 3]		 El JSON pot incloure matrius, que es poden convertir en taules. Aquests valors poden ser matrius de registres o matrius de valors que són efectivament taules d'una columna. ParseJSON() només es poden convertir en una taula de columnes d'una sola columna de valors dinàmics, i es poden utilitzar com a tals o convertir-se en taules de registres escrits utilitzant ForAll(). ForAll( Table( ParseJSON( "[ { "id""": 1, ""name"": "one"" }, { ""id""": 2, ""name""": ""two"" } ]" ) ), { id: Value(ThisRecord.Value.id), name: Text(ThisRecord.Value.name) } )
SMS { "stringField": "this is text" } El text és un tipus explícit en JSON i es pot convertir directament. Text( ParseJSON( "{ """stringField"": ""això és text"" }").stringField )
Dues opcions { "available": true }
{ "available": "Yes" }		 Les dues opcions es presenten com a cadenes loicalitzades, amb el suport d'un booleà. La funció JSON() serialitza dues opcions al seu valor booleà. No hi ha cap conversió directa de booleà, número o cadena a dues opcions, però les funcions Switch() o If() es poden utilitzar en el valor del text, del booleà o el valor numèric. Switch( Boolean( ParseJSON( "{ ""available"": true }" ).available ), false, Availability.No, true, Availability.Yes )

Exemples

Accedir als valors de camp

A partir de la següent cadena JSON en una variable anomenada JsonString

{ "parent": { "child": "text value" }, "number": 567 }
  1. La fórmula següent retorna el text text value: 
    Text( ParseJSON( JsonString ).parent.child )
  2. La fórmula següent retorna el número 567: 
    Value( ParseJSON( JsonString ).number )

En cas que un nom de camp consisteixi en un nom d'identificador no vàlid, podeu col·locar els noms dels camps en cometes simples. A partir de la següent cadena JSON en una variable anomenada JsonString

{ "0": { "child-field": "text value" } }
  1. La fórmula següent retorna el text text value: 
    Text( ParseJSON( JsonString ).'0'.'child-field' )

Buits

A partir de la següent cadena JSON en una variable anomenada JsonString

{ "text": "text value" , "number": 567, "empty": null }
  1. Si intenteu accedir als camps que no existeixen, es retorna Blank(). La fórmula següent retorna true: 
    IsBlank( Text( ParseJSON( JsonString ).parent.child ) )
  2. Els valors JSON null es consideren Blank(). La fórmula següent retorna true: 
    IsBlank( Text( ParseJSON( JsonString ).empty ) )

Matrius simples

A partir de la següent cadena JSON en una variable anomenada JsonString

{ "array": [1, 2, 3] }
  1. Accedir al segon número de la taula de valors dinàmics del camp de matriu i convertir en un nombre utilitzant Value() retorna 2: 
    Value( Index( ParseJSON( JsonString ).array, 2 ) )
  2. Conversió de la taula de valors dinàmics d'una sola columna en el camp de matriu, en una taula de nombres { Value: 1 }, { Value: 2 }, { Value: 3 }d'una sola columna: 
    ForAll( ParseJSON( JsonString ).array, Value( ThisRecord ) )

Matrius de registres

A partir de la següent cadena JSON en una variable anomenada JsonString

{ "array": [
    { "id": 1, "name": "One"},
    { "id": 2, "name": "Two"}
    ] }

  1. La conversió a una taula escrita de registres directament amb ForAll() es pot fer mitjançant l'accés ThisRecord.[fieldname] a camps dinàmics i convertir-los en tipus específics:

    ForAll( ParseJSON( JsonString ).array, { id: Value(ThisRecord.id), name: Text(ThisRecord.name) })

Matriu a taula

  1. La conversió de valors dinàmics en una taula mitjançant la funció Table() dóna com a resultat una taula de valors dinàmics d'una sola columna. A continuació, cal accedir a l'objecte mitjançant una (única) columna Value i convertir-la en tipus tal com s'ha explicat anteriorment.

A partir de la següent cadena JSON en una variable anomenada JsonString

{ "array": [1, 2, 3] }

Table() retorna una taula d'una sola columna de valors dinàmics amb un valor d'una sola columna per al número a la matriu...

 Set(untypedTable, Table( ParseJSON( JsonString ).array ));
 
 Value( Index(untypedTable, 1).Value.Value )
 ```

Given the following JSON string in a variable named `JsonString`
```JSON
{ "array": [
 { "id": 1, "name": "One"},
 { "id": 2, "name": "Two"}
 ] }

Table() retorna una taula d'una sola columna de valors dinàmics que representa cada objecte json de la matriu.

  Set(untypedTable, Table( ParseJSON( JsonString ).array ) );
  
  Text( Index(untypedTable, 1).Value.name )
  • Last updated on