JSON-Stringify fehlt in jQuery 1.4.1?

Anscheinend kann jQuery ein bestimmtes Objekt oder eine bestimmte Zeichenfolge in ein JSON-Objekt dekodieren. Ich habe jedoch ein JS-Objekt, das ich auf den Server zurückschicken muss, und ich finde in jQuery kein Dienstprogramm, das die Funktion JSON.stringify () umschließt. Diese Funktion ist in Chrome, Safari 4, FF3.6 und IE8 enthalten, in früheren Browsern jedoch nicht. Ich kann es nativ in den Browsern verwenden, die es unterstützen, bin aber ansonsten gezwungen, auf die Verwendung von Crockfords JSON-Skripten zurückzugreifen.

Gibt es eine in jQuery integrierte Funktion, die die JSON-Codierung und -Decodierung anstelle der Crockford-Skripte übernimmt?

Vielleicht möchten Sie dies überprüfen: http://www.json.org/js.html

Sie können "Closure Library" (Google) verwenden, um einen browserübergreifenden JSON-Encoder / -Decoder zu erstellen.

Gehen Sie einfach zu http://closure-compiler.appspot.com/

und fügen Sie Folgendes in das Textfeld ein, und klicken Sie dann auf "Kompilieren":

// ==ClosureCompiler==
// @compilation_level ADVANCED_OPTIMIZATIONS
// @output_file_name default.js
// @use_closure_library true
// ==/ClosureCompiler==

goog.require('goog.json');
if (!window['JSON']) window['JSON']={};
if (typeof window['JSON']['stringify'] !== 'function') window['JSON']['stringify']=goog.json.serialize;
if (typeof window['JSON']['parse'] !== 'function') window['JSON']['parse']=goog.json.parse;

jQuery kann JSON-Strings nativ mit dekodieren jQuery.parseJSON().

Für die Codierung kenne ich allerdings nur ein Plugin: jquery-json

jQuery benötigt diese Funktionalität nicht intern und bietet daher keine bequeme Methode dafür.

JSON.stringify () ist die standardmäßige und empfohlene Methode zum Codieren eines Objekts in eine JSON-Zeichenfolgendarstellung dieses Objekts. Es ist eine Methode des nativen JSON-Objekts in vielen Browsern, und es wird empfohlen, json2.js (https://github.com/douglascrockford/JSON-js) zu verwenden, um einen Fallback bereitzustellen.

Um auf der Antwort von stewe aufzubauen, erhalten Sie mit dem Closure Compiler mit aktiviertem Advanced ein Skript, das den globalen Namespace mit einer Reihe von Ein-Buchstaben-Variablen verschmutzt. Also verpacke ich es einfach in einen anonymen Funktionsaufruf wie folgt:

(function() {
  function g(a) {
    var b = typeof a;
    if ("object" == b)
      if (a) {
        if (a instanceof Array) return "array";
        if (a instanceof Object) return b;
        var c = Object.prototype.toString.call(a);
        if ("[object Window]" == c) return "object";
        if ("[object Array]" == c || "number" == typeof a.length && "undefined" != typeof a.splice && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("splice")) return "array";
        if ("[object Function]" == c || "undefined" != typeof a.call && "undefined" != typeof a.propertyIsEnumerable && !a.propertyIsEnumerable("call")) return "function"
      } else return "null";
    else if ("function" == b && "undefined" == typeof a.call) return "object";
    return b
  };

  function h(a) {
    a = "" + a;
    if (/^\s*$/.test(a) ? 0 : /^[\],:{}\s\u2028\u2029]*$/.test(a.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r\u2028\u2029\x00-\x08\x10-\x1f\x80-\x9f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g, ""))) try {
      return eval("(" + a + ")")
    } catch (b) {}
    throw Error("Invalid JSON string: " + a);
  }

  function i(a, b) {
    var c = [];
    j(new k(b), a, c);
    return c.join("")
  }

  function k(a) {
    this.a = a
  }

  function j(a, b, c) {
    switch (typeof b) {
      case "string":
        l(b, c);
        break;
      case "number":
        c.push(isFinite(b) && !isNaN(b) ? b : "null");
        break;
      case "boolean":
        c.push(b);
        break;
      case "undefined":
        c.push("null");
        break;
      case "object":
        if (null == b) {
          c.push("null");
          break
        }
        if ("array" == g(b)) {
          var f = b.length;
          c.push("[");
          for (var d = "", e = 0; e < f; e++) c.push(d), d = b[e], j(a, a.a ? a.a.call(b, "" + e, d) : d, c), d = ",";
          c.push("]");
          break
        }
        c.push("{");
        f = "";
        for (e in b) Object.prototype.hasOwnProperty.call(b, e) && (d = b[e], "function" != typeof d && (c.push(f), l(e, c), c.push(":"),
          j(a, a.a ? a.a.call(b, e, d) : d, c), f = ","));
        c.push("}");
        break;
      case "function":
        break;
      default:
        throw Error("Unknown type: " + typeof b);
    }
  }
  var m = {
      '"': '\\"',
      "\\": "\\\\",
      "/": "\\/",
      "\u0008": "\\b",
      "\u000c": "\\f",
      "\n": "\\n",
      "\r": "\\r",
      "\t": "\\t",
      "\x0B": "\\u000b"
    },
    n = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g;

  function l(a, b) {
    b.push('"', a.replace(n, function(a) {
      if (a in m) return m[a];
      var b = a.charCodeAt(0),
        d = "\\u";
      16 > b ? d += "000" : 256 > b ? d += "00" : 4096 > b && (d += "0");
      return m[a] = d + b.toString(16)
    }), '"')
  };
  window.JSON || (window.JSON = {});
  "function" !== typeof window.JSON.stringify && (window.JSON.stringify = i);
  "function" !== typeof window.JSON.parse && (window.JSON.parse = h);
})();

Jetzt können Sie anrufen:

var JSONString = JSON.stringify({name: 'value'});

Häufig ist die Funktion JSON.stringify () bei Verwendung von jQuery nicht erforderlich. Nehmen wir zum Beispiel den allgemeinen Fall, dass Ajax zum Senden von Javascript-Daten an den Server verwendet wird. Jquery verfügt über integrierte Funktionen, um dies zu handhaben: (Beispiele von http://api.jquery.com/category/ajax/ )

$.post("test.php", { name: "John", time: "2pm" } );
$.post("test.php", { 'choices[]': ["Jon", "Susan"] });
$.getJSON("test.js", { name: "John", time: "2pm" }, function(json) {
    alert("JSON Data: " + json.users[3].name);
});

In allen obigen Beispielen werden die gesendeten Javascript-Daten von jQuery automatisch serialisiert.

Die Serialisierung ist in diesen Fällen nicht mit JSON.Stringify () identisch, sondern die Daten werden in eine HTML-Abfragezeichenfolge serialisiert (siehe: http://en.wikipedia.org/wiki/Query_string#Structure ).

Diese Form der Serialisierung ist jedoch für die meisten (aber nicht alle) Anwendungen in Ordnung