Convertire un object in una stringa

Come posso convertire un object JavaScript in una stringa?

Esempio:

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

Produzione:

Object {a = 1, b = 2} // output molto leggibile 🙂
Articolo: [object Object] // non ho idea di cosa c’è dentro 🙁

Vorrei raccomandare l’uso di JSON.stringify , che converte l’insieme delle variabili nell’object in una stringa JSON. La maggior parte dei browser moderni supporta questo metodo in modo nativo, ma per quelli che non lo fanno, è ansible includere una versione di JS :

 var obj = { name: 'myObj' }; JSON.stringify(obj); 

Certo, per convertire un object in una stringa, devi utilizzare il tuo metodo, ad esempio:

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

In realtà, quanto sopra mostra solo l’approccio generale; potresti voler usare qualcosa come http://phpjs.org/functions/var_export:578 o http://phpjs.org/functions/var_dump:604

oppure, se non stai usando i metodi (funzioni come proprietà del tuo object), potresti essere in grado di usare il nuovo standard (ma non implementato nei browser più vecchi, anche se puoi trovare un’utilità che aiuti anche per loro), JSON .stringify (). Ma ancora, questo non funzionerà se l’object usa funzioni o altre proprietà che non sono serializzabili in JSON.

Usa la funzione javascript String ().

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

o

 JSON.stringify(yourobject) 

.

Mantenendolo semplice con la console , puoi semplicemente usare una virgola invece di un + . + Cercherà di convertire l’object in una stringa, mentre la virgola lo visualizzerà separatamente nella console.

Esempio:

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

Produzione:

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

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

EDIT Non utilizzare questa risposta in quanto non funziona in Internet Explorer. Usa la soluzione di Gary Chambers .

toSource () è la funzione che stai cercando e che la scriverà come JSON.

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

Un’opzione :

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

o è stampato come una stringa

Un’altra opzione (come sottolineato da soktinpk nei commenti), e meglio per IMO di debug della console:

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

o è stampato come un oggetto, che potresti approfondire se avessi più campi

Nessuna delle soluzioni qui ha funzionato per me. JSON.stringify sembra essere quello che molte persone dicono, ma ritaglia le funzioni e sembra piuttosto rotto per alcuni oggetti e array che ho provato durante il test.

Ho creato la mia soluzione che funziona almeno in Chrome. Inseriscilo qui in modo che chiunque possa trovarlo su Google possa trovarlo.

 //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: So che questo codice può essere migliorato ma non è mai riuscito a farlo. L’utente andrey ha suggerito un miglioramento qui con il commento:

Ecco un codice un po ‘cambiato, che può gestire “null” e “undefined”, e inoltre non aggiungere virgole eccessive.

Usalo a tuo rischio, poiché non l’ho ancora verificato. Sentiti libero di suggerire ulteriori miglioramenti come commento.

Se stai trasmettendo solo la console, puoi usare console.log('string:', obj) . Nota la virgola

Nei casi in cui sai che l’object è solo un booleano, una data, una stringa, un numero ecc. La funzione javascript String () funziona perfettamente. Recentemente ho trovato questo utile nel trattare i valori provenienti dalla funzione $ .each di jquery.

Ad esempio quanto segue converte tutti gli elementi in “valore” in una stringa:

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

Maggiori dettagli qui:

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

 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); 

Stavo cercando questo, e ho scritto un profondo ricorsivo con indentazione:

 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(); } } 

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

Se vuoi solo vedere l’object per il debug, puoi usare

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

1.

 JSON.stringify(o); 

Articolo: {“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); 

Articolo: {a: 1, b: 2}

I metodi JSON sono piuttosto inferiori al primitivo del motore Gecko .toSource ().

Vedere la risposta dell’articolo SO per i test di confronto.

Inoltre, la risposta sopra si riferisce a http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html che, come JSON, (che l’altro articolo http: // http://www.davidpirek.com/blog/object-to-string-how-to-deserialize-json utilizza tramite “ExtJs JSON codifica codice sorgente” ) non può gestire riferimenti circolari ed è incompleto. Il codice seguente mostra le limitazioni (spoof) (corrette per gestire matrici e oggetti senza contenuto).

( collegamento diretto al codice in //forums.devshed.com/ … / tosource-with-array-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')); 

che visualizza:

 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")] 

e

 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")] 

e

 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] 

Come firefox non stringe alcun object come object dello schermo; se vuoi avere lo stesso risultato come: 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(',')+'}'; } 

Dai un’occhiata al plugin jQuery-JSON

Al suo interno, usa JSON.stringify ma torna al proprio parser se il browser non lo implementa.

Se ti interessano solo stringhe, oggetti e matrici:

 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 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; } 
 var o = {a:1, b:2}; o.toString=function(){ return 'a='+this.a+', b='+this.b; }; console.log(o); console.log('Item: ' + o); 

Dal momento che Javascript v1.0 funziona ovunque (anche IE) questo è un approccio nativo e consente un aspetto molto costellato del tuo object durante il debugging e in produzione https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / object / toString

Esempio utile

 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 

Inoltre, come 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 

stringify-object è una buona libreria di npm creata dal team di yeoman: https://www.npmjs.com/package/stringify-object

 npm install stringify-object` 

poi:

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

Se si utilizza il framework javascript di Dojo, esiste già una funzione build in do: dojo.toJson () che verrebbe utilizzata in questo modo.

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

che restituirà una stringa. Se si desidera convertire l’object in dati json, aggiungere un secondo parametro di true.

 dojo.toJson(obj, true); 

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

 /* 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; }; 

esempio da usare:

 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*/ } } 

Per il tuo esempio, penso che console.log("Item:",o) sarebbe più semplice. Ma anche console.log("Item:" + o.toString) funzionerebbe.

Usando il metodo numero uno usa un bel menu a discesa nella console, quindi un object lungo funzionerebbe bene.

 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)+"}"; } 

Spero che questo esempio possa aiutare tutti coloro che stanno lavorando su una serie di oggetti

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

Se puoi usare lodash puoi farlo in questo modo:

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

Con la map() lodash map() puoi anche scorrere gli oggetti. Questo mappa ogni voce chiave / valore per la sua rappresentazione di stringa:

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

E join() mette insieme le voci dell’array.

Se è ansible utilizzare ES6 Template String, funziona anche:

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

Si prega di notare che questo non va ricorsivo attraverso l’object:

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

Come il nodo utilizza util.inspect() :

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

Se non aplay join () su Object.

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

Per oggetti non annidati:

 Object.entries(o).map(x=>x.join(":")).join("\r\n") 
 setobjToString:function(obj){ var me =this; obj=obj[0]; var tabjson=[]; for (var p in obj) { if (obj.hasOwnProperty(p)) { if (obj[p] instanceof Array){ tabjson.push('"'+p +'"'+ ':' + me.setobjToString(obj[p])); }else{ tabjson.push('"'+p +'"'+':"'+obj[p]+'"'); } } } tabjson.push() return '{'+tabjson.join(',')+'}'; }