JavaScript第二天

一、数据类型

字符串string

数值型number

布尔型boolean

undefined

unll

object

 

2.类型转换

(1)隐式类型转换

("50"-"30")

自动将数据类型转换成另一种数据类型的过程叫隐式类型转换

(2)显示类型转换(强制类型转换)

显示类型转换需要手动转换到类型

将其他的数据类型转换成数值型

        v1=081       //如超出八进制按十进制输出
        console.log(v1)

        v2=20e500     //infinity   正无穷大
        console.log(v2)

        v3=-20e500     //-infinity   负无穷大
        console.log(v3)

        // js 整型最大表示范围   2^53-----2^-53

        var v1=prompt("请输入：")
        // 输入年龄，判断中年、老年、青年
        console.log(typeof(v1))
        console.log("50"-"30")
        console.log("50"+"30")
        console.log(Number("50")+Number("30"))

Number()

        Number("12.34")   //12.34

        Number("true")   //1

        Number("false")    //0

        Number("")       //0

        Number(null)         //0

        Number(undefined)     //nan

        Number(NaN)           //nan

        console.log(Number(12))   //12
        console.log(Number("12"))   //23
        console.log(Number("hello")) //nan
        console.log(Number("23aa"))  //nan
        console.log(Number("true"))   //1
        console.log(Number("false"))    //0
        console.log(Number(""))       //0
        console.log(Number(0x56))      //86
        console.log(Number("0x56"))    
        console.log(Number(023))       //19
        console.log(Number("023"))      //23
        console.log(Number(00023))      //19
        console.log(Number("00023"))    //23
        console.log(Number("30e5"))      //300000
        console.log(Number(null))         //0
        console.log(Number(undefined))     //nan
        console.log(Number(NaN))           //nan

parseInt()

        parseInt(12)    //12

        parseInt(12.34)  //0

        parseInt(true)   //nan

        parseInt(false)  //nan

        parseInt("")    //nan

        parseInt("30e5")   //30

        parseInt(25,16)    //37

        parseInt(25,8)      //21

        parseInt(1001,2)    //9

        parseInt(25,10)     //25

        console.log(parseInt(12))
        console.log(parseInt(12.34))
        console.log(parseInt(0.12))
        console.log(parseInt("23"))
        console.log(parseInt("hello"))
        console.log(parseInt("23aa"))
        console.log(parseInt(true))   //nan
        console.log(parseInt(false))  //nan
        console.log(parseInt(""))     //nan
        console.log(parseInt(0x56))     //86
        console.log(parseInt("0x56"))  //86
        console.log(parseInt(023))      //19
        console.log(parseInt("023"))    //23
        console.log(parseInt(00023))    //19
        console.log(parseInt("00023"))   //23

        console.log(parseInt("30e5"))   //30

parseFlot()

        parseFloat("23.34")   //23.34

        parseFloat("23.45.78") //23.45

        console.log(parseFloat("23.34"))   //23.34
        console.log(parseFloat("23.45.78")) //23.45

NaN : not a Number   非数值

表示一个本来要返回数值的操作数，而没有返回数值的情况

NaN不等于任何数值

 

3.进制转换

(1)其他进制转换为10进制

parseInt(25,16)

parseInt(25,8)

parseInt(25,10)

parseInt(101,2)

        console.log(parseInt(25,16))    //37
        console.log(parseInt(25,8))      //21
        console.log(parseInt(1001,2))    //9
        console.log(parseInt(25,10))     //25

(2)十进制转换为其他进制

v1=23

v1.toString(16)

v1.toString(8)

v1.toString(2)

v1.toString(10)

        var v1=23
        console.log(v1.toString(16))
        console.log(v1.toString(8))
        console.log(v1.toString(2))
        console.log(v1.toString(10))

 

4.常用方法

isNaN()  判断是否为非数值

isFinite()  判断是否是正负无穷

isFinite(200e500)   //flase

isFinite(200e5)     //ture

        console.log(isFinite(200e500))  //flase
        console.log(isFinite(200e5))    //ture


        console.log(isNaN("hello"))  //T
        console.log(isNaN(true))     //F
        console.log(isNaN(false))     //F
        console.log(isNaN("10"))      //F

任何涉及nan的操作,都返回NaN

        isNaN(NaN/8)

        isNaN(NaN+8)

        isNaN(NaN-8)

        isNaN(NaN*8)

