Convertir un objeto en una cadena

975

¿Cómo puedo convertir un objeto JavaScript en una cadena?

Ejemplo:

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

Salida:

Objeto {a = 1, b = 2} // salida legible muy agradable :)
Elemento: [objeto Objeto] // no tengo idea de qué hay dentro :(

usuario680174
fuente
77
Convertir a cadena con qué propósito? ¿Te refieres a serializar para que puedas construir el objeto más tarde desde la cadena? ¿O solo para exhibir?
Shadow Wizard es Ear For You
19
El autor se fue de años, pero leyendo en mente, después de años, supongo, el punto de entrada para el problema fue console.log (obj), que muestra objetos con propiedades, mientras que console.log ('obj:' + obj ) funciona de manera desorientadora de lo contrario.
Danubian Sailor
2
simplemente no se puede aplicar agregar dos objetos, si podemos hacerlo no habría diferencias en el tipo de valor y el tipo de referencia.
Nishant Kumar
12
var o = {a: 1, b: 2}; console.log ('Item:' + JSON.stringify (o))
Nishant Kumar
22
Si es para la consola, recomendaría hacerlo console.log("Item", obj);. No hay necesidad de nada complicado.
soktinpk

Respuestas:

1333

Recomendaría usar JSON.stringify, que convierte el conjunto de variables en el objeto a una cadena JSON. La mayoría de los navegadores modernos admiten este método de forma nativa, pero para aquellos que no lo hacen, puede incluir una versión JS :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);
Gary Chambers
fuente
77
Para referencia, IE6 y 7 no son compatibles con esto. IE6 no es un gran problema debido a los pocos usuarios y una campaña activa para matarlo ... pero todavía hay bastantes usuarios de IE7 (depende de su base de usuarios).
MikeMurko
30
Me sale un "Error de tipo no capturado: convertir la estructura circular a JSON". Incluso si hay una referencia circular, todavía me gustaría ver una representación de cadena de mi objeto. ¿Que puedo hacer?
Pascal Klein
26
Esto no funciona si el objeto tiene una propiedad función, por ejemplo: foo: function () {...}.
Brock Adams
2
El enlace a la biblioteca JSON no funciona si se hace clic desde StackOverflow. Cópielo y péguelo en la barra de direcciones.
f.ardelian
1
Puede usar JSON.stringify(obj, null, 2);para una salida más bonita.
l.poellabauer
126

El uso de JavaScript String () la función

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

o stringify ()

JSON.stringify(yourobject)
Vikram Pote
fuente
28
var foo = {bar: 1}; Cadena (foo); -> "[objeto Objeto]"
Anti Veeranna
1
var foo = {bar: 1}; Cadena (foo ['bar']); -> "1"
Vikram Pote
3
Si desea un objeto completo como cadena, use JSON.stringify (foo)
Vikram Pote
8
JSON.stringify(yourobject)mucama mi dia!
Neurotransmisor
1
@TranslucentCloud * made
Parampal Pooni
87

Claro, para convertir un objeto en una cadena, debe usar su propio método, como:

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

En realidad, lo anterior solo muestra el enfoque general; es posible que desee utilizar algo como http://phpjs.org/functions/var_export:578 o http://phpjs.org/functions/var_dump:604

o, si no está utilizando métodos (funciones como propiedades de su objeto), puede utilizar el nuevo estándar (pero no está implementado en navegadores más antiguos, aunque también puede encontrar una utilidad para ayudarlo con ellos), JSON .stringify (). Pero nuevamente, eso no funcionará si el objeto usa funciones u otras propiedades que no son serializables para JSON.

Brett Zamir
fuente
78

Manteniéndolo simple con console, puedes usar una coma en lugar de una +. El +tratará de convertir el objeto en una cadena, mientras que la coma se mostrará por separado en la consola.

Ejemplo:

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

Salida:

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

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

