Converting an object to a string

2018-12-31 16:43发布

问题:

How can I convert a JavaScript object into a string?

Example:

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

Output:

Object { a=1, b=2} // very nice readable output :)
Item: [object Object] // no idea what\'s inside :(

回答1:

I would recommend using JSON.stringify, which converts the set of the variables in the object to a JSON string. Most modern browsers support this method natively, but for those that don\'t, you can include a JS version:

var obj = {
  name: \'myObj\'
};

JSON.stringify(obj);


回答2:

Use javascript String() function.

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

or

JSON.stringify(yourobject)

.



回答3:

Sure, to convert an object into a string, you either have to use your own method, such as:

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

Actually, the above just shows the general approach; you may wish to use something like http://phpjs.org/functions/var_export:578 or http://phpjs.org/functions/var_dump:604

or, if you are not using methods (functions as properties of your object), you may be able to use the new standard (but not implemented in older browsers, though you can find a utility to help with it for them too), JSON.stringify(). But again, that won\'t work if the object uses functions or other properties which aren\'t serializable to JSON.



回答4:

Keeping it simple with console, you can just use a comma instead of a +. The + will try to convert the object into a string, whereas the comma will display it separately in the console.

Example:

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

Output:

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

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



回答5:

EDIT Do not use this answer as it does not work in Internet Explorer. Use Gary Chambers solution.

toSource() is the function you are looking for which will write it out as JSON.

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


回答6:

One option:

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

\"o

Another option (as soktinpk pointed out in the comments), and better for console debugging IMO:

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

\"o



回答7:

None of the solutions here worked for me. JSON.stringify seems to be what a lot of people say, but it cuts out functions and seems pretty broken for some objects and arrays I tried when testing it.

I made my own solution which works in Chrome at least. Posting it here so anyone that looks this up on Google can find it.

//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: I know this code can be improved but just never got around to doing it. User andrey suggested an improvement here with the comment:

Here is a little bit changed code, which can handle \'null\' and \'undefined\', and also do not add excessive commas.

Use that at your own risk as I haven\'t verified it at all. Feel free to suggest any additional improvements as a comment.



回答8:

If you\'re just outputting to the console, you can use console.log(\'string:\', obj). Notice the comma.



回答9:

In cases where you know the object is just a Boolean, Date, String, number etc... The javascript String() function works just fine. I recently found this useful in dealing with values coming from jquery\'s $.each function.

For example the following would convert all items in \"value\" to a string:

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

More details here:

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



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


回答11:

I was looking for this, and wrote a deep recursive one with indentation :

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

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



回答12:

If you just want to see the object for debugging, you can use

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


回答13:

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

Item: {a:1, b:2}



回答14:

JSON methods are quite inferior to the Gecko engine .toSource() primitive.

See the SO article response for comparison tests.

