JavaScript判断对象是否为空对象的几种方法
https://blog.csdn.net/MyFuture_MyDream/article/details/116225441

var data = {};
var b = $.isEmptyObject(data); //true

判断是否为空对象在实际开发中很常见，今天就让我们来整理一下有哪些方法吧。

1、空对象对应的字符串为 “{}”

  1. var data = {};
  2. var b = JSON.stringify(data) == "{}";
  3. console.log(b); // true

2、for in

  1. var obj = {};
  2. var b = function () {
  3.   for (var key in obj) {
  4.     return false;
  5.   }
  6.   return true;
  7. };
  8. console.log(b()); //true

3、jquery 的 isEmptyObject()方法

这个方法是对第二个方法的封装。

  1. var data = {};
  2. var b = $.isEmptyObject(data);
  3. console.log(b); //true

4、Object.getOwnPropertyNames()

Object 对象的 getOwnPropertyNames 方法，获取到对象中的属性名，存到一个数组中，返回数组对象，我们可以通过判断数组的 length 来判断此对象是否为空。

  1. var data = {};
  2. var arr = Object.getOwnPropertyNames(data);
  3. console.log(arr.length == 0); // true

5、ES6 的 Object.keys()

此方法也是返回对象中属性名组成的数组。

  1. var data = {};
  2. var arr = Object.keys(data);
  3. console.log(arr.length == 0); // true

JSON.stringify()扩展

JSON.stringify() 方法用于将 JavaScript 值转换为 JSON 字符串。
语法：

JSON.stringify(value[, replacer[, space]])

参数说明：

  • value：必需，要转换的 JavaScript 值（通常为对象或数组）。

  • replacer: 可选。用于转换结果的函数或数组。 如果 replacer 为函数，则 JSON.stringify 将调用该函数，并传入每个成员的键和值。使用返回值而不是原始值。 如果此函数返回 undefined，则排除成员。根对象的键是一个空字符串：””。如果 replacer 是一个数组，则仅转换该数组中具有键值的成员。成员的转换顺序与键在数组中的顺序一样。

  • space：可选，文本添加缩进、空格和换行符，如果 space 是一个数字，则返回值文本在每个级别缩进指定数目的空格，如果 space 大于 10，则文本缩进 10 个空格。space 也可以使用非数字，如：\t。

  • 返回值：返回包含 JSON 文本的字符串。

JSON.stringify()特性挺多的，具体如下：

1、第一大特性

对于 undefined、任意的函数以及 symbol 三个特殊的值分别作为对象属性的值、数组元素、单独的值时 JSON.stringify() 将返回不同的结果。 来看这道题：

  1. const data = {
  2.   a: "aaa",
  3.   b: undefined,
  4.   c: Symbol("dd"),
  5.   fn: function () {
  6.     return true;
  7.   },
  8. };
  9. JSON.stringify(data); // 输出：？
  10.  
  11. // "{"a":"aaa"}"

这是因为 undefined、任意的函数以及 symbol 作为对象属性值时 JSON.stringify() 将跳过（忽略）对它们进行序列化。

假设 undefined、任意的函数以及 symbol 值作为数组元素会是怎样呢？

  1. JSON.stringify([
  2.   "aaa",
  3.   undefined,
  4.   function aa() {
  5.     return true;
  6.   },
  7.   Symbol("dd"),
  8. ]); // 输出：？
  9.  
  10. // "["aaa",null,null,null]"

这是因为 undefined、任意的函数以及 symbol 作为数组元素值时，JSON.stringify() 会将它们序列化为 null。

还有，undefined、任意的函数以及 symbol 被 JSON.stringify() 作为单独的值进行序列化时都会返回 undefined。

  1. JSON.stringify(function a() {
  2.   console.log("a");
  3. });
  4. // undefined
  5. JSON.stringify(undefined);
  6. // undefined
  7. JSON.stringify(Symbol("dd"));
  8. // undefined

