JavaScript数据

Posted 2020-11-10 musong-out

javascript的数据类型：

• 基本数据类型：string（字符串）、numbr（数字）、boolean（布尔）、null（空）、undefined（未定义）
• 引用数据类型（复杂）：object（对象）、Array（数组）、regExp（正则）、function（函数）
• 数据类型检测：typeof、instanceof
• typeof用于检测基本数据类型
• instanceof用于检测引用数据类型

(一) 数据类型  

 - 1-基本数据类型:结构简单,存储在栈内存里面,操作的是值

   - 字符串 string :  `‘‘  ""   ‘a‘  "a"   ‘asdfdf‘`
    - 字符串天生自带一个length属性,表示字符串长度(字符个数)
    - 通过字符串的索引值(下标)可以访问字符串中指定字符  索引值范围:0 - (length-1)
        ```
            var str = ‘hello world!‘;
            console.log(str.length); //12
            console.log(str[0]);  //‘h‘
            console.log(str[str.length-1]); //‘!‘
        ```
   - 数字  number :  正数  负数   小数   `NaN`(not a number) 
    - js小数之间运算会有精度损失,一般应当避免小数之间直接运算
        ```
            console.log(0.1+0.3); //  0.30000000000004
        ```

   - 布尔  boolean :  `true`真   `false`假
   - null  空
   - undefined  未定义(未初始化)
  
 - 2-引用数据类型:结构复杂,存储在堆内存里面,操作的是地址

   - 对象 object  ` { key1:val,key2:val} `  `{}`空对象
   - 数组 array   `[1,2,3,‘aaa‘] `  `[]`空数组
        - 数组天生自带一个length属性,表示数组长度
        - 通过数组的索引值(下标)可以访问数组中的一项  索引值范围:0 - (length-1)
        ```
            var ary = [2,3,4,5]; 
            console.log(ary.length);  //4
            console.log(ary[0]); //2
            console.log(ary[ary.length-1]); //5
        ```
   - 正则 regExp  `/^1$/ `
   - 函数 function     `function(){   }`

null和undefined的区别：

• null是空对象；undefined是没定义（变量声明未赋值；）

数据类型转换：

   - 1- isNaN() 检测一个值是否不是一个有效数字 , 是数字返回false,反之为true (隐式调用Number()方法把值转换成number类型再判断)
    
        ```
        console.log(isNaN(‘12‘)); //false
        console.log(isNaN(true));  //false
        ```
   - 2- Number(); 强制转换成number类型
        ```
            console.log(Number(‘12.345‘)); // 12.345
            console.log(Number(‘‘));  //0

            console.log(Number(true));  //1
            console.log(Number(false));  //0
     
            console.log(Number(null));  //0

            console.log(Number([]));  //0
            console.log(Number([12]));  //12
            console.log(Number([‘12‘]));  //12

        ```
   - 3- parseInt(); 转换成整型的数字
      - 从左到右查找数字,直到碰到非数字就停止查找,把已经找到的数字返回
        ```
        console.log(parseInt(‘12px345‘));  //12
        console.log(parseInt(‘12.5px345‘)); //12        
        console.log(parseInt(‘12.23435‘)); //12
        ``` 
   - 4- parseFloat(); 转换成浮点型的数字
    
      - 比parseInt()多识别一个小数点
    
        ```
        console.log(parseFloat(‘12.5px345‘)); //12.5
        ```

   - 5- Boolean(); 转换成布尔值
      - 空字符串\0\NaN\null\undefined,转换成布尔值都是false,其他的值都是true
    
        ```
        console.log(Boolean(‘‘));  //false
        console.log(Boolean(0)); //false
        console.log(Boolean(NaN)); //false
        console.log(Boolean(null)); //false
        console.log(Boolean(undefined)); //false
        ```
 -  6- toString();  转换成字符串

    ```
        //数组串字符串:去掉括号,加引号
         console.log([1,2,3].toString()); // ‘1,2,3‘ 
         //所有对象转成字符串结果都是 ‘[object Object]‘
         console.log({name:‘ujiuye‘}.toString()); // ‘[oject Object]‘
    ```
    - toString() 不能操作null和undefined ,会报错
    - String()  大部分情况和toString效果一样
       - 可以用来把null和undefined转换成字符串
       ```
        console.log(String(null)); // ‘null‘
        console.log(String(undefined));  // ‘undefined‘
       ``` 

