为啥总是学不好JavaScript啊?
数据类型
数据类型主要分为引用类型以及基本类型。
基本类型
1, String
2,Number
3,null
4,undefined
5,boolean
6,Symbol
7,BigInt
引用类型
1,正则
2,Math
3,Date
4,[ ]
5,function
其中,基本类型主要存储在栈内存中,在引用以及拷贝的时候,会产生同一变量。引用类型主要存储在堆中。
数据类型的判断
方法一:
typeof :
1,特殊的null类型
console.log(typeof null);//object
console.log(typeof { });//object
const a = Math;
console.log(typeof a);//object
2,引用类型除math外剩下都有返回function
const a = function( ){ }
console.log(typeof a);//function
const a = Symbol;
console.log(typeof a );//function
const a = Array;
console.log(typeof a );//function
const a = Math.sin;
console.log(typeof a );//function
const a = Date;
console.log(typeof a);//function
const a = RegExp;
console.log(typeof a );//function
const a = Symbol( );
console.log(typeof a);//symbol
总结 :
1, typeof 只能用于检测基本类型,null除外
2,null 以及{ }以及math会返回object外,其他的引用类型均返回为function。
3,Symbol带上括号就返回对应的数据类型
方法二:
instanceof
const a = [ ];
console.log(a instanceof Array);//true
instanceof只能用于检测引用类型,对基本类型不能检测
方法三:
Object.prototype.toString.call
console.log(Object.prototype.toString({ }))//[object Object]
console.log(Object.prototype.toString.call({ }))//[object Object]
//基本类型
console.log(Object.prototype.toString.call(1));//[object Number]
console.log(Object.prototype.toString.call(null));//[object Null]
console.log(Object.prototype.toString.call(undefined));//[object Undefined]
console.log(Object.prototype.toString.call(true));//[object Boolean]
console.log(Object.prototype.toString.call(Symbol()));//[object Symbol]
console.log(Object.prototype.toString.call(String( )));//[object String]
const a = BigInt(99999999);
console.log(Object.prototype.toString.call( a ));//[object BigInt]
//引用类型
console.log(Object.prototype.toString.call( new Date( )));//[object Date]
console.log(Object.prototype.toString.call(Math));//[object Math]
console.log(Object.prototype.toString.call([ ]));//[object Array]
console.log(Object.prototype.toString.call(Function));//[object Function]
console.log(Object.prototype.toString.call(/123/g));//[object RegExp]
注 :
1,只有检测对象{ }的时候用 Object.prototype.toString进行检测,其他的使用Object.prototype.toString.call进行检测
2,返回的形式均为[object XXX]且第一个字母大写
3.不管是引用类型还是基本类型都可以用Object.prototype.toString.call进行检测
强制类型转换以及隐式转换
强制类型转换方式包括 Number()、parseInt()、parseFloat()、toString()、String()、Boolean()
Number() 方法的强制转换规则
如果是布尔值,true 和 false 分别被转换为 1 和 0;
如果是数字,返回自身;
如果是 null,返回 0;
如果是 undefined,返回 NaN;
如果是字符串,遵循以下规则:如果字符串中只包含数字(或者是 0X / 0x 开头的十六进制数字字符串,允许包含正负号),则将其转换为十进制;如果字符串中包含有效的浮点格式,将其转换为浮点数值;如果是空字符串,将其转换为 0;如果不是以上格式的字符串,均返回 NaN;
如果是 Symbol,抛出错误;
如果是对象,并且部署了 [Symbol.toPrimitive] ,那么调用此方法,否则调用对象的 valueOf() 方法,然后依据前面的规则转换返回的值;如果转换的结果是 NaN ,则调用对象的 toString() 方法,再次依照前面的顺序转换返回对应的值(Object 转换规则会在下面细讲)
Number(true); // 1
Number(false); // 0
Number('0111'); //111
Number(null); //0
Number(''); //0
Number('1a'); //NaN
Number(-0X11); //-17
Number('0X11') //17
Boolean() 方法的强制转换规则
这个方法的规则是:除了 undefined、 null、 false、 ''、 0(包括 +0,-0)、 NaN 转换出来是 false,其他都是 true。
Boolean(0) //false
Boolean(null) //false
Boolean(undefined) //false
Boolean(NaN) //false
Boolean(1) //true
Boolean(13) //true
Boolean('12') //true
隐式类型转换
存在:逻辑运算符 (&&、 ||、 !)、运算符 (+、-、*、/)、关系操作符 (>、 <、 <= 、>=)、相等运算符 (==) 或者 if/while 条件的操作,如果遇到两个数据类型不一样的情况,都会出现隐式类型转换
'==' 的隐式类型转换规则
如果类型相同,无须进行类型转换;
如果其中一个操作值是 null 或者 undefined,那么另一个操作符必须为 null 或者 undefined,才会返回 true,否则都返回 false;
如果其中一个是 Symbol 类型,那么返回 false;
两个操作值如果为 string 和 number 类型,那么就会将字符串转换为 number;
如果一个操作值是 boolean,那么转换成 number;
如果一个操作值为 object 且另一方为 string、number 或者 symbol,就会把 object 转为原始类型再进行判断(调用 object 的 valueOf/toString 方法进行转换)。
null == undefined // true 规则2
null == 0 // false 规则2
'' == null // false 规则2
'' == 0 // true 规则4 字符串转隐式转换成Number之后再对比
'123' == 123 // true 规则4 字符串转隐式转换成Number之后再对比
0 == false // true e规则 布尔型隐式转换成Number之后再对比
1 == true // true e规则 布尔型隐式转换成Number之后再对比
var a = {
value: 0,
valueOf: function() {
this.value++;
return this.value;
}
};
// 注意这里a又可以等于1、2、3
console.log(a == 1 && a == 2 && a ==3); //true f规则 Object隐式转换
// 注:但是执行过3遍之后,再重新执行a==3或之前的数字就是false,因为value已经加上去了,这里需要注意一下
’+’ 的隐式类型转换规则
'+' 号操作符,不仅可以用作数字相加,还可以用作字符串拼接。仅当 '+' 号两边都是数字时,进行的是加法运算;如果两边都是字符串,则直接拼接,无须进行隐式类型转换。
除了上述比较常规的情况外,还有一些特殊的规则,如下所示。
如果其中有一个是字符串,另外一个是 undefined、null 或布尔型,则调用 toString() 方法进行字符串拼接;如果是纯对象、数组、正则等,则默认调用对象的转换方法会存在优先级(下一讲会专门介绍),然后再进行拼接。
如果其中有一个是数字,另外一个是 undefined、null、布尔型或数字,则会将其转换成数字进行加法运算,对象的情况还是参考上一条规则。
如果其中一个是字符串、一个是数字,则按照字符串规则进行拼接。
1 + 2 // 3 常规情况
'1' + '2' // '12' 常规情况
// 下面看一下特殊情况
'1' + undefined // "1undefined" 规则1,undefined转换字符串
'1' + null // "1null" 规则1,null转换字符串
'1' + true // "1true" 规则1,true转换字符串
'1' + 1n // '11' 比较特殊字符串和BigInt相加,BigInt转换为字符串
1 + undefined // NaN 规则2,undefined转换数字相加NaN
1 + null // 1 规则2,null转换为0
1 + true // 2 规则2,true转换为1,二者相加为2
1 + 1n // 错误 不能把BigInt和Number类型直接混合相加
'1' + 3 // '13' 规则3,字符串拼接
Object 的转换规则
对象转换的规则,会先调用内置的 [ToPrimitive] 函数,其规则逻辑如下:
如果部署了 Symbol.toPrimitive 方法,优先调用再返回;
调用 valueOf(),如果转换为基础类型,则返回;
调用 toString(),如果转换为基础类型,则返回;
如果都没有返回基础类型,会报错。
var obj = {
value: 1,
valueOf() {
return 2;
},
toString() {
return '3'
},
[Symbol.toPrimitive]() {
return 4
}
}
console.log(obj + 1); // 输出5
// 因为有Symbol.toPrimitive,就优先执行这个;如果Symbol.toPrimitive这段代码删掉,则执行valueOf打印结果为3;如果valueOf也去掉,则调用toString返回'31'(字符串拼接)
// 再看两个特殊的case:
10 + {}
// "10[object Object]",注意:{}会默认调用valueOf是{},不是基础类型继续转换,调用toString,返回结果"[object Object]",于是和10进行'+'运算,按照字符串拼接规则来,参考'+'的规则C
[1,2,undefined,4,5] + 10
// "1,2,,4,510",注意[1,2,undefined,4,5]会默认先调用valueOf结果还是这个数组,不是基础数据类型继续转换,也还是调用toString,返回"1,2,,4,5",然后再和10进行运算,还是按照字符串拼接规则,参考'+'的第3条规则
完结
多敲代码,才能进步!