JSONATA - Verständnisprobleme

[mickym]

Ich mache mal einen Thread auf, weil ich immer wieder Verständnisprobleme habe, aber ich denke dass das ein geniales System ist. Da JSONATA sowohl in Blockly, als auch in NodeRed integriert ist, dürfte es vielleicht sogar für beide Fraktionen interessant sein.

Beispiel aus dem Parallelthread:

[
  "000|02:15",
  "001|02:20",
  "000|02:25",
  "000|02:30",
  "000|02:35",
  "000|02:40",
  "000|02:45",
  "000|02:50",
  "000|02:55",
  "000|03:00",
  "000|03:05",
  "000|03:10",
  "000|03:15",
  "000|03:20",
  "000|03:25",
  "000|03:30",
  "000|03:35",
  "000|03:40",
  "000|03:45",
  "000|03:50",
  "000|03:55",
  "000|04:00",
  "000|04:05",
  "000|04:10",
  ""
]

soll in ein Objekte-Array überführt werden mit Niederschlag und Uhrzeit. Ich konnte das bislang nur so lösen:

$.{"niederschlag": $.$split("|")[0],"zeit": $.$split("|")[1]}

Ergibt dann wie gewünscht:

[
  {
    "niederschlag": "000",
    "zeit": "02:15"
  },
  {
    "niederschlag": "001",
    "zeit": "02:20"
  },
  {
    "niederschlag": "000",
    "zeit": "02:25"
  },....
]

Mich stört aber - das ich bei jedem Array-Element 2 mal die split Funktion bemühe.

Wenn ich das jedoch einmal am Anfang machen - dann splittet sich das zwar - aber ich bin nicht in der Lage - das jeweils 1. Element in dem Objekt der 1. Eigenschaft und das 2.Element der 2. Eigenschaft zuzuweisen.

$.$split("|")

ergibt zwar das aufgedröselte Array