NaN与任何值都不相等，包括他本身

        isNaN(NaN==NaN)   //flase

        //任何涉及nan的操作，都返回nan
        console.log(isNaN(NaN/8))   //NaN
        console.log(isNaN(NaN+8))
        console.log(isNaN(NaN-8))
        console.log(isNaN(NaN*8))

        //nan与任何值都不相等，包括他本身
        console.log(isNaN(NaN==NaN))  //f
        console.log(isNaN(0/0))     //nan

5.常见面试题

null*5             隐式转换把null转换为0

NaN*3              NaN

undefined*5        NaN 隐式转换把undefined转换为NaN

"hello"*5          NaN

"23"+5             235

"23"*5             115

"23"*1+5            28

        console.log(null*5)
        console.log(null*5)
        console.log(NaN*3)
        console.log(undefined*5)
        console.log("hello"*5)
        console.log("23"+5)
        console.log("23"*5)

6.布尔值

     true   false  小写

   if(10>0){

   }else{}

   if((10>5)==true){}

   等价于

   if(10>5){}

   if(!10>5){}

    类型转换

    Boolean()

    Boolean(23)

    Boolean(0)

    Boolean("hello")

    Boolean("")

    Boolean(null)

    Boolean(undefined)

	true	false
数值型	非空	0
字符型	非空串	""
undefined	false
null	false
object	任意对象返回的都是true

7.undefined类型

(1)变量只声明，未赋值

var a

typeof(a)      undefined

alert(a)       undefined

        var a
        if(undefined==undefined){
            alert("y")
        }else{
            alert("n")
        }

        console.log(undefined==undefined)
        console.log(undefined===undefined)

(2)函数没有返回值默认 undefined

function f1(){

            alert("hello")

        }

        var r=f1()

        console.log(r)

(3)调用函数时，应该提供参数，但没有提供，该参数返回 undefined

function f1(a,b){

            alert(a)

            alert(b)    undefined

        }

        f1(3)

 

8.null 空类型

        var a=null

        console.log(typeof(a))    //object   null是一种特殊的object

        var b={}

        b.a=23

        b.f1=function(){}

        b=null

        if(b==null){}

 

9.object对象类型

对象就是一定属性和方法的封装体，通过对象能够引用到这些方法和属性

 

10.***typeof***

(1)数值类型,typeof返回number

        typeof(1)       //number

        typeof(NaN)     //number

        typeof(Number.MAX_VALUE)      //number

        typeof(Number.MIN_VALUE)      //number

        typeof(Infinity)       //number

(2)字符串类型,typeof返回string

        typeof("123")      //String

(3)布尔类型,typeof返回boolean

        typeof(true)       //Boolean

(4)对象、数组、null,typeof返回object

        typeof(window)     //Object

        typeof(document)   //Object

        typeof(null)       //Object

        typeof(Math)       //Object

        typeof([])         //Object

(5)函数类型,typeof返回function

        function f1(){}

        typeof(f1)

        typeof(date)

        typeof(eval)

(6)未定义的变量或undefined返回undefined

        console.log(typeof(c))          //undefined

        console.log(typeof(undefined))  //undefined

        console.log(typeof(1))       //number
        console.log(typeof(NaN))     //number
        console.log(typeof(Number.MAX_VALUE))      //number
        console.log(typeof(Number.MIN_VALUE))      //number
        console.log(typeof(Infinity))       //number
        console.log(typeof("123"))      //String
        console.log(typeof(true))       //Boolean
        console.log(typeof(window))     //Object
        console.log(typeof(document))   //Object
        console.log(typeof(null))       //Object
        console.log(typeof(Math))       //Object
        console.log(typeof([]))         //Object
        console.log(typeof(Date))       //function
        console.log(typeof(c))          //undefined
        console.log(typeof(undefined))  //undefined

 

二、流程控制语句

1.if(){

}

else if{

}

else if{

}else{

}

2.switch(){

        case:语句体;break:

        case:语句体;break:

        case:语句体;break:

        default  语句体

}

        var a=3

        switch(a){

            case 1:console.log("a1");

            case 2:console.log("a2");

            case 3:console.log("a3");

            case 4:console.log("a4");

            default:console.log("a5");

        }

        var a=4

        switch(a){

            case 1:

            case 2:

            case 3:console.log("a3");break;

            case 4:

            case 5:console.log("a5");

            default:console.log("a6");

        }

3.for(var i=0;i<5;i++){

        语句体

}

//for in / for each

4.while循环

5.do while循环 至少循环一次

6.break      立即跳出循环

  continue   停止当前循环，进入下一次循环