# 数据类型

# Number 数字

在 js 中有个标准对象 Number ，所有的数组都是 Number 的实例

数字不分为整数类型和浮点型类型，所有的数字都是由浮点型类型。JavaScript 采用 IEEE754 标准定义的 64 位浮点格式表示数字，它能表示最大值为 ±1.7976931348623157e+308，最小值为 ±5e-324。

以下都是合法的 Number 类型：

123;      //整数
-123;     //负数
0.123;    //浮点数
1.2e3;    //科学计数法
NaN;      //表示，不是 Number 类型的数
Infinity; //表示无穷大

NaN 的概念比较特殊，它表示非数字值。是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。

let a = 100 / 'abc';  // 计算结果不是数字（NaN）
Number.isNaN(a);      // true
a = 100 / '125'       // 0.8
Number.isNaN(a);      // false

Number 类型可以直接做四则运算，和取余 % 操作

console.log(1 + 2);         // 3
console.log(1 - 2);         // -1
console.log( (1 + 2) * 3 ); // 9
console.log( 1 / 0 );       // Infinity
console.log( 0 / 0 );       // NaN
console.log( 10 % 3 );      // 1

Number 中的类型转换

parseInt('123abc'); // 123
parseInt('abc123'); // NaN
// 也可以这样定义数字
let n = new Number('123');

# Number 的方法

toFixed() 这个方法并不是静态方法，不能直接调用。因为他属于原型链上的方法

var a=123;
b=a.toFixed(2); // b="123.00"

Number.parseFloat() 将字符串转换成浮点数，这个函数会截取掉字符串中不属于数字的部分

parseFloat('123.456abc'); // 123.456
parseFloat('123');        // 123

Number.parseInt() 将字符串转换成整型数字，同样它也会截取掉不属于数字的部分

parseFloat('123a456'); // 123
parseFloat('1a23');    // 1

Number.isFinite() 检查传递的参数是否为有限数字

Number.isFinite(9e1000); // false: 表示一个数字：9后1000个0
Number.isFinite(9999999);//true

Number.isInteger() 检查一个数字是否为整数

Number.isInteger(123);      // true
Number.isInteger('123');    // false 参数必须是 Number 类型
Number.isInteger(123.456);  // false

Number.isNaN() 检查参数是否为 NaN

Number.isNaN(123);  // false
Number.isNaN('123');// false 参数必须是 Number 类型
Number.isNaN(NaN);  // true

# String 字符串

字符串是由引号括起来的内容，就是字符串。引号代表字符串的开头和结尾。

例如：

"abc123";       // 双引号
'abc123';       // 单引号

let a = '123 _ abc'
let b = new String('123 _ abc'); // 对象声明的方式创建字符串

# String 的属性

length 用来表示字符串中字符的个数，又称为长度。

let a = '123 _ abc'
a.length; // 9

# String 的特殊字符

js 中可以使用反斜线（\）插入特殊符号，如：撇号,引号等其他特殊符号。

"abc ' 123 '";  // 双引号可以包含单引号
'abc "123" ';   // 单引号也可以包含双引号
" abc \" 123 "; // 双引号字符串中，如果也想出现双引号，需要用 \" 来转译
'abc \' 123';   // 单引号也一样
'abc \\\\ 123'; // abc \\ 123
'abc \n 123';   // 换行
'abc \t 123';   // tab

# String 的方法

indexOf() 查找字符串中是否包含指定的子字符串。找到了返回对应下标，找不到的返回 -1

'abc _ 123'.indexOf('abc'); // 0 
'abc _ 123'.indexOf('d');   // -1

lastIndexOf() 从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。找到了返回对应下标，找不到的返回 -1

'abc _ 123 _ abc _123'.lastIndexOf('abc'); // 17
'abc _ 123 _ abc _123'.lastIndexOf('d');   // -1

includes() 查找字符串中是否包含指定的子字符串。

'abc _ 123 _ abc _123'.includes('abc');  // true

substr, substring() 这两个方法都是字符串截取，需提供一个开始位置和结束位置。但有对于结束位置的理解有一点不同。

// 包含结束位置
'abc _ 123 _ abc _123'.substring(1, 4);  // "bc _"
// 不包含结束下标
'abc _ 123 _ abc _123'.substr(1, 4);     // "bc "

