zoukankan      html  css  js  c++  java
  • JavaScript数据

    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(); 转换成布尔值
          - 空字符串NaNnullundefined,转换成布尔值都是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
  • 相关阅读:
    Coursera Algorithms week3 快速排序 练习测验: Nuts and bolts
    快速排序及三向切分快排——java实现
    自顶向下(递归)的归并排序和自底向上(循环)的归并排序——java实现
    希尔shell排序——java实现
    插入排序——java实现
    选择排序——java实现
    Coursera Algorithms week3 归并排序 练习测验: Shuffling a linked list
    单向链表的归并排序——java实现
    Coursera Algorithms week3 归并排序 练习测验: Counting inversions
    Coursera Algorithms week2 栈和队列 练习测验: Stack with max
  • 原文地址:https://www.cnblogs.com/musong-out/p/11385652.html
Copyright © 2011-2022 走看看