编辑不要使用此答案，因为它仅适用于某些版本的Firefox。没有其他浏览器支持它。使用Gary Chambers解决方案。

toSource（）是你正在寻找的函数，它将把它写成JSON。

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

我建议使用#0，它将对象中的变量集转换为JSON字符串。

var obj = {name: 'myObj'};
JSON.stringify(obj);

大多数现代浏览器原生支持此方法，但对于那些不支持的浏览器，您可以包含js版本。

当然，要将对象转换为字符串，您必须使用自己的方法，例如：

function objToString (obj) {var str = '';for (var p in obj) {if (Object.prototype.hasOwnProperty.call(obj, 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的函数或其他属性，这将不起作用。

更新：

更现代的解决方案是：

function objToString (obj) {let str = '';for (const [p, val] of Object.entries(obj)) {str += `${p}::${val}\n`;}return str;}

或：

function objToString (obj) {return Object.entries(obj).reduce((str, [p, val]) => {return `${str}${p}::${val}\n`;}, '');}

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/中的代码… /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'));

其中显示：

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]

如果您使用的是Dojo javascript框架，那么已经有一个内置函数可以做到这一点：dojo.toJson（），它将像这样使用。

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

这将返回一个字符串。如果您想将对象转换为json数据，请添加第二个true参数。

dojo.toJson(obj, true);

看看jQuery-JSON

在其核心，它使用JSON.stringify，但如果浏览器不实现它，则回退到自己的解析器。

在你知道对象只是布尔值、日期、字符串、数字等的情况下……javascript String（）函数运行良好。我最近发现这在处理来自jQuery的$. each函数的值时很有用。

例如，下面将把“value”中的所有项目转换为字符串：

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

更多细节在这里：

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

由于Firefox不会将某些对象字符串化为屏幕对象；如果您想获得相同的结果，例如：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(',')+'}';}

这里没有一个解决方案对我有效。JSON.stringify似乎是很多人说的，但它削减了功能，对于我在测试它时尝试的一些对象和数组来说，似乎很糟糕。

我做了我自己的解决方案，至少在Chrome工作。把它贴在这里，这样任何在谷歌上查找的人都可以找到它。

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

编辑：我知道这段代码可以改进，但一直没有时间去做。用户andrey建议改进这里并发表评论：

这是一个稍微改变的代码，它可以处理“null”和“未定义”，并且不会添加过多的逗号。

使用它需要您自担风险，因为我根本没有验证它。请随时提出任何额外的改进作为评论。

如果您只是输出到控制台，您可以使用console.log('string:', obj)。请注意逗号。

/*This function is as JSON.Stringify (but if you has not in your js-engine you can use this)Params:obj - your objectinc_ident - can be " " or "\t".show_types - show types of object or notident - 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*/}
}

我正在寻找这个，并写了一个带有缩进的深度递归：

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)

使用console保持简单，您可以只使用逗号而不是+。+将尝试将对象转换为字符串，而逗号将在控制台中单独显示它。

示例：

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

输出：

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

参考：https://developer.mozilla.org/en-US/docs/Web/API/Console.log

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

一个选择：

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

另一种选择（如评论中soktinpk所指出的），更适合控制台调试IMO：

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

对于你的例子，我认为console.log("Item:",o)最简单不过，console.log("Item:" + o.toString)也可以用

使用方法一在控制台中使用了一个很好的下拉列表，所以一个长对象可以很好地工作。

如果你只关心字符串、对象和数组：

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

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

使用javascript字符串函数

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

或stringify（）

JSON.stringify(yourobject)

我希望这个例子将有助于所有那些谁都在数组的对象

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

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适用于任何地方（甚至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 behaviouralert(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 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);

如果你可以使用Lodash，你可以这样做：

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

请注意，这不会通过Object递归：

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

就像节点的#0一样：

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

stringify-object是由yeoman团队制作的一个很好的npm库：https://www.npmjs.com/package/stringify-object

npm install stringify-object

然后：

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

显然，只有当你有循环对象会以JSON.stringify();失败时，它才会有趣

1.

JSON.stringify(o);

