JSON parsen eines ,mit JS.stringify erstellten Strings

[wicki_]

Hi zusammen,

ich versuche, so einen String zu parsen

"{\"ROW1\":[\"insert\",\"N\",\"0\",\"BA-5678\",\"3197\",\"N\",\"N\"],\"ROW2\":[\"insert\",\"N\",\"1\",\"BA-5678\",\"910\",\"N\",\"N\"]}"

wenn ich das mit

String str="{\"ROW1\":[\"insert\",\"N\",\"0\",\"BA-5678\",\"3197\",\"N\",\"N\"],\"ROW2\":[\"insert\",\"N\",\"1\",\"BA-5678\",\"910\",\"N\",\"N\"]}";

                JSONObject jsnobjectx = new JSONObject(str);

mache, dann geht das auch.
und danach geht das

                JSONArray jsonArrayx = jsnobjectx.getJSONArray("ROW1");

und auch das:

                Iterator<String> dkeys = jsnobjectx.keys();

wenn ich aber den String als Zeichenkette (mit dem ganzen \-Zeugs) in einer
Variablen stehen habe, dann sagt er mit immer, dass das JSON nichts taugt.

Auch parser.parser(Zeichenkette mit dem ganzen \-Zeugs) sagt, das das kein JSON ist.

gelöst wird das Problem jetzt mit
str=str.replace("\\","");

Aber ich dachte, Parser.parse wäre genau dafür da, eine mit .stringify erhaltene
Zeichenette zurückzubauen.

Oder hab ich das was falsch verstanden?

Munter bleiben
Wicki

 

[fhoffmann]

Du musst zwischen den String-Literal und dem Inhalt des Strings unterscheiden!
Probiere einmal:

public class Test {
    public static void main(String[] args) {
        String str = "bla\"blub";
        System.out.println(str); // Ausgabe: bla"blub
    }
}

 

[Robert Zenz]

Was ist ein Escape-Charakter?​

Ein Scape-Charakter wird dafuer verwendet um einen Parser mitzuteilen dass das Zeichen welches folgt nicht als "Steuerzeichen" zu verwendet ist, in Java wird dafuer ein Backslash "\" verwendet. Man muss immer dann Zeichen escapen wenn diese mit Steuerzeichen der Programmiersprache uebereinstimmen, Nehmen wir mal folgenden String:

String name = "Matthias "Tischtennis" Jemand";

Wie wir sehen kommt der Java Parser damit nicht klar, denn fuer den Parser hoert der String beim zweiten Anfuehrungszeichen auf:

String   name        =      "Matthias "Tischtennis" Jemand"       ;
<typ->  <name>  <zuweisung> <-string--><??????????????????><anweisungsende>

Um dieses Problem zu umgehen, muessen wir dem Parser mitteilen dass das zweite und dritte Anfuehrungszeichen Teil des Strings ist, und nicht ein Steuerzeichen um den String zu terminieren. Das passiert mit dem Escape-Character:

String name = "Matthias \"Tischtennis\" Jemand";

String   name        =      "Matthias \"Tischtennis\" Jemand"       ;
<typ->  <name>  <zuweisung> <-------------string------------><anweisungsende>

Wann brauche ich einen Escape-Charakter?​

Immer dann wenn man ein Zeichen hat welches als Steuerzeichen der jeweiligen Sprache dient damit der Parser der Sprache dies nicht falsch interpretiert. Also ich brauche immer nur dann Escape-Charaktere wenn ich im Quellcode der jeweiligen Sprache etwas schreibe.

Man braucht diese nicht wenn man zum Beispiel einen Text durch ein Eingabefeld erhaelt:

String name = nameTextField.getText(); // Matthias "Tischtennis" Jemand

Weil in diesen Faellen muss der Wert einfach nicht durch den Parser der Programmiersprache, und egal was in dem String drinnen steht, egal was man in dieses Eingabefeld schreibt, man wird immer einen String erhalten welcher genau diese Eingabe repraesentiert.

---

Was du jetzt genau falsch machst, weisz ich nicht, du sagst ja nur "wenn ich aber den String als Zeichenkette (mit dem ganzen \-Zeugs) in einer Variablen stehen habe, dann sagt er mit immer, dass das JSON nichts taugt." aber das entspricht ja genau deinem Beispiel welches du oben gibst und sagst dass es funktioniert. Desweiteren zeigst du uns weder den genauen Code welcher den Fehler verursacht, noch die genaue Fehlermeldung, aber ich schaetze mal du liest den String von irgendeiner anderen Quelle (Eingabefeld? Datei?) und hast diesen dort mit Java Escape-Charakteren drinnen stehen. Dies ist natuerlich unnoetig, weil es ja nicht durch den Java Parser muss.

 

