Convertendo um object para uma string

Como posso converter um object JavaScript em uma string?

Exemplo:

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

Saída:

Objeto {a = 1, b = 2} // saída legível muito boa 🙂
Item: [Objeto object] // nenhuma idéia do que está dentro 🙁

Eu recomendaria o uso de JSON.stringify , que converte o conjunto de variables ​​no object em uma string JSON. A maioria dos navegadores modernos suporta esse método nativamente, mas, para aqueles que não o fazem, você pode include uma versão do JS :

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

Claro, para converter um object em uma string, você precisa usar seu próprio método, como:

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

Na verdade, o acima apenas mostra a abordagem geral; talvez você queira usar algo como http://phpjs.org/functions/var_export:578 ou http://phpjs.org/functions/var_dump:604

ou, se você não estiver usando methods (funções como propriedades de seu object), você poderá usar o novo padrão (mas não implementado em navegadores mais antigos, embora você possa encontrar um utilitário para ajudá-lo também), JSON .stringify (). Mas, novamente, isso não funcionará se o object usar funções ou outras propriedades que não são serializáveis ​​para JSON.

Use a function javascript String ().

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

ou

 JSON.stringify(yourobject) 

.

Mantendo a simplicidade com o console , você pode usar apenas uma vírgula ao invés de um + . O + tentará converter o object em uma string, enquanto a vírgula irá exibi-lo separadamente no console.

Exemplo:

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

Saída:

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

Referência: https://developer.mozilla.org/pt-BR/docs/Web/API/Console.log

EDITAR Não use esta resposta, pois ela não funciona no Internet Explorer. Use a solução de Gary Chambers .

toSource () é a function que você está procurando, que irá escrevê-lo como JSON.

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

Uma opção :

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

o é impresso como uma string

Outra opção (como soktinpk apontou nos comentários), e melhor para o console de debugging IMO:

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

o é impresso como um objeto, que você poderia detalhar se tivesse mais campos

Nenhuma das soluções aqui funcionou para mim. JSON.stringify parece ser o que muitas pessoas dizem, mas ele corta funções e parece muito quebrado para alguns objects e matrizes que eu tentei ao testá-lo.

Eu fiz minha própria solução, que funciona no Chrome, pelo menos. Publicá-lo aqui para que qualquer pessoa que procure no Google possa encontrá-lo.

 //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: Eu sei que esse código pode ser melhorado, mas apenas nunca chegou a fazê-lo. Usuário andrey sugeriu uma melhoria aqui com o comentário:

Aqui está um pequeno código alterado, que pode manipular ‘null’ e ‘undefined’, e também não adiciona vírgulas excessivas.

Use isso por sua conta e risco, pois não o confirmei. Sinta-se à vontade para sugerir melhorias adicionais como comentário.

Se você está apenas saindo para o console, você pode usar console.log('string:', obj) . Observe a vírgula .

Nos casos em que você sabe que o object é apenas um Booleano, Data, String, número, etc … A function javascript String () funciona muito bem. Eu recentemente achei isso útil para lidar com valores vindos da function $ .each do jquery.

Por exemplo, o seguinte converteria todos os itens em “value” para uma string:

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

Mais detalhes aqui:

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

Eu estava procurando por isso e escrevi um recursivo profundo com indentação:

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

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

Se você quer apenas ver o object para debugging, você pode usar

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

1

 JSON.stringify(o); 

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

Item: {a: 1, b: 2}

Os methods JSON são muito inferiores ao primitivo do mecanismo Gecko .toSource ().

Veja a resposta do artigo SO para testes de comparação.

Além disso, a resposta acima se refere a http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html que, como JSON, (que o outro artigo http: // O uso de http://www.davidpirek.com/blog/object-to-string-how-to-deserialize-json via “código fonte JSON encode” não pode manipular referências circulares e está incompleto. O código abaixo mostra as limitações (spoof’s) (corrigidas para lidar com matrizes e objects sem conteúdo).

( link direto para o código em //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')); 

que exibe:

 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] 

Como o firefox não restringe algum object como object de canvas; se você quiser ter o mesmo resultado, como: 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(',')+'}'; } 

Dê uma olhada no plugin jQuery-JSON

Em essência, ele usa JSON.stringify, mas retorna ao seu próprio analisador se o navegador não o implementar.

Se você se importa apenas com strings, objects e matrizes:

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

Desde que o Javascript v1.0 funciona em qualquer lugar (mesmo no IE), esta é uma abordagem nativa e permite uma aparência muito costomizada do seu object durante a debugging e produção https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

Exemplo útil

 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 

Além disso, como um bônus

 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 é uma boa biblioteca npm feita pela equipe do yeoman: https://www.npmjs.com/package/stringify-object

 npm install stringify-object` 

então:

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

Se você estiver usando o framework Dojo javascript, então já existe uma function build in para fazer isso: dojo.toJson (), que seria usado assim.

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

que retornará uma string. Se você quiser converter o object em json data, adicione um segundo parâmetro de 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; }; 

exemplo para usar:

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

Por exemplo, acho que console.log("Item:",o) seria mais fácil. Mas, console.log("Item:" + o.toString) também funcionaria.

Usando o método número um usa um bom menu suspenso no console, então um object longo funcionaria muito bem.

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

Espero que este exemplo ajude todos aqueles que estão trabalhando em uma variedade de objects

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

Se você pode usar o lodash, você pode fazer assim:

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

Com lodash map() você também pode percorrer os Objetos. Isso mapeia todas as inputs key / value para sua representação de string:

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

E join() coloca as inputs da matriz juntas.

Se você pode usar o ES6 Template String, isso também funciona:

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

Por favor, note que isso não se torna recursivo através do object:

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

Assim como o util.inspect() do nó fará:

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

Se você não vai aplay join () para Object.

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

Para objects não nesteds:

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