match() 查找找到一个或多个正则表达式的匹配。返回匹配结果

'abc _ 123 _ abc _123'.match(/abc/);
/*
  返回值：
  [
    "abc",
    index: 0,
    input: "abc _ 123 _ abc _123",
    groups: undefined
  ]
*/

search() 查找与正则表达式相匹配的值。返回找到的位置

'abc _ 123 _ abc _123'.search(/123/); // 6

split() 分割字符串，根据提供的参数

'abc _ 123 _ abc _123'.split('_'); 
// ["abc ", " 123 ", " abc ", "123"]

replace() 替换内容，根据提供的字符串或者正则表达式

'abc _ 123 _ abc _123'.replace('_', 'xinglong'); 
// "abc xinglong 123 _ abc _123"
'abc _ 123 '.replace(/_/g, '_xinglong_ ');
// "abc _xinglong_  123 "

toLowerCase()，toUpperCase() 大小写转换

// 全部转换小写
'Abc _ 123 _ ABC _123'.toLowerCase(); // "abc _ 123 _ abc _123"
// 全部转换为大写
'Abc _ 123 _ ABC _123'.toUpperCase(); // "ABC _ 123 _ ABC _123"

charAt() 获取字符串中某个下标的字符

// 全部转换小写
'Abc _ 123 _ ABC _123'.charAt(0); // A
// 全部转换为大写
'Abc _ 123 _ ABC _123'.charAt(2); // c

charCodeAt() 返回在指定的位置的字符的 Unicode 编码。

'Abc _ 123 _ ABC _123'.charCodeAt(0); // 65

concat() 字符串拼接，和 + 号差不多

'abc'.concat(' _ 123'); // "abc _ 123"
'abc' + ' _ 123';       // "abc _ 123"

TIP

双引号或者单引号被包含后，则变成字符串。不再有开头结尾的意义

# Boolean 布尔类型

一个布尔值只有 true、false两种值，要么是true，要么是false，可以直接用true、false表示布尔值，也可以通过布尔运算计算出来：

true;   // 这是一个true值
false;  // 这是一个false值
2 > 1;  // 这是一个true值
2 >= 3; // 这是一个false值

// 以下这些值也会被认为是 false 
0
-0
null
""
false
undefined
NaN

if (0 || -0 || null || '' || false || undefined || NaN) {
  console.log('永远执行不到')
}

和布尔相关的表达式还有 || && ！

|| 是或运算符，|| 的两遍只要有一个为 true, 则整个表达式为 true

(true || false);  // true
(0 || 1 > 0);     // true
(true || 0 > 1);  // true

&& 与运算符：&& 两遍的条件都为true时，则整个表达式为 true

(true && false);  // false
(0 && 1 > 0);     // false
(true && 0 > 1);  // false

! 取反运算符：!把本来为 true 的表达式，翻转为 false

!true;    // false
!(1 > 0); // false

# 比较运算符

比较运算符产生的结果就是 Boolean 值。

比较运算符有一下这几个

>, <

这两个是普通的大于号和小于号。

==，===

这两种等于号它们分别叫做：双等和三等。

三等比双等好用！双等在做条件判断是会做类型转换。

('123' == 123); // true。

这个表达式中字符串类型的 '123' 居然和 Number 类型的 123 相等了！这是不对的。两个值作比较，最先要比较的是类型，如果类型不想同那么这两个值的对等关系是不成立的。

三等不会出现这样的错误。所以忘记双等吧！以后任何场景都要用 === 三等，这也是 js 严格模式的一个规范。

>=，<=

这两个也是普通的 大于等于，小于等于。没有其他特殊之处。

if('abc123' === 'abc123') {
  // true
}
console.log('123' == 123); // true，双等做了类型转换

# Undefined 和 Null 空

Undefined 在 js 中是空指针的意思，一般用来表示某个变量未定义。一般用来判断某些参数是否存在。

Null 就是空的意思，没有任何意义。者也是 js 奇怪的地方。不过在一般用作变量回收

let logList = [];

logList.puhs(); 
...
logList.puhs(); // push 了 1000 次

logList = null; // 释放掉 logList 占用的内存

← 语句数组 →