[Oneixee5]

Die frage ist eher: Wo hast du den String her? Aus einer REST-Schnittstelle - oder in der Art? Dann machst du was falsch, wenn du überhaupt so einen String erhälst. Du solltest direkt eine Object erhalten, wenigstens eine Map - wenn schon nichts konkretes.

 

[wicki_]

Die frage ist eher: Wo hast du den String her? Aus einer REST-Schnittstelle - oder in der Art? Dann machst du was falsch, wenn du überhaupt so einen String erhälst. Du solltest direkt eine Object erhalten, wenigstens eine Map - wenn schon nichts konkretes.

Der String entsteht aus einem Array-Objekt var jArr={}; und damit der über Netz geht, muss ich es ja mit .stringify trasportabel machen.
Ein solches Object in eine sessionVariable zu schreiben ist sicher keine gute Idee.
Das passiert auf der Client-Seite mit JS - auf dem Server gehts dann mit JAVA/JSP/JSTL weiter.

Und ich brauche auch wirklich keine Erklärung von ESC-Chars.
Ich wollte nur wissen, was der "normale" Weg ist, ein Array übers Netz zu transportieren.
Ich dachte, das machen stringify (JS) und .pars (JAVA).
Die replace("\\","")-Lösung ist doch bestimmt nicht so gedacht.

 

[Oneixee5]

@see https://stackoverflow.com/questions/41301751/post-json-data-from-jsp-using-javascript-ajax

 

[wicki_]

@see https://stackoverflow.com/questions/41301751/post-json-data-from-jsp-using-javascript-ajax

das ist schon ganz hilfreich - aber es beantwortet meine frage noch nicht:
in dem beispiel wird eine vordefinierte, bekannte struktur übergeben.
ich habe aber ein arry of arrays

[[insert, N, 0, BA-5678, 3197, N, N], [delete, N, 1, BA-5678, 910, N, N], [update, N, 2, BA-5678, 1807, N, N],

und daran ist nichts fest. also die zahl der zeilen ändert sich ebenso wie die zahl der spalten. (und der typen, aber das ist egal, da es ja eh alles strings sind)

und meins frage ist: wie kriege ich das vom client zum server?
naja, es geht ja - aber nach dem stringify kommt es so an:

{\"ROW1\":[\"insert\",\"N\",\"0\",\"BA-5678\",\"3197\",\"N\",\"N\"],\"ROW2\":[\"insert\",\"N\",\"1\",\"BA-5678\",\"910\",\"N\",\"N\"]]}"

das kann ich aber nicht parsen.
wenn ich ein .replace("//","") auf den string mache, dann geht es.
aber das kann doch nicht der "richtige" weg sein

 

[KonradN]

Dann gib uns einfach einmal mehr Details, was Du genau machst. JSON.stringify funktioniert auch mit Arrays und erzeugt validen JSON Code.

Also was für ein Array hast Du und was genau rufst Du alles darauf auf so dass Du ein ungültiges JSON bekommst?

Und dass es auch mit Array richtig funktioniert kannst Du z.B. unter https://www.w3schools.com/js/js_json_stringify.asp sehen und testen!

 

[wicki_]

Dann gib uns einfach einmal mehr Details, was Du genau machst. JSON.stringify funktioniert auch mit Arrays und erzeugt validen JSON Code.

Also was für ein Array hast Du und was genau rufst Du alles darauf auf so dass Du ein ungültiges JSON bekommst?

Und dass es auch mit Array richtig funktioniert kannst Du z.B. unter https://www.w3schools.com/js/js_json_stringify.asp sehen und testen!

aber das steht doch oben genau beschrieben:
ich habe array, das so aussieht wie im bild (auf der JS-client Seite)
das verpacke ich in einen String
var stringi=JSON.stringify(jArr);
und den verpacke ich dann in ein FormData-Object und sende das dann ab.

auf der server-seite kommt es an als:

"{\"ROW0\":[\"7\",\"8\",\"statement\",\"space2\",\"space3\",\"space4\",\"BA-5678\"],\"ROW1\":[\"insert\",\"N\",\"0\",\"BA-5678\",\"3197\",\"N\",\"N\"],\"ROW2\":[\"insert\",\"N\",\"1\",\"BA-5678\",\"910\",\"N\",\"N\"],\"ROW3\":[\"insert\",\"N\",\"2\",\"BA-5678\",\"1807\",\"N\",\"N\"],\"ROW4\":[\"insert\",\"N\",\"3\",\"BA-5678\",\"51433\",\"N\",\"N\"],\"ROW5\":[\"insert\",\"N\",\"4\",\"BA-5678\",\"3200\",\"N\",\"N\"],\"ROW6\":[\"insert\",\"N\",\"5\",\"BA-5678\",\"3198\",\"N\",\"N\"],\"ROW7\":[\"insert\",\"N\",\"6\",\"BA-5678\",\"808\",\"N\",\"N\"]}"


und das lässt sich nicht parsen (wg. der \) - nehme ich die auf der java-seite mit replace raus, dann geht es.
das beispiel von dir ist zwar ähnlich - aber da wird das dann auch mit JS gelesen. ist also kein vergleich.

ohne die "\" sieht es dann so aus:
{"ROW0":["7","8","statement","space2","space3","space4","BA-5678"],"ROW1":["insert","N","0","BA-5678","3197","N","N"],"ROW2":["insert","N","1","BA-5678","910","N","N"]...}

was sich dann auch wieder parsen lässt.

 

[KonradN]

aber das steht doch oben genau beschrieben:

Nein!

a) Deine Aussagen waren schlicht ungenau und verwirrend! Du zeigst JSON, das ein Objekt zeigt mit mehreren Feldern (ROW0, ROW1, ...) die dann jeweils ein Array enthalten. Sprichst aber von "ich habe aber ein arry of arrays" - und das ist halt kein Array von Arrays.

b) Deine Aussagen zu dem., was Du machst, sind einfach zu ungenau. Damit haben wir keine Chance, Dir einen Fehler aufzuzeigen bzw. Dir zu sagen, wo Du etwas ändern könntest.

