Konwertowanie obiektu na ciąg

974

Jak przekonwertować obiekt JavaScript na ciąg?

Przykład:

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

Wynik:

Obiekt {a = 1, b = 2} // bardzo ładnie czytelny wynik :)
Element: [obiekt Object] // nie mam pojęcia, co jest w środku :(

użytkownik680174
źródło
7
Konwertuj na ciąg w jakim celu? Masz na myśli serializację, aby móc później zbudować obiekt z ciągu? A może tylko na pokaz?
Shadow Wizard is Ear For You
19
Autor nie istnieje od lat, ale pamiętam, że po latach, punktem wyjścia dla problemu była konsola.log (obj), która wyświetla obiekt z właściwościami, podczas gdy konsola.log ('obj:' + obj ) działa dezorientująco inaczej.
Danubian Sailor
2
po prostu nie można zastosować dodać dwóch obiektów, jeśli możemy to zrobić, nie byłoby różnicy w typie wartości i typie odniesienia.
Nishant Kumar
12
var o = {a: 1, b: 2}; console.log („Element:” + JSON.stringify (o))
Nishant Kumar
22
Jeśli chodzi o konsolę, poleciłbym to zrobić console.log("Item", obj);. Nie potrzeba nic skomplikowanego.
soktinpk

Odpowiedzi:

1332

Poleciłbym użycie JSON.stringify, który konwertuje zestaw zmiennych w obiekcie na ciąg JSON. Większość współczesnych przeglądarek obsługuje tę metodę natywnie, ale dla tych, które tego nie robią, możesz dołączyć wersję JS :

var obj = {
  name: 'myObj'
};

JSON.stringify(obj);
Gary Chambers
źródło
7
Dla odniesienia IE6 i 7 nie obsługują tego. IE6 nie jest wielkim problemem ze względu na bardzo małą liczbę użytkowników i aktywną kampanię mającą na celu ich zabicie ... ale wciąż jest sporo użytkowników IE7 (zależy od bazy użytkowników).
MikeMurko
30
Otrzymuję komunikat „Uncaught TypeError: Konwersja okrągłej struktury do JSON”. Nawet jeśli istnieje cykliczne odniesienie, nadal chciałbym zobaczyć ciąg reprezentacji mojego obiektu. Co mogę zrobić?
Pascal Klein
26
To nie działa, jeśli obiekt ma właściwość funkcji, np foo: function () {...}. : .
Brock Adams,
2
Link do biblioteki JSON nie działa po kliknięciu w StackOverflow. Skopiuj i wklej go w pasku adresu.
f. Kardynał
1
Możesz użyć JSON.stringify(obj, null, 2);dla ładniejszego wyjścia.
l.poellabauer
126

Zastosowanie javascript String () funkcja

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

lub stringify ()

JSON.stringify(yourobject)
Vikram Pote
źródło
28
var foo = {bar: 1}; String (foo); -> „[Object Object]”
Anti Veeranna
1
var foo = {bar: 1}; String (foo ['bar']); -> „1”
Vikram Pote
3
Jeśli chcesz cały obiekt jako ciąg, użyj JSON.stringify (foo)
Vikram Pote
8
JSON.stringify(yourobject)pokojówka mój dzień!
Neurotransmitter
1
@TranslucentCloud * made
Parampal Pooni
87

Oczywiście, aby przekonwertować obiekt na ciąg, musisz użyć własnej metody, takiej jak:

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

W rzeczywistości powyższe pokazuje tylko ogólne podejście; możesz użyć czegoś takiego jak http://phpjs.org/functions/var_export:578 lub http://phpjs.org/functions/var_dump:604

lub, jeśli nie korzystasz z metod (funkcji jako właściwości swojego obiektu), możesz być w stanie użyć nowego standardu (ale nie jest on zaimplementowany w starszych przeglądarkach, chociaż możesz znaleźć narzędzie, które może w tym pomóc), JSON .stringify (). Ale znowu to nie zadziała, jeśli obiekt używa funkcji lub innych właściwości, które nie są serializowane w JSON.

Brett Zamir
źródło
78

Upraszczając console, możesz po prostu użyć przecinka zamiast +. +Spróbuje przekonwertować obiekt na ciąg znaków, natomiast przecinek będzie go wyświetlić odrębnie w konsoli.

