Undefiniert beibehalten, das JSON.stringify ansonsten entfernt

Wie behalte ich undefinierte Werte bei JSON.stringify (Hash) bei?

Hier ist ein Beispiel:

var hash = {
  "name" : "boda",
  "email" : undefined,
  "country" : "africa"
};

var string = JSON.stringify(hash);

> "{"name":"boda","country":"africa"}"

E-Mail verschwand aus JSON.stringify.

Sie können eine Ersetzungsfunktion übergeben, JSON.stringifyum undefinedWerte automatisch in nullWerte wie folgt umzuwandeln :

var string = JSON.stringify(
  obj,
  function(k, v) { return v === undefined ? null : v; }
);

Dies funktioniert auch für undefinierte Werte in Arrays, da diese JSON.stringifybereits in konvertiert werden null.

Verwenden Sie nullanstelle von undefined.

var hash = {
  "name" : "boda",
  "email" : null,
  "country" : "africa"
};

var string = JSON.stringify(hash);

> "{"name":"boda","email":null,"country":"africa"}"

Sie können den Schlüssel beibehalten, indem Sie ihn konvertieren, nullda ein gültiger JSON dies nicht zulässt undefined.

Einfacher Einzeiler:

JSON.stringify(obj, (k, v) => v === undefined ? null : v)

Dies sollte den Trick tun

// Since 'JSON.stringify' hides 'undefined', the code bellow is necessary in
// order to display the real param that have invoked the error.
JSON.stringify(hash, (k, v) => (v === undefined) ? '__undefined' : v)
    .replace('"__undefined"', 'undefined')

function stringifyWithUndefined(obj, space) {
  const str = JSON.stringify(obj, (key, value) => value === undefined ? '__undefined__' : value, space);
  return str.replace(/"__undefined__"/g, 'undefined');
}

Beispiel:

const obj = {
  name: 'boda',
  email: undefined,
  country: 'africa'
};
console.log(stringifyWithUndefined(obj, 2));

Ergebnis:

{
  "name": "boda",
  "email": undefined,
  "country": "africa"
}

Ich lese hier zwischen den Zeilen und vermute, dass der Wert undefiniert sein soll, wenn Sie JSON.parse verwenden?

In diesem Fall können Sie Folgendes verwenden:

var encodeUndefined = function(obj, undefinedPaths, path) {
  path = path || 'ROOT';
  for (var key in obj) {
    var keyPath = path + '.' + key;
    var value = obj[key];
    if (value === undefined) {
      undefinedPaths.push(keyPath);
    } else if (typeof value == "object" && value !== null) {
      encodeUndefined(obj[key], undefinedPaths, keyPath);
    }
  }
}

var stringifyAndPreserveUndefined = function(obj) {
  var undefinedPaths = [];
  //save all paths that have are undefined in a array.
  encodeUndefined((obj), undefinedPaths);
  return JSON.stringify({
    ROOT: obj,
    undefinedPaths: undefinedPaths
  }, function(k, v) { if (v === undefined) { return null; } return v; });
}

var parseAndRestoreUndefined = function(value) {
  var data = JSON.parse(value);
  var undefinedPaths = data.undefinedPaths;
  var obj = data.ROOT;
  //Restore all undefined values
  for (var pathIndex = 0; pathIndex < undefinedPaths.length; pathIndex++) {
    var pathParts = undefinedPaths[pathIndex].substring(5).split('.');
    var item = obj;
    for (var pathPartIndex = 0; pathPartIndex < pathParts.length - 1; pathPartIndex++) {
      item = item[pathParts[pathPartIndex]];
    }
    item[pathParts[pathParts.length - 1]] = undefined;
  }
  return obj;
}

var input = {
  test1: 'a',
  test2: 'b',
  test3: undefined,
  test4: {
    test1: 'a',
    test2: undefined
  }
};
var result = stringifyAndPreserveUndefined(input);
var result2 = parseAndRestoreUndefined(result);

stringifyAndPreserveUndefinedcodiert alle undefinierten Werte in einem Array und platziert sie beim Aufrufen parseAndRestoreUndefinedwieder an der richtigen Stelle.

Der einzige Nachteil ist, dass der JSON nicht genau wie das Objekt aussieht. Im obigen Beispiel wird es in{"ROOT":{"test1":"a","test2":"b","test4":{"test1":"a"}},"undefinedPaths":["ROOT.test3","ROOT.test4.test2"]}

Dies führt dazu, dass es gedruckt wird, undefinedaber dies ist UNGÜLTIG json, aber es ist gültiges JavaScript.

var string = JSON.stringify(obj, function(k,v){return v===undefined?"::undefined::":v}, 2).replace(new RegExp("\"::undefined::\"", 'g'), "undefined");