ජාවාස්ක්‍රිප්ට් වස්තුවක් නූලක් බවට පරිවර්තනය කරන්නේ කෙසේද?

උදාහරණයක්:

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

ප්‍රතිදානය:

වස්තුව {a = 1, b = 2} // ඉතා හොඳ කියවිය හැකි ප්‍රතිදානය :)
අයිතමය: [වස්තු වස්තුව] // ඇතුළත ඇති දේ ගැන අදහසක් නැත :(

භාවිතා කිරීමට මම නිර්දේශ කරමි JSON.stringify, එමඟින් වස්තුවෙහි විචල්‍යයන් සමූහය JSON නූලක් බවට පරිවර්තනය කරයි. බොහෝ නවීන බ්‍රව්සර් මෙම ක්‍රමයට දේශීයව සහය දක්වයි, නමුත් එසේ නොකරන අයට ඔබට JS අනුවාදයක් ඇතුළත් කළ හැකිය :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

Javascript String () ශ්‍රිතය භාවිතා කරන්න

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

හෝ දැඩි කරන්න ()

JSON.stringify(yourobject)

නිසැකවම, වස්තුවක් නූලක් බවට පරිවර්තනය කිරීම සඳහා, ඔබට ඔබේම ක්‍රමයක් භාවිතා කළ යුතුය, එනම්:

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

ඇත්ත වශයෙන්ම, ඉහත දැක්වෙන්නේ පොදු ප්‍රවේශයයි; ඔබට http://phpjs.org/functions/var_export:578 හෝ http://phpjs.org/functions/var_dump:604 වැනි දෙයක් භාවිතා කිරීමට අවශ්‍ය විය හැකිය.

හෝ, ඔබ ක්‍රම භාවිතා නොකරන්නේ නම් (ඔබේ වස්තුවේ ගුණාංග ලෙස ක්‍රියා කරයි), ඔබට නව ප්‍රමිතිය භාවිතා කළ හැකිය (නමුත් පැරණි බ්‍රව්සර් වල ක්‍රියාත්මක නොවේ, නමුත් ඔබටත් ඒ සඳහා උදව් කිරීමට උපයෝගීතාවයක් සොයාගත හැකි වුවද), JSON .stringify (). නමුත් නැවතත්, වස්තුව JSON වෙත අනුක්‍රමික නොවන ශ්‍රිත හෝ වෙනත් ගුණාංග භාවිතා කරන්නේ නම් එය ක්‍රියා නොකරනු ඇත.

එය සරළව තබා ගනිමින් console, ඔබට a වෙනුවට කොමාව භාවිතා කළ හැකිය +. මෙම +කොමාව කොන්සෝලය එය, ෙවන් ෙවන් වශෙයන් දර්ශනය වනු ඇත බැවින්ද, string එකකට වස්තුව බවට පරිවර්තනය කිරීමට උත්සාහ කරනු ඇත.

උදාහරණයක්:

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

ප්‍රතිදානය:

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

යොමුව: https://developer.mozilla.org/en-US/docs/Web/API/Console.log

සංස්කරණය කරන්න මෙම පිළිතුර ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි ක්‍රියා නොකරන බැවින් එය භාවිතා නොකරන්න. ගැරී චේම්බර්ස් විසඳුම භාවිතා කරන්න .

toSource () යනු ඔබ සොයන ශ්‍රිතය එය JSON ලෙස ලිවීමයි.

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

එක් විකල්පයක් :

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

තවත් විකල්පයක් ( අදහස් දැක්වීමේදී soktinpk පෙන්වා ඇති පරිදි), සහ IMO කොන්සෝල නිදොස්කරණය සඳහා වඩා හොඳය:

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

මෙහි විසඳුම් කිසිවක් මට වැඩ කළේ නැත. JSON.stringify බොහෝ අය පවසන දේ ලෙස පෙනේ, නමුත් එය කාර්යයන් කපා හරින අතර එය පරීක්ෂා කිරීමේදී මා උත්සාහ කළ සමහර වස්තූන් හා අරා සඳහා එය කැඩී ඇති බව පෙනේ.

මම අවම වශයෙන් ක්‍රෝම් හි වැඩ කරන මගේම විසඳුමක් සකස් කළෙමි. ගූගල් හි මෙය පෙනෙන ඕනෑම කෙනෙකුට එය සොයා ගත හැකි වන පරිදි එය මෙහි පළ කිරීම.

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

සංස්කරණය කරන්න: මෙම කේතය වැඩිදියුණු කළ හැකි බව මම දනිමි. පරිශීලක ඇන්ඩ්‍රි අදහස් දැක්වීම සමඟ මෙහි වැඩි දියුණු කිරීමක් යෝජනා කළේය :

මෙන්න ටිකක් වෙනස් කළ කේතයක් වන අතර එමඟින් 'ශුන්‍ය' සහ 'නිර්වචනය නොකළ' හැසිරවිය හැකි අතර අධික කොමාව එකතු නොකරන්න.