运算符的种类：

• 算数运算符
• 比较运算符
• 赋值运算符
• 逻辑运算符
• 三目运算符

  - 1- 算术运算符
     - 加  +  
       - 如果 + 号两边有一个是字符串,那么就是字符串连接符

        ```
         console.log(‘10‘+20);  //‘1020‘
        ```
     - 减  -
     - 乘  * 
     - 除  /
     - 取模 % 
       - 算术运算符两边如果不是数字,会隐式转换成数字然后运算(+除外)
     - 自增  ++  

        ```
            var  n = 0;
            n++;  // n = n + 1;
            console.log(n); //1

            var x = 0;
            var y = x++; //++写在后面,先赋值再运算
            console.log(y); //0

            var a = 0;
            var b = ++a; //++写在前面,先运算再赋值
            console.log(b); //1
        ```
     - 自减  --

   - 2- 比较运算符
     - 等于  ==  :如果数据类型不同会进行隐式转换,然后比较
     - 全等  ===  : 数据类型和值都必须相等
     - 不等  !=  
     - 不全等  !==

        ```
            console.log( 12 == ‘12‘); //true
            console.log( 12 === ‘12‘); //false
            console.log( 12 != ‘12‘); //false
            console.log( 12 !== ‘12‘); //true
        ```
     - 大于   >
     - 小于   <
     - 大于等于   >=
     - 小于等于   <=

   - 3- 赋值运算符
     -   = 
     -   +=     ` x += y ==>  x = x + y;`
     -   -=     ` x -= y ==>  x = x - y;`
     -   *=     ` x *= y ==>  x = x * y;`
     -   /=     ` x /= y ==>  x = x / y;`
     -   %=     ` x %= y ==>  x = x % y;`

   - 4- 逻辑运算符
     - 与(且) `&&`  : 两边的表达式都成立,最终结果成立 
     - 或  `||`  : 两边的表达式有一个成立,整个表达式结果成立
       - `&&`和`||`: 返回决定表达式最终结果那一边的值
     - 非 `!` : 取反,结果一定是布尔值

        ```
            console.log(1&&0); //0
            console.log(1&&2); //2
            console.log(1&&-1); //-1
            console.log(0&&-1); //0
            console.log(1||0);  // 1
            console.log(0||false);  //false
            console.log(1||true);  //1
        ```

   - 5- 三目运算符

        ```
        条件 ? 条件成立执行的代码 : 条件不成立执行的代码 ; 
        ```

不同数据的比较guilv：

    - ① : 字符串和数字比较 : 字符串转数字,然后比较
    - ② : 字符串和布尔值 : 字符串和布尔值都转数字,比较
    - ③ : 数字和布尔比较 :  布尔转数字再比较
    - ④ : NaN和任何的值比较都不相等,包括自己
    - ⑤ : 字符串和数组 : 数组转字符串,再比较
    - ⑥ : 字符串和对象 : 对象转字符串,再比较
    - ⑦ : null和undefined比较相等,各自和其他数据类型的值比较都不相等
    - ⑧ : 引用数据类型的值相比较永不相等

 ‘==’和‘===’的区别？

• ‘==’：等于，如果数据类型不同则进行隐式数据类型转换，然后再比较；
• ‘===’：全等于，数据类型和值都必须相同，返回值才能为true

NaN会在什么样的情况下出现呢？

• number（‘12aaa’）
• parseint（‘abc’）
• ‘abc’-1