it-swarm.com.de

Ein Objekt in einen String konvertieren

Wie kann ich ein JavaScript-Objekt in eine Zeichenfolge konvertieren?

Beispiel:

var o = {a:1, b:2}
console.log(o)
console.log('Item: ' + o)

Ausgabe:

Objekt {a = 1, b = 2} // sehr schön lesbare Ausgabe :)
Item: [object Object] // keine Ahnung was drin ist :(

863
user680174

Ich würde empfehlen, JSON.stringify zu verwenden, wodurch die Menge der Variablen im Objekt in einen JSON-String umgewandelt wird. Die meisten modernen Browser unterstützen diese Methode nativ, aber für diejenigen, die dies nicht tun, können Sie eine JS-Version hinzufügen

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);
1235
Gary Chambers

Verwenden Sie die JavaScript-Funktion String ().

 String(yourobject); //returns [object Object]

oder

JSON.stringify(yourobject)

.

89
Vikram Pote

Um ein Objekt in einen String zu konvertieren, müssen Sie entweder eine eigene Methode verwenden, z.

function objToString (obj) {
    var str = '';
    for (var p in obj) {
        if (obj.hasOwnProperty(p)) {
            str += p + '::' + obj[p] + '\n';
        }
    }
    return str;
}

Tatsächlich zeigt das Obige nur den allgemeinen Ansatz. Sie möchten vielleicht etwas wie http://phpjs.org/functions/var_export:578 oder http://phpjs.org/functions/var_dump:604

wenn Sie keine Methoden verwenden (Funktionen als Eigenschaften Ihres Objekts), können Sie möglicherweise den neuen Standard verwenden (der jedoch nicht in älteren Browsern implementiert ist, obwohl Sie auch ein Hilfsprogramm dafür finden können), JSON .stringify (). Das funktioniert jedoch nicht, wenn das Objekt Funktionen oder andere Eigenschaften verwendet, die für JSON nicht serialisierbar sind.

84
Brett Zamir

Um es mit console einfach zu halten, können Sie statt eines + einfach ein Komma verwenden. + versucht, das Objekt in eine Zeichenfolge umzuwandeln, während das Komma es in der Konsole separat anzeigt.

Beispiel:

var o = {a:1, b:2};
console.log(o);
console.log('Item: ' + o);
console.log('Item: ', o);   // :)

Ausgabe:

Object { a=1, b=2}           // useful
Item: [object Object]        // not useful
Item:  Object {a: 1, b: 2}   // Best of both worlds! :)

Referenz: https://developer.mozilla.org/en-US/docs/Web/API/Console.log

68
Luke

EDIT Verwenden Sie diese Antwort nicht, da sie in Internet Explorer nicht funktioniert. Verwenden Sie Gary Chambers Lösung.

toSource () ist die Funktion, nach der Sie suchen und die sie als JSON ausschreibt.

var object = {};
object.first = "test";
object.second = "test2";
alert(object.toSource());
32
Gazler

Eine Option:

console.log('Item: ' + JSON.stringify(o));

o is printed as a string

Eine andere Option (wie soktinpk in den Kommentaren erwähnt) und besser für das Debuggen von Konsolen IMO:

console.log('Item: ', o);

o is printed as an object, which you could drill down if you had more fields

31
nabn

Keine der Lösungen hier funktionierte für mich. JSON.stringify scheint das zu sein, was viele Leute sagen, aber es unterdrückt Funktionen und scheint für einige Objekte und Arrays, die ich beim Testen getestet habe, ziemlich kaputt.

Ich habe meine eigene Lösung entwickelt, die zumindest in Chrome funktioniert. Wenn Sie es hier posten, kann es jeder finden, der dies bei Google nachschlägt.

//Make an object a string that evaluates to an equivalent object
//  Note that eval() seems tricky and sometimes you have to do
//  something like eval("a = " + yourString), then use the value
//  of a.
//
//  Also this leaves extra commas after everything, but JavaScript
//  ignores them.
function convertToText(obj) {
    //create an array that will later be joined into a string.
    var string = [];

    //is object
    //    Both arrays and objects seem to return "object"
    //    when typeof(obj) is applied to them. So instead
    //    I am checking to see if they have the property
    //    join, which normal objects don't have but
    //    arrays do.
    if (typeof(obj) == "object" && (obj.join == undefined)) {
        string.Push("{");
        for (prop in obj) {
            string.Push(prop, ": ", convertToText(obj[prop]), ",");
        };
        string.Push("}");

    //is array
    } else if (typeof(obj) == "object" && !(obj.join == undefined)) {
        string.Push("[")
        for(prop in obj) {
            string.Push(convertToText(obj[prop]), ",");
        }
        string.Push("]")

    //is function
    } else if (typeof(obj) == "function") {
        string.Push(obj.toString())

    //all other values can be done with JSON.stringify
    } else {
        string.Push(JSON.stringify(obj))
    }

    return string.join("")
}