Luke
fuente
¡Gran solución! Pero, ¿podría decirme qué sucede detrás de escena cuando simplemente hace esto console.log(o):? Dado que si intenta registrar un objeto agregado a una cadena, en realidad llama toString()al objeto.
Gocy015
1
console.logfinalmente llama a algo llamado lo Printerque la especificación señala: "La forma en que la implementación imprime args depende de la implementación", lo que significa que cada navegador puede hacer esto de manera diferente (consulte console.spec.whatwg.org/#printer ). Firefox mostrará los objetos como una cadena, pero de buen color. Chrome mostrará el objeto como un grupo interactivo que puede expandir para ver las propiedades. ¡Darle una oportunidad!
Lucas
2
Muy buen truco y probablemente bueno para los navegadores web modernos, pero no es 100% confiable para todas las implementaciones de JS. por ejemplo, en Qt QML, que implementa un motor JS, la salida console.log('Item: ', o);sigue siendo Item: [object Object].
Paul Masri-Stone
En lugar de console.logusar, puede console.dir(o)imprimir el objeto javascript para imprimirlo como una cadena. En las herramientas de desarrollador, esto permite abrir el objeto y verificar todas las propiedades, incluso las matrices. (ver: developer.mozilla.org/de/docs/Web/API/Console/dir )
EagleT el
37

EDITAR No use esta respuesta ya que no funciona en Internet Explorer. Use la solución de Gary Chambers .

toSource () es la función que está buscando que lo escribirá como JSON.

var object = {};
object.first = "test";
object.second = "test2";
alert(object.toSource());
Gazler
fuente
66
Aunque es conveniente para la depuración en Firefox, toSource()no funciona en IE.
Brett Zamir
44
toSource()no es un estándar reconocido, por lo que no se puede garantizar que sea compatible con todos los navegadores
Gary Chambers
11
Ahh, gracias por señalar eso. Dejaré mi respuesta aquí para otros que no lo saben.
Gazler
Desearía poder votar más, ya que esta es una solución brillante para entornos que tienen JavaScript (pero el registro de la consola es inconveniente / imposible de acceder).
Zack Morris el
Puede proporcionar una pólypill a toSource: github.com/oliver-moran/toSource.js/blob/master/toSource.js
roland
32

Una opción :

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

o se imprime como una cadena

Otra opción (como soktinpk señaló en los comentarios), y mejor para la depuración de la consola IMO:

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

o se imprime como un objeto, que podría desglosar si tuviera más campos

nabn
fuente
22

Ninguna de las soluciones aquí funcionó para mí. JSON.stringify parece ser lo que mucha gente dice, pero corta funciones y parece bastante roto para algunos objetos y matrices que probé al probarlo.

Hice mi propia solución que funciona en Chrome al menos. Publicarlo aquí para que cualquiera que busque esto en Google pueda encontrarlo.

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

EDITAR: Sé que este código se puede mejorar, pero nunca lo logré. El usuario andrey sugirió una mejora aquí con el comentario:

Aquí hay un código un poco cambiado, que puede manejar 'nulo' y 'indefinido', y también no agrega comas excesivas.

Use eso bajo su propio riesgo ya que no lo he verificado en absoluto. No dude en sugerir mejoras adicionales como comentario.

Houshalter
fuente
Te faltan algunos '}'
dacopenhagen
2
Muy buen código, pero hay un final ,al final de cada objeto / matriz.
NiCk Newman
esta es la mejor respuesta
Roman
20

Si solo está enviando a la consola, puede usar console.log('string:', obj). Observe la coma .

Alexandre R. Janini
fuente
Esto plantea problemas en escenarios en los que entran en juego AJAX y diferido: la salida de a console.logmenudo se muestra después de que AJAX ha terminado de suministrar datos a la matriz en paralelo, lo que conduce a resultados engañosos. En tales casos, la clonación o la serialización de objetos es el camino a seguir: dado que registramos objetos duplicados, incluso cuando AJAX termina su trabajo, llenará datos "antiguos".
rr-
18

En los casos en que sabe que el objeto es solo un Booleano, Fecha, Cadena, número, etc. La función String () de JavaScript funciona bien. Recientemente encontré esto útil al tratar con valores que provienen de la función $ .each de jquery.

Por ejemplo, lo siguiente convertiría todos los elementos en "valor" en una cadena:

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

Más detalles aquí:

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

Jake Drew
fuente
O bienvar my_string = ''+value+'';
John Magnolia
1
Funciona para mi. Prefiero esta solución porque no usaría un complemento para una tarea tan simple.
Tillito
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);
rai soleado
fuente
12

Estaba buscando esto, y escribí uno profundo recursivo con sangría:

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
fuente
tenga en cuenta que si desea evitar bucles infinitos para objetos con referencias circulares, puede agregar if(ndeep > MAX_DEPTH_LEVEL){ return '...'; }la función, con MAX_DEPTH_LEVEL como el número máximo elegido de capas de objetos para excavar.
SylvainPV
11

Si solo desea ver el objeto para la depuración, puede usar

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

1)

JSON.stringify(o);