und den verpacke ich dann in ein FormData-Object und sende das dann ab.

Und wie genau machst Du das?

Lass Dir bei Deiner Fehlersuche doch einmal den generierten JSON String ausgeben. Der dürfte korrekt sein (bin ich mir relativ sicher)!

Einfach mal ein Objekt mit Feldern, die String Arrays enthalten erzeugt und dann zu einem JSON gemacht:

<!DOCTYPE html>
<html>
<body>

<h2>Create a JSON string from a JavaScript object with arrays inside.</h2>
<p id="demo"></p>

<script>
const obj = { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] };
const myJSON = JSON.stringify(obj);
document.getElementById("demo").innerHTML = myJSON;
console.log(myJSON);
</script>

</body>
</html>

Und siehe da:
{"ROW0":["John","Peter","Sally","Jane"],"ROW1":["John","Peter","Sally","Jane"]}

Somit sind solche Objekte aus meiner Sicht problemlos in JSON umwandelbar und das Problem muss an anderer Stelle sein.

 

[wicki_]

<script>
const obj = { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] };
const myJSON = JSON.stringify(obj);
document.getElementById("demo").innerHTML = myJSON;
console.log(myJSON);
</script>

</body>
</html>[/CODE]

Und siehe da:
{"ROW0":["John","Peter","Sally","Jane"],"ROW1":["John","Peter","Sally","Jane"]}

Somit sind solche Objekte aus meiner Sicht problemlos in JSON umwandelbar und das Problem muss an anderer Stelle sein.

das ist aber javsascript.
Mit JS ist das auch nicht das problem.
ich nehme das zeug aber mit java an.
und da sieht es so aus, wie es oben aussieht.
und das kannst du auch in der console nachsehen:

 (JSON.stringify(new Object( { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] })));

wenn du das nach console.log schreibst, dann sieht es anders aus. probier selbst.

console.log(JSON.stringify(new Object( { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] })));

es war überigens mal ein arry of arrays - das habe ich dann aber imer weiter reduziert und das problem einzugrenzen.
vielleicht ist ja wirklich das .replace("\\","") die standard-lösung dafür.....
erscheint schräg - löst aber das problem. solange, bis einer mit einem \ im string auftaucht. regex-replace müsste es dann werden.
ich sag doch: das ist schräg

 

