JS Day2

其他类型转换转换为数值类型：

        1.Number（） 方法

                语法：Number(x)

                作用：将x转为数值类型

                返回值（结果）：转换后的值

                转换规则：把x当做一个整体来转换的

        2.parseInt（）方法

                parseInt（x）

                作用：将x转为数值类型，只保留整数部分

                返回值（结果）：转换后的值

                转换规则：从左到右一个一个进行转换

                                  第一个就转换不了，返回NaN

                                  将转换成功的保留

        3.parseFloat（）方法

                parseFloat（x）

                作用：将x转为数值类型，可以保留小数部分

                返回值（结果）：转换后的值

                转换规则：从左到右一个一个进行转换

                                 第一个转换不了，返回NaN

                                 将转换成功的保留

var x = "100px"
console.log(Number(x));;//NaN
console.log(parseInt(x));;//100



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

        4.隐式转换

         +(正号)

         -        

         *        

         /

        %

// 隐式转换  +(正号) - * / %

var a = "10";
console.log(typeof(a));
console.log(typeof(a-0));//隐式转换
console.log(typeof(a*1));//隐式转换
console.log(typeof(a/1));//隐式转换
console.log(typeof(a%11));//隐式转换

console.log(typeof(a+0));//这个不行
console.log(typeof(+a));//正号,可以转为数值类型

布尔转数值类型：

        Number（）可以将布尔转为数值 

        ture 是 1

        false 是 0

        parseInt()/parseFloat不可以将布尔转为数值

其他类型转为字符串

        1.String（）

                语法：String（x）

                作用：转为字符串类型，所有数值类型都可以

                返回值（结果）字符串类型的值

        2.toString（）

                语法：x.toString（）

                作用：转为字符串类型，有些数据类型不能使用 toString（）方法，比如undefined和null

                返回值（结果）：字符串类型的值

        3.隐式转换：           

                +（拼接） 10+""---》将数值10转成字符串

                    String(10)

                    10.toString()

                    区别：String()可以将任意其他类型转为成字符串类型

                               toString()不能将null和undefined转为字符串，其他的都可以转

    var num = 1;//数值类型
    console.log(typeof String(num)); //string
    console.log(typeof num.toString());//string

    var n = true;//布尔类型
    console.log(n);
    console.log(typeof String(n));//string
    console.log(typeof n.toString());//string

    var x;//未定义类型
    console.log(typeof String(x));//string
    // console.log(x.toString());

    var nl = null;

    console.log(typeof String(nl));//string
    // console.log(nl.toString());

    var y = 10;
    console.log(typeof(y+""));//字符串类型的10

 转为布尔类型

        Boolean()

        使用：Boolean（x）

        作用：转布尔类型的

        返回值（结果）：ture或者false

        规则：只能将null，undefined，' '，0 ,NaN 转为false。其他全都是ture

    console.log(Boolean(10));   
    console.log(Boolean("10"));
    console.log(Boolean("hahah"));
    console.log(Boolean(undefined));
    console.log(Boolean(null));
    console.log(Boolean(0));
    console.log(Boolean(''));
    console.log(Boolean(NaN));

 检测是否为非数字：isNaN（）

        语法：isNaN（x）

        作用：检测x是否是非数字，是 非数字结果就是 ture

                                                     不是 非数字 结果就是 false

                （是数字返回false，不是数字返回true）

       

        举例：isNaN("abc")--》true  isNaN(10)--->false

                     返回结果：true或者false

       注意点：isNaN(x)等价于isNaN(Number(x))

                     isNaN(true)等价于  isNaN(Number(true))

 console.log(isNaN(100));//false
 console.log(isNaN('100'));//false
 console.log(isNaN("px100"));//true
 console.log(isNaN(true));//false

运算符之算术运算符

    /* 
     +   3+2=5
     -   3-2=1
     *   3*2=6
     /   3/2=1.5
     %   3%2=1
    */

    console.log(10%3);
    console.log(10%11);//分子小于分母，结果就是分子
    console.log(5%9);
    console.log(5%3);//2

运算符之赋值运算符

    /* 
      1、 = ： 赋值 
       var a;
       a = 10;10赋值给a，a中存储的就是10
      2、+=：
       a+=20;等价于a = a+20; 将左边和右边求和，重新赋值给a
      
     3、-=
       a-=20;等价于a = a-20; 将左边和右边求差，重新赋值给a
     4、*=
       a*=20;等价于a = a*20; 将左边和右边求积，重新赋值给a

    5、/=
       a/=20;等价于a = a/20; 将左边和右边求商，重新赋值给a

    
    6、%=
      a%=20;等价于a = a%20; 将左边和右边求余数，重新赋值给a
    
    */
    var a = 10
    a += 20;//a=a+20;//a=10+20
    console.log(a);//30

    a -= 20;// a= a-20
    console.log(a);//10


    a *= 20;//a=a*20
    console.log(a);//200

    a /= 20;//a=a/20
    console.log(a);//10

    a %= 3;//a=a%3;
    console.log(a);

