Bir nesneyi dizeye dönüştürme

Bir JavaScript nesnesini bir dizeye nasıl dönüştürebilirim?

Misal:

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

Çıktı:

Nesne {a = 1, b = 2} // çok güzel okunabilir çıktı :)
Öğe: [nesne Nesne] // içinde ne olduğu hakkında hiçbir fikrim yok :(

JSON.stringifyNesnede değişkenler kümesini bir JSON dizesine dönüştüren, kullanmanızı öneririm . Çoğu modern tarayıcı bu yöntemi yerel olarak destekler, ancak istemeyenler için bir JS sürümü ekleyebilirsiniz :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);

Javascript String () işlevini kullan

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

veya stringify ()

JSON.stringify(yourobject)

Elbette, bir nesneyi bir dizeye dönüştürmek için ya kendi yönteminizi kullanmanız gerekir, örneğin:

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

Aslında yukarıdakiler sadece genel yaklaşımı göstermektedir; http://phpjs.org/functions/var_export:578 veya http://phpjs.org/functions/var_dump:604 gibi bir şey kullanmak isteyebilirsiniz

veya yöntemleri (nesnenizin özellikleri olarak işlevler) kullanmıyorsanız, yeni standardı kullanabilirsiniz (ancak eski tarayıcılarda uygulanamaz, ancak onlar için de yardımcı olacak bir yardımcı program bulabilirsiniz), JSON .stringify (). Ancak yine de, nesne JSON tarafından serileştirilemeyen işlevler veya diğer özellikler kullanıyorsa, bu çalışmaz.

Basit tutmak için console, a yerine virgül kullanabilirsiniz +. +Virgül konsolda ayrı olarak gösterecektir, oysa bir dizeye nesneyi dönüştürmek için çalışacağız.

Misal:

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

Çıktı:

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

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

DÜZENLEME Internet Explorer'da çalışmadığı için bu yanıtı kullanmayın. Gary Chambers çözümünü kullanın .

toSource () , aradığınız işlevi JSON olarak yazacak olan işlevdir.

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

Bir seçenek :

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

