js之数据类型（原始类型）

　　JavaScript的数据类型分为两类：原始类型和引用类型。本文讨论的是原始类型。原始类型包括数字，字符串，布尔值，undefined(未定义)和null(空)。undefined和null它们不是数字，字符串和布尔值中的任何一类，但是也属于原始类型。它们通常分别代表了各自特殊类型的唯一成员。下面来进行详细了解。

　　一、数字

　　　　javascript只有一种数字类型，它在内部被表示为64位的浮点数，和java的double数字类型一样，与其它大多数编程语言不同的是，它没有分离出整数类型和浮点型。javascript中的所有数字都用浮点数值表示。数字Number是javascript中基本的原始数据类型，同时javascript也支持Number对象。它是一个原始数值的包装对象，在需要的时候，javascript会自动在原始形式和对象形式之间进行转换。

　　　　当一个数字直接出现在javascript程序中，称之为数字的字面量，而当Number()使用new操作符用作构造函数时，称之为Number对象。

　　　　1、整数直接量　

　　　　javascript的整数表示共有四种字面量格式是十进制、二进制、八进制、十六进制。但在进行算术计算时，所有以二进制、八进制和十六进制表示的数值最终都将被转换成十进制数值。

　　　　a: 八进制字面值的第一位必须是0，然后是八进制数字序列(0-7)。如果字面值中的数值超出了范围，那么前导0将被忽略，后面的数值被当作十进制数解析。(严格模式下是禁止的，所以最好不用)。

　　　　b. 十六进制字面值的前两位必须是0x，后跟十六进制数字序列(0-9,a-f)，字母可大写可小写。如果十六进制中字面值中的数值超出范围会报错

　　　　c. 二进制字面值的前两位必须是0b，如果出现除0、1以外的数字会报错

　　　　2、浮点型直接量

　　　　浮点数是指数值中必须包含一个小数点，且小数点后面必须至少有一位数字。与整数支持多进制不同，一般地，浮点数只可用十进制表示.

　　　   虽然小数点前面可以有整数，但是不推荐。涉及到浮点数的比较和运算时一定要小心。

    <script>
        　　　　  0.11;
        　　.ll111;
        　　1.4738223E-32 //1.4738223*10*(-23)(前一个*表示乖后一个*表示幂)
    </script>

　　　　3、特殊数值

　　　　Number.MAX_VALUE　　　　　　　　　　最大值

　　　　Number.MIN_VALUE　　　　　　　　　　 最小值

　　　　Number.MAX_SAFE_INTEGER　　    　　   最大整数

　　　　Number.MIN_SAFE_INTEGER　　　　        最小整数

　　　　Infinity　　　　　　　　　　　　　　　　  无穷大

　　　　NaN(not a number)　　　　　　　　　　  非数字，NaN与任何值都不相等，包括它本身，且涉及到NaN的操作都会返回NaN

　　　　正负0　　　　　　　　　　　　　　　　    js内部存在2个0，它们是等价的

    <script>
        console.log(Number.MAX_VALUE);//1.7976931348623157e+308
        console.log(Number.MIN_VALUE);//5e-324
        console.log(Number.MAX_SAFE_INTEGER);//9007199254740991
        console.log(Number.MIN_SAFE_INTEGER);//-9007199254740991

        //过isFinite()来确定一个数值是不是有穷的，包含着隐式类型转换Number()
        console.log(isFinite(Infinity))//false

        //isNaN() 来判断这个数字是不是NaN，包含着隐式类型转换Number()
        console.log(isNaN('hello'));//true

        -0 === +0;//true;
        0 === -0;//true;
        0 === +0;//true
    </script>

　　　　4、转成数值

　　　　有3个函数可以把非数值转换成数值：Number(),parseInt(),parseFloat().其中Number()可以将任意类型的值转化成数值，而parseInt和parseFloat()只应用于字符串向数字的转换。Number()走的是v8引擎机制，parseInt/parseFloat()它是我们额外提供的方法，这二者是有根本上的区别。

　　　　4.1  Number([val])

　　　　Number([val])把字符中转成数字：把字符串转换为数字，只要字符串中包含任意一个非有效数字字符（第一点除外）都会转成NaN。空字符串转成0。

　　　　Number([val])把对象转成数字时会按照以下的步骤：

　　　　　　首先，调用对象的Valueof()方法，如果返回原始类型的值，则直接对该值使用Number()；

