Traballando con JSON en Power Fx

Power Fx permite aos creadores ler JSON nun obxecto sen tipo usando a función ParseJSON.

Lectura e conversión de valores

ParseJSON convertirá a seguinte cadea de rexistro JSON nun obxecto sen tipo con campos ItemName, Quantity, ReleaseDate e AvailableForPreOrder.

{
  "ItemName" : "Widget 1",
  "Quantity" : 46,
  "ReleaseDate" : "2022-09-01",
  "AvailableForPreOrder" : true
}

Pódese acceder a cada un dos campos mediante a notación de puntos no valor de Obxecto sen tipo devolto desde ParseJSON.

Set( untyped, ParseJSON( jsonStringVariable ) );

Set( item, Text ( untyped.ItemName ) );
Set( quantity, Value ( untyped.Quantity ) );
Set( release, DateValue ( untyped.ReleaseDate ) );
Set( preorder, Boolean ( untyped.AvailableForPreOrder ) );

Xeralmente é un bo idea converter explícitamente o valor dun obxecto sen tipo nun tipo específico. Establecer un obxecto sen tipo como un valor de variable fai que a variable sexa tamén un obxecto sen tipo . Polo tanto, é probable que se necesite converter tal valor de forma explícita ao configurar unha variable. Pero na maioría dos casos, os valores obxecto sen tipo converteranse nun tipo específico automaticamente ("coaccionar") cando se usan como parámetros de función onde o tipo é un tipo simple como booleano, número ou texto, e o perfil de parámetros da función non ten posibles sobrecargas en conflito. .

Left( untyped.ItemName, 1 ); // "W"
Radians( untyped.Quantity ); // 0.80285146
If (untyped.AvailableForPreOrder, "Available", "Not Available" ); // "Available"

Ademais de converter automaticamente o tipo en chamadas de función, os obxectos sen escribir tamén se converterán cando se asignen a propiedades de control, sempre que sexa posible.

Label1.Text: untyped.Quantity
InputText1.Default: untyped.ItemName

E, finalmente, cando usan operadores como & ou +, un obxecto sen tipo será coaccionado se non hai ambigüidade sobre o tipo esperado.

untyped.Quantity + 1 // result is a number
untyped.ItemName & " (preorder)" // result is text
untyped.Quantity + untyped.Quantity // result is a number
untyped.Quantity & untyped.ItemName // result is text

Nota

JSON non ten un GUID, Cor, Time ou DateTime tipo. Estes valores represéntanse como unha cadea. Se asigna un valor JSON obxecto sen tipo que contén unha data a unha propiedade de texto directamente, o texto orixinal do JSON utilizarase. Isto pode ser importante cando se trata de zonas horarias, formatos de data, etc. Nestes casos, deberías converter explícitamente os valores mediante GUID(), ColorValue(), DateValue(), DateTimeValue(), etc.

No caso de que un nome de campo consista nun nome de identificador non válido, por exemplo, cando os nomes de campo comezan cun número ou conteñen caracteres non válidos, como un guión, pode poñer os nomes de campo entre comiñas simples:

untyped.'01'
untyped.'my-field'

Power Fx non avaliará a existencia do campo ata que se execute a fórmula. Isto permite flexibilidade no JSON entrante. Por exemplo, o anterior JSON pode conter ás veces un campo adicional chamado Discount. Pero no noso exemplo anterior, este campo non está presente. Escribir unha fórmula que utilice o campo Discount non producirá erros durante o proceso de creación da aplicación ou cando os usuarios usen a aplicación. Se falta o campo cando se executa a fórmula, o valor só dará como resultado un valor En branco().

Nota

JSON admite valores null para campos. Estes tamén darán como resultado valores En branco(). Actualmente, non hai distinción en Power Fx entre un campo que falta ou un campo que teña o valor null.

Como o acceso aos campos de Obxectos sen tipo non se avalía ao escribir a fórmula, tampouco hai Intellisense dispoñible. Tanto JSON como Power Fx distinguen entre maiúsculas e minúsculas, polo que teña moito coidado ao escribir os nomes dos campos.