运算符之逻辑运算符

      &&  且，并且

        使用：布尔类型值&&布尔类型值

        特点：一假即假

      ||  或，或者

         使用：布尔类型值||布尔类型值

         特点：一真即真

      !   取反

          使用  !布尔类型值

          特点：颠倒真假

    console.log(false&&false);
    console.log(false&&true);
    console.log(true&&true);


    console.log(3>2&&6===9);//false
    console.log(3>2||6===9);//true


    console.log(false||false);//false
    console.log(false||true);//true
    console.log(true||true);//true


    console.log(!false);//true
    console.log(!true);//false
    console.log(!!true);//true

运算符之比较运算符

    比较运算符（关系运算符）：比较出来的结果是一个布尔类型的值

     >

     <

     >=

     <=

     ==（不严格等号）：只比较符号左右的数值，不比较他们的类型

     ===（严格等号）： 即比较符号左右的数值，又比较他们的类型

     !=  （不等于）

     注意：除了===,其他的都会进行隐式转换

   console.log(3>2);//true
   console.log(3==2);//false
   console.log(3>=3);//true
   console.log(3=="3");
   console.log(3==="3");


   console.log("3">=2);//它会进行隐式转换，将字符串3转为数字3

运算符值自加自减运算符

    符号：++（自加） -- （自减）

    使用：a++（后置自加）、++a（前置自加）

    区别：1、单独使用时，没有区别都是自身加1

    var x = 1;
    // x++;
    ++x;
    console.log(x);//2

               2、在参与运算，输出，赋值等操作的时候，++a，先加1，再操作（运算，输出，赋值）

                                                                                     a++，先操作（运算，输出，赋值），后加1

    // 参与输出时。a++先输出变量，再加1
    // var a = 10;
    // console.log(a++);//10   11
    // console.log(a);



    // var a = 10;
    // console.log(++a); //11
    // console.log(a);//11




    // var x = 10;
    // var y = x++; // 参与赋值运算，先赋值，先把x赋值给y
    // console.log(y);//11


    var x = 10;
    var k = x++ + ++x;//参与运算时,先运算，后自加
    //  10  + 12


    console.log(k);
    // 分析：代码的执行时从上向下，从左向右

if语句

        语法1： if（关系表达式）{ }

                        关系表达式：能够计算出一个镇或者加的表达式

       执行流程：当关系表达式为true，就执行{}内部的代码

                         当关系表达式为false，就不执行{}内部的代码

        语法2： if（）{}else{}

        执行流程：当关系表达式为true，就执行if后{}内部的代码

                          当关系表达式为false，就执行else后{}内部的代码

        语法3： if（true）{}else if（）{}else if（）{}..else

        执行流程：从上向下进行条件的判断，满足那个条件执行对应的代码，后面代码就不会执行了

    //    if (true) {
    //        console.log('今天天气还不错...');
    //    }

    // if (3<2) {
    //     console.log('今天天气还不错...');
    // }
    // console.log('--over--');



    // var x = 1;
    // if (x > 4) {
    //     console.log("我是大于4的");
    // } else {
    //     console.log('我是小于等于4的');
    // }



    // 注意：只要是输入框输出来的，都是字符串类型，所以需要进行隐式转换
    // var x = +prompt('请输入...');//prompt('请输入...')是一个输入框，输入的值存储到x变量中
    // var x = prompt('请输入...') - 0;//prompt('请输入...')是一个输入框，输入的值存储到x变量中

    // console.log(typeof x);  
    // if (x > 4) {
    //     console.log("我是大于4的");
    // } else {
    //     console.log('我是小于等于4的');
    // }




    // if(true){}else if(){}else if(){}..else{}

    // var x = +prompt('请输入..')
    // if (x==1) {
    //       console.log('1');
    // } else if (x==2) {
    //       console.log('2');
    // } else if (x==3) {
    //        console.log('3');
    // } else {
    //      console.log('不是1,2,3');
    // }

通过多分支，判断一个人成绩，在A，B，C，D

    var x = +prompt('请输入您的战绩...');
    if (x >= 90&&x<=100) {
        alert('真棒，优秀，漂亮')
    }
    else if (x >= 80) {
        //    只要代码能走到这儿，说明x是小于90的
        alert('良好,能行,还阔以...')
    }
    else if (x >= 60) {
        alert('就这，还得加油...')
    }
    else if (x >= 0) {
        alert('末班吧....种地吧，喂猪吧...')
    }else{
        alert('输入的成绩有误...')
    }

双分支案例演示

    // var x = prompt('请输入您想输入的数字...');

    // // 奇数：1 3 5 7   对2取余数，得到的是1
    // // 偶数：2 4 6 8

    // if (x%2==0) {
    //     alert('双的，偶数')
    // }else{
    //     alert('单的，奇数')
    // }

闰年

    // 闰年（1年366天，闰年在2月份的时，是29天）: 能被4整除且不能被100整除，或者能被400整除
    // 平年（1年365天，闰年在2月份的时，是28天）:


    // var x = prompt('输入年份...')
    // if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0) {
    //     alert('是闰年')
    // } else {
    //     alert('是平年')
    // }

 三元运算符

        写法： 条件表达式?表达式1:表达式2

        运行流程：条件表达式为true，走表达式1，为false，走表达式2

        奇数和偶数的判断

var x = prompt('请输入数字...')

    var res = x % 2 == 0 ? "是偶数" : '是奇数';//把运算的结果存储到res变量中

    console.log(res);