Convertendo um objeto em uma string

975

Como posso converter um objeto JavaScript em uma string?

Exemplo:

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

Resultado:

Objeto {a = 1, b = 2} // saída legível muito boa :)
Item: [objeto Objeto] // não faz ideia do que está dentro :(

user680174
fonte
7
Converter em string para qual finalidade? Você quer dizer serializar para poder construir o objeto posteriormente a partir da string? Ou apenas para exibição?
Shadow Wizard é Ear For You
19
O autor desapareceu de anos, mas, lendo anos depois, acho que o ponto de entrada para o problema foi o console.log (obj), que exibe o objeto com propriedades, enquanto console.log ('obj:' + obj ) funciona de maneira desorientadora.
Danubian Sailor
2
simplesmente não é possível aplicar adicionar dois objetos. Se pudermos fazê-lo, não haverá diferenças no tipo de valor e no tipo ref.
Nishant Kumar
12
var o = {a: 1, b: 2}; console.log ('Item:' + JSON.stringify (o))
Nishant Kumar
22
Se for para o console, eu recomendaria fazer console.log("Item", obj);. Não há necessidade de nada complicado.
soktinpk

Respostas:

1333

Eu recomendaria usar JSON.stringify, que converte o conjunto de variáveis ​​no objeto em uma string JSON. A maioria dos navegadores modernos suporta esse método nativamente, mas para aqueles que não suportam, você pode incluir uma versão JS :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);
Gary Chambers
fonte
7
Para referência IE6 e 7, não há suporte para isso. O IE6 não é grande coisa por causa de muito poucos usuários e uma campanha ativa para eliminá-lo ... mas ainda existem muitos usuários do IE7 por aí (depende da sua base de usuários).
precisa saber é o seguinte
30
Recebo um "TypeError não capturado: convertendo estrutura circular para JSON". Mesmo se houver uma referência circular, eu ainda gostaria de ver uma representação de string do meu objeto. O que eu posso fazer?
Pascal Klein
26
Isso não funciona se o objeto tem uma propriedade de função, por exemplo: foo: function () {...}.
Brock Adams
2
O link para a biblioteca JSON não funciona se clicado no StackOverflow. Copie e cole na barra de endereço.
precisa saber é o seguinte
1
Você pode usar JSON.stringify(obj, null, 2);para obter uma saída mais bonita.
l.poellabauer
126

Use javascript String () função

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

ou stringify ()

JSON.stringify(yourobject)
Vikram Pote
fonte
28
var foo = {bar: 1}; String (foo); -> "[objeto Objeto]"
Anti Veeranna
1
var foo = {bar: 1}; String (foo ['bar']); -> "1"
Vikram Pote
3
Se você quiser objeto inteiro como o uso corda JSON.stringify (foo)
Vikram Pote
8
JSON.stringify(yourobject)empregada doméstica meu dia!
Neurotransmitter
1
@TranslucentCloud * made
Parampal Pooni
87

Claro, para converter um objeto 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 mostra apenas a abordagem geral; você pode 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 métodos (funciona como propriedades do seu objeto), poderá usar o novo padrão (mas não implementado em navegadores mais antigos, embora possa encontrar um utilitário para ajudá-lo também), JSON .stringify (). Mas, novamente, isso não funcionará se o objeto usar funções ou outras propriedades que não sejam serializáveis ​​para JSON.

Brett Zamir
fonte
78

Para simplificar console, você pode usar vírgula em vez de a +. O +tentará converter o objeto em uma string, enquanto a vírgula o exibirá separadamente no console.

Exemplo:

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

Resultado:

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/en-US/docs/Web/API/Console.log