EDIT: Ich weiß, dass dieser Code verbessert werden kann, aber ich bin nie dazu gekommen. User andrey schlug eine Verbesserung hier mit dem Kommentar vor:

Hier ist ein wenig geänderter Code, der 'null' und 'undefined' verarbeiten kann und keine übermäßigen Kommas hinzufügt.

Verwenden Sie das auf eigene Gefahr, da ich es überhaupt nicht bestätigt habe. Fühlen Sie sich frei, um weitere Verbesserungen als Kommentar vorzuschlagen.

20
Houshalter

Wenn Sie nur auf der Konsole ausgeben, können Sie console.log('string:', obj) verwenden. Beachten Sie das Komma .

19

Wenn Sie wissen, dass es sich bei dem Objekt nur um ein boolesches Objekt, ein Datum, eine Zeichenfolge, eine Nummer usw. handelt ... Die JavaScript-Funktion String () funktioniert einwandfrei. Ich habe dies kürzlich für den Umgang mit Werten gefunden, die aus der $ .each-Funktion von jquery stammen.

Das folgende Beispiel würde beispielsweise alle Elemente in "value" in eine Zeichenfolge konvertieren:

$.each(this, function (name, value) {
  alert(String(value));
});

Weitere Details hier:

http://www.w3schools.com/jsref/jsref_string.asp

15
Jake Drew
var obj={
name:'xyz',
Address:'123, Somestreet'
 }
var convertedString=JSON.stringify(obj) 
 console.log("literal object is",obj ,typeof obj);
 console.log("converted string :",convertedString);
 console.log(" convertedString type:",typeof convertedString);
13
sunny rai

Ich suchte das und schrieb eine tief rekursive mit Einrückung:

function objToString(obj, ndeep) {
  if(obj == null){ return String(obj); }
  switch(typeof obj){
    case "string": return '"'+obj+'"';
    case "function": return obj.name || obj.toString();
    case "object":
      var indent = Array(ndeep||1).join('\t'), isArray = Array.isArray(obj);
      return '{['[+isArray] + Object.keys(obj).map(function(key){
           return '\n\t' + indent + key + ': ' + objToString(obj[key], (ndeep||1)+1);
         }).join(',') + '\n' + indent + '}]'[+isArray];
    default: return obj.toString();
  }
}

Verwendung: objToString({ a: 1, b: { c: "test" } })

10
SylvainPV

Wenn Sie nur das Objekt zum Debuggen anzeigen möchten, können Sie verwenden

var o = {a:1, b:2} 
console.dir(o)
9
PaulAndrewLang

1.

JSON.stringify(o);

Element: {"a": "1", "b": "2"}

2.

var o = {a:1, b:2};
var b=[]; Object.keys(o).forEach(function(k){b.Push(k+":"+o[k]);});
b="{"+b.join(', ')+"}";
console.log('Item: ' + b);

Gegenstand: {a: 1, b: 2}

7
vacsati

JSON-Methoden sind dem .toSource () - Primitiv der Gecko-Engine ziemlich unterlegen.

Siehe SO Artikelantwort für Vergleichstests.

