JS复习一

167 阅读7分钟

基本数据类型

类型名typeof检测结果值举例
数字类型number5
字符串类型string‘百度’
布尔类型booleantrue
undefined类型undefinedundefined
null类型objectnull

特殊数字类型NaN不自等

字符串

  • 字符串的length属性

    '我喜欢你'.length  //5
    
  • charAt()方法: 得到指定位置字符

    'hello'.charAt(1);   //e   从0开始
    
  • substring()方法:提取子串

    'helloworld'.substring(1,4);  //ell  提取1-4不包含4  可以大的在前 
    
  • substr()方法:提取子串

    'helloworld'.substr(1,4);   //ello 1开始提取4个   第一个数可以是负数 
    
  • slice()方法:提取子串

    'helloworld'.slice(1,4);   //ell  提取1-4不包含4  两个都可以是负数  a必须小于b
    
  • 三个提取子串的,省略第二个参数都表示提取到字符串结尾

  • toUpperCase()方法:将字符串变为大写

    'i love you'.toUpperCase();  //'I LOVE YOU'
    
  • toLowerCase();方法:将字符串变为小写

    'I LOVE YOU'.toLowerCase();  //'i love you'
    
  • indexOf()方法:检索字符串

    'i love you'.indexOf('l');  //2  获取第一次出现的位置,包含空格,没有就返回-1
    

数据类型的转换

其他值转数字

  • 使用Number()函数

    Number('123');   //123
    Number('123年')  //NaN
    Number('')  //0
    
    Number(true)  //1
    Number(false)  //0
    
    Number(undefined)  //NaN
    Number(null)   //0
    
  • 使用parseInt()函数 将字符串转为整数

    parseInt('3.14')    //3  parseInt()将自动截掉第一个非数字字符之后的所有字符
    parseInt('3.14是圆周率')   //3
    parseInt('圆周率是3.14')   //NaN
    parseInt('3.99')    //3  
    
  • 使用parseFloat() 将字符串转为浮点数

    parseFloat('3.14')   //3.14  
    parseFloat('3.14是圆周率')  //3.14
    parseFloat('圆周率是3.14')   //NaN
    parseFloat('3.99')   //3.99
    

其他值转字符串

  • 使用String()函数

    String(123)   //'123'
    String(123.4)  //'123.4'
    String(2e3)   //'2000'
    String(NaN)   //'NaN'
    String(Infinity)  //'Infinity'
    String(0xf)  //'15'
    
    String(true)  //'true'
    String(false)  //'false'
    
    String(unfefined)  //'undefined'
    String(null)   //'null'
    
  • 使用toString()方法

其他值转布尔值

  • 使用Boolean()函数

    Boolean(123)   //true
    Boolean(0)    //false
    Boolean(NaN)  //false
    Boolean(Infinity)  //true
    Boolean(-Infinity)  //true
    
    Boolean('')  //false
    Boolean('abc')  //true
    Boolean('false')  //true
    
    Boolean(undefined)  //false
    Boolean(null)   //false
    