[httpdigest]

Ich glaube, eigentliche Ursache des Missverständnisses ist, dass hier niemand weiß, was du genau wie im Java-Code machst, also wie genau der JSON String bei dir in deinem Java-Service ankommt und umgewandelt/unmarshalled wird.
Vielleicht solltest du das eher mal zeigen.

 

[KonradN]

das ist aber javsascript.

Ja, denn Du hast ja geschrieben:

Das passiert auf der Client-Seite mit JS - auf dem Server gehts dann mit JAVA/JSP/JSTL weiter.

Somit erzeugst Du auf der Client-Seite mit dem, was Du uns gezeigt hast, erst einmal einen gültigen JSON String.

Dann kommt eine "Black Box", denn da hast Du bisher nichts genaues geschrieben:

• Mit dem String machst Du irgendwas, das Du als "und den verpacke ich dann in ein FormData-Object und sende das dann ab." umschrieben hast
• auf der Server Seite in Java empfängst Du irgendwie das, was da der Client gemacht hat.

Und dann wissen wir wieder: Der String ist nicht so, wie erwartet.

So der String vor der Black Box korrekt gewesen sein sollte (Tipp: Kannst Du ja selbst einmal prüfen!) und es nach der Black Box schlicht falsch ist, dann müsste man prüfen, was in der Black Box passiert. Dazu fehlen zumindest mir bisher schlicht die Informationen, daher kann ich Dir dazu nichts sagen und Dir auch nicht weiter helfen.

Generell ist es aber problemlos möglich, einen String, unabhängig von dessen Inhalt, korrekt zu übertragen. Somit ist auch ein String, der JSON enthält, übertragbar.

 

[KonradN]

Ich glaube, eigentliche Ursache des Missverständnisses ist, dass hier niemand weiß, was du genau wie im Java-Code machst, also wie genau der JSON String bei dir in deinem Java-Service ankommt und umgewandelt/unmarshalled wird.
Vielleicht solltest du das eher mal zeigen.

Wobei mich die Details auf der Client Seite auch interessieren würden. Denn da wird vermutlich ein Encoding stattfinden und dementsprechend wäre ein passendes Decoding notwendig.

 

[shokwave]

Und siehe da:
{"ROW0":["John","Peter","Sally","Jane"],"ROW1":["John","Peter","Sally","Jane"]}

Somit sind solche Objekte aus meiner Sicht problemlos in JSON umwandelbar und das Problem muss an anderer Stelle sein.

Vielleicht auch nicht. Bei mir(Firefox) sieht dein Beispiel im HTML und in der Konsole ordentlich aus, aber wenn man im Debugger die Konstante myJSON anguckt, dann sieht das so aus.

myJSON: "{\"ROW0\":[\"John\",\"Peter\",\"Sally\",\"Jane\"],\"ROW1\":[\"John\",\"Peter\",\"Sally\",\"Jane\"]}"

Vielleicht hilft das: https://stackoverflow.com/questions...-stringified-json-object-back-to-json-in-java

 

[shokwave]

import org.json.simple.*;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;


public class Main {
    
  public static void main(String[] args) {
      String jsonString ="{\"ROW0\":[\"John\",\"Peter\",\"Sally\",\"Jane\"],\"ROW1\":[\"John\",\"Peter\",\"Sally\",\"Jane\"]}"; 
      JSONParser parser = new JSONParser();
      JSONObject obj;
      try {
          obj = (JSONObject)parser.parse(jsonString);
          System.out.println(obj.get("ROW0"));
      } catch(ParseException e) {
         e.printStackTrace();
      }
   }
}

Das sieht bei mir ganz gut aus...

 

[KonradN]

Vielleicht auch nicht. Bei mir(Firefox) sieht dein Beispiel im HTML und in der Konsole ordentlich aus, aber wenn man im Debugger die Konstante myJSON anguckt, dann sieht das so aus.

Dann erstell einfach mal eine String Variable mit escaped Zeichen. Ich nehme an, dass der Debugger von Firefox das generell so anzeigt.

Das sieht bei mir ganz gut aus...

Das liegt einfach daran, dass Du halt schlicht den korrekten JSON String angegeben hast. Die \ bei Dir sind dann ja nur Escape Zeichen um das nachfolgende Quote zu "escapen".

