Konvertieren eines Objekts in eine Zeichenfolge

Wie kann ich ein JavaScript-Objekt in eine Zeichenfolge konvertieren?

Beispiel:

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

Ausgabe:

Objekt {a = 1, b = 2} // sehr schöne lesbare Ausgabe :)
Element: [Objekt Objekt] // keine Ahnung, was drin ist :(

Ich würde die Verwendung empfehlen JSON.stringify, die die Menge der Variablen im Objekt in eine JSON-Zeichenfolge konvertiert. Die meisten modernen Browser unterstützen diese Methode nativ, aber für diejenigen, die dies nicht tun, können Sie eine JS-Version einschließen :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

Verwendung JavaScript String () Funktion

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

oder stringify ()

JSON.stringify(yourobject)

Um ein Objekt in eine Zeichenfolge zu konvertieren, müssen Sie entweder Ihre eigene Methode verwenden, z.

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

Tatsächlich zeigt das Obige nur den allgemeinen Ansatz; Möglicherweise möchten Sie etwas wie http://phpjs.org/functions/var_export:578 oder http://phpjs.org/functions/var_dump:604 verwenden

Wenn Sie keine Methoden verwenden (Funktionen als Eigenschaften Ihres Objekts), können Sie möglicherweise den neuen Standard verwenden (der jedoch in älteren Browsern nicht implementiert ist, obwohl Sie auch ein Hilfsprogramm finden, das Ihnen dabei hilft), JSON .stringify (). Dies funktioniert jedoch nicht, wenn das Objekt Funktionen oder andere Eigenschaften verwendet, die für JSON nicht serialisierbar sind.

Um es einfach zu halten console, können Sie einfach ein Komma anstelle von a verwenden +. Der +versucht, das Objekt in eine Zeichenfolge zu konvertieren, während das Komma es separat in der Konsole anzeigt.

Beispiel:

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

Ausgabe:

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

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

BEARBEITEN Verwenden Sie diese Antwort nicht, da sie in Internet Explorer nicht funktioniert. Verwenden Sie die Gary Chambers- Lösung.

toSource () ist die gesuchte Funktion, die sie als JSON ausgibt .

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

Eine Option :

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

Eine weitere Option (wie soktinpk in den Kommentaren hervorhob ) und besser für das Debuggen von IMO-Konsolen:

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

Keine der Lösungen hier hat bei mir funktioniert. JSON.stringify scheint das zu sein, was viele Leute sagen, aber es schneidet Funktionen aus und scheint für einige Objekte und Arrays, die ich beim Testen ausprobiert habe, ziemlich kaputt zu sein.

Ich habe meine eigene Lösung entwickelt, die zumindest in Chrome funktioniert. Wenn Sie es hier veröffentlichen, kann es jeder finden, der es bei Google nachschlägt.

//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: Ich weiß, dass dieser Code verbessert werden kann, bin aber nie dazu gekommen. Benutzer andrey vorgeschlagen , eine Verbesserung hier mit der Bemerkung:

Hier ist ein wenig geänderter Code, der 'null' und 'undefined' verarbeiten kann und auch keine übermäßigen Kommas hinzufügt.

Verwenden Sie dies auf eigenes Risiko, da ich es überhaupt nicht überprüft habe. Fühlen Sie sich frei, zusätzliche Verbesserungen als Kommentar vorzuschlagen.

Wenn Sie nur auf der Konsole ausgeben, können Sie verwenden console.log('string:', obj). Beachten Sie das Komma .

In Fällen, in denen Sie wissen, dass das Objekt nur ein Boolescher Wert, ein Datum, eine Zeichenfolge, eine Zahl usw. ist, funktioniert die Javascript-Funktion String () einwandfrei. Ich fand dies kürzlich nützlich im Umgang mit Werten, die aus der $ .each-Funktion von jquery stammen.

Zum Beispiel würde das Folgende alle Elemente in "Wert" in eine Zeichenfolge konvertieren:

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

Weitere Details hier:

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

Ich suchte danach und schrieb eine tiefe rekursive mit Einrückung:

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

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

Wenn Sie nur das Objekt zum Debuggen anzeigen möchten, können Sie es verwenden

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

1.

JSON.stringify(o);

Item: {"a": "1", "b": "2"}

2.

var o = {a:1, b:2};
var b=[]; Object.keys(o).forEach(function(k){b.push(k+":"+o[k]);});
b="{"+b.join(', ')+"}";
console.log('Item: ' + b);