算数表达式

  • IEEE754丢失精度解决办法

    image-20210915080716706

  • 加减乘除只有加不会隐式转换

    5+'5'  //55
    5-'5'  //0
    5*'5'  //25
    5/'5'  //1 
    
  • JS不像C,整数除法可以是小数,不会省去小数部分

  • 小括号对自增自减计算不影响

    		let a=4,b=5;
            let result=(a++)+(--b);
            let res=a+++--b;
            console.log(result);   //8
            console.log(res);     //8
    
  • 幂和开方

    Math.pow(2,3)    //8
    
    Math.sqrt(9)   //3
    Math(sqrt(-9))   //NaN
    
  • 向上取整和向下取整

    Math.ceil(2.4)   //3
    
    Math.floor(2.99)   //2
    
  • 相等和全等:相等比较值,全等还要比较类型

    3==3   //true
    3===3   //true
    3=='3'   //true
    3==='3'  //false
    
    1==true  //true
    1===true  //false
    
    0==false  //true
    0===false  //false
    
    0==undefined  //false
    0===undefined  //false
    
    undefined==null   //true
    undefined===null   //false
    
  • NaN不自等

    NaN==NaN  //false 
    NaN===NaN  //false
    
  • 使用isNaN()函数判断变量值是否为NaN

    isNaN(NaN)  //true
    isNaN(1)  //false
    isNaN(undefined)  //true
    isNaN('3天')  //true
    isNaN(null)  //false
    
  • 特殊值的相等关系

    null==undefined  //true
    null=0    //false
    NaN=NaN  //false
    
  • 短路计算

    • a&&b:a真,表达式值为b;a假,表达式值为a
    3&&6  //6
    undefined&&15  //undefined
    15&&undefined  //undefined
    null&&2   //null
    ''&&16   //''
    NaN&&undefined  //NaN
    
    • a||b:a真,表达式值为a;a假,表达式值为b
    3||6   //3
    0||6   //6
    null||undefined   //undefined
    'a'||'b'  //'a'
    NaN||null   //null
    

流程控制语句

  • if()语句

    if(条件表达式){
       语句块
    }
    
    • 如果条件表达式成立,则执行语句块
  • if(){}else{}

    if(条件表达式1){
        语句块1
    }else{
        语句块2
    }
    
    • 如果条件表达式成立,则执行语句块1,否则执行语句块2
  • if(){}else if(){}else if(){}else{}

    if(条件表达式1){
        语句块1
    }else if(条件表达式2){
        语句块2
    }else if(条件表达式3){
        语句块3
    }else{
        语句块4
    }
    
    • 如果表达式1成立或表达式2成立或……成立,则执行对应语句块,若都不成立,则执行else中的语句块
  • switch(){}语句

    switch(n){
        case 1:
            语句块1
            break;
        case 2:
            语句块2
            break;
        case 3:
            语句块3
            break;
        default:
            语句块4
            break;
    }
    
    • 满足case条件则执行对应语句块,若都不满足则执行default中的语句块
  • while(){}语句

    while(true){
        alert("你是猪")
    }
    while(a<5){
        alert("小于5");
        a++;
    }
    while(true){
        alter("你是猪")
        if(a>5){
            break;
        }
    }
    
    • 满足条件则一直执行下去,直到条件不满足时退出循环
  • for(){}语句

    for(let i=0;i<5;i++){
        console.log(i);
    }
    
    • 条件由三个表达式组成,第一个是初始变量值,第二个是满足该条件的情况下执行语句块,不满足直接退出玄幻,第三个是每次执行换循环语句块,自变量的变化
  • do{}while()语句

    do{
        我先执行一次,你再判断
    }while(a>5)
    
    • 先自己执行一次,再判断条件表达式是否成立,如果不成立则不再执行;若成立继续执行
  • 随机函数

    • 得到[a,b]区间的整数,公式

      parseInt(Math.random()*(b-a+1))+a;
      