　　　　　　其次：如果Valueof()方法返回的还是对象，则调用对象的toString()方法，把它转成字符串后再使用使用Number()；

　　　　　　最后：如果toString()方法返回的依然是对象，则结果是NaN.

　　　　注意：undefined转数字的结果是NaN；Null转数字的结果是0；true转数字的结果为1，false转数字的结果是0；空字符串，空格字符串转数字的结果为0，字符串里面的内容如果是纯数字就转成对应的数字，如果不是那结果为NaN；数字转数字的结果还是原来的数字；Object转数字不确定

   <script>
        console.log(Number(1));//1
        console.log(Number(true));//1
        console.log(Number(undefined));//NaN
        console.log(Number(NaN));//NaN
        console.log(Number(null));//0

        //转字符串
        console.log(Number(''));//0
        console.log(Number(' '));//0
        console.log(Number('hello'));//NaN

        //转对象
        console.log(Number([]));   //0
        console.log(Number([1,2]));//NaN
        // console.log(Number(其它对象)); //NaN
    </script>

　　　　4.2  parseInt(string,radix)用于把字符串转换成radix进制的整数，radix代表进制。

　　　　它是专门用来处理字符串转数字的，string是要被解析的值，如果参数不是字符串，先用toString()方法转成字符串，从字符串左边开始查找，找到有效数字字符转换为数字，遇到非有效数字字符则停止查找。

　　　　radix代表进制，从2到36之间。它是可选的。首先string这个字符串，他是把个值看做是radix这个进制，然后转换为10进制的数字。它省略或者是为0时,radix默认按照10进制处理（特殊:字符串以0x/oX开头，radix默认按照16进制处理）。

　　　　返回整数或者是NaN.

    <script>
        console.log(parseInt(' 1234'));//1234
        console.log(parseInt(' 1234fa'));//1234
        console.log(parseInt('  a1234ps'));//NaN
        console.log(parseInt([1,3])); //1 [1,3].toString()=>'1,3'
        console.log(parseInt(''),parseInt('  '),parseInt({}));//NaN NaN NaN
    </script>

    <script>
      /*
       *意思是'2AF5'当做16进制，最后转成10进制
       * 现在要知道进制的转换：
       * 5*1+15*16^1+10*16^2+2*16^3=10997
       */
      parseInt("2AF5", 16);//10997
       /*
         *3进制只能是0-2,所以查到3的时候，发现已经不是3进制的范围了，不再继续查找下去
         *意思是'2'当做3进制，最后转成10进制
         * 2*3^0 = 2
         */
      parseInt("231", 3);//2
        /*
         * '234看做是5进制，转换为10进制'
         * 4+3*5+2*5*5=69
         */
      parseInt('23461',5);//69
        //radix不在2-36之间，最后结果为NaN
      parseInt(1,1);//NaN
        //radix省略或者为0时，默认按10进制处理
      parseInt(1,0);//1
    </script>

　　　　4.3  parseFloat(string)用于字符串转换浮点数

　　　　　string需要被解析成为浮点数的值，返回被解析成的浮点数，如果给定值不能被转换成数值，则会返回NaN.

    <script>
        console.log(parseFloat(' 1234ad'));//1234
        console.log(parseFloat(' 1234'));//1234
        console.log(parseFloat([1, 2]));//1
        console.log(parseFloat(true), parseFloat(false));
        console.log(parseFloat([]), parseFloat([2.1]), parseFloat(['2.1px']));//NaN 2.1 2.1
        console.log(parseFloat({}), parseFloat(' '), parseFloat(''));//NaN NaN NaN

</script>　

　　　　d.isNaN()方法

　　　　　　判断一个值是不是NaN，它会先把参数用number()方法转一下。具有一个功能是用来检测数字的，但是它的本意并不是用来检测数字，而是检查一个值是否为NaN。如果参数的结果为NaN，那它返回一个ture，如果参数不为NaN，则返回一个false.

　　　　　　isNaN()传进的值，如果是一个数字那它返回一个false。

<script>
    var n = NaN;
    var s = 'davina';//这个地方先用number()方法转一下，再用isNaN()方法
    var n1 = ;
    console.log(isNaN(n), isNaN(s), isNaN(n1));//true true false
</script>

