Hoe kan ik een JavaScript-object converteren naar een string?

Voorbeeld:

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

Uitvoer:

Object { a=1, b=2} // zeer mooie leesbare uitvoer 🙂
Item: [object Object] // geen idee wat erin zit 🙁

Antwoord 1, autoriteit 100%

Ik raad aan om JSON.stringify, die de set variabelen in het object converteert naar een JSON-tekenreeks. De meeste moderne browsers ondersteunen deze methode standaard, maar voor degenen die dat niet doen, kun je een JS-versie:

var obj = {
  name: 'myObj'
};
JSON.stringify(obj);

Antwoord 2, autoriteit 10%

Gebruik javascript String()functie

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

of stringify()

JSON.stringify(yourobject)

Antwoord 3, autoriteit 7%

Natuurlijk, om een ​​object in een string te converteren, moet je ofwel je eigen methode gebruiken, zoals:

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

Eigenlijk toont het bovenstaande slechts de algemene benadering; misschien wil je iets gebruiken als http://phpjs.org/functions/var_export:578of http://phpjs.org/functions/var_dump:604

of, als u geen methoden gebruikt (functioneert als eigenschappen van uw object), kunt u mogelijk de nieuwe standaard gebruiken (maar niet geïmplementeerd in oudere browsers, hoewel u ook voor hen een hulpprogramma kunt vinden om hiermee te helpen ), JSON.stringify(). Maar nogmaals, dat werkt niet als het object functies of andere eigenschappen gebruikt die niet serialiseerbaar zijn naar JSON.

Bijwerken:

Een modernere oplossing zou zijn:

function objToString (obj) {
    let str = '';
    for (const [p, val] of Object.entries(obj)) {
        str += `${p}::${val}\n`;
    }
    return str;
}

of:

function objToString (obj) {
    return Object.entries(obj).reduce((str, [p, val]) => {
        return `${str}${p}::${val}\n`;
    }, '');
}

Antwoord 4, autoriteit 6%

Om het simpel te houden met console, kun je gewoon een komma gebruiken in plaats van een +. De +zal proberen het object om te zetten in een string, terwijl de komma het apart in de console zal weergeven.

Voorbeeld:

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

Uitvoer:

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

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

Antwoord 5, autoriteit 3%

BEWERKENGebruik dit antwoord niet omdat het alleen in sommige versies van Firefox werkt. Geen enkele andere browser ondersteunt het. Gebruik de Gary Chambers-oplossing.

toSource()is de functie die u zoekt die het zal wegschrijven als JSON.

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

Antwoord 6, autoriteit 2%

Eén optie:

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

Een andere optie(zoals soktinpkaangaf in de opmerkingen), en beter voor console-foutopsporing IMO:

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

Antwoord 7, autoriteit 2%

Geen van de oplossingen hier werkte voor mij. JSON.stringify lijkt te zijn wat veel mensen zeggen, maar het snijdt functies weg en lijkt behoorlijk kapot voor sommige objecten en arrays die ik heb geprobeerd tijdens het testen.

Ik heb mijn eigen oplossing gemaakt die in ieder geval in Chrome werkt. Plaats het hier zodat iedereen die dit opzoekt op Google het kan vinden.

//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: ik weet dat deze code kan worden verbeterd, maar het is er nooit van gekomen. Gebruiker andrey stelde hiereen verbetering voor met de opmerking:

Hier is een beetje gewijzigde code, die ‘null’ en ‘undefined’ aankan, en ook geen overmatige komma’s kan toevoegen.

Gebruik dat op eigen risico, want ik heb het helemaal niet geverifieerd. Voel je vrij om eventuele aanvullende verbeteringen als opmerking voor te stellen.

Antwoord 8

Als je alleen iets naar de console uitvoert, kun je console.log('string:', obj)gebruiken. Let op de komma.

Antwoord 9

In gevallen waarin u weet dat het object slechts een Boolean, Datum, Tekenreeks, getal enz. is… De javascript String()-functie werkt prima. Ik vond dit onlangs nuttig bij het omgaan met waarden die afkomstig zijn van de $.each-functie van jQuery.

Het volgende zou bijvoorbeeld alle items in “value” naar een tekenreeks converteren:

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

Meer details hier:

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

Antwoord 10

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

Antwoord 11

Ik was hiernaar op zoek en schreef een diepe recursieve met inspringing :

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

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

Antwoord 12

Als u alleen het object voor debuggen wilt zien, kunt u gebruik maken van

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

Antwoord 13

