JSON Parsen

[Sir Rufo]

Mal eben so heruntergetippt ...

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Json,
  System.SysUtils;

function IsEven( const Value: Integer ): Boolean;
begin
  Result := Value mod 2 = 0;
end;

function ParseSingleExpression( AJsonArray: TJsonArray ): string;
var
  lInner    : TJsonArray;
  lFieldName: string;
  lOperator : string;
  lValue    : string;
begin
  if AJsonArray.Count <> 1
  then
    raise EArgumentException.Create( 'single item in array expected' );

  if not( AJsonArray.Items[ 0 ] is TJsonArray )
  then
    raise EArgumentException.Create( 'array expected' );

  lInner := AJsonArray.Items[ 0 ] as TJsonArray;

  if lInner.Count <> 3
  then
    raise EArgumentException.Create( 'three items expected' );

  if not( lInner.Items[ 0 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lFieldName := lInner.Items[ 0 ].Value;

  if not( lInner.Items[ 1 ] is TJSONString )
  then
    raise EArgumentException.Create( 'string expected' );
  lOperator := lInner.Items[ 1 ].Value;

  if lInner.Items[ 2 ] is TJSONString
  then
    lValue := QuotedStr( lInner.Items[ 2 ].Value )
  else
    lValue := lInner.Items[ 2 ].Value;

  Result := string.Format( '(%s %s %s)', [ lFieldName, lOperator, lValue ] );
end;

function ParseJsonExpression( AJsonArray: TJsonArray ): string;
overload
var
  I: Integer;
begin
  if IsEven( AJsonArray.Count )
  then
    raise EArgumentException.Create( 'odd items in array expected' );

  if AJsonArray.Count = 1
  then
    Result := ParseSingleExpression( AJsonArray )
  else
    begin
      Result := '( ';
      for I  := 0 to AJsonArray.Count - 1 do
        begin
          if I mod 2 = 0
          then
            if AJsonArray.Items[ I ] is TJsonArray
            then
              Result := Result + ParseJsonExpression( AJsonArray.Items[ I ] as TJsonArray )
            else
              raise EArgumentException.Create( 'Array expected' )
          else
            Result := Result + ' ' + AJsonArray.Items[ I ].Value + ' ';
        end;
      Result := Result + ' )';
    end;
end;

function ParseJsonExpression( AJsonStr: string ): string; overload;
var
  lValue: TJSONValue;
begin
  lValue := TJSONObject.ParseJSONValue( AJsonStr );
  try
    if lValue is TJsonArray
    then
      Result := ParseJsonExpression( lValue as TJsonArray )
    else
      raise EArgumentException.Create( 'Fehlermeldung' );
  finally
    lValue.Free;
  end;
end;

const
  Data1 = '[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]';
  Data2 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]';
  Data3 = '[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]';

procedure Main;
begin
  WriteLn( Data1 );
  WriteLn( ParseJsonExpression( Data1 ) );
  WriteLn;
  WriteLn( Data2 );
  WriteLn( ParseJsonExpression( Data2 ) );
  WriteLn;
  WriteLn( Data3 );
  WriteLn( ParseJsonExpression( Data3 ) );
end;

begin
  try
    Main( );
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

und liefert

Code:

[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]]
(Bezeichnung = 'Angussstutzen-Rev/B-PPTV30')

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') )

[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]],"and",[[["Bezeichnung","=","Angussstutzen-Rev/B-PPTV30"]],"and",[["charge","=","11"]]]]
( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') and ( (Bezeichnung = 'Angussstutzen-Rev/B-PPTV30') and (charge = '11') ) )

[Sherlock]

Sorry4OT: So viel zum Thema "JSON ist sooo einfach" XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Sherlock

[franktron]

Zitat von Sherlock:

Sorry4OT: So viel zum Thema "JSON ist sooo einfach" XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Sherlock

Ja aber mit Javascript ist nun mal alles JSON.

Ich habe es jetzt gelöst etwas Krank aber es geht,
ich habe den String in ein Array zerlegt.

[Valle]

Zitat von Sherlock:

So viel zum Thema "JSON ist sooo einfach" XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Tut mir leid, aber da muss ich dir etwas OT widersprechen.

Wenn diese spezielle Syntax nicht so aufgebläht wäre und man die zu Verfügung stehenden Datentypen benutzen würde, wäre JSON deutlich einfacher. Hier sind allerdings unnötig verschachtelte Klammern und es werden nur Arrays statt Objekte verwendet. Ein tolles Beispiel für ziemlich schlechte Verwendung von JSON.

Mein Vorschlag für Variante 2 aus #4:

Code:

{
    "left": {
       "left": "Bezeichnung",
       "op": "=",
       "right": "Angussstutzen-Rev/B-PPTV30"
    },
    "op": "and",
    "right": {
        "left": "charge",
        "op": "=",
        "right": "11"
    }
}

Vorteile:

• Keine unnötige Verschachtelung
• Dank Objects keine ungültige Syntax möglich (z.B. "A, =, B, C")
• Einfach lesbar und rekursiv zu verarbeiten
• Klare und logische Verwendung von Datentypen
  • Objekte sind Ausdrücke
  • Strings entsprechen je nach Kontext Bezeichnern, Werten oder Operationen

[p80286]

Zitat von Sherlock:

Sorry4OT: So viel zum Thema "JSON ist sooo einfach" XML hat halt etwas mehr overhead, aber einfacher als JSON ist es allemal.

Sherlock

Nunja wenn ich mir die XML-Sourcen anschaue, die bei Windows mitgeliefert werden, kräuseln sich mir die Fußnägel. Ich mußte einen ganzen Satz von abhängigen Parametern (u.a. SQL-Sourcen Array of record ...) ablegen. Das ging mit JSON wesentlich eleganter als mit XML. Wobei die Lesbarkeit der verschiedenen Sourcen nicht für JSON spricht.

Gruß
K-H

[Phoenix]

Laut dem Titel geht es hier um C#.
Und da gibts mit Newtonsoft.JSON ein Library das das komplett übernimmt.

man schmeisst das Json da nur rein und bekommt ein deserialisiertes Objekt zurück mit dem man weiter arbeiten kann.

[madas]

Zitat von Phoenix:

Laut dem Titel geht es hier um C#.
Und da gibts mit Newtonsoft.JSON ein Library das das komplett übernimmt.

man schmeisst das Json da nur rein und bekommt ein deserialisiertes Objekt zurück mit dem man weiter arbeiten kann.

Und selbst für Delphi gibt es superobject. Verstehe nicht, was man da doch selber parsen möchte.

Madas

[p80286]

Zumindest "Lesen können" ist doch recht hilfreich bei der Fehlersuche.
(Das ist nichts gegen Superobject gesagt!!)

Gruß
K-H