目录
- 7种基本数据类型
- 类型判断(基本类型、引用类型、自定义类型)
- 类型转换
- 值相等比较(==、===、Object.is())
一、7种基本数据类型
1.Null
只有一个 值 ： null
①声明一个对象为null，则为：销毁该变量
②返回null，则为该对象不存在。typeof Null === 'Object'
2.Undefined
只有一个 值 ： undefined
代表对象存在，但未赋值
当声明的变量未初始化时，该变量的默认值是 undefined
函数没有明确返回值时，返回undefined
3.Boolean
只有两个 值 ： true、false
4.Number
值 ： 数字
特殊的Number值:Number.MAX_VALUE 和 Number.MIN_VALUE、NaN
NaN；//表示非数（Not a Number）一般说来，这种情况发生在类型（String、Boolean 等）转换失败时返回的值 或 数字/0
5.String
值 ： 字符串
6.Symbol
可以用于命名冲突及私有属性
7.Object
所有对象都是继承Object.prototype
image.jpg
二、类型判断
1.基本类型判断 typeof
a.语法：typeof 变量;eg:typeof "zzz";//string
b.返回的是字符串："undefined"，"number"，"boolean"，"string"，"function"，"object"
c.判断方式：typeof 变量==="undefined"/"number"等基本数据类型
总结：
1.对于基本类型，除 null 以外，均可以返回正确的类型。typeof null为objecct(null表示空引用，即不存在)
2.对于引用类型，除 function 以外，一律返回 object 类型。typeof 函数名为function
2.引用类型判断
- constructor
- Object.prototype.toString.call(变量)
- instanceof
1.constructor
语法：obj.constructor;//返回的是对象的构造函数
使用：obj.constructot===Class;//进行"==="判断，或is判断。
例子：child.constructor===Child;
console.log((2).constructor === Number);
console.log((true).constructor === Boolean);
console.log(('str').constructor === String);
console.log(([]).constructor === Array);
console.log((function() {}).constructor === Function);
console.log(({}).constructor === Object);
问题：要确保原型的constructor指向了该对象的父类
用costructor来判断类型看起来是完美的，然而，如果我创建一个对象，更改它的原型，这种方式也变得不可靠了
2.Object.prototype.toString.call()
a.语法：Object.prototype.toString.call(变量)
b.返回的是字符串："[object String]"，"[object Number]"，"[object Boolean]"
"[object Object]"，"[object Array]"，"[object Date]"，"[object Function]"
c.判断方式：Object.prototype.toString.call(a) === '[object String]'/ '[object Number]'等原生引用类型
总结：对于引用对象，相对于typeof可以更具体的判断引用的具体类型
相对于constructor就算我们改变对象的原型，他依然会显示正确的数据类型。
可以用于原生引用的判断(js有17种内置对象)
3.instanceof
语法：obj instanceof Class;
//返回，布尔值。如果为true,说明Class.prototype是obj祖先原型
//instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上
instanceof模拟代码
function instance_of(obj,arg_Class){
while(true){
if (obj===null) return false; //如果对象为空，或者找到对象的最后原型为空，函数返回，为false
if (obj===arg_Class.property) return true; //如果和祖先类相等，函数返回，为true
obj =obj.__proto__; //查找原型链
}
}
Function instanceof Function;//true Function它的父类是Function Function._proto_=Function.prototype
Object instanceof Function; //true Object它的父类是Function Object._proto_=Function.prototype
Function instanceof Object; //true Function它的祖先原型是Object.prototype Function._proto_._proto_=Object.prototype
Object instanceof Object; //true Object它的祖先原型是Object.prototype Object._proto_._proto_=Object.prototype
Number instanceof Number; //false 其它类型它的父类是Object
总结：
1.用于引用对象的类型检查， t instanceof Array
2.用于判断是不是某个类的实例
3、总结
a.原生基本类型判断： √
typeof 变量==="number";
//"undefined"，"number"，"boolean"，"string"，"function"，"object"
优点：简单
缺点：针对引用对象只能识别object及function
识别不出null类型。typeof null为'object'
b.原生引用原型判断：
Object.prototype.toString.call(obj)==="[object Number]";
"[object String]"，"[object Number]"，"[object Boolean]"
"[object Object]"，"[object Array]"，"[object Date]"，"[object Function]"
优点：可以准确的识别出引用对象类型
缺点：写法稍微复杂，适用于原型会改变的情况。
c.自定义及原生类判断父类： √
obj.constructor===Class;
//String，Number，Boolean，Object，Array，Date，Function
优点：简单
缺点：如果继承链中换了原型，则会出错，不稳定
d:自定义及原生类判断父原型：
obj._proto_===Class.prototype;如果为true，说明Class.prototype是obj父原型
e:自定义及原生类判断祖先原型： √
obj instanceof Class;如果true，说明Class.prototype是obj的祖先原型
//String，Number，Boolean，Object，Array，Date，Function
三、类型转换
1.转Boolean
显示语法：Boolean(value)//转换函数
隐式方式：条件语句中
1.Null // null
2.Undefined // undefined
3.Boolean // false
4.Number // +0,-0,NaN
5.String // "" 以上这部分为false
6.Object // 引用类型转换为布尔，始终为true
2.转Number
显示语法：Number(value)//转换函数。。。其它方法：parseFloat()，parseInt()
隐式方式：一元运算符 +。eg:{var x="5",var y=+x;//则x为number类型}
1.Null // 0
2.Undefined // NaN
3.Boolean // false为0，true为1
4.Number // 可以转其它进制
5.String // 有其它字符，则返回NaN,如只有连续数字(首位允许有空格)，则返回数字
6.Object // NaN，除了[]为0，[15]为15，[15,20]也为NaN
总结：如果没办法转化为数字，则为NaN
其中，Null表示空对象，为0
Undefined 表示没有定义值，值是未知的，为NaN
3.转String
显示语法：String(s); //转换函数
隐式方式："+"运算符
1.Null // "null"
2.Undefined // "undefined"
3.Boolean // false为"false"，true为"true"
4.Number // "对应数字" //0,+0,-0为0
5.String //
6.Object // Object为："[object Object]"； function为："function(){}"；数组为："数组内容1，数组内容2"
四、值相等判断
前面有说到类型种类，类型判断及类型转换。
这里再补充对于值相等的判断
==：相等运算法===严格相等运算符：对比==增加了类型的判断(typeof)。都一致才相等Object.is()：对比==、===修复了特殊值的相等判断：NaN、+0，-0
1.==
a.比较的是值
b.如果类型不同，会自动转换成同一类型进行比较值。[]==0为true
c.null和undefined尽管有不同，但是都表示“值的空缺”。用“==”认为两者相等
总结：
会自动类型转换
站在值的角度，null和undefined都表示“值的空缺”，用“==”认为两者相等
适用于只是值的比较，比如后台给的数据(对类型并不知情)，刚好==会忽略类型
2.===
a.比较的是值和类型，先对比类型，类型不一样，为false。类型相同则对比值
b.+0和-0或0,虽然看起来不一样,因为类型相同值也相等,为true
c.NaN和NaN之间，为false
d.基础类型和引用类型之间：因为类型不同，为false。
e.引用类型之间：尽管object,array,function不一样，但都是属于引用类型，对比值(物理地址)即同一对象的引用为true，否则为false
总结：
对比==只是增加了个类型判断。类型判断方式为typeof
适用于严格的判断
3.Object.is()
==缺点：会进行类型转换eg:"10"==[10]==10类似问题，及[]==0为true
===缺点：没办法区分0===-0为true及NaN===NaN为false
Object.is()修复了===的缺点：Object.is(+0,-0)为false 及 Object.is(NaN,NaN)为true
网友评论