Er ontbreekt eigenlijk één gemakkelijke optie (voor recente browsers en Node.js) in de bestaande antwoorden:

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

Ik zou hier de voorkeur aan geven omdat JSON.stringify()bepaalde beperkingen heeft (bijvoorbeeld met cirkelvormige structuren).

Antwoord 14

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

Artikel: {a:1, b:2}

Antwoord 15

JSON-methoden zijn behoorlijk inferieur aan de primitieve Gecko-engine .toSource().

Zie de SO artikelreactievoor vergelijkende tests.

Ook het antwoord hierboven verwijst naar http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.htmldie, net als JSON, (die de andere artikel http://www .davidpirek.com/blog/object-to-string-how-to-deserialize-jsongebruikt via “ExtJs JSON encode source code”) kan geen kringverwijzingen aan en is onvolledig. De onderstaande code toont de (spoof) beperkingen (gecorrigeerd om arrays en objecten zonder inhoud te verwerken).

(directe link naar code in / /forum.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'));

die wordt weergegeven:

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

en

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

en

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]

Antwoord 16

Het lijkt erop dat JSON de tweede parameter accepteert die zou kunnen helpen met functies – vervanger, dit lost het probleem van converteren op de meest elegante manier op:

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

Antwoord 17

Voor niet-geneste objecten:

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

Antwoord 18

stringify-objectis een goede npm-bibliotheek gemaakt door het yeoman-team: https://www.npmjs.com/package/stringify-object

npm install stringify-object

dan:

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

Het is duidelijk alleen interessant als je een cirkelvormig object hebt dat zou mislukken met JSON.stringify();

Antwoord 19

Omdat Firefox een object niet stringificeert als schermobject; als u hetzelfde resultaat wilt hebben, zoals: 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(',')+'}';
}

Antwoord 20

Als je alleen om strings, objecten en arrays geeft:

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

Antwoord 21

misschien ben je op zoek naar

JSON.stringify(JSON.stringify(obj))
"{\"id\":30}"

Antwoord 22

Bekijk de jQuery-JSON-plug-in

In de kern gebruikt het JSON.stringify, maar valt terug op zijn eigen parser als de browser het niet implementeert.

Antwoord 23

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

Aangezien Javascript v1.0 overal werkt (zelfs IE)
dit is een native benadering en zorgt voor een zeer aangepast uiterlijk van uw object tijdens het debuggen en in productie
https://developer.mozilla.org/en/docs /Web/JavaScript/Referentie/Global_Objects/Object/toString

Handig voorbeeld

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

Ook 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

Antwoord 24

Als je lodash kunt gebruiken, kun je het op deze manier doen:

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

Met lodash map()kun je ook objecten herhalen.
Dit wijst elke sleutel/waarde-invoer toe aan zijn tekenreeksrepresentatie:

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

En join()zet de array-items bij elkaar.

Als je ES6 Template String kunt gebruiken, werkt dit ook:

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

Let op: dit gaat niet recursief door het object:

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

Zoals node’s util.inspect()zal doen:

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

Antwoord 25

Circulaire referenties

Door onderstaande vervanger te gebruiken we kunnen minder redundante JSON produceren – als het bronobject meerdere verwijzingen naar een object bevat, of kringverwijzingen bevat – dan verwijzen we ernaar met een speciale padtekenreeks (vergelijkbaar met JSONPath) – we gebruiken het als volgt

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

Antwoord 26

Als u het Dojo javascript-framework gebruikt, is er al een ingebouwde functie om dit te doen: dojo.toJson() die zo zou worden gebruikt.

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

die een string teruggeeft. Als u het object naar json-gegevens wilt converteren, voegt u een tweede parameter van true toe.

dojo.toJson(obj, true);

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

Antwoord 27

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

te gebruiken voorbeeld:

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

uw_object1.txt:

{ 
    "str" : "hello" ,
    "arr" : [ 
        "1" ,
        "2" ,
        "3" ,
        4
    ],
    "b" : true,
    "vobj" : { 
        "str" : "hello2" 
    }
}

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

Antwoord 28

Voor jouw voorbeeld denk ik
console.log("Item:",o)
het gemakkelijkst zou zijn. Maar,
console.log("Item:" + o.toString)
zou ook werken.

Met methode nummer één wordt een mooie vervolgkeuzelijst in de console gebruikt, dus een lang object zou goed werken.

Antwoord 29

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

Antwoord 30

Ik hoop dat dit voorbeeld iedereen zal helpen die aan een reeks objecten werkt

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