Also, the answer above refers to http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html which, like JSON, (which the other article http://www.davidpirek.com/blog/object-to-string-how-to-deserialize-json uses via \"ExtJs JSON encode source code\") cannot handle circular references and is incomplete. The code below shows it\'s (spoof\'s) limitations (corrected to handle arrays and objects without content).

(direct link to 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\'));

which displays:

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

and

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

and

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]


回答15:

As firefox does not stringify some object as screen object ; if you want to have the same result such as : 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(\',\')+\'}\';
}


回答16:

Take a look at the jQuery-JSON plugin

At its core, it uses JSON.stringify but falls back to its own parser if the browser doesn\'t implement it.



回答17:

If you only care about strings, objects, and arrays:

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


回答18:

stringify-object is a good npm library made by the yeoman team: https://www.npmjs.com/package/stringify-object

npm install stringify-object

then:

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

Obviously it\'s interesting only if you have circular object that would fail with JSON.stringify();



回答19:

var o = {a:1, b:2};

o.toString=function(){
  return \'a=\'+this.a+\', b=\'+this.b;
};

console.log(o);
console.log(\'Item: \' + o);

Since Javascript v1.0 works everywhere (even IE) this is a native approach and allows for a very costomised look of your object while debugging and in production https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/toString

Usefull example

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

Also, as a 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


回答20:

If you are using the Dojo javascript framework then there is already a build in function to do this: dojo.toJson() which would be used like so.

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

which will return a string. If you want to convert the object to json data then add a second parameter of true.

dojo.toJson(obj, true);

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



回答21:

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

example to use:

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

}


回答22:

For your example, I think console.log(\"Item:\",o) would be easiest. But, console.log(\"Item:\" + o.toString) would also work.

Using method number one uses a nice dropdown in the console, so a long object would work nicely.



回答23:

For non-nested objects:

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


回答24:

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


回答25:

I hope this example will help for all those who all are working on array of objects

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


回答26:

If you can use lodash you can do it this way:

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

With lodash map() you can iterate over Objects as well. This maps every key/value entry to its string representation:

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

And join() put the array entries together.

If you can use ES6 Template String, this works also:

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

Please note this do not goes recursive through the Object:

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

Like node\'s util.inspect() will do:

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


回答27:

If you wont aplay join() to Object.

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


回答28:

If you want a minimalist method of converting a variable to a string for an inline expression type situation, \'\'+variablename is the best I have golfed.

If \'variablename\' is an object and you use the empty string concatenation operation, it will give the annoying [object Object], in which case you probably want Gary C.\'s enormously upvoted JSON.stringify answer to the posted question, which you can read about on Mozilla\'s Developer Network at the link in that answer at the top.



回答29:

I had need to make a more configurable version of JSON.stringify as I had to add comments and know the JSON path:

const someObj = {
  a: {
    nested: {
      value: \'apple\',
    },
    sibling: \'peanut\'
  },
  b: {
    languages: [\'en\', \'de\', \'fr\'],
    c: {
      nice: \'heh\'
    }
  },
  c: \'butter\',
  d: function () {}
};

function* objIter(obj, indent = \'  \', depth = 0, path = \'\') {
  const t = indent.repeat(depth);
  const t1 = indent.repeat(depth + 1);
  const v = v => JSON.stringify(v);
  yield { type: Array.isArray(obj) ? \'OPEN_ARR\' : \'OPEN_OBJ\', indent, depth };
  const keys = Object.keys(obj);
  
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i];
    const prop = obj[key];
    const nextPath = !path && key || `${path}.${key}`;
 
    if (typeof prop !== \'object\') {
      yield { type:  isNaN(key) ? \'VAL\' : \'ARR_VAL\', key, prop, indent, depth, path: nextPath };
    } else {
      yield { type: \'OBJ_KEY\', key, indent, depth, path: nextPath };
      yield* objIter(prop, indent, depth + 1, nextPath);
    }
  }

  yield { type: Array.isArray(obj) ? \'CLOSE_ARR\' : \'CLOSE_OBJ\', indent, depth };
}

const iterMap = (it, mapFn) => {
  const arr = [];
  for (const x of it) { arr.push(mapFn(x)) }
  return arr;
}

const objToStr = obj => iterMap(objIter(obj), ({ type, key, prop, indent, depth, path }) => {
  const t = indent.repeat(depth);
  const t1 = indent.repeat(depth + 1);
  const v = v => JSON.stringify(v);

  switch (type) {
    case \'OPEN_ARR\':
      return \'[\\n\';
    case \'OPEN_OBJ\':
      return \'{\\n\';
    case \'VAL\':
      return `${t1}// ${path}\\n${t1}${v(key)}: ${v(prop)},\\n`;
    case \'ARR_VAL\':
      return `${t1}// ${path}\\n${t1}${v(prop)},\\n`;
    case \'OBJ_KEY\':
      return `${t1}// ${path}\\n${t1}${v(key)}: `;
    case \'CLOSE_ARR\':
    case \'CLOSE_OBJ\':
      return `${t}${type === \'CLOSE_ARR\' ? \']\' : \'}\'}${depth ? \',\' : \';\'}\\n`;
    default:
      throw new Error(\'Unknown type:\', type);
  }
}).join(\'\');

const s = objToStr(someObj);
console.log(s);



回答30:

If all you want is to simply get a string output, then this should work: String(object)