JS中的类型与值

1、类型

我们这样来定义类型：类型是值的内部特征，它定义了值的行为，以使其区别于其他值

1.1、内置类型

JS有其中内置类型：null、undefined、boolean、number、string、object、symbol（ES6新增），除了对象之外，其余统称为“基本类型”

可以使用typeof运算符来查看值的类型，但是null是一个例外

typeof null === "object" // true

在函数对象中，length属性是其声明的参数的个数，数组也是对象，是object的一个“子类型”

function a(b,c){...
}
a.length // 2

1.2、值和类型

JS中的变量是没有类型的，只有值才有。变量可以随时持有任何类型的值

typeof运算符总是会返回一个字符串

已在作用域中声明但还没有赋值的变量，是undefined。相反，还没有在作用域中声明过的变量，是undeclared的

var a ;
a // undefined
b // ReferenceError: b is not defined

对于这类情况的处理让人抓狂，如果对于b可以返回undeclared的话，情况会好很多

1.3、总结

JS有七种内置类型：null、undefined、boolean、number、string、object 和symbol，可以使用 typeof 运算符来查看。

变量没有类型，但它们持有的值有类型。类型定义了值的行为特征。

很多开发人员将 undefined 和 undeclared 混为一谈，但在JS中它们是两码事。undefined 是值的一种。undeclared 则表示变量还没有被声明过。遗憾的是，JavaScript 却将它们混为一谈，在我们试图访问 “undeclared” 变量时这样报错：ReferenceError: a is not defined，并且 typeof 对 undefined 和 undeclared 变量都返回"undefined"。

然而，通过 typeof 的安全防范机制（阻止报错）来检查 undeclared 变量，有时是个不错的办法。

2、值

2.1、数组

在JS中，数组可以容纳任何类型的值，可以是字符串、数组、对象，甚至是其他数组

使用delete运算符可以将单元从数组中删除，但是删除后，数组的length属性并不会发生变化

var a = [ ];
a[0] = 1;
a["foobar"] = 2;
a.length; // 1
a["foobar"]; // 2
a.foobar; // 2

数组通过数字进行索引，但是有趣的是他们也是对象，所以他们也可以包含字符串键值和属性

2.2、类数组

可以使用数组工具函数（indexOf（…）、concat（…）、forEach（…））将类数组转换位真正的数组，也可以使用Array.from（）

const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
const arr = Array.from(arrayLike);
console.log(arr); // ['a', 'b', 'c']const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
const arr = Array.prototype.slice.call(arrayLike);
console.log(arr); // ['a', 'b', 'c']

2.3、字符串

字符串与数组类似，，他们都是类数组，都有length属性以及indexOf（…）和concat（…）方法，但是在JS中字符串是不可变的，而数组是可变的，在进行字符串反转时，我们可以如下来做：

var c = a.split("") // 将a的值转换为字符数组.reverse() // 将数组中的字符进行倒转.join("") // 将字符串中的字符拼接回字符串

2.4、数字

JS只有一种数值类型，包括“整数”和带小数的十进制数

JS中的数字类型是基于IEEE754标准来实现的，该标准通常也被称为“浮点数”，JS使用的是“双精度”格式（64位二进制）

特别大和特别小的数字默认用指数格式显示，与toExponential（）函数（用于将数字转换为指数形式的字符串）的输出结果一致

const num = 123.456789;
console.log(num.toExponential()); // 输出：1.23456789e+2
console.log(num.toExponential(2)); // 输出：1.23e+2
console.log(num.toExponential(6)); // 输出：1.234568e+2

tofixed（…）方法可指定小数部分的显示位数

var a = 42.59;
a.toFixed( 0 ); // "43"
a.toFixed( 1 ); // "42.6"
a.toFixed( 2 ); // "42.59"
a.toFixed( 3 ); // "42.590"
a.toFixed( 4 ); // "42.5900"

toPrecision(…) 方法用来指定有效数位的显示位数

var a = 42.59;
a.toPrecision( 1 ); // "4e+1"
a.toPrecision( 2 ); // "43"
a.toPrecision( 3 ); // "42.6"
a.toPrecision( 4 ); // "42.59"
a.toPrecision( 5 ); // "42.590"
a.toPrecision( 6 ); // "42.5900"

