原生JavaScript基础学习1：数据类型

学习一门语言，最基础的是掌握该语言支持的数据类型。掌握数据类型，只能在项目中多多使用，练习。

常用数据类型：

基础类型

String    // 字符串
Number    // 数字
Boolean   // 布尔
Null      // 空
Undefined // 未定义
Symbol    // 原子 es5新添加

引用类型

Object    // 对象
Array     // 数组
Date      // 日期
RegExp    // 正则
Function  // 函数

数组结构：栈与堆

栈（Stack）

以键值对的形式自动分配在内存空间中，可以使用值直接访问。

let name = 'xuweihua'     // 这是一个标准的键值对，基础数据类型中的字符串
let username = name       // 此时为username赋予的值是name的值'xuweihua'
username = 'xuweihua.net' // 改变username的值
console.log(name)         // 输出 xuweihua
console.log(username)     // 输出 xuweihua.net

从上面这个例子可以看出基础数据类型的健和值是一一对应，不存在值引用另一个键的情况。

堆（Heap）

健仍存储在栈空间，值却引用了内存中被动态分配一个空间。

let user = new Object()   // 这是一个引用类型：对象，对象本身在堆空间
let admin = user          // 用新变量admin引用user，引用的是同一个对象本体
admin.name = 'xuweihua'   // 为新对象设备属性namew值'xuweihua'
console.log(user.name)    // 输出第一个变量admin，结果 xuweihua

从上面例子可以看出，引用类型的键对应值，值对应一个内存空间；当引用此类数据时，引用的是它的值，而它的值对应的空间仍是同一个。

数据类型的判断

typeof方法

typeof的判断，本质是根据该数据存储的二进制前三位来判断。具体值如下：

前三位	类型	值
000	对象	对象
00	整数	31位整数
010	双精度	双精度数字
100	字符串	字符串
110	布尔	布尔值

typeof是一个元运算符，返回数据类型的名称

typeOf undefind   // ‘undefind’
typeOf ’15’       // ‘String’
typeOf 15         // ‘Number’
typeOf false      // ‘Boolean
typeOf symbol()   // ‘Symbol’
typeOf Function   // ‘function’
typeOf null       // ‘Object’
typeOf []         // ‘Object’
typeOf {}         // ‘Object’

null的存储二进制前三位为000，会被系统判定为 Object 类型

instanceof方式

instanceof 本质是是测试一个对象的原型链上构造函数 prototype 属性的值：

let user = { name: 'xuweihua' }
console.log(user instanceof Object )  // true

instanceof用判断一个数据是不是某个类型，返回true或false：

原型链中prototype的值可以被更改，更改后的值可能不存于 object 的原型链上，再次测试可能返回 false。

数据类型转换

js为弱类型语言，变量不受类型限制，在特定情况下才需要对类型进行转换；

显示转换

转换成字符串 String()

String(996)       // '996'
String(true)      // 'true'
String(null)      // 'null'
String(undefined) // 'undefined'
String([1,2,3])   // '1,2,3'
String({})        // '[Object Object]'

转换为布尔型 Boolean()

除了 ‘’、 undefined、 NAN、 null、 false、 0 转化为 false 外，其它全部为 true

Boolean('')     // false
Boolean(0)      // false
Boolean(1)      // true
Boolean({})     // true

转化为数字类型 Number()

Number('1')         // 123
Number('a123')      // NaN
Number(true)        // 1
Number(false)       // 0
Number(null)        // 0
Number(undefined)   // NaN
Number([])          // 0
Number([1])         // 1
Number([1, 2])      // NaN
Number(undefined)   // NaN

对象转换为原始类型

转为字符类型 toString() 转为基本类型 valuerOf()

隐式转换

隐式转换不需要强制转化。

加法运算

加法运算在运行时根据运算元素的类别不同，再决定是执行相加，还是执行连接。

true + true   // 2 布尔加布尔，先转为数字再相加
1 + true      // 2 数字加布尔，布尔转为数字再相加
[1] + 1       // '11' 对象调用 valuerOf，如果不是 String、Boolean 或 Number 类型，转再转换为 toString() 转为字符串，最后执行连接
1 + 'a'       // ‘1b' 数字加字符，执行连接
false + 'a'   // 'falsea'  false先转为字符串，再执行连接

其它运算

减法、除法、乘法不会发生重载，所有运算元素一律转为数值，再进行数字运算

1 * '2'   // 2  '2'转为2，再相乘
1 * []    // 0  []转化为0，再相乘

逻辑运算

条件判断

true && true    // true 与
true && false   // false 与
true || true    // true 或
true || false   // true 或

赋值操作 A && B

console.log(0 && 1)   // 0  0为false为0的值
console.log(1 && 2)   // 2  1为true返回2的值

A || B

console.log(0 || 1)   // 2 0为false返回1的值
console.log(1 || 2)   // 1 1为true返回1的值

比较运算符

在逻辑语句中使用，以判定变量或值是否相等。 A === B 严格意义上相等，会比较两端的类型和值

undefined === undefined   // true
null === null             // true
'a' === 'a'               // true
'a' === 'aa'              // false
true === true             // true
false ==== false          // false
NaN === NaN               // false 其中有一个NaN值为false
NaN === 1                 // false 其中有一个NaN值为false
3 === 3                   // true
+0 === -1                 // true

A == B 非严格意义上的相等。先判断两个值类型是否相同，如果不同，则转换为相同的类型，然后再判断值是否相等。

null == undefined         // true
'2' == 2                  // true
true == 1                 // true
[1] == 1                  // true
[1] == '1'                // true

其它返回false