මම එය කිසිසේත්ම සත්‍යාපනය කර නොමැති බැවින් එය ඔබේම අවදානමකින් භාවිතා කරන්න. අදහස් දැක්වීමක් ලෙස අමතර වැඩිදියුණු කිරීම් යෝජනා කිරීමට නිදහස් වන්න.

ඔබ කොන්සෝලය වෙත ප්‍රතිදානය කරන්නේ නම්, ඔබට භාවිතා කළ හැකිය console.log('string:', obj). මේ tag කොමා .

ඔබ දන්නා අවස්ථාවන්හිදී වස්තුව හුදෙක් බූලියන්, දිනය, නූල්, අංකය යනාදියයි ... javascript String () ශ්‍රිතය හොඳින් ක්‍රියාත්මක වේ. Jquery හි $ .each ශ්‍රිතයෙන් ලැබෙන අගයන් සමඟ කටයුතු කිරීමේදී මෙය මෑතකදී මට ප්‍රයෝජනවත් විය.

උදාහරණයක් ලෙස පහත දැක්වෙන්නේ “අගය” තුළ ඇති සියලුම අයිතමයන් නූලකට පරිවර්තනය කිරීමයි:

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

වැඩි විස්තර මෙතැනින්:

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

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

මම මෙය සොයමින් සිටි අතර, ගැඹුරු පුනරාවර්තන එකක් ඉන්ඩෙන්ටේෂන් සමඟ ලිවීය:

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

භාවිතය : objToString({ a: 1, b: { c: "test" } })

නිදොස් කිරීම සඳහා ඔබට වස්තුව බැලීමට අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය

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

1.

JSON.stringify(o);

අයිතමය: {"අ": "1", "ආ": "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);

අයිතමය: {a: 1, b: 2}

පවතින පිළිතුරු වල ඇත්ත වශයෙන්ම එක් පහසු විකල්පයක් (මෑත බ්‍රව්සර් සහ Node.js සඳහා) නොමැත:

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

JSON.stringify()යම් සීමාවන් ඇති බැවින් මම මෙය වඩාත් කැමැත්තෙමි (උදා: රවුම් ව්‍යුහයන් සහිත).

JSON ක්‍රම Gecko එන්ජිමට වඩා බෙහෙවින් පහත් ය .ToSource () ප්‍රාථමික.

සංසන්දනාත්මක පරීක්ෂණ සඳහා SO ලිපි ප්‍රතිචාරය බලන්න .

එසේම, ඉහත පිළිතුර යොමු http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html JSON, (එය අනෙක් ලිපිය වැනි වූ, http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json හරහා භාවිතා "ExtJs JSON ආවරණ මූල කේතය" ) චක්රලේඛය යොමු හැසිරවිය හා අසම්පූර්ණයි නොහැක. පහත කේතය එහි (කොල්ලයේ) සීමාවන් පෙන්වයි (අන්තර්ගතයකින් තොරව අරා සහ වස්තු හැසිරවීමට නිවැරදි කර ඇත).

( //forums.devshed.com/ හි කේතයට link ජු සබැඳිය ... / tosource-with-rays-in-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'));

පෙන්වන:

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

සහ

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

සහ

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]

කාර්යයන් සඳහා උපකාර කළ හැකි දෙවන පරාමිතිය JSON පිළිගන්නා බව පෙනේ - ප්‍රතිස්ථාපකය , මෙය වඩාත් අලංකාර ආකාරයකින් පරිවර්තනය කිරීමේ ගැටළුව විසඳයි:

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

ඔබ නූල්, වස්තු සහ අරා ගැන පමණක් සැලකිලිමත් වන්නේ නම්:

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

stringify-objectයූමන් කණ්ඩායම විසින් සාදන ලද හොඳ එන්පීඑම් පුස්තකාලයකි: https://www.npmjs.com/package/stringify-object

npm install stringify-object

එවිට:

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

නිසැකවම එය සිත්ගන්නා සුළු වන්නේ ඔබ අසමත් වන රවුම් වස්තුවක් ඇත්නම් පමණි JSON.stringify();

JQuery-JSON ප්ලගිනය දෙස බලන්න

එහි හරය තුළ, එය JSON.stringify භාවිතා කරයි, නමුත් බ්‍රව්සරය එය ක්‍රියාත්මක නොකරන්නේ නම් එය නැවත එහි විග්‍රහයට වැටේ.

ෆයර්ෆොක්ස් කිසියම් වස්තුවක් තිර වස්තුවක් ලෙස තද නොකරන බැවින්; ඔබට සමාන ප්‍රති result ල ලබා ගැනීමට අවශ්‍ය නම් 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(',')+'}';
}

කැදැලි නොවන වස්තු සඳහා:

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

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

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

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

ජාවාස්ක්‍රිප්ට් v1.0 සෑම තැනකම ක්‍රියාත්මක වන හෙයින් (IE පවා) මෙය ස්වදේශීය ප්‍රවේශයක් වන අතර එය නිදොස් කිරීමේදී සහ නිෂ්පාදනය කිරීමේදී ඔබේ වස්තුව ඉතා මිල අධික ලෙස බැලීමට ඉඩ දෙයි https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