小结

  • undefined、任意的函数以及 symbol 作为对象属性值时 JSON.stringify() 对跳过（忽略）它们进行序列化。

  • undefined、任意的函数以及 symbol 作为数组元素值时，JSON.stringify() 将会将它们序列化为 null。

  • undefined、任意的函数以及 symbol 被 JSON.stringify() 作为单独的值进行序列化时，都会返回 undefined。

2、第二大特性

非数组对象的属性不能保证以特定的顺序出现在序列化后的字符串中。因为 JSON.stringify() 序列化时会忽略一些特殊的值，所以不能保证序列化后的字符串还是以特定的顺序出现（数组除外）。

  1. const data = {
  2.   a: "aaa",
  3.   b: undefined,
  4.   c: Symbol("dd"),
  5.   fn: function () {
  6.     return true;
  7.   },
  8.   d: "ddd",
  9. };
  10. JSON.stringify(data); // 输出：？
  11. // "{"a":"aaa","d":"ddd"}"
  12.  
  13. JSON.stringify([
  14.   "aaa",
  15.   undefined,
  16.   function aa() {
  17.     return true;
  18.   },
  19.   Symbol("dd"),
  20.   "eee",
  21. ]); // 输出：？
  22.  
  23. // "["aaa",null,null,null,"eee"]"

3、第三大特性

转换值如果有 toJSON() 函数，该函数返回什么值，序列化结果就是什么值，并且忽略其他属性的值。

  1. JSON.stringify({
  2.     say: "hello JSON.stringify",
  3.     toJSON: function() {
  4.       return "today i learn";
  5.     }
  6.   })
  7. // "today i learn"

4、第四大特性

JSON.stringify() 将会正常序列化 Date 的值。

  1. JSON.stringify({ now: new Date() });
  2. // "{"now":"2019-12-08T07:42:11.973Z"}"

5、第五大特性

NaN 和 Infinity 格式的数值及 null 都会被当做 null。

  1. JSON.stringify(NaN)
  2. // "null"
  3. JSON.stringify(null)
  4. // "null"
  5. JSON.stringify(Infinity)
  6. // "null"

6、第六大特性

布尔值、数字、字符串的包装对象在序列化过程中会自动转换成对应的原始值。

  1. JSON.stringify([new Number(1), new String("false"), new Boolean(false)]);
  2. // "[1,"false",false]"

7、第七大特性

其他类型的对象，包括 Map/Set/WeakMap/WeakSet，仅会序列化可枚举的属性。

  1. // 不可枚举的属性默认会被忽略：
  2. JSON.stringify( 
  3.     Object.create(
  4.         null, 
  5.         { 
  6.             x: { value: 'json', enumerable: false }, 
  7.             y: { value: 'stringify', enumerable: true } 
  8.         }
  9.     )
  10. );
  11. // "{"y":"stringify"}"

8、第八大特性

深拷贝最粗暴的方式是JSON.parse(JSON.stringify())，这个方式实现深拷贝会因为序列化的诸多特性从而导致诸多的坑点：比如现在我们要说的循环引用问题。

  1. // 对包含循环引用的对象（对象之间相互引用，形成无限循环）执行此方法，会抛出错误。 
  2. const obj = {
  3.   name: "loopObj"
  4. };
  5. const loopObj = {
  6.   obj
  7. };
  8. // 对象之间形成循环引用，形成闭环
  9. obj.loopObj = loopObj;
  10.  
  11. // 封装一个深拷贝的函数
  12. function deepClone(obj) {
  13.   return JSON.parse(JSON.stringify(obj));
  14. }
  15. // 执行深拷贝，抛出错误
  16. deepClone(obj)
  17. /**
  18.  VM44:9 Uncaught TypeError: Converting circular structure to JSON
  19.     --> starting at object with constructor 'Object'
  20.     |     property 'loopObj' -> object with constructor 'Object'
  21.     --- property 'obj' closes the circle
  22.     at JSON.stringify (<anonymous>)
  23.     at deepClone (<anonymous>:9:26)
  24.     at <anonymous>:11:13
  25.  */

 欢迎关注公众号【前端技术驿站】，关注获取视频资源，共同学习！

 

 

版权声明：本文为sunny123456原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/sunny3158/p/16023838.html