上边的方法不仅适用于数字变量，也适用于数字字面量。不过对于.运算符需要给予特别注意，因为它是一个有效数字字符，会被优先识别为数字字面量的一部分，然后才是对象属性访问运算符

// 无效语法：
42.toFixed( 3 ); // SyntaxError
// 下面的语法都有效：
(42).toFixed( 3 ); // "42.000"
0.42.toFixed( 3 ); // "0.420"
42..toFixed( 3 ); // "42.000"

在JS中0.1+0.2!=0.3，因为他是浮点数，我们可以设置一个误差范围值，该值定义在Number.EPSILON中，可以使用它来比较两个数字是否相等

function numbersCloseEnoughToEqual(n1,n2) {return Math.abs( n1 - n2 ) < Number.EPSILON;
}
var a = 0.1 + 0.2;
var b = 0.3;
numbersCloseEnoughToEqual( a, b ); // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 ); // false

如果要检测一个值是否为整数，可以使用ES6中的Number.isInteger（…）方法

Number.isInteger( 42 ); // true
Number.isInteger( 42.000 ); // true
Number.isInteger( 42.3 ); // false

2.5、特殊的值

null是一个特殊关键字，不是标识符，不能将其当做变量来使用，尽管 null 可以被赋值给变量，但它本身并不是变量，也不应该被当做变量来使用。当我们需要表示一个空的对象引用时，才将 null 赋值给变量，并使用该变量来表达空值的概念

undefined是一个标识符，可以被当做变量来使用和赋值

void运算符，void___ 没有返回值，因此返回结果是undefined，void并不改变表达式的结果，只是让表达式不返回值，如果要将代码中的值设为undefined，就可以使用void

var a = 42;
console.log( void a, a ); // undefined 42

2.6、特殊的数字

NaN意指“不是一个数字”，是一个特殊值，它和自身不相等，是唯一一个非自反的值，因此无法对其进行比较，那么应该如何判断它，可以使用isNaN，该方法意思是“参数是否不是NaN，也不是数字”

var a = 2 / "foo";
isNaN( a ); // true

我们也可以使用下边的方法

var a = 2 / 'foo';
var b = 'foo';
console.log(Number.isNaN(a)); // true
console.log(Number.isNaN(b)); // false

无穷数Infinity

在JS中var a = 1 / 0 的结果为Infinity，如果该式中一个数为负数，结果即为-Infinity

JS中，零值分为+0和-0，为什么我们需要-0，因为某些程序中的数据需要以级数形式来表示（比如动画帧的移动速度）

在ES6中，新加入了一个工具方法Object.is（…）来判断两个值是否相等，但是能使用“”和“=”的时候就尽量不要使Object.is（…），因为前者的效率更高也更为通用

2.7、值和引用

在许多语言中，复制和参数传递可以通过值复制或者引用复制来完成。引用就像一种特殊的指针，是来指向变量的指针，但是在JS中没有指针，引用的工作机制也不尽相同。在JS中变量不可能成为指向另一个变量的引用。JS引用指向的是值。如果一个值有10个引用，这些引用指向的都是同一个值，它们之间没有引用/指向关系。

简单值（基本类型值）总是通过值复制的方式来赋值/传递，包括null、undefined、字符串、数组、布尔和ES6中的symbol，复合值—对象和函数，则总是通过引用复制的方式来赋值/传递。

引用指向的是值本身而非变量，所以一个引用无法更改另一个引用的指向

function foo(x) {x.push( 4 );x; // [1,2,3,4]// 然后x = [4,5,6];x.push( 7 );x; // [4,5,6,7]
}
var a = [1,2,3];
foo( a );
a; // 是[1,2,3,4]，不是[4,5,6,7]

我们不能通过引用 x 来更改引用 a 的指向，只能更改 a 和 x 共同指向的值。

如果要将a的值变为[4,5,6,7]，必须更改x指向的数组，而不是为x赋值一个新数组

function foo(x) {x.push( 4 );x; // [1,2,3,4]// 然后x.length = 0; // 清空数组x.push( 4, 5, 6, 7 );x; // [4,5,6,7]
}
var a = [1,2,3];
foo( a );
a; // 是[4,5,6,7]，不是[1,2,3,4]