题目：{"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);

项目：{a： 1， b： 2}

如果你不玩连接（）到对象。

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

对于非嵌套对象：

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

如果您想要一种将变量转换为字符串以用于内联表达式类型情况的极简方法，那么''+variablename是我玩过的最好的方法。

如果'Variablename'是一个对象，并且您使用空字符串连接操作，它将给出烦人的[object Object]，在这种情况下，您可能希望Gary C.对发布的问题给予极大的支持JSON.stringify答案，您可以在Mozilla的开发者网络上阅读答案在顶部中的链接。

我需要创建一个更可配置的JSON.stringify版本，因为我必须添加注释并知道JSON路径：

const someObj = {a: {nested: {value: 'apple',},sibling: 'peanut'},b: {languages: ['en', 'de', 'fr'],c: {nice: 'heh'}},c: 'butter',d: function () {}};
function* objIter(obj, indent = '  ', depth = 0, path = '') {const t = indent.repeat(depth);const t1 = indent.repeat(depth + 1);const v = v => JSON.stringify(v);yield { type: Array.isArray(obj) ? 'OPEN_ARR' : 'OPEN_OBJ', indent, depth };const keys = Object.keys(obj);  
for (let i = 0, l = keys.length; i < l; i++) {const key = keys[i];const prop = obj[key];const nextPath = !path && key || `${path}.${key}`; 
if (typeof prop !== 'object') {yield { type:  isNaN(key) ? 'VAL' : 'ARR_VAL', key, prop, indent, depth, path: nextPath };} else {yield { type: 'OBJ_KEY', key, indent, depth, path: nextPath };yield* objIter(prop, indent, depth + 1, nextPath);}}
yield { type: Array.isArray(obj) ? 'CLOSE_ARR' : 'CLOSE_OBJ', indent, depth };}
const iterMap = (it, mapFn) => {const arr = [];for (const x of it) { arr.push(mapFn(x)) }return arr;}
const objToStr = obj => iterMap(objIter(obj), ({ type, key, prop, indent, depth, path }) => {const t = indent.repeat(depth);const t1 = indent.repeat(depth + 1);const v = v => JSON.stringify(v);
switch (type) {case 'OPEN_ARR':return '[\n';case 'OPEN_OBJ':return '{\n';case 'VAL':return `${t1}// ${path}\n${t1}${v(key)}: ${v(prop)},\n`;case 'ARR_VAL':return `${t1}// ${path}\n${t1}${v(prop)},\n`;case 'OBJ_KEY':return `${t1}// ${path}\n${t1}${v(key)}: `;case 'CLOSE_ARR':case 'CLOSE_OBJ':return `${t}${type === 'CLOSE_ARR' ? ']' : '}'}${depth ? ',' : ';'}\n`;default:throw new Error('Unknown type:', type);}}).join('');
const s = objToStr(someObj);console.log(s);

如果你想要的只是简单地得到一个字符串输出，那么这应该可以：String(object)

实际上，现有答案中缺少一个简单的选项（适用于最近的浏览器和Node.js）：

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

我更喜欢这样，因为JSON.stringify()有一定的限制（例如圆形结构）。

似乎JSON接受第二个可以帮助函数的参数-替代品，这解决了以最优雅的方式转换的问题：

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

通函

通过使用下面的替换r，我们可以产生更少的冗余JSON-如果源对象包含对某个对象的多引用，或者包含循环引用-那么我们通过特殊的路径字符串（类似于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 referenceslet a = { a1: 1, a2: 2 };let b = { b1: 3, b2: "4" };let obj = { o1: { o2:  a  }, b, a }; // duplicate referencea.a3 = [1,2,b];                      // circular referenceb.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);

添加---

JSON.stringify（obj）很好，但它会转换为json字符串对象。有时我们需要它的字符串，就像在WCF超文本传输协议的正文中发布它并作为字符串接收时一样。

为此，我们应该重用stringify（）如下：

let obj = {id:1, name:'cherry'};let jsonObj = JSON.stringify(doc); //json object stringlet strObj = JSON.stringify(jsonObj); //json object string wrapped with string

也许你正在寻找

JSON.stringify(JSON.stringify(obj))

"{\"id\":30}"

如果对象是jQuery对象，那么您应该使用：

obj.html()

而不是：

JSON.stringify(obj)

示例：

var tr = $('tr')
console.log('This does not work:')console.log(JSON.stringify(tr))console.log('But this does:')console.log(tr.html())

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script><table><tr><td>a</td><td>b</td></table>

下面是一些简单的解决方案。

它只显示字符串的“”，而不显示数字和函数/方法（如果方法按此处所示编写）：

  let obj = {name: "Philips TV",price: 2500,somemethod: function() {return "Hi there"}};  
let readableobj = '{ ';  
for(key in obj) {readableobj +=(typeof obj[key] === "string")? `${key}: "${obj[key]}", ` : `${key}: ${obj[key]}, `;} 
readableobj += '}';  
console.log('obj', readableobj); // obj { name: "Philips TV", price: 42, somemethod: function() {return "Hi there"}, }

此解决方案使用尾随逗号（自ECMAScript 5以来是合法的-请参阅MDN中的参考这里。）

代码基于最简单的“对于在”循环形式：

let obj = {key: "value"};for(key in obj) {return "The property " + key + " with value " + obj[key];}

注意：它甚至适用于这种方法符号：

  let obj = {name: "Philips TV",price: 2500,somemethod() {return "Hi there"}};

将结果显示为

    obj { name: "Philips TV", price: 42, somemethod: somemethod() {return "Hi there"}, }

甚至对于箭头函数表示法

  let obj = {name: "Philips TV",price: 2500,somemethod: () => {return "Hi there"}};

将结果显示为

    obj { name: "Philips TV", price: 42, somemethod: () => {return "Hi there"}, }

因此，您可以以可接受的格式显示甚至是一个包含所有三种形式的方法符号的对象，就像这样：

  let obj = {name: "Philips TV",price: 2500,method1: function() {return "Hi there"},method2() {return "Hi there"},method3: () => {return "Hi there"}};

人们可能会看到，即使是第二种格式方法2（）{返回"你好"}也最终显示为一对<说明>key： value，通过复制其标识符

// method2: method2() {return "Hi there"}

最后，true/false，未定义， null与数字和函数的处理方式相同（最终格式中没有显示“”），因为它们也不是字符串。

<强>重要：

JSON.stringify（）破坏原始对象中的含义是方法丢失并未显示在它创建的最终字符串中。

因此，我们可能不应该接受涉及其使用的解决方案。

console.log('obj', JSON.stringify(obj)); // obj {"name":"Philips TV","price":2500} // which is NOT acceptable

使用reduce的修改方法，让在检查最后一项时更改(key,value)元组之间的分隔符sep：

/*** Object to string* @param {*} obj* @param {*} k_sep keys separator* @param {*} v_sep values separator* @returns*/var objectToString: function (obj, k_sep = '=', v_sep = ',') {const entries = Object.entries(obj);return entries.reduce((str, [p, val], counter) => {if (counter < entries.length - 1) {return `${str}${p}${k_sep}${val}${v_sep}`;} else {return `${str}${p}${k_sep}${val}`;}}, '');}

/*** Object to string* @param {*} obj* @param {*} k_sep keys separator* @param {*} v_sep values separator* @returns*/var objectToString = function(obj, k_sep = '=', v_sep = ',') {const entries = Object.entries(obj);return entries.reduce((str, [p, val], counter) => {if (counter < entries.length - 1) {return `${str}${p}${k_sep}${val}${v_sep}`;} else {return `${str}${p}${k_sep}${val}`;}}, '');}
console.log(objectToString({status_code: 200,execute_time: 0.1,ip: '1270.0.0.1'}, ':', ","))console.log(objectToString({status_code: 200,execute_time: 0.1,ip: '1270.0.0.1'}, '=', ","))

我用for in和template literal在string中有两个键值对，它对我有用。

let obj = {name: "John",age: 22,isDev: true,};let toStr = "";for (let key in obj) {if (obj.hasOwnProperty(key)) {toStr += `${key} ${obj[key]}` + ", ";}}console.log(toStr);console.log(typeof toStr);