数组

  • 数组的定义

    var arr=['a','b','c','d'];
    var arr=('a','b','c','d');
    var arr=new Array(4)  //四项都是undefined
    
  • 数组的更改

    var arr=['2','6','7','3'];
    arr[1]++;
    console.log(arr)  //[2,7,0,3]
    
    • 更改的数组项超过了length-1,则会创建这项

    image-20210915142900769

  • 数组类型的检测

    • Array.isArray()方法检测数组

      var arr=['a','b','c','d'];
      Array.isArray(arr)   //true
      
  • 数组的头尾操作

    • push()在尾部插入新项

      var arr=['a','b','c','d'];
      arr.push('e')    
      console.log(arr)  //a,b,c,d,e
      

      插入成功返回数组长度

    • pop()在尾部删除

      var arr=['a','b','c','d'];
      arr.pop()    
      console.log(arr)  //a,b,c
      

      删除成功返回被删除的元素

    • unshift()在头部插入新项

      var arr=['a','b','c','d'];
      arr.unshift('e');   
      console.log(arr)  //e,a,b,c,d
      

      插入返回数组长度

    • shift()在头部删除

      var arr=['a','b','c','d'];
      arr.shift();   
      console.log(arr)  //b,c,d
      

      删除成功返回被删除的元素

  • 使用头尾操作实现栈

    const stack=[];
    //入栈
    stack.push();
    //出栈
    stack.pop();
    
  • splice()替换数组中的指定项

    var arr=['a','b','c','d','e','f','g'];
    arr.splice(3,2,'x','y','z');
    console.log(arr);  //a,b,c,x,y,z,f,g
    
    var arr=['a','b','c','d','e','f','g'];
    arr.splice(3,0,'x','y','z');
    console.log(arr); //a,b,c,x,y,z,d,e,f,g
    
    var arr=['a','b','c','d','e','f','g'];
    arr.splice(3,2);
    console.log(arr);  //a,b,c,f
    
    • 在下标为3的位置替换该下标和后面的一项,变为三项x,y,z
    • 如果第二个参数为0,则是从下标为a的地方开始插入,以前下标为a的项往后移
    • 没有设置新项,则删除3及之后的包括两项,如果不加第二个参数,则从a开始删除到数组结束
    • 以数组形式返回被删除的项
  • slice()得到子数组

    • slice(a,b)截取从a开始,到b的结束(不包括b)的项
    • 不提供第二个参数,默认截取所有后续项作为子数组
    • 允许负数,表示倒数第几项
    • 不会改变原有数组
    • 其他功能和字符串的slice()方法一样
    var arr=['a','b','c','d','e','f','g'];
    console.log(arr.slice(3));   //d,e,f,g
    console.log(arr);   //a,b,c,d,e,f,g
    console.log(arr.slice(3,5)) //d,e
    
  • concat()方法合并连结多个数组

    concat不会改变原数组

    var arr1=[1,2,3,4];
    var arr2=[5,6,7,8];
    var arr3=[9,10];
    var arr=arr1.concat(arr2);
    console.log(arr);  
    /*
    0: 1
    1: 2
    2: 3
    3: 4
    4: 5
    5: 6
    6: 7
    
    */
    arr=arr1.concat(arr2,arr3);
    console.log(arr);
    /*
    0: 1
    1: 2
    2: 3
    3: 4
    4: 5
    5: 6
    6: 7
    7: 8
    8: 9
    9: 10
    */
    
  • reverse()方法将数组项置反

    var arr=['a','b','c','d'];
    arr.reverse();
    console.log(arr);  
    /*
    0: "d"
    1: "c"
    2: "b"
    3: "a"
    */
    
  • indexOf()方法搜索数组中的元素

    返回所属下标位置,不在则返回-1

    var arr=['a','b','c','d'];
    console.log(arr.indexOf('b'));  //1
    
  • includes()方法判断一个数组是否包含一个指定的值,返回布尔值

    var arr=['a','b','c','d'];
    console.log(arr.includes('c'))  //true
    

数组和字符串相互转换

  • join()使数组转为字符串

     var arr=['a','b','c','d','e','f','g'];
    var str1=arr.join(' ');
    var str2=arr.join();
    console.log(arr);
    console.log(str1);
    console.log(str2);
    
    
    
    • join()参数表示以什么字符作为连接符,留空默认逗号,如同调用toString()方法
  • split()使字符串转为数组

    var str1="竹杖芒鞋轻胜马,一蓑烟雨任平生";
    var arr=str1.split(',');
    console.log(arr);  
    
    • split()参数表示以什么字符拆分字符串,一般不能留空

数组去重

var arr=[1,1,1,4,4,2,1,3,3];
var res=[];
for(let i=0;i<arr.length;i++){
    if(!res.includes(arr[i])){
       res.push(arr[i]);
    }
}
console.log(res);