Przykład:

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

Wynik:

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

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

Łukasz
źródło
Rozkoszne rozwiązanie! Ale czy możesz mi powiedzieć, co dzieje się za kulisami, gdy po prostu to robisz console.log(o):? Ponieważ jeśli spróbujesz zalogować obiekt dodany do ciągu, w rzeczywistości wywołuje toString()on obiekt.
Gocy015,
1
console.logostatecznie wywołuje coś, co nazywa się tym, Printerco zauważa specyfikacja: „Sposób, w jaki implementacja drukuje argumenty, zależy od implementacji” - co oznacza, że ​​każda przeglądarka może to zrobić inaczej (patrz console.spec.whatwg.org/#printer ). Firefox wyświetli obiekty w postaci łańcucha, ale ładnie pokolorowane. Chrome wyświetli obiekt jako interaktywną grupę, którą możesz rozwinąć, aby zobaczyć właściwości. Spróbuj!
Łukasz
2
Bardzo fajna sztuczka i prawdopodobnie dobra dla nowoczesnych przeglądarek internetowych, ale nie jest w 100% niezawodna dla wszystkich implementacji JS. np. w Qt QML, który implementuje silnik JS, wyjściem console.log('Item: ', o);jest nadal Item: [object Object].
Paul Masri-Stone
Zamiast tego console.logmożesz użyć console.dir(o)do wydrukowania obiektu javascript zamiast do wydrukowania go jako łańcucha. W narzędziach programistycznych umożliwia to otwarcie obiektu i sprawdzenie wszystkich właściwości, nawet tablic. (patrz: developer.mozilla.org/de/docs/Web/API/Console/dir )
EagleT
37

EDYCJA Nie używaj tej odpowiedzi, ponieważ nie działa ona w Internet Explorerze. Użyj rozwiązania Gary Chambers .

toSource () to funkcja, której szukasz, która zapisze ją jako JSON.

var object = {};
object.first = "test";
object.second = "test2";
alert(object.toSource());
Gazler
źródło
6
Chociaż jest wygodny do debugowania w Firefoksie, toSource()nie działa w IE.
Brett Zamir
4
toSource()nie jest uznanym standardem, dlatego nie można zagwarantować, że będzie obsługiwany we wszystkich przeglądarkach.
Gary Chambers
11
Ahh, dziękuję za zwrócenie na to uwagi. Pozostawię swoją odpowiedź tutaj innym, którzy nie są tego świadomi.
Gazler,
Chciałbym móc cię bardziej głosować, ponieważ jest to genialne rozwiązanie dla środowisk z javascript (ale dostęp do dziennika konsoli jest niewygodny / niemożliwy).
Zack Morris,
Możesz podać polypill
roland
32

Jedna opcja :

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

o jest drukowane jako ciąg

Kolejna opcja (jak wskazał soktinpk w komentarzach) i lepsza do debugowania konsoli IMO:

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

o jest drukowane jako obiekt, który można pogłębić, jeśli masz więcej pól

nabn
źródło
22

Żadne z rozwiązań tutaj nie działało dla mnie. JSON.stringify wydaje się być tym, co mówi wiele osób, ale odcina funkcje i wydaje się dość zepsuty dla niektórych obiektów i tablic, które próbowałem podczas testowania.

Stworzyłem własne rozwiązanie, które działa przynajmniej w Chrome. Opublikuj go tutaj, aby każdy, kto szuka tego w Google, mógł go znaleźć.

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

EDYCJA: Wiem, że ten kod można ulepszyć, ale po prostu nigdy tego nie zrobiłem. Użytkownik andrey zasugerował tutaj ulepszenie z komentarzem:

Oto nieco zmieniony kod, który może obsługiwać wartości „null” i „undefined”, a także nie dodawać nadmiernych przecinków.

Wykorzystaj to na własne ryzyko, ponieważ w ogóle tego nie zweryfikowałem. Jako sugestię możesz zaproponować dodatkowe ulepszenia.

Houshalter
źródło
Brakuje niektórych „}”
dacopenhagen
2
Bardzo ładny kod, ale ,na końcu każdego obiektu / tablicy znajduje się znak końcowy .
NiCk Newman
to najlepsza odpowiedź
Roman
20

Jeśli po prostu wysyłasz dane do konsoli, możesz użyć console.log('string:', obj). Zwróć uwagę na przecinek .