Os valores JSON non teñen que estar nunha notación de estilo rexistro. O JSON válido pode ser só un valor, como "text value", true ou 123.456. Neste caso, o obxecto sen tipo que ParseJSON devolve é o propio valor e a notación do punto non se usa.

Set( myText, Boolean( ParseJSON( "true" ) ) );

Set( myNumber, Value( ParseJSON( "123.456" ) ) );

Finalmente, JSON admite rexistros aniñados. A conversión de tales JSON a obxecto sen tipo da como resultado obxectos aniñados e a notación de puntos pódese utilizar para percorrer a xerarquía.

{
  "Version" : 1,
  "RootElement" : {
    "Parent" : {
      "Name" : "This is the parent",
      "Child" : {
        "Name" : "This is the child"
      }
    }
  }
}

Ao converter esta cadea de JSON nunha variable de obxecto sen tipo chamada jsonObject, os campos poden acceder mediante a notación de puntos.

Set( jsonObject, ParseJSON( jsonStringVariable ) );

Set( parentName, Text( jsonObject.RootElement.Parent.Name ) ); // "This is the parent"

Set( childName, Text( jsonObject.RootElement.Parent.Child.Name ) ); // "This is the child"

Se algún dos campos da expresión de notación de puntos non existe, devolverase, En branco().

Matrices e táboas

JSON pode conter matrices de valores ou rexistros. Pódese acceder a estas matrices directamente ou convertelas en táboas de Power Fx.

{
  "OrderNumber" : "SO000010",
  "CustomerID" : "CUST0126",
  "OrderLines" : [
    {
      "Item" : "Widget 1",
      "Quantity" : 3
    },
    {
      "Item" : "Widget 2",
      "Quantity" : 5
    }
  ]
}

Este JSON contén un rexistro cun campo chamado OrderLines que contén unha matriz de rexistros. Cada rexistro ten dous campos: Item e Quantity. Se o JSON se converte nun obxecto sen tipo usando a función ParseJSON e se establece nunha variable chamada jsonOrder, podemos acceder ás liñas de pedido individuais de varias maneiras.

Set( jsonOrder, ParseJSON( jsonStringVariable ) );

Pode recuperar rexistros e valores individuais mediante a función Índice(). Por exemplo, para obter o segundo rexistro no campo OrderLines, despois acceder ao campo Quantity e convertelo nun valor.

Set( line2Quantity, Value( Index( jsonOrder.OrderLines, 2 ).Quantity ); // 5

Pode converter a matriz de liñas de pedido directamente nunha táboa. Isto creará unha táboa dunha soa columna cun obxecto sen tipo que representa o rexistro.

Set( orderLines, Table( jsonOrder.OrderLines ) );

Agora "orderLines" da táboa dunha soa columna ten unha columna "Valor" que representa o obxecto sen tipo. Para utilizar calquera dos campos dun rexistro desta táboa, use a notación de puntos para acceder ao campo JSON específico no obxecto sen tipo na columna Value.

Set( jsonRecord, Index( orderLines, 2 ) ); // Get the second record in the table

Set( line2Item, Text( jsonRecord.Value.Item ) ); // "Widget 2"

Para que o uso dos rexistros da liña de pedido sexa máis sinxelo noutras partes da súa aplicación, podes converter o obxecto sen tipo nun rexistro con tipo usando a función Para todos(). Fornecer o obxecto sen tipo directamente en Para todos() significa que pode acceder aos campos do obxecto directamente en lugar de utilizar o campo dunha soa columna Value.

Set( typedOrderLines, ForAll( jsonOrder.OrderLines, { Item : Text( ThisRecord.Item ), Quantity : Value( ThisRecord.Quantity ) } ) );

A nova variable typedOrderLines é una táboa de Power Fx completamente escrita coas seguintes columnas e valores:

Elemento	Cantidade
"Widget 1"	3
"Widget 2"	5

Os exemplos anteriores usan matrices de rexistros, pero JSON tamén pode conter matrices de só valores. Considere o seguinte exemplo como unha cadea JSON válida que contén unha matriz de tres cadeas.

[ "First Item", "Second Item", "Third Item"]

Podemos recuperar un dos elementos da matriz mediante a función Índice() e convertelo en texto.

Text( Index( ParseJSON( jsonStringVariable ), 2 ) ) // "Second Item"