Conversion d'un objet en chaîne


975

Comment puis-je convertir un objet JavaScript en chaîne?

Exemple:

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

Production:

Object {a = 1, b = 2} // très belle sortie lisible :)
Item: [objet Object] // aucune idée de ce qu'il y a à l'intérieur :(


7
Convertir en chaîne dans quel but? Vous voulez dire sérialiser pour pouvoir construire l'objet plus tard à partir de la chaîne? Ou juste pour l'affichage?
Shadow Wizard est Ear For You

19
L'auteur est parti depuis des années, mais en lisant dans l'esprit, après des années, je suppose, le point d'entrée du problème était le console.log (obj), qui affiche l'objet avec des propriétés, tandis que console.log ('obj:' + obj ) fonctionne autrement de manière désorientante.
Danubian Sailor

2
ne peut tout simplement pas appliquer ajouter deux objets, si nous pouvons le faire, il n'y aurait pas de différence dans le type de valeur et le type de référence.
Nishant Kumar

12
var o = {a: 1, b: 2}; console.log ('Item:' + JSON.stringify (o))
Nishant Kumar

22
Si c'est pour la console, je recommanderais de le faire console.log("Item", obj);. Pas besoin de quoi que ce soit de compliqué.
soktinpk

Réponses:


1333

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

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