[
  "000",
  "02:15",
  "001",
  "02:20",
  "000",
  "02:25",
  "000",
  "02:30",
  "000",

aber ich schaffe es nicht nun das wie gehabt zuzuordnen:

Wenn ich das mache:

$.$split("|"){"niederschlag": $[0],"zeit": $[1]  }

bekomme ich nur ein korrektes Element - es wird aber nicht durch iteriert.

$.$split("|")#$i[$i%2=0]

.. gibt mir zwar nur jedes gerade Element aus - aber ich kann in dem Objekt über $i nicht auf das nächste Element zugreifen.

$.$split("|")#$i[$i%2=0]{"niederschlag":$[$i],"zeit":$[$i+1]}

Das funktioniert nicht:

Warum?

[rewenode]

@mickym Also ich denke die Variante mit den beiden $split() ist schon eine optimale Variante, jedenfalls hätte ich das auch so gemacht.

Natürlich kannst du auch die zahlreich vorhandenen Stringfunktionen verwenden

$.{"niederschlag": $.$substringBefore("|"),"zeit": $.$substringAfter("|")}

Tut das selbe. Kann dir aber auch nicht sagen, ob das optimaler ist.

@mickym sagte in JSONATA - Verständnisprobleme:

$.$split("|")#$i[$i%2=0]{"niederschlag":$[$i],"zeit":$[$i+1]}

Warum das nicht funktioniert liegt (glaube ich) daran, dass

#$i

keineswegs als Schleifenzähler interpretiert werden darf! Siehe hier.

Gruß
Reiner

[mickym]

@rewenode sagte in JSONATA - Verständnisprobleme:

Warum das nicht funktioniert liegt (glaube ich) daran, dass

Ja - so ganz schlüssig ist mir das erst mal nicht - kann ich auch so nicht aus der Beschreibung erkennen.

Hast Du noch eine Idee, warum

$.$split("|"){"niederschlag": $[0],"zeit": $[1] }

nicht durch das Array durchgeht. (durch iteriert wird ?)

[rewenode]

@mickym sagte in JSONATA - Verständnisprobleme:

$.$split("|"){"niederschlag": $[0],"zeit": $[1] }

Was sollte da iteriert werden?

/*Beispielinput*/
[
  "000|02:15",
  "001|02:20",
  "004|02:25",
  "003|02:30"
]

$.$split("|")

gibt:

[
  "000",
  "02:15",
  "001",
  "02:20",
  "004",
  "02:25",
  "003",
  "02:30"
]

Darauf wird dann

{"niederschlag": $[0],"zeit": $[1] }

angewendet.

Und davon ist

$[0] = "000" und
$[1] = "02:15"

da gibt es keine Iteration.

Das geht aber (getestet in tryJSONata) :

JSON

[
  "000|02:15",
  "001|02:20",
  "000|02:25",
  "000|02:30",
  "000|02:35",
  "000|02:40",
  "000|02:45",
  "000|02:50",
  "000|02:55",
  "000|03:00",
  "000|03:05",
  "000|03:10",
  "000|03:15",
  "000|03:20",
  "000|03:25",
  "000|03:30",
  "000|03:35",
  "000|03:40",
  "000|03:45",
  "000|03:50",
  "000|03:55",
  "000|04:00",
  "000|04:05",
  "000|04:10"
]

(
   $input := $.$split("|");

   $output := $input#$i[$i%2=0].{"niederschlag":$.$input[$i],"zeit": $.$input[$i+1] }

)

Weis aber grad nicht, wie die beiden Zeilen am sinnvollsten zu vereinen sind.

[mickym]

@rewenode sagte in JSONATA - Verständnisprobleme:

Was sollte da iteriert werden?
...
gibt:

                                                                                                                            [                                                                                                                                                                              "000",                                                                                                                                                                              "02:15",                                                                                                                                                                              "001",                                                                                                                                                                              "02:20",                                                                                                                                                                              "004",                                                                                                                                                                              "02:25",                                                                                                                                                                              "003",                                                                                                                                                                              "02:30"                                                                                                                                                                            ]                                            

Darauf wird dann

{"niederschlag": $[0],"zeit": $[1] }

angewendet.
Und davon ist
$[0] = "000" und $[1] = "02:15"
da gibt es keine Iteration.

Ok nach langen Hin und Her Überlegen verstehe ich das. Und genau die Lösung, die Du dann vorgeschlagen hast, ist mir eben auch in den Sinn gekommen, anstelle der 2 maligen splits - aber hab nicht verstanden, warum hier das Verketten nicht funktioniert. Bei 2 Variablen geht es anscheinend.

Weis aber grad nicht, wie die beiden Zeilen am sinnvollsten zu vereinen sind.

Ok - dann haben wir hier das gleiche Verständnisproblem. Vielleicht geht das mit der Verkettung noch irgendwie.

[mickym]

@rewenode sagte in JSONATA - Verständnisprobleme:

Weis aber grad nicht, wie die beiden Zeilen am sinnvollsten zu vereinen sind.

Mit dem Verkettungsoperator habe ich nach langem Probieren - eine Version hinbekommen:
der Input:

[  "000|02:15",  "010|02:20",  "020|02:25",  "030|02:30",  "050|02:35",  "045|02:40"]

$.$split("|")~>$map(function($v,$i,$arr){($i%2=0) ? {"niederschlag": $arr[$i],"zeit" : $arr[$i+1]}})

ergibt dann das gewünschte Ergebnis. Aber direkt mit dem "Punkt" mappen oder eine function zu definieren geht wohl nicht. Auch diese "if" Abfrage ist gewöhnungsbedürftig.

aber es kommt erstmal auch mit diesem Einzeiler das Ergebnis raus:

[
  {
    "niederschlag": "000",
    "zeit": "02:15"
  },
  {
    "niederschlag": "010",
    "zeit": "02:20"
  },
  {
    "niederschlag": "020",
    "zeit": "02:25"
  },
  {
    "niederschlag": "030",
    "zeit": "02:30"
  },
  {
    "niederschlag": "050",
    "zeit": "02:35"
  },
  {
    "niederschlag": "045",
    "zeit": "02:40"
  }
]

Das geht auch:

$.$split("|")~>$map(function($v,$i,$arr){($i%2=0) ? {"niederschlag": $v,"zeit" : $arr[$i+1]}})

aber $v ist wohl immer ein skalarer Wert und nicht das Array an sich - deshalb kann man auch über $v[$i+1] NICHT auf das nächste Element verwiesen. wahrscheinlich ist das auch das Problem - wenn man es nicht über die Verkettung machen will.

[rewenode]

@mickym sagte in JSONATA - Verständnisprobleme:

aber $v ist wohl immer ein skalarer Wert und nicht das Array an sich

Ja $v, oder besser der erste Parameter, ist immer der array-Inhalt an der Stelle $i.
Viel kürzer wird's dann wohl nicht werden, wenn es unbedingt ein Einzeiler sein soll.
Der Verkettungsoparator schafft i.d.R. eine gute Übersichtlichkeit.
Im konkreten Fall kannst du ihn natürlich vermeiden:

$map($.$split("|"),function($v,$i,$arr){($i%2=0) ? {"niederschlag": $v,"zeit" : $arr[$i+1]}})

Ich verwende i.d.R. eher $map() als #$i. Letzterer iteriert ja nicht unbedingt übder das komplette Array. Dass gibt dann schon mal Seiteneffekte.
$map() iteriert ja schon per Definition über das komplette Array

Gruß
Reiner

[mickym]

Ein paar komplexere JSONATA Abfragen funktionieren, wenn man immer auf das Ausgangsarray verweist.

Ich hab mal ein Musterdepot ausgelesen und einmal den DAX.

[payload#$i[$i<8]{"Überschriften" : $},payload#$i[$i>7 and ($i+1)%9=0].{"Stück": $[0],
"Name": $$.payload[$i+1],
"WKN": $split($$.payload[$i+2]," ")[0],
"Währung" : $split($$.payload[$i+2]," ")[2],...

Man kann also mehrere Arrays in einem Zug erstellen und auch komplexere Bedingungen mit UND im Filter verknüpfen.

Wenn man die table Node verwendet - dann muss man nur bei Eingabe der Spalten in der GUI keine Punkte in den Eigenschaften verweist:

payload#$i[$i%9=0].{"Name" : $$.payload[$i+1],
"Aktueller Kurs": $$.payload[$i+2],
"Differenz zum Vortag in €" : $$.payload[$i+4],
"Differenz zum Vortag %" : $split($$.payload[$i+0],' ')[2],

Aber macht langsam Spass.