Elemento: {"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);

Artículo: {a: 1, b: 2}

vacsati
fuente
1
Sería mejor si considera agregar más detalles sobre su respuesta.
Harun Diluka Heshan
8

Los métodos JSON son bastante inferiores a los del motor Gecko .toSource () primitivo.

Consulte la respuesta del artículo SO para ver las pruebas de comparación.

Además, la respuesta anterior se refiere a http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html que, como JSON, (que el otro artículo http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json utiliza a través del "Código fuente de codificación ExtJs JSON" ) no puede manejar referencias circulares y está incompleto. El siguiente código muestra sus limitaciones (falsificaciones) (corregidas para manejar matrices y objetos sin contenido).

( enlace directo al código en //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 muestra:

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

y

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

y

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
fuente
8

En realidad, falta una opción fácil (para navegadores recientes y Node.js) en las respuestas existentes:

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

Preferiría esto ya que JSON.stringify()tiene ciertas limitaciones (por ejemplo, con estructuras circulares).

Christian Gawron
fuente
7

Parece que JSON acepta el segundo parámetro que podría ayudar con las funciones: reemplazante , esto resuelve el problema de la conversión de la manera más elegante:

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

Si solo le interesan las cadenas, los objetos y las matrices:

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
fuente
5

stringify-objectes una buena biblioteca de npm hecha por el equipo de yeoman: https://www.npmjs.com/package/stringify-object

npm install stringify-object

entonces:

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

Obviamente, es interesante solo si tiene un objeto circular que fallaría con JSON.stringify();

Nicolas Zozol
fuente
1
¿Por qué alguien usaría un módulo NPM para algo como esto, que se puede lograr con una sola línea en JS simple? Esta respuesta necesita detalles sobre por qué alguien lo haría.
Zelphir Kaltstahl el
Como a menudo, una lib ayudaría en casos extremos. Lo usé para tratar referencias circulares.
Nicolas Zozol
1
Esto tiene más sentido con la nota agregada sobre objetos circulares, eliminando mi voto negativo.
Zelphir Kaltstahl
4

Echa un vistazo al complemento jQuery-JSON

En esencia, utiliza JSON.stringify pero recurre a su propio analizador si el navegador no lo implementa.

Evan Plaice
fuente
4

Como firefox no stringifica algún objeto como objeto de pantalla; si quieres tener el mismo 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
fuente
4

Para objetos no anidados:

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

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

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

Dado que Javascript v1.0 funciona en todas partes (incluso IE), este es un enfoque nativo y permite una apariencia muy costosa de su objeto durante la depuración y la producción https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

Ejemplo ú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

Además, como un bono

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
fuente
2

Si puede usar lodash, puede hacerlo de esta manera:

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

Con lodash map()puedes iterar sobre objetos también. Esto asigna cada entrada de clave / valor a su representación de cadena:

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

Y join()junte las entradas de la matriz.

Si puede usar la cadena de plantilla ES6, esto también funciona:

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

Tenga en cuenta que esto no es recursivo a través del objeto:

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

Al igual que los nodosutil.inspect() harán:

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

Si está utilizando el framework Dojo javascript, entonces ya hay una función de compilación para hacer esto: dojo.toJson () que se usaría así.

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

que devolverá una cadena. Si desea convertir el objeto a datos json, agregue un segundo parámetro de verdadero.

dojo.toJson(obj, true);

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

Chris O'Connell
fuente
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;
};

ejemplo a 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 de mar
fuente
1
Sería bueno y una explicación de lo que hace el código y un ejemplo de cómo usarlo. Gracias
estemendoza
1

Para su ejemplo, creo console.log("Item:",o) que sería más fácil. Pero, console.log("Item:" + o.toString) también funcionaría.

El uso del método número uno usa un buen menú desplegable en la consola, por lo que un objeto largo funcionaría bien.

Fuzzyzilla
fuente
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
fuente
1

Espero que este ejemplo ayude a todos aquellos que trabajan en una variedad 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
fuente
1

Si no vas a unir, únete () a Object.

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

Referencias circulares

Al usar el sustituto a continuación , podemos producir JSON menos redundantes, si el objeto fuente contiene múltiples referencias a algún objeto, o contiene referencias circulares, entonces lo hacemos mediante una cadena de ruta especial (similar a JSONPath ), lo usamos de la siguiente manera

let s = JSON.stringify(obj, refReplacer());

BONIFICACIÓN : y aquí está la función inversa de dicha serialización

Kamil Kiełczewski
fuente