前言：经常用，必记！

  • 前端开发的时候经常需要判断某个值的类型是不是对象，不能通过typeof来判断，要用别的方法。
  • JS对象的操作类似于Java中的Map和HashMap，很多时候我们需要找到对象在某个特定key对应的value，或者说是找到某个value对应的key。
  • 当然，一般一个key只能对应一个value，但是一个value可以对应多个key。这里重点讲一下通过value来找到特定key的方法

对象类型判断

Object.prototype.toString.call()方法

1
2
3
4
let obj = {}

var res = Object.prototype.toString.call(obj); 
console.log(res); //[object Object]
  • 这个方法还能判断其他类型，如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var a = NaN;
var b= '222';
var c = null;
var d = false;
var e = undefined;
var f = Symbol(); 
var arr = ['aa','bb','cc'];
var obj = { 'a': 'aa', 'b': 'bb', 'c': 'cc' }; 
var res = Object.prototype.toString.call(arr);
console.log(res);  //[object Array] 
var res2 = Object.prototype.toString.call(obj); 
console.log(res2); //[object Object] 
var res3 = Object.prototype.toString.call(a);
 console.log(res3); //[object Number] 
 var res4 = Object.prototype.toString.call(b); 
 console.log(res4); //[object String] 
 var res4 = Object.prototype.toString.call(c); 
 console.log(res4); //[object Null] 
 var res5 = Object.prototype.toString.call(d); 
 console.log(res5); //[object Boolean] 
 var res6 = Object.prototype.toString.call(e); 
 console.log(res6); //[object Undefined] 
 var res7 = Object.prototype.toString.call(f); 
 console.log(res7); //[object Symbol]

constructor方法

1
2
3
4
5
6
7
8
9
var arr = ['aa','bb','cc'];
var obj = {
    'a': 'aa',
    'b': 'bb',
    'c': 'cc'
};
console.log(arr.constructor === Array); // true
console.log(arr.constructor === Object); // false
console.log(obj.constructor === Object); // true

instanceof

注意：数组也是对象的一种，因此用 arr instanceof Object 也为true。

1
2
3
4
5
6
7
8
9
10
11
var arr = new Array();
var arr = ['aa','bb','cc'];
var obj = { a: 'aa', b: 'bb', c: 'cc' };
 
console.log(arr instanceof Array); // true
 
console.log(arr instanceof Object); // true 数组也是对象的一种
 
console.log(obj instanceof Array); // false
 
console.log(obj instanceof Object); // true

typeof

使用typeof判断对象其实也不太准确

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
let obj = {}
typeof obj === Object
 
// 表达式                           返回值
 
typeof undefined      //         'undefined'
 
typeof null           //         'object'
 
typeof true           //         'boolean'
 
typeof 123            //         'number'
 
typeof "abc"          //         'string'
 
typeof function() {}  //         'function'
 
typeof {}             //         'object'
 
typeof []             //         'object'

JS对象通过value找到key

  • 首先最简单暴力的方法当然是通过循环来查找
  • 很简单暴力，就几行代码
1
2
3
4
5
for(let key in obj){
	if(obj[key] === value){
		return key
	}
}
  • 然后是比较好用的方法，通过 Object.entries()将对象转换成键值对数组，然后使用Array.prototype.find() 方法查找匹配的键值对（key，value），并返回key。
  • 或者是通过数组遍历的方法，比如map、filter、find来找到想要的key
1
2
3
4
function findKeyByValue(obj, value) {
  const result = Object.entries(obj).find(([key, val]) => val === value);
  return result ? result[0] : null;
}

JS对象通过key取value

  • 这个比上面哪个简单，因为key一般是唯一的，而像value取key的话，由于value是不唯一的，有可能有多个key对应的value值是一样的，所以操作起来比较麻烦。
  • 可以直接通过Obj.key或者Obj[key]来获取