ප්‍රයෝජනවත් උදාහරණය

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

එසේම, ප්රසාද දීමනාවක් ලෙස

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

ඔබට ලොඩාෂ් භාවිතා කළ හැකි නම් ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

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

ලොඩාෂ් සමඟින් map()ඔබට වස්තූන් හරහාද නැවත යෙදිය හැකිය. මෙය සෑම යතුරක් / වටිනාකමක්ම එහි නිරූපණයට සිතියම් ගත කරයි:

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

හා join()එකට අරාව සටහන් ය.

ඔබට ES6 අච්චු නූල් භාවිතා කළ හැකි නම්, මෙයද ක්‍රියාත්මක වේ:

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

මෙය වස්තුව හරහා පුනරාවර්තනය නොවන බව කරුණාවෙන් සලකන්න:

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

වැනි node එකක් මතම ඊට අදාල ගේutil.inspect() කරන්නේ:

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

ඔබ ඩෝජෝ ජාවාස්ක්‍රිප්ට් රාමුව භාවිතා කරන්නේ නම් මෙය සිදු කිරීම සඳහා දැනටමත් ගොඩ නැගීමේ කාර්යයක් ඇත: dojo.toJson () එසේ භාවිතා කරනු ඇත.

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

එමඟින් නූලක් ලැබෙනු ඇත. ඔබට වස්තුව json දත්ත බවට පරිවර්තනය කිරීමට අවශ්‍ය නම් සත්‍යයේ දෙවන පරාමිතිය එක් කරන්න.

dojo.toJson(obj, true);

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

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

භාවිතා කිරීමට උදාහරණය:

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

}

ඔබේ උදාහරණය සඳහා, මම හිතන්නේ console.log("Item:",o) පහසුම ය. එහෙත්, console.log("Item:" + o.toString) ද වැඩ කරනු ඇත.

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

මෙම උදාහරණය සියලු දෙනාටම වස්තු සමූහයක් මත වැඩ කරන සියල්ලන්ට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි

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

ඔබ වස්තුවට සම්බන්ධ නොවන්නේ නම් ().

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

චක්‍රලේඛ යොමුව

පහත භාවිතා කිරීමෙන් replacer වස්තුවේ යම් වස්තුවකට බහු-යොමු අඩංගු, හෝ චක්රලේඛය යොමු අඩංගු නම් - - අපි අඩු අතිරික්ත JSON නිෂ්පාදනය කළ හැකි නම් අප (සමාන විශේෂ path-string එය අදාල JSONPath ) - අපි පහත සඳහන් පරිදි එය භාවිතා

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

function refReplacer() {
  let m = new Map(), v= new Map(), init = null;

  return function(field, value) {
    let p= m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field); 
    let isComplex= value===Object(value)
    
    if (isComplex) m.set(value, p);  
    
    let pp = v.get(value)||'';
    let path = p.replace(/undefined\.\.?/,'');
    let val = pp ? `#REF:${pp[0]=='[' ? '$':'$.'}${pp}` : value;
    
    !init ? (init=value) : (val===init ? val="#REF:$" : 0);
    if(!pp && isComplex) v.set(value, path);
   
    return val;
  }
}




// ---------------
// TEST
// ---------------

// gen obj with duplicate references
let a = { a1: 1, a2: 2 };
let b = { b1: 3, b2: "4" };
let obj = { o1: { o2:  a  }, b, a }; // duplicate reference
a.a3 = [1,2,b];                      // circular reference
b.b3 = a;                            // circular reference


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

console.log(s);

බෝනස් : එවැනි අනුක්‍රමිකකරණයේ ප්‍රතිලෝම ක්‍රියාකාරිත්වය මෙහි දැක්වේ

function parseRefJSON(json) {
  let objToPath = new Map();
  let pathToObj = new Map();
  let o = JSON.parse(json);
  
  let traverse = (parent, field) => {
    let obj = parent;
    let path = '#REF:$';

    if (field !== undefined) {
      obj = parent[field];
      path = objToPath.get(parent) + (Array.isArray(parent) ? `[${field}]` : `${field?'.'+field:''}`);
    }

    objToPath.set(obj, path);
    pathToObj.set(path, obj);
    
    let ref = pathToObj.get(obj);
    if (ref) parent[field] = ref;

    for (let f in obj) if (obj === Object(obj)) traverse(obj, f);
  }
  
  traverse(o);
  return o;
}



// ------------
// TEST
// ------------

let s = `{
    "o1": {
        "o2": {
            "a1": 1,
            "a2": 2,
            "a3": [
                1,
                2,
                {
                    "b1": 3,
                    "b2": "4",
                    "b3": "#REF:$.o1.o2"
                }
            ]
        }
    },
    "b": "#REF:$.o1.o2.a3[2]",
    "a": "#REF:$.o1.o2"
}`;

console.log('Open Chrome console to see nested fields:');
let obj = parseRefJSON(s);

console.log(obj);