javascript中的内置值类型

1.数组

var a = [ 1, "2" , [3]];

a.length;        //3
a[0] === 1;      //true
a[2][0] === 3;  //true

创建稀疏矩阵，中间会留有一些空白单元，值为undefined

var a = [ ];

a["13"] = 42;

a.length;  //14

从0到12的值都为undefined

类数组

function foo() {
    var arr = Array.prototype.slice.call( arguments );
    arr.push( "bam" );
    console.log( arr );
}

foo( "bar","baz" );

arguments是arr的参数，而slice()返回参数列表的一个数组副本，原来arguments的类数组就被转化为数组，es6中也同样有实现该功能的函数,Array.from()

var arr = Array.from( arguments );

2.字符串

字符串和字符数组都属于类数组，它们在许多方面都特别相似，都有length属性以及indexOf(...)和concat(...)方法

var a = "foo";
var b = ["f","o","o"];

a.length;
b.length;
a.indexOf( "o" );
b.indexOf( "o" );

var c = a.concat( "bar" );
var d = b.concat( ["b","a","r"]);

a === c;
b === d;

a;    //"foo"
b;    //["f","o","o"]

javascript中字符串是不可变的，而数组是可变的。

字符串可变是指字符串的成员函数不会改变其原始值，而是创建并返回一个新的字符串。

而数组的成员函数都是在其原始值上进行操作。

数组的许多函数处理字符串很方便，虽然字符串没有这些函数，但可以借用

var c = Array.prototype.join.call( a,"-" );
var d = Array.prototype.map.call ( a, function() {
    return v.toUpperCase() + ".";
}).join( "" );

3.数字

javascript只有一种数值类型： number。它包括整数和小数

默认情况下大部分数字都以十进制显示，小数最后的0被省略

特别大和特别小的数都以十进制进行显示，与ToExponential（）函数相同

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

toPrecision（）可以指定有效数位的显示位数

2.浮点误差

0.1 + 0.2 === 0.3; //false

上面的表达式值为false,说明机器内的小数存在误差，不能用这个来判断相等

最常见的做法就是设置误差范围，通常称为机器精度，es6中这个值定义在Number.EPSILON,在es6之前，我们的polyfill代码如下

if(!Number.EPSILON) {
    Number.EPSILON = Math.pow(2,-52);
}

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.01, 0.02); //false

上面的函数numbersCloseEnoughToEqual可以判断浮点数的相等与否

3.浮点数范围与整数范围

Number.MAX_VALUE 

Number.MIN_VALUE

Number.MAX_SAFE_INTEGER

Number.MIN_SAFE_INTEGER

整数如果存放不下就需要用字符串来模拟

4.整数检测

Number.isInteger(....)方法  判断是整数

Number.isSafeInteger（....）方法   判断是安全的整数

 

4.特殊数值

null 空值

undefined 没有值

void的值为undefined

NaN 不是数字但仍然是number类型，比如一些极限值，NaN ！=NaN

es6开始我们使用工具函数Number.isNaN(..)

es6之前的NaN存在严重bug,所以在es6之前我们仍然会采用Number.isNaN(..) ,不过是polyfill

if(!Number.NaN) {
    Number.isNaN = function(n) {
        return (
            typeof n === "number" &&
            window.isNaN( n )
        );
    };
}

+-Infinity，正无穷大和负无穷大

正负零 -0字符串化是“0”

JSON.stringify(-0) 0

JSON.parse("-0")  -0

判断-0的等式

function isNegZero(n) {
    n = Number( n );
    return (n === 0) && (1 / n === -Infinity);
}

es6中判断两个值是否绝对相等 Object.is(....)

var a = 2 / "foo";  //NaN
var b = -3 * 0;    //-0

Object.is( a,NaN );    // true
Object.is( b, -0 );    //true

Object.is( b, 0 );    //false

polyfill代码 

if(!Object.is) {
    Object.is = function(v1,v2) {
        if(v1 === 0 && v2 === 0) {
            return 1 / v1 === 1 / v2;
        }
        if(v1 !== v1）{
            return v2 ！== v2;
        }
        return v1 === v2;
    }
}

5.值和引用

简单值总是通过值复制的方式来复制，传递，包括null,undefined,字符串，数字，布尔，ES6中的symbol

复合值，对象和函数都是通过引用复制来赋值，传递

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

 x和a是值的两个引用，修改x无法引起a的变动

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]

x.length = 0 ,x.push(4,5,6,7)更改了当前数组，a的指向的值变成了[4,5,6,7]

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]

我们无法自行决定使用值复制还是引用复制，一切有值的类型决定。

如果通过值复制的方式传递复合值，就需要为其创建一个复本，这样传递的就不再是原始值

a.slice() 不带参数会返回当前数组的一个浅复本

如果要将标量基本类型值传递到函数内并进行更改,就需要将该值封装到一个复合值中，然后通过引用复制的方式传递

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a;