Başka bir seçenek ( soktinpk'in yorumlarda belirtildiği gibi) ve IMO konsolunda hata ayıklama için daha iyi:

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

Buradaki çözümlerin hiçbiri benim için işe yaramadı. JSON.stringify, birçok insanın söylediği gibi görünüyor, ancak işlevleri keser ve test ederken denediğim bazı nesneler ve diziler için oldukça kırık görünüyor.

En azından Chrome'da çalışan kendi çözümümü yaptım. Bunu Google'da görüntüleyen herkesin bulabilmesi için buraya gönderiyor.

//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: Bu kod geliştirilebilir biliyorum ama sadece bunu yapmak için etrafında var asla. Kullanıcı andrey burada yorum ile bir iyileştirme önerdi :

İşte 'null' ve 'undefined' işleyebilen ve aşırı virgül eklemeyen biraz değiştirilmiş kod.

Bunu hiç doğrulamadığım için kendi sorumluluğunuzdadır. Herhangi bir ek iyileştirmeyi yorum olarak önermekten çekinmeyin.

Sadece konsola çıkış yapıyorsanız, kullanabilirsiniz console.log('string:', obj). Virgül dikkat edin .

Nesnenin yalnızca bir Boole, Tarih, Dize, sayı vb. Olduğunu bildiğiniz durumlarda ... Javascript String () işlevi gayet iyi çalışır. Son zamanlarda bu jquery $ .each işlevinden gelen değerlerle ilgili yararlı buldum.

Örneğin, "value" içindeki tüm öğeleri bir dizeye dönüştürür:

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

Daha fazla ayrıntı burada:

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

Bunu arıyordum ve girintili derin bir özyinelemeli yazdım:

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

Kullanımı: objToString({ a: 1, b: { c: "test" } })

Nesneyi hata ayıklamak için görmek istiyorsanız,

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

1.

JSON.stringify(o);

Öğe: {"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);

Öğe: {a: 1, b: 2}

JSON yöntemleri, Gecko motoru .toSource () ilkelinden oldukça düşüktür.

SO makalesinin yanıtına bakınKarşılaştırma testleri için .

Ayrıca, yanıt yukarıda atıfta http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html JSON'dan (diğer makale gibi, hangi http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json , "ExtJs JSON kodlama kaynak kodu" aracılığıyla kullanır ) döngüsel başvuruları işleyemez ve eksiktir. Aşağıdaki kod (parodi) sınırlamalarını gösterir (dizileri ve içeriği olmayan nesneleri işlemek için düzeltilmiştir).

( //Forums.devshed.com/ kod doğrudan bağlantı ... / tosource-ile-diziler-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'));

hangi görüntüler:

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

ve

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

ve

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]

Mevcut yanıtlarda eksik olan tek bir kolay seçenek (son tarayıcılar ve Node.js için) yoktur:

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

JSON.stringify()Belirli sınırlamaları olduğu için bunu tercih ederim (örneğin dairesel yapılarda).

Görünüşe göre JSON, işlevlere yardımcı olabilecek ikinci parametreyi kabul ediyor - replacer , bu en zarif şekilde dönüştürme sorununu çözüyor:

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

Yalnızca dizeleri, nesneleri ve dizileri önemsiyorsanız:

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-objectyeoman ekibi tarafından yapılmış iyi bir npm kütüphanesi: https://www.npmjs.com/package/stringify-object

npm install stringify-object

sonra:

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

Açıkçası bu sadece başarısız olacak dairesel bir nesneniz varsa JSON.stringify();

JQuery-JSON eklentisine bir göz atın

Özünde JSON.stringify kullanır, ancak tarayıcı uygulamazsa kendi ayrıştırıcısına geri döner.

Firefox bazı nesneleri ekran nesnesi olarak dizginlemediğinden; aşağıdaki gibi aynı sonuca sahip olmak istiyorsanız 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(',')+'}';
}

Yuvalanmamış nesneler için:

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

Javascript v1.0 her yerde (hatta IE) çalıştığı için bu yerel bir yaklaşımdır ve hata ayıklama ve üretim sırasında nesnenizin çok kozmik bir görüntüsüne izin verir https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Nesne / toString

Yararlı örnek

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

Ayrıca, bonus olarak

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

Lodash'ı kullanabiliyorsanız şu şekilde yapabilirsiniz:

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

Lodash ile map()Nesneler üzerinde de yineleme yapabilirsiniz. Bu, her anahtar / değer girdisini dize temsiliyle eşleştirir:

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

Ve join()dizi girişlerini bir araya getirin.

ES6 Şablon Dizesi'ni kullanabiliyorsanız, bu ayrıca çalışır:

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

Lütfen bunun Nesne boyunca özyinelemediğini unutmayın:

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

Gibi düğüm enutil.inspect() yapacağız:

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

Dojo javascript çerçevesini kullanıyorsanız, bunu yapmak için zaten bir yapı işlevi vardır: dojo.toJson () bu şekilde kullanılır.

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

bir dize döndürür. Nesneyi json verilerine dönüştürmek istiyorsanız, ikinci bir true parametresi ekleyin.

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

örnek:

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

}

Örneğin, console.log("Item:",o) en kolay olacağını düşünüyorum . Ama console.log("Item:" + o.toString) aynı zamanda işe yarayacaktır.

Birinci yöntem kullanılarak konsolda hoş bir açılır liste kullanılır, bu nedenle uzun bir nesne güzel çalışır.

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

Umarım bu örnek, nesne dizisi üzerinde çalışan herkes için yardımcı olacaktır.

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

Eğer aplay yapmayacaksanız Object'e () katılın.

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

Bir değişken bir satır içi ifade türü durum için bir dizeye dönüştürme minimalist bir yöntem istiyorsanız, ''+variablenameben golf var en iyisidir.

'Variablename' bir nesneyse ve boş dize birleştirme işlemini kullanırsanız, sinir bozucu olur [object Object], bu durumda Gary C.'nin JSON.stringifyyayınlanan soruya muazzam derecede yükseltilmiş cevabını Mozilla Geliştirici Ağı'nda okuyabileceğinizi istersiniz. üstteki yanıtta yer alan bağlantıda .