XProfan X4 mit JSON-Unterstützung

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Michael Wodrich schrieb:

      Warum, macht man das in einer Datenbank anders? Da bekommst Du auch die ganze Datenbank.
      Json ist eigentlich auch nur zum Austausch gedacht.
      In jeder DB kann man satzweise zugreifen, sonst würde es ja auch
      keinen Sinn machen. Dann reicht ja auch eine einfache Textdatei,
      in der die Sätze aneinander gereiht sind. Die kann man auch wunderbar
      rausfriemeln.

      Also, für mich macht Json, mal abgesehen von der Austauschbarkeit,
      keinen Sinn. Da bleibe ich lieber bei einer DB oder speichere mir
      Strukturen, die ich mit eigenen Funktionen auslesen kann.
    • JSON ist kein Dartenbankersatz, sondern dient zum Datenaustausch, unter anderem auch mit Datenbanken.

      Und wenn man es richtig organisiert, kann man auch satzweise zugreifen. Etwa, indem man einen Datensatz zu einem Objekt macht und in eine Liste aus Objekten einfügt. So kann man nachher bequem über den Index auf die einzelnen Sätze zugreifen. (So werden z.B. auch mit den Datenbankbefehlen SQLExec, FBExec und SLExec die Selectergebnisse als JSON-Datei exportiert, wenn man im Modus 2 als SQLFile eine Datei mit der Endung JSON verwendet.)

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X3
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X3


      http://www.xprofan.de
    • INI-Dateien sind auch gut, sogar besser geeignet.
      Damit hatte ich mal vor ein paar Jahren eine DB gemacht.
      Das ging ganz gut.

      Einfach eine Datei mit der Rubrik

      [Datensätze]
      Anzahl = 0


      und dann die Sätze numerieren :
      [1]
      Name = "..."
      Nummer = Str$(nummer)
      usw.
      [2]
      ........

      Dann einfach in einer WhileLoop Schleife schreiben bzw. lesen
      (WriteIni, ReadIni).
      Wenn es keine Tausende DS sind, geht das wunderbar.
    • Ich denke, daß Roland sowieso die Profile-Funktionen
      nutzt. Die werden nur mit WriteIni und ReadIni$ gekapselt.
      Wenn ich mal so ältere VB(A) - Codes anschaue, wird das
      dort auch schon mit ProfileString gemacht.

      Aber ich denke, daß Roland schon einen Grundstein
      gelegt hat. Er hat ja schon die HKEY_ - Klassen implementiert.
      Die werden bestimmt mit den Profile-Funktionen in die
      Registry geschrieben.

      Wäre vielleicht jetzt für X4 so eine Gelegenheit dafür,
      es mit den Profile-Funktionen umzuleiten, falls noch nicht
      geschehen.

      Das größere Problem ist, daß MS das irgendwann mal so ändert,
      daß nur noch in die Registry geschrieben werden kann.
    • Irgendwie verstehe ich deinen Beitrag nicht.
      Writeini und Readini$ greifen auf zwei unterschiedliche API Sätze zu - je nachdem, was als erster Parameter eingetrgen ist.

      1.Parameter Registry Hauptschlüssel in der Registry:
      1.Parameter Dateiname:
      Was soll da wie umgeleitet werden - und warum überhaupt????
      PPFScanner PPFS Android MisterXMail@web.de
      Mfg AHT

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von AHT ()

    • H.Brill schrieb:

      Das größere Problem ist, daß MS das irgendwann mal so ändert,
      daß nur noch in die Registry geschrieben werden kann.
      Warum sollte MS das tun? Ist doch eigentlich klar definiert, was MS macht:

      https://msdn.microsoft.com/en-us/library/windows/desktop/ms725501(v=vs.85).aspx schrieb:

      The system maps most .ini file references to the registry, using the mapping defined under the following registry key:HKEY_LOCAL_MACHINE SOFTWARE Microsoft Windows NT CurrentVersion IniFileMappingThis mapping is likely if an application modifies system-component initialization files, such as Control.ini, System.ini, and Winfile.ini. In this case, the function writes information to the registry, not to the initialization file; the change in the storage location has no effect on the function's behavior.
      Hinzu kommt dann PrivateProfile... für die heute gar nicht mehr existente WIN.INI.

      Es geht nur um die Windows-Einstellungen. Und nur um Kompatibilität zu alten 16-Bit-Programmen zu wahren. Betrifft ein 64-Bit-System gar nicht und ein 32-Bit-System nur soweit, wie 16-Bit-Anwendungen ausgeführt werden. Was da in VBA gemacht wurde, damit nicht jeder Office-Macro eine eigene INI-Datei erstellt, wenn er mal einen Wert ablegen will, ist dann wieder eine ganz andere Frage. habe ich nur der Vollständigkeit halber erwähnt, daß es sowas gibt.

      Gruß Volkmar
    • ... und ab sofort gibt es die Subscriptionsversion: xprofan.net/intl/de/xprofan/xprofan-x4-subscription/

      Die Doku im offiziellen Forum folgt in den nächsten Tagen.

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X3
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X3


      http://www.xprofan.de
    • JSON in Hash zwängen:

      Zeigt, wie man die Verschachtelungen handhaben kann.
      In diesem Schnipsel sind 21 Unterebenen möglich.

      Da Listen in Listen nicht erlaubt sind und Roland das beim Laden einer JSON-Datei bereits berücksichtigt, ist hier keine Fehlerprüfung eingebaut.

      Unten sind einige JSON-Dateien angefügt zum Testen (und ein Ergebnis).

      Brainfuck-Quellcode: ShowJSON.prf

      1. ' ---------------------------------------------
      2. Proc OneOf
      3. Parameters string Wert,Liste
      4. Var int Erg = 0
      5. WhileLoop Len(Liste, ",")
      6. Case Wert = SubStr$(Liste,&Loop,",") : Erg = 1
      7. EndWhile
      8. Return Erg
      9. EndProc
      10. ' ---------------------------------------------
      11. Proc JSON_auswerten
      12. Parameters string Dateiname
      13. Declare long js[21], Idx[21], Counter[21], CounterMax[21], Ebene, Typ, HashListe
      14. Declare string key[21], OName, Name, Value, tmp
      15. HashListe = Create("List",0)
      16. Ebene = 0
      17. Idx[Ebene] = 0
      18. js[Ebene] = Create("json", Dateiname)
      19. OName = Dateiname
      20. Case Upper$(Right$(OName,5)) = ".JSON" : OName = Left$(Dateiname, Len(Dateiname) - 5)
      21. CounterMax[Ebene] = json("Count",js[Ebene])
      22. Counter[Ebene] = 0
      23. ' - - - - - - - - - - - - - - - - - - - - - - -
      24. Repeat
      25. While Counter[Ebene] < CounterMax[Ebene]
      26. Name = json("Name",js[Ebene],Counter[Ebene])
      27. Value = json("Value",js[Ebene],Counter[Ebene])
      28. Typ = json("Typ",js[Ebene],Counter[Ebene])
      29. Select Typ
      30. ' - - - - - - - - - - - - - - -
      31. CaseOf 1 'num
      32. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      33. If Name = "[]"
      34. Name = Str$(Idx[Ebene])
      35. Idx[Ebene] = Idx[Ebene] + 1
      36. EndIf
      37. key[Ebene] = Name
      38. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ Value
      39. AddString(HashListe,tmp)
      40. ' - - - - - - - - - - - - - - -
      41. CaseOf 2 'str
      42. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      43. If Name = "[]"
      44. Name = Str$(Idx[Ebene])
      45. Idx[Ebene] = Idx[Ebene] + 1
      46. EndIf
      47. key[Ebene] = Name
      48. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ Value
      49. AddString(HashListe,tmp)
      50. ' - - - - - - - - - - - - - - -
      51. CaseOf 3 'bool
      52. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      53. Case OneOf(Upper$(Value),"0,FALSE,NO,NEIN") : Value = "*FALSE*"
      54. Case OneOf(Upper$(Value),"1,TRUE,YES,JA") : Value = "*TRUE*"
      55. If Name = "[]"
      56. Name = Str$(Idx[Ebene])
      57. Idx[Ebene] = Idx[Ebene] + 1
      58. EndIf
      59. key[Ebene] = Name
      60. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ Value
      61. AddString(HashListe,tmp)
      62. ' - - - - - - - - - - - - - - -
      63. CaseOf 4 'null
      64. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      65. If Name = "[]"
      66. Name = Str$(Idx[Ebene])
      67. Idx[Ebene] = Idx[Ebene] + 1
      68. EndIf
      69. key[Ebene] = Name
      70. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ "*NULL*"
      71. AddString(HashListe,tmp)
      72. ' - - - - - - - - - - - - - - -
      73. CaseOf 5 'list
      74. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      75. If Name = "[]"
      76. Name = Str$(Idx[Ebene])
      77. Idx[Ebene] = Idx[Ebene] + 1
      78. EndIf
      79. key[Ebene] = Name
      80. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ "***LIST***"
      81. AddString(HashListe,tmp)
      82. Inc Ebene
      83. Idx[Ebene] = 0
      84. js[Ebene] = json("GetList", js[Ebene - 1], Name )
      85. CounterMax[Ebene] = json("Count",js[Ebene])
      86. Counter[Ebene] = 0
      87. Case CounterMax[Ebene] = 0 : Dec Ebene
      88. ' - - - - - - - - - - - - - - -
      89. CaseOf 6 'obj
      90. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      91. If Name = "[]"
      92. Name = Str$(Idx[Ebene])
      93. Idx[Ebene] = Idx[Ebene] + 1
      94. EndIf
      95. key[Ebene] = Name
      96. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ "***OBJECT***"
      97. AddString(HashListe,tmp)
      98. Inc Ebene
      99. Idx[Ebene] = 0
      100. js[Ebene] = json("GetObject", js[Ebene - 1], Name )
      101. CounterMax[Ebene] = json("Count",js[Ebene])
      102. Counter[Ebene] = 0
      103. ' - - - - - - - - - - - - - - -
      104. Otherwise
      105. ERROR 999,"UNBEKANNTER JSON-TYP (" + Str$(Typ) + ")"
      106. ' - - - - - - - - - - - - - - -
      107. EndSelect
      108. EndWhile
      109. Dec Ebene
      110. Until Ebene < 0
      111. ' - - - - - - - - - - - - - - - - - - - - - - -
      112. Return HashListe
      113. EndProc
      114. ' ---------------------------------------------
      115. window 1920,1000
      116. Declare string Dateiname, s,s1,s2, long js1, HashLst, hash Obj[]
      117. Dateiname = LoadFile$("Wähle eine JSON-Datei","*.json")
      118. Print "Dateiname:",Dateiname
      119. Dateiname = SubStr$(Dateiname,-1,"\\")
      120. Print "Dateiname:",Dateiname
      121. js1 = Create("json", Dateiname)
      122. s = json("Text",js1,0)
      123. Print MkStr$("-",30) + "\nkomprimiert:\n",s
      124. s = json("Text",js1,1)
      125. Print MkStr$("-",30) + "\nunkomprimiert:\n",s
      126. 'assign #1, Dateiname + ".txt"
      127. 'rewrite #1
      128. 'Print #1, s
      129. 'close #1
      130. Print "\n";MkStr$("-",30)
      131. Set("HashMode",1)
      132. Set("HashDel","|")
      133. Set("HashListDel","=")
      134. ClearList 0
      135. HashLst = JSON_auswerten(Dateiname)
      136. Move("HandleToList",HashLst)
      137. Move("ListToArr",Obj[])
      138. Print "\n";MkStr$("-",30)
      139. ForEach Obj[],s1,s2
      140. 'print str$(&loop) + ": ";
      141. print s1 + " = " + s2
      142. EndFor
      143. Print MkStr$("-",30) + "\nEnde mit ENTER"
      144. waitkey
      145. ClearList
      146. End
      Alles anzeigen


      Beispieldateien:

      Quellcode: test15.json

      1. {[{
      2. "title": "Professional JavaScript",
      3. "authors": ["Nicholas C. Zakas"],
      4. "edition": 3,
      5. "year": 2011
      6. },
      7. {
      8. "title": "Professional JavaScript",
      9. "authors": ["Nicholas C.Zakas"],
      10. "edition": 2,
      11. "year": 2009
      12. },
      13. {
      14. "title": "Professional Ajax",
      15. "authors": ["Nicholas C. Zakas","Jeremy McPeak","Joe Fawcett"],
      16. "edition": 2,
      17. "year": 2008
      18. }
      19. ]
      20. }
      Alles anzeigen

      Quellcode: test15a.json

      1. {
      2. "FehlerKorr":[
      3. {
      4. "title": "Professional JavaScript",
      5. "authors": [
      6. "Nicholas C. Zakas"
      7. ],
      8. "edition": 3,
      9. "year": 2011
      10. },
      11. {
      12. "title": "Professional JavaScript",
      13. "authors": [
      14. "Nicholas C.Zakas"
      15. ],
      16. "edition": 2,
      17. "year": 2009
      18. },
      19. {
      20. "title": "Professional Ajax",
      21. "authors": [
      22. "Nicholas C. Zakas",
      23. "Jeremy McPeak",
      24. "Joe Fawcett"
      25. ],
      26. "edition": 2,
      27. "year": 2008
      28. }
      29. ]
      30. }
      Alles anzeigen

      Quellcode: test9.json

      1. {"id": "0001","type": "donut","name": "Cake","image":{"url": "images/0001.jpg", "width": 200,"height": 200},"thumbnail":{"url": "images/thumbnails/0001.jpg", "width": 32,"height": 32}}

      Quellcode: test8a.json

      1. {
      2. "FehlerKorr":
      3. [{"id": "0001", "type": "donut","name": "Cake", "ppu": 0.55,"batters":{"batter":
      4. [{ "id": "1001", "type": "Regular" },{ "id": "1002", "type": "Chocolate" },
      5. { "id": "1003", "type": "Blueberry" },{ "id": "1004", "type": "Devil's Food" }
      6. ]},"topping":[{ "id": "5001", "type": "None" }, { "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5007", "type": "Powdered Sugar" },
      7. { "id": "5006", "type": "Chocolate with Sprinkles" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{"id": "0002","type": "donut",
      8. "name": "Raised","ppu": 0.55,"batters": {"batter":[{ "id": "1001", "type": "Regular" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5005", "type": "Sugar" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]},{ "id": "0003","type": "donut","name": "Old Fashioned","ppu": 0.55, "batters":{"batter":[{ "id": "1001", "type": "Regular" },
      9. { "id": "1002", "type": "Chocolate" }]},"topping":[{ "id": "5001", "type": "None" },{ "id": "5002", "type": "Glazed" },{ "id": "5003", "type": "Chocolate" },{ "id": "5004", "type": "Maple" }]}]}

      Quellcode: test_db.json

      1. {"Adressen":[{"Name":"Bernd Müller","Nummer":100,"Ort":"Hamburg","Hobbys":["Golf","Tennis","Schwimmen","Tauchen"]},{"Name":"Max Mustermann","Nummer":42,"Ort":"Lübeck","Hobbys":["Reiten","Golfen","Lesen"]}]}
      Ergebnis von test_db.json:

      Quellcode: Ergebnis von test_db.json

      1. test_db2|Adressen = ***LIST***
      2. test_db2|Adressen|0 = ***OBJECT***
      3. test_db2|Adressen|0|Name = Bernd Müller
      4. test_db2|Adressen|0|Nummer = 100
      5. test_db2|Adressen|0|Ort = Hamburg
      6. test_db2|Adressen|0|Hobbys = ***LIST***
      7. test_db2|Adressen|0|Hobbys|0 = Golf
      8. test_db2|Adressen|0|Hobbys|1 = Tennis
      9. test_db2|Adressen|0|Hobbys|2 = Schwimmen
      10. test_db2|Adressen|0|Hobbys|3 = Tauchen
      11. test_db2|Adressen|1 = ***OBJECT***
      12. test_db2|Adressen|1|Name = Max Mustermann
      13. test_db2|Adressen|1|Nummer = 42
      14. test_db2|Adressen|1|Ort = Lübeck
      15. test_db2|Adressen|1|Hobbys = ***LIST***
      16. test_db2|Adressen|1|Hobbys|0 = Reiten
      17. test_db2|Adressen|1|Hobbys|1 = Golfen
      18. test_db2|Adressen|1|Hobbys|2 = Lesen
      Alles anzeigen
      Programmieren, das spannendste Detektivspiel der Welt.

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Michael Wodrich () aus folgendem Grund: Durch Korrektur der Umlaute verschwanden die Daten. Ein "Ergebnis" hinzugefügt.

    • Verbesserte Version.
      Jetzt ist das Ergebnis besser zu vergleichen.

      Brainfuck-Quellcode: ShowJSON.prf

      1. ' ShowJSON v2 (XProfan X4)
      2. ' ------------------------------
      3. Proc OneOf
      4. Parameters string Wert, Liste
      5. Var int Erg = 0
      6. WhileLoop Len(Liste, ",")
      7. If Wert = SubStr$( Liste, &Loop, "," )
      8. Erg = 1
      9. BREAK
      10. EndIf
      11. EndWhile
      12. Return Erg
      13. EndProc
      14. ' ------------------------------
      15. Proc JSON_auswerten
      16. Parameters string Dateiname
      17. Declare long js[21], Idx[21], Counter[21], CounterMax[21], Ebene, Typ, HashListe
      18. Declare string key[21], OName, Name, Value, tmp
      19. HashListe = Create("List",0)
      20. Ebene = 0
      21. Idx[Ebene] = 0
      22. js[Ebene] = Create("json", Dateiname)
      23. OName = Dateiname
      24. Case Upper$(Right$(OName,5)) = ".JSON" : OName = Left$(Dateiname, Len(Dateiname) - 5)
      25. CounterMax[Ebene] = json("Count",js[Ebene])
      26. Counter[Ebene] = 0
      27. ' - - - - - - - - - - - - - - - -
      28. Repeat
      29. While Counter[Ebene] < CounterMax[Ebene]
      30. Name = json("Name",js[Ebene],Counter[Ebene])
      31. Value = json("Value",js[Ebene],Counter[Ebene])
      32. Typ = json("Typ",js[Ebene],Counter[Ebene])
      33. Select Typ
      34. ' - - - - - - - - - - -
      35. CaseOf 1,2 'num,str
      36. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      37. If Name = "[]"
      38. Name = Str$(Idx[Ebene])
      39. Idx[Ebene] = Idx[Ebene] + 1
      40. EndIf
      41. key[Ebene] = Name
      42. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ Value
      43. AddString(HashListe,tmp)
      44. ' - - - - - - - - - - -
      45. CaseOf 3,4 'bool,null
      46. If Typ = 3
      47. Case OneOf(Upper$(Value),"0,FALSE,NO,NEIN") : Value = "*FALSE*"
      48. Case OneOf(Upper$(Value),"1,TRUE,YES,JA") : Value = "*TRUE*"
      49. EndIf
      50. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      51. If Name = "[]"
      52. Name = Str$(Idx[Ebene])
      53. Idx[Ebene] = Idx[Ebene] + 1
      54. EndIf
      55. key[Ebene] = Name
      56. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ if( Typ=4, "*NULL*", Value )
      57. AddString(HashListe,tmp)
      58. ' - - - - - - - - - - -
      59. CaseOf 5,6 'list,obj
      60. Case Ebene >= 0 : Counter[Ebene] = Counter[Ebene] + 1
      61. If Name = "[]"
      62. Name = Str$(Idx[Ebene])
      63. Idx[Ebene] = Idx[Ebene] + 1
      64. EndIf
      65. key[Ebene] = Name
      66. tmp = OName : WhileLoop 0,Ebene : tmp = tmp $ "|" $ key[&loop] : EndWhile : tmp = tmp $ "=" $ if( Typ=5, "***LIST***", "***OBJECT***" )
      67. AddString(HashListe,tmp)
      68. Inc Ebene
      69. Idx[Ebene] = 0
      70. If Typ = 5
      71. js[Ebene] = json("GetList", js[Ebene - 1], Name )
      72. Else
      73. js[Ebene] = json("GetObject", js[Ebene - 1], Name )
      74. EndIf
      75. CounterMax[Ebene] = json("Count",js[Ebene])
      76. Counter[Ebene] = 0
      77. If Typ = 5
      78. Case CounterMax[Ebene] = 0 : Dec Ebene
      79. EndIf
      80. ' - - - - - - - - - - -
      81. Otherwise
      82. ERROR 999,"UNBEKANNTER JSON-TYP (" + Str$(Typ) + ")"
      83. ' - - - - - - - - - - -
      84. EndSelect
      85. EndWhile
      86. Dec Ebene
      87. Until Ebene < 0
      88. ' - - - - - - - - - - - - - - - -
      89. Return HashListe
      90. EndProc
      91. ' ------------------------------
      92. window 1920,1000
      93. Declare string Dateiname, s,s1,s2, long js1, HashLst, hash Obj[]
      94. Dateiname = LoadFile$("Wähle eine JSON-Datei","*.json")
      95. s = SubStr$(Dateiname,-1,"\\")
      96. Case %IOResult : Print "";
      97. Assign #1, s + ".txt"
      98. Rewrite #1
      99. Case %IOResult : Print "*"
      100. ' Wenn Ihr Sternchen seht, dann habt Ihr kein Schreibrecht im gewählten Verzeichnis
      101. Print "Dateiname (voll): ";Dateiname;"\nDateiname (kurz): ";s
      102. Print #1, "Dateiname (voll): ";Dateiname;"\nDateiname (kurz): ";s : Case %IOResult : Print "*"
      103. js1 = Create("json", Dateiname)
      104. Dateiname = s
      105. Print MkStr$("-",30) + "\nkomprimiert:\n"; json("Text",js1,0); "\n"; MkStr$("-",30) + "\nunkomprimiert:\n"; json("Text",js1,1); "\n";MkStr$("-",30)
      106. Print #1, MkStr$("-",30) + "\nkomprimiert:\n"; json("Text",js1,0); "\n"; MkStr$("-",30) + "\nunkomprimiert:\n"; json("Text",js1,1); "\n";MkStr$("-",30) : Case %IOResult : Print "*"
      107. Set("HashMode",1)
      108. Set("HashDel","|")
      109. Set("HashListDel","=")
      110. ClearList 0
      111. HashLst = JSON_auswerten(Dateiname)
      112. Move("HandleToList",HashLst)
      113. Move("ListToArr",Obj[])
      114. ForEach Obj[],s1,s2
      115. s = s1 $ " = " $ s2
      116. Print s
      117. Print #1, s
      118. EndFor
      119. Print MkStr$("-",30) + "\nEnde mit ENTER"
      120. Print #1, MkStr$("-",30)
      121. Close #1
      122. WaitKey
      123. DeleteObject HashLst
      124. ClearList
      125. End ' ShowJSON v2 (XProfan X4)
      Alles anzeigen

      Ergebnis bei Anwendung auf Test.json:

      Brainfuck-Quellcode: test.json.txt

      1. Dateiname (voll): C:\XProfanX4subscription\test.json
      2. Dateiname (kurz): test.json
      3. ------------------------------
      4. komprimiert:
      5. {"Herausgeber":"Xema","Nummer":"1234-5678-9012-3456","Deckung":2000000,"Waehrung":"EURO","Inhaber":{"Name":"Mustermann","Vorname":"Max","maennlich":true,"Hobbys":["Reiten","Golfen","Lesen"],"Alter":42,"Kinder":[],"Partner":null}}
      6. ------------------------------
      7. unkomprimiert:
      8. {
      9. "Herausgeber":"Xema",
      10. "Nummer":"1234-5678-9012-3456",
      11. "Deckung":2000000,
      12. "Waehrung":"EURO",
      13. "Inhaber":{
      14. "Name":"Mustermann",
      15. "Vorname":"Max",
      16. "maennlich":true,
      17. "Hobbys":[
      18. "Reiten",
      19. "Golfen",
      20. "Lesen"
      21. ],
      22. "Alter":42,
      23. "Kinder":[],
      24. "Partner":null
      25. }
      26. }
      27. ------------------------------
      28. test|Herausgeber = Xema
      29. test|Nummer = 1234-5678-9012-3456
      30. test|Deckung = 2000000
      31. test|Waehrung = EURO
      32. test|Inhaber = ***OBJECT***
      33. test|Inhaber|Name = Mustermann
      34. test|Inhaber|Vorname = Max
      35. test|Inhaber|maennlich = *TRUE*
      36. test|Inhaber|Hobbys = ***LIST***
      37. test|Inhaber|Hobbys|0 = Reiten
      38. test|Inhaber|Hobbys|1 = Golfen
      39. test|Inhaber|Hobbys|2 = Lesen
      40. test|Inhaber|Alter = 42
      41. test|Inhaber|Kinder = ***LIST***
      42. test|Inhaber|Partner = *NULL*
      43. ------------------------------
      Alles anzeigen
      Programmieren, das spannendste Detektivspiel der Welt.
    • Neu

      Noch mal kurz OFFTOPIC zum Thema INI-Dateien:

      Einträge in den INI-Dateien des Systems (etwa "system.ini" oder "windows.ini" im Windowsverzeichnis) werden tatsächlich von Windows in die Registry gemapt, damit alte Programme und Routinen weiterhin funktionieren. So kannst Du im Programm z.B. noch die Druckereinstelleungen oder lokalen Einstellungen durch das Lesen der entsprechenden Einträge in den INI-Dateien in Erfahrung bringen, auch wenn diese Dateien im akltuellen System gar nicht existieren. Umgekehrt kannst Du in diese INI-Dateien schreiben und die Werte landen in der Registry da, wo sie hin gehören.

      Aber: Wenn Du selber INI-Dateien in Deinem Programm anlegst, die keine vom System genutzten INI-Dateien sind, werden diese grundsätzluich NICHT in die Registry gemapt. (Wie auch?) In diesem Fall werden die gewohnten INI-Dateien da angelegt, wo Du sie haben willst. Und damit es auch bei Usern klappt, die keione Admins sind, dürfen diese natürlich NICHT im Windows-Verzeichnis oder anderen geschützten Verzeichnissen landen. $UserDir und $AppDataDir (siehe Hilfe) wären hier passende Orte!

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X3
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X3


      http://www.xprofan.de