Lucas
fonte
Greate solução! Mas você poderia me dizer o que acontece nos bastidores quando você simplesmente faz isso console.log(o):? Como se você tentar registrar um objeto adicionado a uma string, ele realmente chamará toString()o objeto.
Gocy015
1
console.logem última análise, chama algo chamado Printerque a especificação observa: "Como a implementação imprime args depende da implementação" - o que significa que todo navegador pode fazer isso de maneira diferente (consulte console.spec.whatwg.org/#printer ). O Firefox exibirá objetos como uma string, mas com cores bonitas. O Chrome exibirá o objeto como um grupo interativo que você pode expandir para ver as propriedades. De uma chance!
29416 Luke
2
Truque muito bom e provavelmente bom para navegadores da web modernos, mas não é 100% confiável para todas as implementações de JS. por exemplo, no Qt QML, que implementa um mecanismo JS, a saída para console.log('Item: ', o);ainda é Item: [object Object].
Paul Masri-Stone
Em vez de console.logvocê pode usar console.dir(o)para imprimir o objeto javascript, para imprimi-lo como uma string. Nas ferramentas do desenvolvedor, isso permite abrir o objeto e verificar todas as propriedades, mesmo matrizes. (consulte: developer.mozilla.org/de/docs/Web/API/Console/dir )
EagleT
37

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

toSource () é a função que você está procurando que a escreverá como JSON.

var object = {};
object.first = "test";
object.second = "test2";
alert(object.toSource());
Gazler
fonte
6
Embora seja conveniente para depuração no Firefox, toSource()não funciona no IE.
Brett Zamir
4
toSource()não é um padrão reconhecido, portanto, não é possível garantir o suporte em todos os navegadores.
Gary Chambers
11
Ahh, obrigado por apontar isso. Deixarei minha resposta aqui para outros que desconhecem isso.
Gazler
Eu gostaria de poder te votar mais, pois esta é uma solução brilhante para ambientes que possuem javascript (mas o log do console é inconveniente / impossível de acessar).
Zack Morris
Você poderia fornecer um polypill para toSource: github.com/oliver-moran/toSource.js/blob/master/toSource.js
roland
32

Uma opção :

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

o é impresso como uma sequência

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

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

o é impresso como um objeto, que você pode detalhar se tiver mais campos

nabn
fonte
22

Nenhuma das soluções aqui funcionou para mim. JSON.stringify parece ser o que muita gente diz, mas corta funções e parece bastante danificado para alguns objetos e matrizes que tentei ao testá-lo.

Eu fiz minha própria solução que funciona pelo menos no Chrome. Postá-lo aqui para que qualquer pessoa que pesquisar isso 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("")
}

Edição: Eu sei que este código pode ser melhorado, mas nunca chegou a fazê-lo. O usuário andrey sugeriu uma melhoria aqui com o comentário:

Aqui está um código um pouco alterado, que pode manipular 'nulo' e 'indefinido' e também não adiciona vírgulas excessivas.

Use isso por sua conta e risco, pois eu ainda não o verifiquei. Sinta-se livre para sugerir melhorias adicionais como um comentário.

Houshalter
fonte
Faltam alguns '}
dacopenhagen
2
Código muito bom, mas existe um final ,no final de cada objeto / matriz.
NiCk Newman
esta é a melhor resposta
Roman
20

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

Alexandre R. Janini
fonte
Isso coloca problemas nos cenários em que o AJAX e o adiado são reproduzidos - a saída console.loggeralmente é exibida após o AJAX concluir o fornecimento de dados em paralelo à matriz, o que leva a resultados enganosos. Nesses casos, a clonagem ou a serialização de objetos é o caminho a seguir: desde que registramos objetos duplicados, mesmo quando o AJAX termina seu trabalho, ele preenche dados "antigos".
RR
18

Nos casos em que você sabe que o objeto é apenas um Booleano, Data, String, número etc ... A função javascript String () funciona perfeitamente. Recentemente, eu achei isso útil ao lidar com valores provenientes da função $ .each do jquery.

Por exemplo, o seguinte converteria todos os itens em "valor" em uma cadeia de caracteres:

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

Mais detalhes aqui:

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

Jake Drew
fonte
Ouvar my_string = ''+value+'';
John Magnolia
1
Funciona para mim. Prefiro esta solução porque não usaria um plug-in para uma tarefa tão simples.
Tillito 15/09/2013
15
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);
ensolarado rai
fonte
12

Eu estava procurando por isso e escrevi uma profunda recursiva com recuo:

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

SylvainPV
fonte
note que se você quer evitar loops infinitos para objetos com referências circulares, você pode adicionar if(ndeep > MAX_DEPTH_LEVEL){ return '...'; }na função, com MAX_DEPTH_LEVEL sendo o seu número máximo escolhido de camadas de objeto para cavar.
SylvainPV
11

Se você quiser apenas ver o objeto para depuração, poderá usar

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

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}