Alexandre R. Janini
źródło
Stwarza to problemy w scenariuszach, w których AJAX i odroczone przychodzą do gry - dane wyjściowe console.logsą często wyświetlane po tym, jak AJAX zakończy równoległe dostarczanie tablicy danych, co prowadzi do mylących wyników. W takich przypadkach należy klonować lub serializować obiekty: ponieważ zarejestrowaliśmy zduplikowany obiekt, nawet gdy AJAX zakończy swoją pracę, wypełni „stare” dane.
rr-
18

W przypadkach, gdy wiesz, że obiekt jest tylko logiczną, datą, łańcuchem, liczbą itp. Funkcja javascript String () działa dobrze. Niedawno uznałem to za przydatne w przypadku wartości pochodzących z funkcji $ .each jquery.

Na przykład następujące przekonwertuje wszystkie elementy w „wartości” na ciąg znaków:

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

Więcej informacji tutaj:

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

Jake Drew
źródło
Lubvar my_string = ''+value+'';
John Magnolia
1
Pracuje dla mnie. Wolę to rozwiązanie, ponieważ nie użyłbym wtyczki do tak prostego zadania.
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);
słoneczny rai
źródło
12

Szukałem tego i napisałem głęboką rekurencyjną z wcięciem:

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

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

SylvainPV
źródło
zwróć uwagę, że jeśli chcesz zapobiec nieskończonym pętlom dla obiektów z referencjami kołowymi, możesz dodać if(ndeep > MAX_DEPTH_LEVEL){ return '...'; }tę funkcję, przy czym MAX_DEPTH_LEVEL jest wybraną maksymalną liczbą warstw obiektów do wykopania.
SylvainPV
11

Jeśli chcesz tylko zobaczyć obiekt do debugowania, możesz użyć

var o = {a:1, b:2} 
console.dir(o)
PaulAndrewLang
źródło
9

1.

JSON.stringify(o);

Pozycja: {„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);

Pozycja: {a: 1, b: 2}

vacsati
źródło
1
Byłoby lepiej, gdybyś rozważył dodanie dodatkowych szczegółów na temat swojej odpowiedzi.
Harun Diluka Heshan
8

Metody JSON są gorsze od prymitywnego silnika .toSource () silnika Gecko.

Zobacz odpowiedź artykułu SO na testy porównawcze.

Również powyższa odpowiedź odnosi się do http://forums.devshed.com/javascript-development-115/tosource-with-arrays-in-ie-386109.html, które, podobnie jak JSON, (które drugi artykuł http: // www.davidpirek.com/blog/object-to-string-how-to-deserialize-json korzysta z „ExtJs JSON kod kod źródłowy” ) nie może obsługiwać referencji cyklicznych i jest niekompletny. Poniższy kod pokazuje ograniczenia (fałszerstwa) (poprawione do obsługi tablic i obiektów bez zawartości).

( bezpośredni link do kodu w //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'));

który wyświetla:

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

i

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

i

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]
Ekim
źródło
8

W istniejących odpowiedziach brakuje jednej prostej opcji (dla najnowszych przeglądarek i Node.js):

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

Wolałbym to, ponieważ JSON.stringify()ma pewne ograniczenia (np. W przypadku okrągłych struktur).

Christian Gawron
źródło
7

Wygląda na to, że JSON akceptuje drugi parametr, który może pomóc w funkcjach - zamień , rozwiązuje to problem konwersji w najbardziej elegancki sposób:

JSON.stringify(object, (key, val) => {
    if (typeof val === 'function') {
      return String(val);
    }
    return val;
  });
Gleb Dolzikov
źródło
5

Jeśli zależy Ci tylko na ciągach, obiektach i tablicach:

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;
    }
Anuraag Vaidya
źródło
5

stringify-objectto dobra biblioteka npm wykonana przez zespół Yeoman: https://www.npmjs.com/package/stringify-object

npm install stringify-object

następnie:

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

Oczywiście jest to interesujące tylko wtedy, gdy masz okrągły obiekt, z którym by się nie powiodło JSON.stringify();

