javascript - Konvertera ett objekt till en sträng

Hur kan jag konvertera ett JavaScript-objekt till en sträng?

Exempel :

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

Utdata :

Objekt { a=1, b=2}/mycket fint läsbart utdata :)\n Objekt: [object Object]/ingen aning om vad som finns inuti :(

Svar #1

Jag skulle rekommendera att använda JSON.stringify, som konverterar uppsättningen av variabler i objektet till en JSON-sträng.

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

De flesta moderna webbläsare stöder denna metod inbyggt, men för de som inte gör det kan du inkludera en JS-version.

Svar #2

Använd javascript-funktionen String()

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

eller stringify()

JSON.stringify(yourobject)

Svar #3

Håller det enkelt med console, du kan bara använda ett kommatecken istället för ett +. + kommer att försöka omvandla objektet till en sträng, medan kommatecknet visar det separat i konsolen.

Exempel :

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

Utdata :

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

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

Svar #4

Självklart, för att konvertera ett objekt till en sträng måste du antingen använda din egen metod, såsom:

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

Faktiskt visar ovanstående bara den allmänna metoden; du kanske vill använda något som http://phpjs.org/functions/var_export:578 eller http://phpjs.org/functions/var_dump:604

eller, om du inte använder metoder (funktioner som egenskaper i ditt objekt), kan du kanske använda den nya standarden (men inte implementerad i äldre webbläsare, även om du kan hitta ett verktyg som hjälper med det för dem också), JSON.stringify(). Men igen, det fungerar inte om objektet använder funktioner eller andra egenskaper som inte kan serialiseras till JSON.

Uppdatering:

En mer modern lösning skulle vara:

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

eller :

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

Svar #5

REDIGERA Använd inte detta svar eftersom det endast fungerar i vissa versioner av Firefox. Inga andra webbläsare stöder det. Använd Gary Chambers lösning.

toSource() är funktionen du letar efter som kommer att skriva ut det som JSON.

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

Svar #6

Ett alternativ:

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

Ett annat alternativ (som soktinpk påpekade i kommentarerna), och bättre för felsökning på konsolen enligt min åsikt:

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

Svar #7

Inget av lösningarna här fungerade för mig. JSON.stringify verkar vara det som många säger, men det tar bort funktioner och verkar ganska trasigt för vissa objekt och arrayer jag försökte när jag testade det.

Jag gjorde min egen lösning som åtminstone fungerar i Chrome. Lägger upp den här så att alla som söker efter detta på Google kan hitta den.

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

REDIGERA: Jag vet att den här koden kan förbättras men har bara aldrig kommit runt att göra det. Användaren andrey föreslog en förbättring här med kommentaren:

Här är en lite ändrad kod, som kan hantera 'null' och 'undefined', och som också inte lägger till överflödiga kommatecken.

Använd det på egen risk eftersom jag inte har verifierat det alls. Känn dig fri att föreslå ytterligare förbättringar som en kommentar.

Svar #8

Om du bara skriver ut till konsolen kan du använda console.log('string:', obj). Observera kommatecknet.

Svar #9

I fall där du vet att objektet bara är en Boolean, Date, String, nummer etc... fungerar javascript-funktionen String() alldeles utmärkt. Jag upptäckte nyligen att detta var användbart när jag hanterade värden som kommer från jQuerys $.each-funktion.

Till exempel skulle följande konvertera alla objekt i "value" till en sträng:

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

Mer information här:

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

Svar #10

Jag letade efter detta och skrev en djup rekursiv med indrag :

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

Användning: objToString({ a: 1, b: { c: "test" } })

Svar #11

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

Svar #12

Det finns faktiskt ett enkelt alternativ (för nyare webbläsare och Node.js) som saknas i de befintliga svaren:

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

Jag skulle föredra detta eftersom JSON.stringify() har vissa begränsningar (t.ex. med cirkulära strukturer).

Svar #13

Om du bara vill se objektet för felsökning kan du använda

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

Svar #14

1.

JSON.stringify(o);

Artikel: {"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}

Svar #15

Det verkar som om JSON accepterar den andra parametern som kan hjälpa till med funktioner - replacer, detta löser problemet med att konvertera på det mest eleganta sättet:

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

Relaterade artiklar