vacsati
fonte
1
Seria melhor se você considerasse adicionar mais detalhes sobre sua resposta.
Harun Diluka Heshan
8

Os métodos JSON são bastante inferiores ao primitivo .toSource () do mecanismo Gecko.

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

Também o 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: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json usa via "ExtJs JSON codificar código fonte" ) não pode manipular referências circulares e está incompleto. O código abaixo mostra suas limitações (falsas) (corrigidas para manipular matrizes e objetos 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]
Ekim
fonte
8

Na verdade, existe uma opção fácil (para navegadores recentes e Node.js) ausente nas respostas existentes:

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

Eu preferiria isso porque JSON.stringify()tem certas limitações (por exemplo, com estruturas circulares).

Christian Gawron
fonte
7

Parece que o JSON aceita o segundo parâmetro que poderia ajudar nas funções - substituto , isso resolve o problema de conversão da maneira mais elegante:

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

Se você se importa apenas com cadeias, objetos 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<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;
    }
Anuraag Vaidya
fonte
5

stringify-objecté uma boa biblioteca de npm feita pela equipe yeoman: https://www.npmjs.com/package/stringify-object

npm install stringify-object

então:

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

Obviamente, é interessante apenas se você tiver um objeto circular que falharia com JSON.stringify();

Nicolas Zozol
fonte
1
Por que alguém usaria um módulo NPM para algo assim, que pode ser alcançado por uma linha em JS simples? Esta resposta precisa de detalhes sobre por que alguém faria isso.
Zelphir Kaltstahl
Com frequência, uma lib ajudaria em casos extremos. Eu usei para lidar com referências circulares.
Nicolas Zozol 15/1018
1
Isso faz mais sentido com a observação adicionada sobre objetos circulares, removendo meu voto negativo.
Zelphir Kaltstahl
4

Dê uma olhada no plugin jQuery-JSON

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

Evan Plaice
fonte
4

Como o Firefox não especifica algum objeto como objeto de tela; se você deseja obter 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(',')+'}';
}
Abdennour TOUMI
fonte
4

Para objetos não aninhados:

Object.entries(o).map(x=>x.join(":")).join("\r\n")
Alex Szücs
fonte
2
var o = {a:1, b:2};

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

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

Como o Javascript v1.0 funciona em qualquer lugar (até o IE), essa é uma abordagem nativa e permite uma aparência muito cara do seu objeto durante a depuração e na produção https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Objetos_ globais / Objeto / 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
Alex
fonte
2

Se você pode usar o lodash, pode fazê-lo desta maneira:

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

Com o lodash, map()você também pode interagir com os objetos. Isso mapeia cada entrada de chave / valor para sua representação de sequência:

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

E join()coloque as entradas da matriz juntas.

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

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

Observe que isso não é recursivo através do objeto:

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

Como o util.inspect() fará:

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

Se você estiver usando a estrutura javascript do Dojo, já existe uma função de construção para fazer isso: dojo.toJson () que seria usada dessa maneira.

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

que retornará uma string. Se você deseja converter o objeto em dados json, adicione um segundo parâmetro de true.

dojo.toJson(obj, true);

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

Chris O'Connell
fonte
1
/*
    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*/
    }

}
kg-mar
fonte
1
Seria uma boa explicação do que o código faz e um exemplo de como usá-lo. Obrigado
estemendoza
1

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

O uso do método número um usa um bom menu suspenso no console; portanto, um objeto longo funcionaria bem.

Fuzzyzilla
fonte
1
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)+"}";
}
Mauro
fonte
1

Espero que este exemplo ajude a todos aqueles que estão trabalhando na variedade de objetos

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

Se você não jogará join () no Object.

const obj = {one:1, two:2, three:3};
let arr = [];
for(let p in obj)
    arr.push(obj[p]);
const str = arr.join(',');
Илья Индиго
fonte
0

Se você deseja um método minimalista de converter uma variável em uma sequência de caracteres para uma situação de tipo de expressão embutida, ''+variablename é o melhor que já joguei.

Se 'variablename' for um objeto e você usar a operação de concatenação de cadeias vazias, isso causará irritante [object Object]; nesse caso, você provavelmente deseja a JSON.stringifyresposta enormemente votada por Gary C. à pergunta publicada, sobre a qual você pode ler na Mozilla's Developer Network. no link dessa resposta na parte superior .

stackuser83
fonte