Conversione di un oggetto in una stringa

Come posso convertire un oggetto 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 leggibile molto piacevole :)
Item: [oggetto object] // nessuna idea di cosa ci sia dentro :(

Consiglierei di usare JSON.stringify, che converte l'insieme delle variabili nell'oggetto in una stringa JSON. La maggior parte dei browser moderni supporta questo metodo in modo nativo, ma per quelli che non lo fanno, puoi includere una versione JS :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

Usa la funzione String () di JavaScript

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

o stringify ()

JSON.stringify(yourobject)

Certo, per convertire un oggetto in una stringa, devi usare il tuo metodo, come 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 si utilizzano metodi (funzioni come proprietà dell'oggetto), è possibile utilizzare il nuovo standard (ma non implementato nei browser meno recenti, sebbene sia possibile trovare un'utilità che li aiuti anche per loro), JSON .stringify (). Ma ancora una volta, ciò non funzionerà se l'oggetto utilizza funzioni o altre proprietà che non sono serializzabili su JSON.

Per farla semplice console, puoi semplicemente usare una virgola anziché una +. Il +cercherà di convertire l'oggetto in una stringa, mentre la virgola verrà visualizzato 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

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

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

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

Un'opzione :

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

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

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

Nessuna delle soluzioni qui ha funzionato per me. JSON.stringify sembra essere quello che dicono molte persone, ma interrompe 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. Pubblicandolo qui in modo che chiunque lo cerchi 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 sono mai riuscito a farlo. L'utente andrey ha suggerito un miglioramento qui con il commento:

Ecco un po 'di codice modificato, che può gestire' null 'e' undefined ', e inoltre non aggiungere virgole eccessive.

Usalo a tuo rischio e pericolo poiché non l'ho verificato affatto. Sentiti libero di suggerire eventuali miglioramenti aggiuntivi come commento.

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

Nel caso in cui si sappia che l'oggetto è solo un valore booleano, data, stringa, numero ecc ... La funzione String () di javascript funziona perfettamente. Di recente l'ho trovato 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 rientro:

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'oggetto 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 abbastanza inferiori al primitivo .toSource () del motore Gecko.

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: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json utilizza tramite "Codice sorgente codifica JSON ExtJs" ) non è in grado di gestire riferimenti circolari ed è incompleto. Il codice seguente mostra i suoi limiti (spoof) (corretti per gestire matrici e oggetti senza contenuto).

( collegamento diretto al codice in //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'));

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]

In realtà esiste un'opzione semplice (per browser recenti e Node.js) mancante nelle risposte esistenti:

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

Preferirei questo perché JSON.stringify()ha alcune limitazioni (ad esempio con strutture circolari).

Sembra che JSON accetti il ​​secondo parametro che potrebbe aiutare con le funzioni: il sostituto , questo risolve il problema della conversione nel modo più elegante:

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

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<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-objectè una buona libreria npm creata dal team di yeoman: https://www.npmjs.com/package/stringify-object

npm install stringify-object

poi:

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

Ovviamente è interessante solo se hai un oggetto circolare che fallirebbe JSON.stringify();

Dai un'occhiata al plugin jQuery-JSON

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

Poiché firefox non restringe alcuni oggetti come oggetto 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(',')+'}';
}

Per oggetti non nidificati:

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

Poiché Javascript v1.0 funziona ovunque (anche IE), questo è un approccio nativo e consente un aspetto molto personalizzato del tuo oggetto durante il debug e in produzione https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / oggetto / 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

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 lodash map()puoi anche iterare su Oggetti. In questo modo ogni voce chiave / valore viene associata alla sua rappresentazione di stringa:

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

E join()metti insieme le voci dell'array.

Se puoi utilizzare ES6 Template String, funziona anche:

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

Si noti che questo non è ricorsivo attraverso l'Oggetto:

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

Come farà il nodoutil.inspect() :

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

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

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

che restituirà una stringa. Se si desidera convertire l'oggetto in dati json, aggiungere un secondo parametro su 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 console.log("Item:" + o.toString) funzionerebbe anche.

Utilizzando il metodo numero uno si utilizza un bel menu a discesa nella console, quindi un oggetto 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 sia di aiuto per tutti coloro che stanno lavorando su array 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 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(',');

Se vuoi un metodo minimalista per convertire una variabile in una stringa per una situazione di tipo di espressione in linea, ''+variablenameè il migliore che abbia mai giocato a golf.

Se 'variablename' è un oggetto e usi l'operazione di concatenazione di stringhe vuote, ti darà il fastidioso [object Object], nel qual caso probabilmente vorrai la JSON.stringifyrisposta enormemente votata di Gary C. alla domanda pubblicata, di cui puoi leggere sulla Rete degli sviluppatori di Mozilla al link in quella risposta in alto .