Das Problem bei @wicki_ ist ja - so ich ihn richtig verstanden habe - dass er eben einen String bekommt mit \ drin. Und daher funktioniert bei ihm ein Workaround, der alle \ entfernt.

 

[httpdigest]

Der Java-Code:

String jsonString ="{\"ROW0\":[\"John\",\"Peter\",\"Sally\",\"Jane\"],\"ROW1\":[\"John\",\"Peter\",\"Sally\",\"Jane\"]}";

erzeugt eine Variable mit einem String-Objekt, welches KEINE Backslashes beinhaltet...
Die Backslashes sind Teil der Java-Syntax, um dem Java-Parser zu sagen, wie er das String-Literal interpretieren soll, nämlich, dass bei einem folgenden " Zeichen das String-Literal nicht zu Ende sein soll. Der Backslash ist nicht Teil des letztlich erzeugten String-Objektes.
Ein String-Literal ist etwas anderes als das durch dieses Literal beschriebene String-Objekt, welches dann zur Laufzeit existiert.

 

[KonradN]

Einfach noch einmal den Test etwas erweitert: Wir packen den JSON String einfach mal in ein input Feld. (Wenn Form data verwendet wird, dann könnte es ein hidden field sein - die Übertragung würde dann automatisch geschehen und man müsste nur den Wert des Feldes auslesen. Encoding / Decoding wäre dann sozusagen automatisch passend.

<!DOCTYPE html>
<html>
<body>

<h2>Create a JSON string from a JavaScript array.</h2>
<p id="demo"></p>

<script>
const obj = { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] };
const myJSON = JSON.stringify(obj);
document.getElementById("demo").innerHTML = myJSON;
</script>

</body>
</html>
konrad@MBP-von-Konrad ~ % vi test.html
konrad@MBP-von-Konrad ~ % vi test.html
konrad@MBP-von-Konrad ~ % vi test.html
konrad@MBP-von-Konrad ~ % cat test.html
<!DOCTYPE html>
<html>
<body>

<h2>Create a JSON string from a JavaScript array.</h2>
<p id="demo"></p>
<input id="data" type="text" />
<script>
const obj = { ROW0: ["John", "Peter", "Sally", "Jane"], ROW1: ["John", "Peter", "Sally", "Jane"] };
const myJSON = JSON.stringify(obj);
document.getElementById("demo").innerHTML = myJSON;
document.getElementById("data").value = myJSON;
console.log(myJSON);
</script>

</body>
</html>

@shokwave Du kannst ja mal schauen - Dein Firefox sollte da auch einen JSON String ohne \ einfügen.

 

[shokwave]

@KonradN, @httpdigest Ihr habt natürlich Recht, ich hatte das Problem falsch verstanden.

 

[wicki_]

also ich hab jetzt sogar das versucht:

        var stringif=JSON.stringify(jArr);
        stringif=JSON.parse(stringif);
        localStorage.setItem("JSON."+iFrameName+"_v8",stringif);

dieses localStorage wird auf der sendeseite einfach in ein formdata geschrieben
und wie jedes text/hidden oder "was auch immer"-feld per http versendet

wenn ich das mache wie oben, dann wird aus dem string natürlich wieder
ein object "[object Object]" und das kann man nicht parsen.