Gegenstand: {a: 1, b: 2}

JSON-Methoden sind dem Grundelement der Gecko-Engine .toSource () weit unterlegen.

Vergleichstests finden Sie in der Antwort des SO-Artikels .

Die obige Antwort bezieht sich auch auf http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html, das wie JSON (das der andere Artikel http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json verwendet über "ExtJs JSON-Codierungsquellcode" ) kann keine Zirkelverweise verarbeiten und ist unvollständig. Der folgende Code zeigt die (gefälschten) Einschränkungen (korrigiert, um Arrays und Objekte ohne Inhalt zu behandeln).

( direkter Link zum Code 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'));

welches anzeigt:

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

und

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

und

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 den vorhandenen Antworten fehlt tatsächlich eine einfache Option (für aktuelle Browser und Node.js):

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

Ich würde dies vorziehen, da JSON.stringify()es bestimmte Einschränkungen gibt (z. B. bei kreisförmigen Strukturen).

Es scheint, dass JSON den zweiten Parameter akzeptiert, der bei Funktionen helfen könnte - Ersetzer , dies löst das Problem der Konvertierung auf eleganteste Weise:

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

Wenn Sie sich nur für Zeichenfolgen, Objekte und Arrays interessieren:

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-objectist eine gute npm-Bibliothek, die vom yeoman-Team erstellt wurde: https://www.npmjs.com/package/stringify-object

npm install stringify-object

dann:

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

Offensichtlich ist es nur interessant, wenn Sie ein kreisförmiges Objekt haben, mit dem Sie versagen würden JSON.stringify();

Schauen Sie sich das jQuery-JSON- Plugin an

Im Kern verwendet es JSON.stringify, greift jedoch auf seinen eigenen Parser zurück, wenn der Browser dies nicht implementiert.

Da Firefox ein Objekt nicht als Bildschirmobjekt stringifiziert; wenn Sie möchten , um das gleiche Ergebnis haben , wie zum Beispiel: 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(',')+'}';
}

Für nicht verschachtelte Objekte:

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

Da Javascript v1.0 überall funktioniert (auch im Internet Explorer), ist dies ein nativer Ansatz, der ein sehr individuelles Erscheinungsbild Ihres Objekts beim Debuggen und in der Produktion ermöglicht. Https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

Nützliches Beispiel

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

Auch als 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

Wenn Sie lodash verwenden können, können Sie dies folgendermaßen tun:

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

Mit lodash map()können Sie auch Objekte durchlaufen . Dadurch wird jeder Schlüssel- / Werteintrag seiner Zeichenfolgendarstellung zugeordnet:

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

Und join()setzen Sie die Array-Einträge zusammen.

Wenn Sie ES6 Template String verwenden können, funktioniert dies auch:

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

Bitte beachten Sie, dass dies nicht durch das Objekt rekursiv geht:

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

Wie Knotenutil.inspect() tun:

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

Wenn Sie das Dojo-Javascript-Framework verwenden, gibt es dafür bereits eine integrierte Funktion: dojo.toJson (), die so verwendet wird.

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

Dies wird eine Zeichenfolge zurückgeben. Wenn Sie das Objekt in JSON-Daten konvertieren möchten, fügen Sie einen zweiten Parameter von true hinzu.

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

zu verwendendes Beispiel:

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

}

Für Ihr Beispiel denke ich, console.log("Item:",o) wäre am einfachsten. Aber console.log("Item:" + o.toString) würde auch funktionieren.

Bei Verwendung der ersten Methode wird ein schönes Dropdown-Menü in der Konsole verwendet, sodass ein langes Objekt gut funktioniert.

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

Ich hoffe, dieses Beispiel hilft all jenen, die alle an einer Reihe von Objekten arbeiten

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

Wenn Sie nicht spielen möchten, verbinden Sie () mit Object.

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

Wenn Sie eine minimalistische Methode zum Konvertieren einer Variablen in eine Zeichenfolge für eine Situation mit Inline-Ausdruckstypen ''+variablenamewünschen , ist dies die beste, die ich je gespielt habe.

Wenn 'Variablenname' ein Objekt ist und Sie die Verkettungsoperation für leere Zeichenfolgen verwenden, wird dies ärgerlich [object Object]. In diesem Fall möchten Sie wahrscheinlich die enorm positiv bewertete JSON.stringifyAntwort von Gary C. auf die gestellte Frage, über die Sie im Mozilla Developer Network lesen können unter dem Link in dieser Antwort oben .