7
Pour référence IE6 et 7 ne prennent pas en charge cela. IE6 n'est pas si important à cause de très peu d'utilisateurs et d'une campagne active pour le tuer ... mais il y a encore pas mal d'utilisateurs IE7 (cela dépend de votre base d'utilisateurs).
MikeMurko

30
J'obtiens une "TypeError non capturée: Conversion d'une structure circulaire en JSON". Même s'il existe une référence circulaire, j'aimerais quand même voir une représentation sous forme de chaîne de mon objet. Que puis-je faire?
Pascal Klein

26
Cela ne fonctionne pas si l'objet a une propriété de fonction, par exemple: foo: function () {...}.
Brock Adams

2
Le lien vers la bibliothèque JSON ne fonctionne pas si vous cliquez sur StackOverflow. Copiez et collez-le dans la barre d'adresse.
f.ardelian

1
Vous pouvez utiliser JSON.stringify(obj, null, 2);pour une sortie plus jolie.
l.poellabauer

126

Utilisation javascript String () fonction

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

ou stringify ()

JSON.stringify(yourobject)

28
var foo = {bar: 1}; Chaîne (foo); -> "[object Object]"
Anti Veeranna

1
var foo = {bar: 1}; String (foo ['bar']); -> "1"
Vikram Pote

3
Si vous voulez un objet entier en tant que chaîne, utilisez JSON.stringify (foo)
Vikram Pote

8
JSON.stringify(yourobject)bonne ma journée!
Neurotransmetteur

1
@TranslucentCloud * made
Parampal Pooni

87

Bien sûr, pour convertir un objet en chaîne, vous devez soit 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, ce qui précède montre juste l'approche générale; vous souhaiterez peut-être utiliser quelque chose comme http://phpjs.org/functions/var_export:578 ou http://phpjs.org/functions/var_dump:604

ou, si vous n'utilisez pas de méthodes (fonctions en tant que propriétés de votre objet), vous pourrez peut-être utiliser le nouveau standard (mais pas implémenté dans les navigateurs plus anciens, bien que vous puissiez trouver un utilitaire pour vous y aider également), JSON .stringify (). Mais encore une fois, cela ne fonctionnera pas si l'objet utilise des fonctions ou d'autres propriétés qui ne sont pas sérialisables en JSON.


78

Pour consolerester simple avec , vous pouvez simplement utiliser une virgule au lieu d'un +. Le +va essayer de convertir l'objet en une chaîne, tandis que la virgule l'affichera séparément dans la console.

Exemple:

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

Production:

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

Référence: https://developer.mozilla.org/en-US/docs/Web/API/Console.log


Greate solution! Mais pourriez-vous me dire ce qui se passe dans les coulisses lorsque vous faites simplement ceci console.log(o):? Étant donné que si vous essayez de consigner un objet ajouté à une chaîne, il appelle en fait toString()l'objet.
Gocy015

1
console.logappelle finalement quelque chose appelé ce Printerque la spécification note: "La façon dont l'implémentation imprime les arguments dépend de l'implémentation" - ce qui signifie que chaque navigateur peut faire cela différemment (voir console.spec.whatwg.org/#printer ). Firefox affichera les objets sous forme de chaîne, mais joliment colorés. Chrome affichera l'objet sous forme de groupe interactif que vous pourrez développer pour voir les propriétés. Essaie!
Luke

2
Très bonne astuce et probablement très bien pour les navigateurs Web modernes, mais ce n'est pas fiable à 100% pour toutes les implémentations JS. Par exemple, dans Qt QML, qui implémente un moteur JS, la sortie pour console.log('Item: ', o);est toujours Item: [object Object].
Paul Masri-Stone

Au lieu de cela, console.logvous pouvez utiliser console.dir(o)pour imprimer l'objet javascript à la place pour l'imprimer en tant que chaîne. Dans les outils de développement, cela permet d'ouvrir l'objet et de vérifier toutes les propriétés, même les tableaux. (voir: developer.mozilla.org/de/docs/Web/API/Console/dir )
EagleT

37

EDIT N'utilisez pas cette réponse car elle ne fonctionne pas dans Internet Explorer. Utilisez Gary Chambers solution .

toSource () est la fonction que vous recherchez qui l'écrira en JSON.

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

6
Bien qu'il soit pratique pour le débogage dans Firefox, toSource()ne fonctionne pas dans IE.
Brett Zamir

4
toSource()n'est pas un standard reconnu, il n'est donc pas garanti qu'il soit pris en charge par tous les navigateurs.
Gary Chambers

11
Ahh, merci de l'avoir signalé. Je laisserai ma réponse ici à ceux qui ne le savent pas.
Gazler

J'aimerais pouvoir vous voter davantage, car c'est une excellente solution pour les environnements qui ont du javascript (mais le journal de la console est gênant / impossible d'accès).
Zack Morris

Vous pouvez fournir une polypill à toSource: github.com/oliver-moran/toSource.js/blob/master/toSource.js
roland

32

Une option :

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

o est imprimé sous forme de chaîne

Une autre option (comme l' a souligné soktinpk dans les commentaires), et mieux pour le débogage de la console IMO:

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

o est imprimé en tant qu'objet, que vous pourriez explorer si vous aviez plus de champs


22

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

J'ai créé ma propre solution qui fonctionne au moins dans Chrome. Le publier ici pour que toute personne qui le recherche sur Google puisse le 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 que ce code peut être amélioré, mais je n'ai jamais réussi à le faire. L'utilisateur andrey a suggéré une amélioration ici avec le commentaire:

Voici un peu de code modifié, qui peut gérer 'null' et 'undefined', et n'ajoute pas non plus de virgules excessives.

Utilisez-le à vos risques et périls car je ne l'ai pas vérifié du tout. N'hésitez pas à suggérer des améliorations supplémentaires en tant que commentaire.


Il vous manque quelques '}'
dacopenhagen

2
Très beau code, mais il y a une fin ,à la fin de chaque objet / tableau.
NiCk Newman

c'est la meilleure réponse
Roman

20

Si vous sortez simplement sur la console, vous pouvez utiliser console.log('string:', obj). Remarquez la virgule .


Cela pose des problèmes dans les scénarios où AJAX et différé entrent en jeu - la sortie de console.logest souvent affichée après que AJAX a fini de fournir la baie de données en parallèle, ce qui conduit à des résultats trompeurs. Dans de tels cas, le clonage ou la sérialisation d'objets est la voie à suivre: puisque nous avons enregistré l'objet dupliqué, même lorsque AJAX a terminé son travail, il remplira les "anciennes" données.
rr-

18

Dans les cas où vous savez que l'objet est juste un booléen, une date, une chaîne, un nombre, etc. La fonction javascript String () fonctionne très bien. J'ai récemment trouvé cela utile pour gérer les valeurs provenant de la fonction $ .each de jquery.

Par exemple, ce qui suit convertirait tous les éléments de "valeur" en une chaîne:

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

Plus de détails ici:

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


Ouvar my_string = ''+value+'';
John Magnolia

1
Travaille pour moi. Je préfère cette solution car je n'utiliserais pas de plugin pour une tâche aussi simple.
Tillito

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

12

Je cherchais cela, et j'en ai écrit une profonde récursive avec 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" } })


notez que si vous voulez empêcher les boucles infinies pour les objets avec des références circulaires, vous pouvez ajouter if(ndeep > MAX_DEPTH_LEVEL){ return '...'; }la fonction, MAX_DEPTH_LEVEL étant le nombre maximum de couches d'objets que vous avez choisi pour creuser.
SylvainPV

11

Si vous souhaitez simplement voir l'objet à déboguer, vous pouvez utiliser

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

9

1.

JSON.stringify(o);

Élément: {"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);

Élément: {a: 1, b: 2}


1
Il serait préférable que vous envisagiez d'ajouter plus de détails sur votre réponse.
Harun Diluka Heshan

8

Les méthodes JSON sont assez inférieures à la primitive .toSource () du moteur Gecko.

Voir la réponse de l'article SO pour les tests de comparaison.

De plus, la réponse ci-dessus fait référence à http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html qui, comme JSON, (que l'autre article http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json utilise via "ExtJs JSON encode code source" ) ne peut pas gérer les références circulaires et est incomplet. Le code ci-dessous montre ses limites (usurpation) (corrigées pour gérer les tableaux et les objets sans contenu).

( lien direct vers le code dans //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'));

qui 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]

8

Il y a en fait une option simple (pour les navigateurs récents et Node.js) manquante dans les réponses existantes:

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

Je préférerais cela car il JSON.stringify()a certaines limites (par exemple avec des structures circulaires).


7

Il semble que JSON accepte le deuxième paramètre qui pourrait aider avec les fonctions - remplaçant , cela résout le problème de la conversion de la manière la plus élégante:

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

5

Si vous ne vous souciez 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;
    }

5

stringify-objectest une bonne bibliothèque npm créée par l'équipe yeoman: https://www.npmjs.com/package/stringify-object

npm install stringify-object

puis:

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

Évidemment, c'est intéressant seulement si vous avez un objet circulaire qui échouerait avec JSON.stringify();


1
Pourquoi quelqu'un utiliserait-il un module NPM pour quelque chose comme ça, qui peut être réalisé par un seul revêtement en JS ordinaire? Cette réponse nécessite des détails sur les raisons pour lesquelles quelqu'un le ferait.
Zelphir Kaltstahl du

Comme souvent, une bibliothèque aiderait dans le cas de bord. Je l'ai utilisé pour traiter des références circulaires.
Nicolas Zozol

1
Cela a plus de sens avec la note ajoutée sur les objets circulaires, supprimant mon downvote.
Zelphir Kaltstahl

4

Jetez un oeil au plugin jQuery-JSON

À la base, il utilise JSON.stringify mais revient à son propre analyseur si le navigateur ne l'implémente pas.


4

Comme firefox ne stringifie pas un objet en tant qu'objet écran; si vous voulez avoir le même résultat tel que 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(',')+'}';
}

4

Pour les objets non imbriqués:

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

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

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

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

Étant donné que Javascript v1.0 fonctionne partout (même IE), il s'agit d'une approche native et permet une apparence très personnalisée de votre objet lors du débogage et de la production https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

Exemple utile

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

Aussi, en 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

2

Si vous pouvez utiliser lodash, vous pouvez le faire de cette façon:

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

Avec lodash, map()vous pouvez également parcourir les objets. Cela mappe chaque entrée de clé / valeur à sa représentation sous forme de chaîne:

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

Et join()regroupez les entrées du tableau.

Si vous pouvez utiliser ES6 Template String, cela fonctionne également:

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

Veuillez noter que cela ne passe pas récursivement par l'objet:

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

Comme leutil.inspect() fera le nœud :

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


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

exemple à utiliser:

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

votre_objet1.txt:

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

}

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

}

1
Ce serait bien et une explication de ce que fait le code et un exemple de la façon de l'utiliser. Merci
estemendoza

1

Pour votre exemple, je pense que ce console.log("Item:",o) serait plus facile. Mais, console.log("Item:" + o.toString) cela fonctionnerait aussi.

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


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

1

J'espère que cet exemple aidera tous ceux qui travaillent tous sur un 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"]));

1

Si vous ne jouez pas, joignez () à Object.

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

1

Références circulaires

En utilisant ci - dessous succédané nous pouvons produire JSON moins redondante - si l' objet source contient plusieurs références à un objet, ou contient des références circulaires - nous référençons par chemin de chaîne spéciale (similaire à JSONPath ) - nous l' utilisons comme suit

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

BONUS : et voici la fonction inverse d'une telle sérialisation

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.