Die Antwort oben bezieht sich auf http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html die wie JSON ( was der andere Artikel http://www.davidpirek.com/blog/object-to-string-how-to-deserialize-json verwendet, das über "ExtJs JSON encode source code" ) nicht umgehen kann Referenzen und ist unvollständig. Der folgende Code zeigt seine Einschränkungen (Spoof) (korrigiert, um Arrays und Objekte ohne Inhalt zu behandeln).

( Direkter Link zu Code in //forums.devshed.com/ .../tosource-with-arrays-in-ie-386109 )

javascript:
Object.prototype.spoof=function(){
    if (this instanceof String){
      return '(new String("'+this.replace(/"/g, '\\"')+'"))';
    }
    var str=(this instanceof Array)
        ? '['
        : (this instanceof Object)
            ? '{'
            : '(';
    for (var i in this){
      if (this[i] != Object.prototype.spoof) {
        if (this instanceof Array == false) {
          str+=(i.match(/\W/))
              ? '"'+i.replace('"', '\\"')+'":'
              : i+':';
        }
        if (typeof this[i] == 'string'){
          str+='"'+this[i].replace('"', '\\"');
        }
        else if (this[i] instanceof Date){
          str+='new Date("'+this[i].toGMTString()+'")';
        }
        else if (this[i] instanceof Array || this[i] instanceof Object){
          str+=this[i].spoof();
        }
        else {
          str+=this[i];
        }
        str+=', ';
      }
    };
    str=/* fix */(str.length>2?str.substring(0, str.length-2):str)/* -ed */+(
        (this instanceof Array)
        ? ']'
        : (this instanceof Object)
            ? '}'
            : ')'
    );
    return str;
  };
for(i in objRA=[
    [   'Simple Raw Object source code:',
        '[new Array, new Object, new Boolean, new Number, ' +
            'new String, new RegExp, new Function, new Date]'   ] ,

    [   'Literal Instances source code:',
        '[ [], {}, true, 1, "", /./, function(){}, new Date() ]'    ] ,

    [   'some predefined entities:',
        '[JSON, Math, null, Infinity, NaN, ' +
            'void(0), Function, Array, Object, undefined]'      ]
    ])
alert([
    '\n\n\ntesting:',objRA[i][0],objRA[i][1],
    '\n.toSource()',(obj=eval(objRA[i][1])).toSource(),
    '\ntoSource() spoof:',obj.spoof()
].join('\n'));

welche zeigt:

testing:
Simple Raw Object source code:
[new Array, new Object, new Boolean, new Number, new String,
          new RegExp, new Function, new Date]

.toSource()
[[], {}, (new Boolean(false)), (new Number(0)), (new String("")),
          /(?:)/, (function anonymous() {}), (new Date(1303248037722))]

toSource() spoof:
[[], {}, {}, {}, (new String("")),
          {}, {}, new Date("Tue, 19 Apr 2011 21:20:37 GMT")]

und

testing:
Literal Instances source code:
[ [], {}, true, 1, "", /./, function(){}, new Date() ]

.toSource()
[[], {}, true, 1, "", /./, (function () {}), (new Date(1303248055778))]

toSource() spoof:
[[], {}, true, 1, ", {}, {}, new Date("Tue, 19 Apr 2011 21:20:55 GMT")]

und

testing:
some predefined entities:
[JSON, Math, null, Infinity, NaN, void(0), Function, Array, Object, undefined]

.toSource()
[JSON, Math, null, Infinity, NaN, (void 0),
       function Function() {[native code]}, function Array() {[native code]},
              function Object() {[native code]}, (void 0)]

toSource() spoof:
[{}, {}, null, Infinity, NaN, undefined, {}, {}, {}, undefined]
6
Ekim

Da Firefox ein Objekt nicht als Bildschirmobjekt festlegt; Wenn Sie dasselbe Ergebnis erzielen möchten, z. B .: JSON.stringify(obj)

function objToString (obj) {
    var tabjson=[];
    for (var p in obj) {
        if (obj.hasOwnProperty(p)) {
            tabjson.Push('"'+p +'"'+ ':' + obj[p]);
        }
    }  tabjson.Push()
    return '{'+tabjson.join(',')+'}';
}
4
Abdennour TOUMI

stringify-object ist eine gute npm-Bibliothek, die vom yeoman-Team erstellt wurde: https://www.npmjs.com/package/stringify-object

npm install stringify-object

dann: 

const stringifyObject = require('stringify-object');
stringifyObject(myCircularObject);

Offensichtlich ist es nur interessant, wenn Sie ein kreisförmiges Objekt haben, das mit JSON.stringify(); fehlschlagen würde.

3
Nicolas Zozol

Schau dir das jQuery-JSON plugin an

Im Kern verwendet es JSON.stringify, greift jedoch auf seinen eigenen Parser zurück, wenn der Browser es nicht implementiert.

3
Evan Plaice

Wenn Sie sich nur um Zeichenfolgen, Objekte und Arrays kümmern:

function objectToString (obj) {
        var str = '';
        var i=0;
        for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
                if(typeof obj[key] == 'object')
                {
                    if(obj[key] instanceof Array)
                    {
                        str+= key + ' : [ ';
                        for(var j=0;j<obj[key].length;j++)
                        {
                            if(typeof obj[key][j]=='object') {
                                str += '{' + objectToString(obj[key][j]) + (j > 0 ? ',' : '') + '}';
                            }
                            else
                            {
                                str += '\'' + obj[key][j] + '\'' + (j > 0 ? ',' : ''); //non objects would be represented as strings
                            }
                        }
                        str+= ']' + (i > 0 ? ',' : '')
                    }
                    else
                    {
                        str += key + ' : { ' + objectToString(obj[key]) + '} ' + (i > 0 ? ',' : '');
                    }
                }
                else {
                    str +=key + ':\'' + obj[key] + '\'' + (i > 0 ? ',' : '');
                }
                i++;
            }
        }
        return str;
    }
3
Anuraag Vaidya
var o = {a:1, b:2};

o.toString=function(){
  return 'a='+this.a+', b='+this.b;
};

console.log(o);
console.log('Item: ' + o);

Da Javascript v1.0 überall funktioniert (auch im IE), ist dies ein nativer Ansatz, der ein sehr kostenoptimiertes Aussehen Ihres Objekts während des Debugging und in der Produktion ermöglicht https://developer.mozilla.org/ de/docs/Web/JavaScript/Referenz/Global_Objects/Object/toString

Nützliches Beispiel

var Ship=function(n,x,y){
  this.name = n;
  this.x = x;
  this.y = y;
};
Ship.prototype.toString=function(){
  return '"'+this.name+'" located at: x:'+this.x+' y:'+this.y;
};

alert([new Ship('Star Destroyer', 50.001, 53.201),
new Ship('Millennium Falcon', 123.987, 287.543),
new Ship('TIE fighter', 83.060, 102.523)].join('\n'));//now they can battle!
//"Star Destroyer" located at: x:50.001 y:53.201
//"Millennium Falcon" located at: x:123.987 y:287.543
//"TIE fighter" located at: x:83.06 y:102.523

Auch als Bonus

function ISO8601Date(){
  return this.getFullYear()+'-'+(this.getMonth()+1)+'-'+this.getDate();
}
var d=new Date();
d.toString=ISO8601Date;//demonstrates altering native object behaviour
alert(d);
//IE6   Fri Jul 29 04:21:26 UTC+1200 2016
//FF&GC Fri Jul 29 2016 04:21:26 GMT+1200 (New Zealand Standard Time)
//d.toString=ISO8601Date; 2016-7-29
2
Alex

Ich denke, für Ihr Beispiel wäre console.log("Item:",o) Am einfachsten. Aber console.log("Item:" + o.toString) Würde auch funktionieren.

Bei der Methode Nummer 1 wird ein Nice-Dropdown-Menü in der Konsole verwendet, sodass ein langes Objekt gut funktioniert.

1
Fuzzyzilla

Wenn Sie das Dojo-Javascript-Framework verwenden, gibt es bereits eine eingebaute Funktion, um dies auszuführen: dojo.toJson (), die so verwendet wird. 

var obj = {
  name: 'myObj'
};
dojo.toJson(obj);

das wird eine Zeichenfolge zurückgeben. Wenn Sie das Objekt in Json-Daten konvertieren möchten, fügen Sie den zweiten Parameter "true" hinzu.

dojo.toJson(obj, true);

http://dojotoolkit.org/reference-guide/dojo/toJson.html#dojo-tojson

1
Chris O'Connell
/*
    This function is as JSON.Stringify (but if you has not in your js-engine you can use this)
    Params:
        obj - your object
        inc_ident - can be " " or "\t".
        show_types - show types of object or not
        ident - need for recoursion but you can not set this parameter.
*/
function getAsText(obj, inc_ident, show_types, ident) {
    var res = "";
    if (!ident)
        ident = "";
    if (typeof(obj) == "string") {
        res += "\"" + obj + "\" ";
        res += (show_types == true) ? "/* typeobj: " + typeof(obj) + "*/" : "";
    } else if (typeof(obj) == "number" || typeof(obj) == "boolean") {
        res += obj;
        res += (show_types == true) ? "/* typeobj: " + typeof(obj) + "*/" : "";
    } else if (obj instanceof Array) {
        res += "[ ";
        res += show_types ? "/* typeobj: " + typeof(obj) + "*/" : "";
        res += "\r\n";
        var new_ident = ident + inc_ident;
        var arr = [];
        for(var key in obj) {
            arr.Push(new_ident + getAsText(obj[key], inc_ident, show_types, new_ident));
        } 
        res += arr.join(",\r\n") + "\r\n";
        res += ident + "]";
    } else {
        var new_ident = ident + inc_ident;      
        res += "{ ";
        res += (show_types == true) ? "/* typeobj: " + typeof(obj) + "*/" : "";
        res += "\r\n";
        var arr = [];
        for(var key in obj) {
            arr.Push(new_ident + '"' + key + "\" : " + getAsText(obj[key], inc_ident, show_types, new_ident));
        }
        res += arr.join(",\r\n") + "\r\n";
        res += ident + "}\r\n";
    } 
    return res;
};

zu verwendendes Beispiel:

var obj = {
    str : "hello",
    arr : ["1", "2", "3", 4],
b : true,
    vobj : {
        str : "hello2"
    }
}

var ForReading = 1, ForWriting = 2;
var fso = new ActiveXObject("Scripting.FileSystemObject")
f1 = fso.OpenTextFile("your_object1.txt", ForWriting, true)
f1.Write(getAsText(obj, "\t"));
f1.Close();

f2 = fso.OpenTextFile("your_object2.txt", ForWriting, true)
f2.Write(getAsText(obj, "\t", true));
f2.Close();

your_object1.txt:

{ 
    "str" : "hello" ,
    "arr" : [ 
        "1" ,
        "2" ,
        "3" ,
        4
    ],
    "b" : true,
    "vobj" : { 
        "str" : "hello2" 
    }

}

your_object2.txt:

{ /* typeobj: object*/
    "str" : "hello" /* typeobj: string*/,
    "arr" : [ /* typeobj: object*/
        "1" /* typeobj: string*/,
        "2" /* typeobj: string*/,
        "3" /* typeobj: string*/,
        4/* typeobj: number*/
    ],
    "b" : true/* typeobj: boolean*/,
    "vobj" : { /* typeobj: object*/
        "str" : "hello2" /* typeobj: string*/
    }

}
1
sea-kg

Für nicht geschachtelte Objekte:

Object.entries(o).map(x=>x.join(":")).join("\r\n")
1
Alex Szücs

Wenn Sie nur eine Zeichenfolgenausgabe erhalten möchten, sollte dies funktionieren: String(object)

1
Moe

Ich musste eine konfigurierbarere Version von JSON.stringify erstellen, da ich Kommentare hinzufügen und den JSON-Pfad kennen musste:

const someObj = {
  a: {
    nested: {
      value: 'Apple',
    },
    sibling: 'peanut'
  },
  b: {
    languages: ['en', 'de', 'fr'],
    c: {
      Nice: 'heh'
    }
  },
  c: 'butter',
  d: function () {}
};

function* objIter(obj, indent = '  ', depth = 0, path = '') {
  const t = indent.repeat(depth);
  const t1 = indent.repeat(depth + 1);
  const v = v => JSON.stringify(v);
  yield { type: Array.isArray(obj) ? 'OPEN_ARR' : 'OPEN_OBJ', indent, depth };
  const keys = Object.keys(obj);
  
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i];
    const prop = obj[key];
    const nextPath = !path && key || `${path}.${key}`;
 
    if (typeof prop !== 'object') {
      yield { type:  isNaN(key) ? 'VAL' : 'ARR_VAL', key, prop, indent, depth, path: nextPath };
    } else {
      yield { type: 'OBJ_KEY', key, indent, depth, path: nextPath };
      yield* objIter(prop, indent, depth + 1, nextPath);
    }
  }

  yield { type: Array.isArray(obj) ? 'CLOSE_ARR' : 'CLOSE_OBJ', indent, depth };
}

