La conversion d'un objet en une chaîne

Je vous conseille d'utiliser JSON.stringify, qui convertit l'ensemble des variables de l'objet à une chaîne JSON. La plupart des navigateurs modernes prennent en charge cette méthode en natif, mais pour ceux qui ne le font pas, vous pouvez inclure un JS version:

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

Sûr, pour convertir un objet en chaîne de caractères, vous devez utiliser votre propre méthode, telle que:

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

En fait, le ci-dessus montre l'approche générale; vous pouvez utiliser quelque chose comme http://phpjs.org/functions/var_export:578 ou http://phpjs.org/functions/var_dump:604

ou, si vous n'êtes pas en utilisant des méthodes (fonctions en tant que propriétés de votre objet), vous pourriez être en mesure d'utiliser la nouvelle norme (mais pas implémentée dans les navigateurs plus anciens, mais vous pouvez trouver une utilité à l'aide pour eux aussi), JSON.stringify(). Mais encore une fois, cela ne fonctionnera pas si l'objet qui utilise des fonctions ou d'autres propriétés qui ne sont pas sérialisables JSON.

MODIFIER Ne pas utiliser cette réponse car il ne fonctionne pas dans Internet Explorer. Utilisation Gary Chambres solution.

toSource() est la fonction vous êtes à la recherche pour qui va l'écrire sous forme de JSON.

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

Aucune des solutions ici a fonctionné pour moi. JSON.stringify semble être ce que beaucoup de gens disent, mais il supprime les fonctions et semble assez cassé pour certains objets et les tableaux que j'ai essayé lors de l'essai il.

J'ai fait ma propre solution qui fonctionne dans Chrome au moins. Le poster ici afin que toute personne qui regarde sur Google peut trouver.

//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: je sais ce code peut être amélioré, mais qui ne l'a jamais fait. L'utilisateur andrey suggéré une amélioration ici avec le commentaire:

Ici est un peu modifié le code, qui peut gérer des 'null' et 'undefined', et aussi ne pas ajouter excessive des virgules.

L'utiliser à vos risques et périls, car je n'ai pas vérifié du tout. Hésitez pas à suggérer d'autres améliorations comme un commentaire.

Dans le cas où vous savez que l'objet est un Booléen, Date, Chaîne, nombre, etc... le javascript de La fonction String() fonctionne très bien. J'ai récemment trouvé ce utile dans le traitement avec des valeurs provenant de jquery $.chaque fonction.

Par exemple convertir tous les éléments de la "valeur" d'une chaîne de caractères:

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

Plus de détails ici:

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

J'étais à la recherche de ce, et a écrit une profonde récursive avec l'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();
  }
}

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

JSON méthodes sont très inférieures à moteur Gecko .toSource() primitive.

Voir le DONC, l'article de réponse pour les tests de comparaison.

Aussi, le la réponse ci-dessus se réfère à http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html qui, comme JSON, (l'autre article http://www.davidpirek.com/blog/object-to-string-how-to-deserialize-json utilise via "ExtJs JSON encoder le code source") ne peut pas gérer les références circulaires et est incomplète. Le code ci-dessous montre qu'il est (usurpation de l') limites (corrigé pour manipuler les tableaux et les objets sans contenu).

(lien direct vers code //forums.devshed.com/... /tosource-avec-des tableaux-dans-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'));

qui s'affiche:

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

et

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

et

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]

Il est en fait une option facile (pour les navigateurs récents et Node.js) manquant dans les réponses:

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

Je préfère ce que JSON.stringify() a certaines limites (par exemple, avec des structures circulaires).

Si vous ne se soucient que des chaînes, des objets et des tableaux:

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

Prendre un coup d'oeil à la jQuery JSON plugin

À sa base, il utilise JSON.stringify mais revient à sa propre analyseur si le navigateur ne prend pas la mettre en œuvre.

stringify-object est une bonne mnp bibliothèque faite par le yeoman équipe: https://www.npmjs.com/package/stringify-object

npm install stringify-object

alors:

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

Bien évidemment, il est intéressant que si vous avez de l'objet circulaire qui échouerait avec JSON.stringify();

Si vous utilisez le Dojo framework javascript puis il y a déjà une fonction pour ce faire: dojo.la méthode toJson() qui serait utilisé comme.

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

qui renvoie une chaîne de caractères. Si vous voulez convertir l'objet en json données, puis ajouter un second paramètre de vrai.

dojo.toJson(obj, true);

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

Pour ton exemple, je pense
console.log("Item:",o)
serait plus facile. Mais,
console.log("Item:" + o.toString)
serait aussi travailler.

L'aide de la méthode numéro un utilise une belle liste déroulante dans la console, donc un objet assez long, fonctionnerait bien.

J'espère que cet exemple de l'aide pour tous ceux qui travaillent sur le tableau d'objets

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

Si vous ne aplay join() de l'Objet.

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

J'avais besoin de faire un plus configurable version de JSON.stringify que j'ai dû ajouter des commentaires et de savoir le JSON chemin:

JS:

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

setobjToString:function(obj){
var me =this;
obj=obj[0];
var tabjson=[];
for (var p in obj) {
if (obj.hasOwnProperty(p)) {
if (obj[p] instanceof Array){
tabjson.push('"'+p +'"'+ ':' + me.setobjToString(obj[p]));
}else{
tabjson.push('"'+p +'"'+':"'+obj[p]+'"');
}
}
}  tabjson.push()
return '{'+tabjson.join(',')+'}';
}