　　　　e. Math是一个内置对象，它具有数学常数和函数的属性和方法，常用的有Math.ceil()，Math.floor()，Math.round()，Math.abs()，Math.random()等等。下文来详细说明这几个方法的语法和用处。

　　　　Math.ceil()把一个数向上取整。语法：Math.ceil() 参数就为一个数字，返回参数向上取整的数字

　　　　Math.floor()把一个数向下取整。语法：Math.floor() 参数就为一个数字，返回参数向上取整的数字

　　　　Math.round()把一个数四舍五入。语法：Math.round() 参数就为一个数字，返回四舍五入后的数字

　　　　Math.abs()求一个数的绝对值。语法：Math.abs() 参数就为一个数字，返回一个数字的绝对值

　　　　Math.random()取0-1之间的随机数(包括0不包括1)。语法：Math.random() 参数就为一个数字，返回一个0-1之间的随机数。

　　　　　　常用的一些随机取值方法：

　　　　　　x~y:Math.round(Math.random()*(y-x)+x)；0~x:Math.round(Math.random()*x);

　　　　　　1~x:Math.ceil(Math.random()*x)||1；0~x:Math.floor(Math.random()*x)　　

    <script>
        console.log(Math.ceil(0.234)); //1
        console.log(Math.floor(0.789));//0
        console.log(Math.round(4.5));//5
        console.log(Math.abs(-9));//9
        console.log(Math.random())// 0.7037158897016866
    </script>

　　例子：简单计算器

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <script>
            window.onload=function(){
                var text1=document.getElementById('text1');
                var text2=document.getElementById('text2');
                var btn=document.querySelector('button');
                var result=document.getElementById('result');
                btn.onclick=function(){
                    var val1=parseFloat(text1.value);
                    var val2=parseFloat(text2.value);
                    result.value=val1+val2;
                }
            }
        </script>
    </head>
    <body>
        <input type="text" id="text1" value=""  />
        <span>+</span>
        <input type="text" id="text2" value="" />
        <button id="btn">=</button>
        <input type="text" id="result"></input>
    </body>
</html>

　　二、字符串

　　　　字符串String是javascript基本数据类型，同时javascript也支持String对象，它是一个原始值的包装对象。在需要的时候javascript会自动的在原始形式和对象形式之间进行转换。