const iterMap = (it, mapFn) => {
  const arr = [];
  for (const x of it) { arr.Push(mapFn(x)) }
  return arr;
}

const objToStr = obj => iterMap(objIter(obj), ({ type, key, prop, indent, depth, path }) => {
  const t = indent.repeat(depth);
  const t1 = indent.repeat(depth + 1);
  const v = v => JSON.stringify(v);

  switch (type) {
    case 'OPEN_ARR':
      return '[\n';
    case 'OPEN_OBJ':
      return '{\n';
    case 'VAL':
      return `${t1}// ${path}\n${t1}${v(key)}: ${v(prop)},\n`;
    case 'ARR_VAL':
      return `${t1}// ${path}\n${t1}${v(prop)},\n`;
    case 'OBJ_KEY':
      return `${t1}// ${path}\n${t1}${v(key)}: `;
    case 'CLOSE_ARR':
    case 'CLOSE_OBJ':
      return `${t}${type === 'CLOSE_ARR' ? ']' : '}'}${depth ? ',' : ';'}\n`;
    default:
      throw new Error('Unknown type:', type);
  }
}).join('');

const s = objToStr(someObj);
console.log(s);

0
Dominic
function objToString (obj) {
    var str = '{';
    if(typeof obj=='object')
      {

        for (var p in obj) {
          if (obj.hasOwnProperty(p)) {
              str += p + ':' + objToString (obj[p]) + ',';
          }
      }
    }
      else
      {
         if(typeof obj=='string')
          {
            return '"'+obj+'"';
          }
          else
          {
            return obj+'';
          }
      }



    return str.substring(0,str.length-1)+"}";
}
0
Mauro

