¿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 :(

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

El uso de JavaScript String () la función

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

o stringify ()

JSON.stringify(yourobject)

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.

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

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

Una opción :

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

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

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

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.

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

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

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

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

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

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

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}

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]

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

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

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

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

Echa un vistazo al complemento jQuery-JSON

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

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

Para objetos no anidados:

Object.entries(o).map(x=>x.join(":")).join("\r\n")

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

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 } }'

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

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

}

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.

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

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

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

function refReplacer() {
  let m = new Map();
  let v = new Map();
  replacer = (field,value) => value;

  return function(field, value) {
    let p= m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field); 
    let isComplex= value===Object(value)
    
    if (isComplex) m.set(value, p);  
    
    let pp = v.get(value)||'';
    let path = p.replace(/undefined\.\.?/,'');
    let val = pp ? `#REF:${pp[0]=='[' ? '$':'$.'}${pp}` : value;
    
    if(!pp && isComplex) v.set(value, path);
   
    return replacer.call(this, field, val)
  }
}




// ---------------
// TEST
// ---------------

// gen obj with duplicate references
let a = { a1: 1, a2: 2 };
let b = { b1: 3, b2: "4" };
let obj = { o1: { o2:  a  }, b, a }; // duplicate reference
a.a3 = [1,2,b];                      // circular reference
b.b3 = a;                            // circular reference


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

console.log(s);

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

function parseRefJSON(json) {
  let objToPath = new Map();
  let pathToObj = new Map();
  let o = JSON.parse(json);
  
  let traverse = (parent, field) => {
    let obj = parent;
    let path = '#REF:$';

    if (field !== undefined) {
      obj = parent[field];
      path = objToPath.get(parent) + (Array.isArray(parent) ? `[${field}]` : `${field?'.'+field:''}`);
    }

    objToPath.set(obj, path);
    pathToObj.set(path, obj);
    
    let ref = pathToObj.get(obj);
    if (ref) parent[field] = ref;

    for (let f in obj) if (obj === Object(obj)) traverse(obj, f);
  }
  
  traverse(o);
  return o;
}



// ------------
// TEST
// ------------

let s = `{
    "o1": {
        "o2": {
            "a1": 1,
            "a2": 2,
            "a3": [
                1,
                2,
                {
                    "b1": 3,
                    "b2": "4",
                    "b3": "#REF:$.o1.o2"
                }
            ]
        }
    },
    "b": "#REF:$.o1.o2.a3[2]",
    "a": "#REF:$.o1.o2"
}`;

console.log('Open Chrome console to see nested fields:');
let obj = parseRefJSON(s);

console.log(obj);