　　　　字符串类型常被用于表示文本数据。字符串String是由双引号(")或单引号(')声明的。由单引号定义的字符串中可以包含双引号，由双引号定界的字符串也可以包含单引号。

　　　　如果想在单引号定界的字符串中使用单引号，或在双引号定界的字符串中使用双引号，则需要使用反斜线(\)（转义字符进行转义）。字符串默认只能写在一行内，分成多行将会报错，如果希望在字符串另起一行，可以使用转义字符\n。

　　　　javascript中的字符串是不可变的。一旦字符串被创建，就永远无法改变它。要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。可以通过+运算符连接其他字符串来创建一个新字符串。

　　　　转字符串：String(),toString().

　　　　把一个值转成字符串有两种方法：toString()和String().但是要注意一点，可以使用空字符串“”+某个值，将该值转换为字符串。

　　　   toString()方法：几乎每一个值都会有这个方法。它返回相应字符串

　　　   String()方法：在不知道要转换的值是不是null或者是undefined时，可以使用这个方法。

　　　　它遵循以下的原则：如果值是null，则返回'null'；如果值是undefined，则返回'undefined'；如果值不是null或undefined，则调用toString()方法并返回原始类型值；若使用toString()方法返回的是对象，则再调用valueOf()方法返回原始类型值，若使用valueOf()方法返回的是对象，会报错

　　　　总之，undefined转字符串为'undefined'; Null转字符串为'null'; Number转字符串，把数字加上字符串; true转字符串'true',false转字符串'false';  String转字符串结果就是它本身; Object转字符串,给对象加上引号　　　　　　　　　　　

    <script>
        console.log('"hello world!!!"');//"hello world!!!"
        console.log("'hello world!!!'");//'hello world!!!'
        console.log('\'hello world\'!!!');//'hello world'!!!
        console.log('I don\'t know.');//I don't know.

        //可以通过+运算符连接其他字符串来创建一个新字符串
        var lang = "java";
        lang = lang + "script";
        console.log(lang); //javascript

        //转字符串
        //a.toString()方法
        console.log(true.toString()); //true
        console.log([].toString());//
        console.log({}.toString());//[object Object]
        console.log([1, 2, 3, 4].toString());//1,2,3,4
        console.log(new Date().toString());//Wed Nov 13 2019 12:06:11 GMT+0800 (中国标准时间)
        // console.log(null.toString()); 报错
        // console.log(undefined.toString()); 报错

        //b.String()方法
        var u = undefined;
        console.log(String(u)); //undefined

        var nul = null;
        console.log(String(nul));//null

        var num = 12;
        console.log(String(num));//12

        var b1 = true;
        var b2 = false;
        console.log(String(b1), String(b2));//true false
    </script>

　　　三、布尔值

　　　　Boolean类型表示逻辑实体，它只有两个值true和false分别代表真和假这两个状态。它主要是应用于条件和循环语句，逻辑运算符，关系运算符。

　　　　转Boolean方法：Boolean()

　　　　undefined转布尔值为false； Null转布尔值为false；Number中转布尔值0，NaN转布尔值的结果是false,其它的转布尔值的结果为true；空字符串转布尔值的结果为false,其它（包括空格字符串）都转换成了true.

　　　　!! 其它类型：！是取反的意思，因此加上两个!!，两次取反后即得到本身的布尔值。

        //条件语句
        // if(a){
        //     条件为true时,执行这里的函数
        // }else{
        //     条件为false时，执行这里的函数
        // }

        //逻辑运算符 同时使用两个逻辑非操作符，可以将类型转换成布尔值
        console.log(!!1); //true
        console.log(!!0);//false
        console.log(!!'')//false
        console.log(!!" ");//true

        //关系运算符用于测试两个值之间的关系，根据关系是否存在而返回true或者是false
        console.log(1 > 3);//false

        //转布尔值
        console.log(Boolean(undefined));//false
        console.log(Boolean(null));//false
        console.log(Boolean(NaN));//false
        console.log(Boolean(0));//false
        console.log(Boolean(''));//false
        console.log(Boolean(' '));//true
        console.log(Boolean(false));//false
        console.log(Boolean('1234'));//true
        //注意：空字符串转为false，空白字符串转为true
    </script>

　　四、null（空）

　　　　Null类型只有一个值，就是null。它是javascript语言的关键字，它表示一个特殊的值，常用来描述为"空"。

　　　　从逻辑的角度上来说，null表示为一个空对象指针。

　　　　尽管null和undefined不同，但它们都表示"值的空缺"，null表示"空值"，undefined表示"未定义"。两者往往可以互换。相等运算符认为两者是相等的。

　　　　判断一个值是否为null可以用恒等来进行比较。

    <script>
        console.log(document.getElementById('test'));//null
        console.log(typeof null);//object
        console.log(null == undefined);//true

        console.log(null === null);//true
        console.log(undefined === null);//false
        console.log('null' === null);//false

    </script>

　　五、undefined（未定义）

　　　　undefined类型只有一个值就是它自身，当声明的变量末初始化时，该变量的默认值是undefined,所以一般来说，undefined表示变量没有初始化。

　　　　对于没有声明的变量只能执行一个操作，使用typeof操作符检测其数据类型，但严格模式下会导致错误。

　　　　它一般出现在已声明但没有赋值的变量，获取对象不存在的属性，无返回值的函数的执行结果，函数的参数没有传入，void(expression).

    <script>
        var i;
        console.log(typeof (i));// undefined

        var n = [];
        console.log(n.i);//undefined

        function fn() { };
        console.log(fn());//undefined

        function f(x) {
            return x;
        }
        console.log(f()); //undefined
    </script>

　　六、隐式类型

　　　　　类型转换分为两种：一是显式类型转换，二是隐式类型转换。

　　　　　显式类型转换，通过一种方法很明确的某种数据类型转换为另一种数据类型，像是Number(),parseInt(),parseFloat()明确遥将数据转数字类型；String()明确将数据转为字符串类型；Boolean()明确将数据转为布尔值类型。

　　　　　隐式类型转换：在进行一些操作的时候，根本的目的不是做类型转换，但是如要进行操作的话，那数据必需符合某种类型，js会在内部对数据进行一些转换

　　　　　如：+ - * /

 <script>
        console.log( + );  //
        console.log( + 'a');  //1a
        console.log(true + ); //
        console.log(false + '');  // false1
        console.log(false - true); //-1
        console.log('' - ); //-1
 </script>