typeof 检测，返回的是对应的数据类型
console.log(typeof (123)); //number
console.log(typeof (true)); //boolean
console.log('MOOC'); //MOOC
console.log(typeof (undefined)); //undefined
console.log(typeof (null)); //object
//计算机typeof 检测数据类型 根据机器码后三位，后三位为000返回object,
//null 0000....000返回object
console.log(typeof ([])); //object
console.log(typeof (new Date())); //object
console.log(typeof ({})); //object
console.log(typeof (function () {})); //function
console.log(typeof (Array)); //function
//typeof 检测引用类型返回 object 分为 object : function
//object 定义一个内部的call方法，有则返回 function,没有则返回object
例子：
var str = 'MOOC';
console.log('----------------');
console.log(str); //MOOC
console.log(typeof (str)); //string
console.log('----------------');
console.log('----------------');
var str1 = new String('MOOC');
console.log(str1); //{} key:value 0:M,1:O,2:O,3:C
console.log(typeof (str1)); //object
总结：typeof少null 多function ,检测引用数据类型原本返回object,object检测返回两种数据类型 object和function,在js设置的时候，会在引用类型以函数形式时在内部定义一个内部的call方法，当typeof去检测的时候，遇到这个call方法会返回function,否则返回object
instanceof 检测是布尔值，返回true和false
A instanceof B:A是B实例化出来的对象
console.log([] instanceof Array); //true
console.log({} instanceof Object); //true
console.log(new Date() instanceof Date); //true
function Person() {};
console.log(new Person() instanceof Person);//true
console.log([] instanceof Object); //true
console.log(new Date() instanceof Object); //true
function Person() {};
console.log(new Person instanceof Object); //true
检测数据类型的方法
console.log(Object.prototype.toString.call('1'));
console.log(Object.prototype.toString.call([]));
console.log(Object.prototype.toString.call(Object));
console.log(Object.prototype.toString.call(true));
console.log(Object.prototype.toString.call(null));
console.log(Object.prototype.toString.call(undefined));
console.log(Object.prototype.toString.call(new Date()));
输出：
[object String]
[object Array]
[object Function]
[object Boolean]
[object Null]
[object Undefined]
[object Date]
typeof 和instanceof 检测数据类型的异同
- typeof返回值是一个字符串，该字符串说明检测该数据的类型；结果为number,boolean,string,function,object(null，数组，对象),undefined.
- instanceof是用来判断A是否为B的实例对象，检测是原型，基于原型链的结构检测
深入理解数据的存储形式-堆栈
栈：计算机为原始类型开辟的一块内存空间string number…
例子：
var a = 'MOOC';
var b = a;
b = 'MOOC2';
console.log(a, b);//MOOC MOOC2
堆：计算机为引用类型开辟的一块内存空间object.堆在栈中存在一个地址值。
例子：
var c = {
key: 1
};
var d = c;
d.key = 2;
console.log(c, d); //key:2,key:2
深拷贝与浅拷贝
简单表述：假设B复制了A,当A修改时，看B是否发生变化，如果B也跟着变化，说明这个是浅拷贝，如果B没变那就是深拷贝
c d{key:1},d{key:2},c{key:2} 浅拷贝 c{key:1}深拷贝
浅拷贝
浅拷贝方式一（遍历赋值）
var obj = {
a: 'hello',
b: {
a: 'world',
b: 111
},
c: [11, 'Jack', 'Tom']
}
//objCopy
function simpleClone(objNew) {
var obj = {};
for (var i in objNew) {
obj[i] = objNew[i];
}
return obj
}
var objCopy = simpleClone(obj);
objCopy.b.a = 'world1'
console.log(obj);
console.log(objCopy);
输出：
浅拷贝方式二（Object.create()）
var obj = {
a: 'hello',
b: {
a: 'world',
b: 111
},
c: [11, 'Jack', 'Tom']
}
var objCopy = Object.create(obj);
objCopy.b.a = 'world1';
console.log(obj);
console.log(objCopy);
输出：
深拷贝
深拷贝方式一（遍历赋值）
var obj = {
a: 'hello',
b: {
a: 'world',
b: 111
},
c: [11, 'Jack', 'Tom']
}
function deepClone(startObj, endObj) {
var obj = endObj || {};
for (var i in startObj) {
if (typeof startObj[i] === 'object') {
obj[i] = startObj[i].constructor === Array ? [] : {};
deepClone(startObj[i], obj[i])
} else {
obj[i] = startObj[i]
}
}
return obj
}
var objCopy = deepClone(obj);
objCopy.b.a = 'world1'
console.log(obj);
console.log(objCopy);
输出：
深拷贝方式二（JSON.parse和JSON.stringify）
var obj = {
a: 'hello',
b: {
a: 'world',
b: 111
},
c: [11, 'Jack', 'Tom']
}
var objCopy = JSON.parse(JSON.stringify(obj));
objCopy.c[0]=222
console.log(obj);
console.log(objCopy);
输出：
特殊类型的隐士转换
console.log(Boolean(NaN));//false
console.log(Boolean(0));false
console.log(Boolean(undefined));//false
console.log(Boolean(null));//false
console.log(Boolean(""));//false
= =和===的区别
console.log(null == undefined); //true
console.log(null === undefined); //false