Wenn Sie kein Spiel beitreten (), werden Sie mit Object verbunden.

const obj = {one:1, two:2, three:3};
let arr = [];
for(let p in obj)
    arr.Push(obj[p]);
const str = arr.join(',');

Ich hoffe, dieses Beispiel hilft allen, die an einer Reihe von Objekten arbeiten

var data_array = [{
                    "id": "0",
                    "store": "ABC"
                },{
                    "id":"1",
                    "store":"XYZ"
                }];
console.log(String(data_array[1]["id"]+data_array[1]["store"]));
0
Khushal Chheda

In den vorhandenen Antworten fehlt eine einfache Option (für aktuelle Browser und Node.js):

console.log('Item: %o', o);

Ich würde dies vorziehen, da JSON.stringify() bestimmte Einschränkungen hat (z. B. bei kreisförmigen Strukturen).

0

Wenn Sie lodash verwenden können, können Sie dies folgendermaßen tun:

> var o = {a:1, b:2};
> '{' + _.map(o, (value, key) => key + ':' + value).join(', ') + '}'
'{a:1, b:2}'

Mit lodash map() können Sie auch über Objekte iterieren ..__ Dies ordnet jeden Schlüssel-/Werteintrag seiner String-Darstellung zu:

> _.map(o, (value, key) => key + ':' + value)
[ 'a:1', 'b:2' ]