Nicolas Zozol
źródło
1
Dlaczego ktoś miałby używać modułu NPM do czegoś takiego, co można osiągnąć za pomocą jednej linijki w zwykłym JS? Ta odpowiedź wymaga szczegółowych informacji o tym, dlaczego ktoś to zrobił.
Zelphir Kaltstahl
Jak często lib może pomóc w przypadku krawędzi. Użyłem go do obsługi okólników.
Nicolas Zozol,
1
Ma to większy sens z dodaną uwagą na temat okrągłych obiektów, usuwającą moją opinię.
Zelphir Kaltstahl
4

Spójrz na wtyczkę jQuery-JSON

Zasadniczo używa JSON.stringify, ale wraca do własnego parsera, jeśli przeglądarka go nie implementuje.

Evan Plaice
źródło
4

Ponieważ firefox nie określa jakiegoś obiektu jako obiektu ekranowego; jeśli chcesz mieć taki sam wynik, jak 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(',')+'}';
}
Abdennour TOUMI
źródło
4

W przypadku obiektów zagnieżdżonych:

Object.entries(o).map(x=>x.join(":")).join("\r\n")
Alex Szücs
źródło
2
var o = {a:1, b:2};

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

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

Ponieważ Javascript v1.0 działa wszędzie (nawet IE), jest to podejście natywne i pozwala na bardzo kosztowny wygląd twojego obiektu podczas debugowania i produkcji https://developer.mozilla.org/en/docs/Web/JavaScript/Reference / Global_Objects / Object / toString

Przydatny przykład

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

Dodatkowo jako 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
Alex
źródło
2

Jeśli możesz użyć lodash, możesz to zrobić w ten sposób:

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

Z lodash map()możesz także iterować obiekty. Spowoduje to odwzorowanie każdego wpisu klucza / wartości na jego reprezentację ciągu:

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

I join()połącz wpisy tablicy.

Jeśli możesz użyć ciągu szablonów ES6, działa to również:

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

Pamiętaj, że to nie przechodzi przez obiekt:

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

Podobnie jak węzłyutil.inspect() zrobią:

> util.inspect(o)
'{ a: 1, b: { c: 2 } }'
kwarnke
źródło
1

Jeśli używasz frameworku Java Dojo, istnieje już wbudowana funkcja: dojo.toJson (), która byłaby używana w ten sposób.

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

który zwróci ciąg. Jeśli chcesz przekonwertować obiekt na dane json, dodaj drugi parametr true.

dojo.toJson(obj, true);

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

Chris O'Connell
źródło
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;
};

przykład do użycia:

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

twój_obiekt1.txt:

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

}

twój_obiekt2.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*/
    }

}
morze-kg
źródło
1
Byłoby dobrze i wyjaśnienie, co robi kod oraz przykład, jak go używać. Dzięki
estemendoza,
1

Dla twojego przykładu myślę, że console.log("Item:",o) byłoby to najłatwiejsze. Ale console.log("Item:" + o.toString) działałoby również.

Używając metody numer jeden, używa ładnego menu rozwijanego w konsoli, więc długi obiekt działałby ładnie.

Fuzzyzilla
źródło
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)+"}";
}
Mauro
źródło
1

Mam nadzieję, że ten przykład pomoże wszystkim tym, którzy pracują nad szeregiem obiektów

var data_array = [{
                    "id": "0",
                    "store": "ABC"
                },{
                    "id":"1",
                    "store":"XYZ"
                }];
console.log(String(data_array[1]["id"]+data_array[1]["store"]));
Khushal Chheda
źródło
1

Jeśli nie chcesz odtwarzać, dołącz () do Object.

const obj = {one:1, two:2, three:3};
let arr = [];
for(let p in obj)
    arr.push(obj[p]);
const str = arr.join(',');
Илья Индиго
źródło
0

Jeśli chcesz minimalistyczną metodę konwersji zmiennej na ciąg znaków dla sytuacji typu wyrażenia wbudowanego, ''+variablenamejest to najlepsza gra w golfa.

Jeśli „variablename” jest obiektem i użyjesz operacji konkatenacji pustych ciągów, będzie to denerwujące [object Object], w takim przypadku prawdopodobnie będziesz potrzebować niezwykle pozytywnej JSON.stringifyodpowiedzi Gary'ego C. na zadane pytanie, o której możesz przeczytać w Sieci deweloperów Mozilli pod linkiem w tej odpowiedzi u góry .

stackuser83
źródło