also entweder so:
{\"ROW0\":[\"7\
org.json.JSONException: Missing value at 1 [character 2 line 1]
oder so:
str2x:{"ROW1":["insert"

das problem hatten andere ja wohl auch schon:

JSON.stringify escaping without need

JSON.stringify is converting my json object to the following string {\"2003\":{\"1\":{\"2\":[\"test\"],\"3\":[\"test2\"]}}} When it should not be escaped. The result should be as the string quo...

stackoverflow.com

Why Is JSON Stringify Adding Backslashes To A String

The JSON.stringify() method converts a JavaScript object or value to a JSON string, optionally replacing values if a replacer function is specified or

askingthelot.com

ohne jetzt gross nachzudenken - das sollte das problem beseitigen.
(es könnten ja doppelte \\ vorkommen. und eine wirklich gute lösung ist das so nicht)
das geht sicher auch cleverer:

var dString =  "This-\\Is-\\\\Dummy\\String\\\\\\\\";dString =  dString.replaceAll(/\\\\/g, '__DS__');
dString =  dString.replaceAll(/\\/g, '') ;dString =  dString.replaceAll('__DS__',"\\");
console.log( dString );

 

[KonradN]

Also die Links zeigen lediglich auf, wie JSON.stringify bei einem String solche Dinge einfügt. Das ist auch normal, denn stell Dir vor Du hast ein Feld password mit dem Wert geheimes"Passwort7 - Wenn man das als JSON darstellen würde, dann wäre ein
{ ...., "password": "geheimes"Passwort7", ..... }
ungültig. Das innere Quote Zeichen muss escaped werden.
{ ...., "password": "geheimes\"Passwort7", ..... }

Das ist, was da beschrieben wurde. Das ist aber nicht bei Dir der Fall. Oder zumindest nicht in dem Teil, den Du uns bisher gezeigt hast.

Denn Der Inhalt Deines Forms / dein Formdata muss ja jetzt auch codiert und übermittelt werden. Und dazu wird es auch codiert. Wenn man sich das etwas vorstellen mag, dann ist dies auch wieder (stark vereinfacht) ein Objekt, dass die Daten hält. Du hast also in deinem formdata objekt jetzt den JSON String. Zur Übermittlung wird der in JSON verpackt. Damit hast Du dann einen JSON codierten JSON String, der übermittelt wird.

Ich weiss wirklich nicht mehr, was ich Dir noch schreiben soll und ich verstehe nicht, wieso Du einfach nicht gewillt bist, Details zu nennen, was Du genau wie auf der JavaScript und Java Seite machst. Daher einfach noch einmal die konkrete Bitte, da einfach einmal Details zu bringen.

So ist das einfach nur eine sehr frustrierende Zeitverschwendung.

 

[KonradN]

Was Du aber unabhängig davon machen kannst: Du kannst den JSON codierten String natürlich nehmen und wieder in ein JSON Objekt setzen. Du baust einfach etwas wie:
"˜\"value\": \"" + receivedString + "\"}"
und das kannst Du dann parsen. Dann nimmst Du den Inhalt von value und parst diesen erneut.

Aber das ist sicher nicht die Lösung! Das ist ein Workaround, der schlicht laut "schreit": Hier ist jemand am Werk, der die Kommunikation zwischen Client und Server nicht verstanden hat.

 

[KonradN]

Das mit dem separaten Attribut ist ja nicht einmal notwendig. Das ist ja bereits ein JSON kodierter JSON String. Damit ist der direkt 1:1 einlesbar.

Also z.B. mittels gson wäre das einfach etwas wie:

        String doubleEncodedValue = "\"{\\\"ROW1\\\":[\\\"insert\\\",\\\"N\\\",\\\"0\\\",\\\"BA-5678\\\",\\\"3197\\\",\\\"N\\\",\\\"N\\\"],\\\"ROW2\\\":[\\\"insert\\\",\\\"N\\\",\\\"1\\\",\\\"BA-5678\\\",\\\"910\\\",\\\"N\\\",\\\"N\\\"]}\"";
        Gson gson = new Gson();
        String jsonString = gson.fromJson(doubleEncodedValue, String.class);

Das ist ja auch klar, denn der TE hat ja im ersten Post schon geschrieben, dass auch sein Aufruf funktionierte:
JSONObject jsnobjectx = new JSONObject(str);

Dieses JSONObject ist aber halt nur der String. Da kann er also lediglich den String Wert des original JSON auslesen und keine Werte für ROW0 oder so auslesen. Daher wäre der Workaround hier, da einfach den Stringwert auszulesen um daraus dann erneut ein JSONObject zu erstellen.

 

[wicki_]

Aber das ist sicher nicht die Lösung! Das ist ein Workaround, der schlicht laut "schreit": Hier ist jemand am Werk, der die Kommunikation zwischen Client und Server nicht verstanden hat.

nun sind wie ja auf dem niveau angekommen, auf dem es sinnfrei ist, weiter zu diskutieren

 

[KonradN]

nun sind wie ja auf dem niveau angekommen, auf dem es sinnfrei ist, weiter zu diskutieren

Ok, kannst Du das ggf. noch etwas erläutern? Hast Du denn die inhaltlichen Dinge verstanden? Also verstanden, was da der Client macht und wieso vermutlich das ankommt, was da ankommt? Und dann mal das, was ich als Workaround angeboten habe, ausprobiert?

Und unabhängig davon, wie ich so einen Workaround einschätze: Du kannst es gerne so handhaben. Wenn Du damit glücklich bist, dann ist es so.

Wenn Du uns aber mehr Details gibst, dann haben wir ggf. auch eine Lösung, wie Du das eben nicht brauchst. Denn dass der Client Daten als JSON (oder XML, das gibt es auch noch) übergibt ist sozusagen Standard. Das können die üblichen Serverseitigen Frameworks also auch und bieten da dann entsprechende Möglichkeiten. Das ist aber einfach eine Option - die musst Du nicht wollen. Aber ich denke, damit bin ich aus dem Thread raus, denn ich denke, es ist erst einmal alles gesagt.

 

[wicki_]

Nun hab ich mir das alles mal in Ruhe angesehen und bin auf den Fehler gestossen.

Ja, ein saublöder Fehler. so derartig blöd, dass man nicht drauf komt.
Weil man den Wald vor lauter Bäumen nicht sieht.

Der langen Rede kurzer Sinn:
Das Ding wurde einfach 2x gestringified. Und dann kommt da halt sowas bei heraus.
Und weil die Versendefunktion "historisch gewachsen" ist, hab ich da überhaupt nicht nachgesehen.

Hätte ich tun sollen. Hätte man sofort drauf kommen können.... grmbl

Wer den Fehler gern auch mal haben möchte, der denn ihn sich hier einfach mal erzeugen ;-)

<!DOCTYPE HTML> <html lang="de"> <head> <title>Testseite - send/rec eines Arrys - wo kommen die "\" her ?</title>
<meta content="text/html; charset=utf-8" http-equiv="content-type" />
<%@ page     import="org.json.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"  %>
<%
try{
    Enumeration paramNames = request.getParameterNames();
    String[] paramValues = request.getParameterValues( "jArr" );
    String str1=Arrays.deepToString( paramValues);
if (str1.indexOf("null") != 0){
    str1=paramValues[0];
    out.println("jArr:"+str1+"\n");
    String jsonString = ""+str1;
    out.println("jsonString:"+jsonString);
    System.err.println("jsonString:"+jsonString);
    JSONObject obj = new JSONObject(jsonString);
Iterator<String> akeys = obj.keys();
    while(akeys.hasNext()) {
            String akey = akeys.next();
        JSONArray jsonArray = obj.getJSONArray(akey);
        out.println("key:"+akey+" val:"+jsonArray);
         for(int i = 0; i < jsonArray.length(); i++){
              Object aobj = jsonArray.get(i);
                out.println("aobj:"+aobj);
        }
    }
}
} catch (Exception e) { out.println("\n\nERROR: "+e.getMessage());
    }
%>
<script>
function send(targeturl,doctarget,err) {
    var request = new XMLHttpRequest();
var jArr={};
var oneRow=[];
 oneRow.push("space1"); oneRow.push("space2"); oneRow.push("space3"); oneRow.push("space4");
 jArr["ROW0"]=oneRow; jArr["ROW1"]=oneRow;
    request.open("POST",targeturl);
    request.onreadystatechange = function() {
        if(this.readyState === 4 && this.status === 200) {
                   console.log("send....responseText:"+this.responseText);
            document.getElementById(doctarget).innerText = "I'm back...."+this.responseText.substring(0,800)+"...";
                readyCallback();
        }
    console.log("send incomplete:"+this.status);
    if (this.status==404)  document.getElementById(doctarget).innerHTML='[{"JA":"ERROR! 404","t":"File not found:'+targeturl+'"}]:EOJ:';
    if (this.status==500)  document.getElementById(doctarget).innerHTML='[{"JA":"ERROR! 500","t":"Internal Server Error:'+targeturl+'"}]:EOJ:';
    };
    var formData = new FormData();
    var str=JSON.stringify(jArr);
    if (err == 1) str=JSON.stringify(str);
    formData.append("jArr", str);
    request.send(formData);
}

function readyCallback(){ console.log("send done!"); }
</script>
</head>
<body>
<HR>
<input type="button" value="send"
    onClick="
    send('jtest3.jsp','result',0);
    ">

<input type="button" value="sendMitFehler"
    onClick="
    send('jtest3.jsp','result',1);
    ">

request-Parameter:<BR>
<DIV id="result"></DIV>
</body>

 

[KonradN]

a) hättest Du das, was du genau machst mal früher gesagt ... hätte man Dich bloss danach gefragt
b) Schade, dass niemand das mit dem doppelt JSON codierten Element gesagt hat ... das hätte man ja durchaus erkennen können ...