Und join() fügt die Array-Einträge zusammen.

Wenn Sie ES6 Template String verwenden können, funktioniert dies auch:

> `{${_.map(o, (value, key) => `${key}:${value}`).join(', ')}}`
'{a:1, b:2}'

Bitte beachten Sie, dass das Objekt nicht rekursiv durchläuft:

> var o = {a:1, b:{c:2}}
> _.map(o, (value, key) => `${key}:${value}`)
[ 'a:1', 'b:[object Object]' ]

Wie Nodes util.inspect() wird Folgendes tun:

> util.inspect(o)
'{ a: 1, b: { c: 2 } }'
0
kwarnke

Wenn Sie eine minimalistische Methode zum Konvertieren einer Variablen in eine Zeichenfolge für eine Situation mit Inline-Ausdruckstypen wünschen, ist ''+variablename die beste, die ich gespielt habe.

Wenn "Variablenname" ein Objekt ist und Sie die leere Zeichenfolgenverkettung verwenden, wird [object Object] angezeigt. In diesem Fall möchten Sie wahrscheinlich, dass Gary C. JSON.stringify die enorm gestellte Antwort auf die veröffentlichte Frage hat, die Sie in Mozilla lesen können Entwicklernetzwerk unter dem Link in diese Antwort oben .

0
stackuser83

Es scheint, dass JSON den zweiten Parameter akzeptiert, der bei Funktionen hilfreich sein kann - replace . Dies löst das Problem der Konvertierung auf eleganteste Weise:

JSON.stringify(object, (key, val) => {
    if (typeof val === 'function') {
      return String(val);
    }
    return val;
  });
0
Gleb Dolzikov