升阶之JS在线

数据类型

typeof输出值

• string number object boolean undefined function
  不可能是null

function fn(){}
alert(typeof fn)  //function

\ 转义

alert("hello 'wally'")
alert('hello \'wally\'')
console.log('hello \n world!')
console.log('hello \r world!')
console.log('hello\\world')
console.log('hello \" world')
console.log('hello ' + 'world string number \object boolean  null undefined  function')

toString()

• 转换成string类型，参数可以添加进制

var num = 10
var bool = true
console.log(typeof num.toString())
console.log(num.toString(2)) // 2进制 1010
console.log(num.toString(8)) // 12
console.log(num.toString(16)) // a
console.log(bool.toString())  // 'true'

Number

• NaN
  
  • NaN: not a number 不是一个数字, 但是是number类型

console.log(undefined + 23)     //NaN
console.log(typeof NaN)     //number

• 跟谁都不相等 包括自己也不相等

console.log(123 == 123)     //true
console.log(NaN == NaN)     //false

• isNaN() 方法 检测参数值 是否是 NaN

console.log(isNaN(undefined + 23))     //true
console.log(isNaN(23))     //false

• 科学计数

console.log(3.1e10)     //31000000000
console.log(3e-2)     //0.03

• Infinity

console.log(3.1e100000)     //Infinity 超出范围 无限大
console.log(-3.1e100000)     //-Infinity 超出范围 无限小
//是否在范围中，在 true，不在 false
console.log(isFinite(3.1e10000))  //false
console.log(idFinite(3.1e2))     //true

• Number()
  
  • 将参数转换成number类型， 可以转换任意类型

console.log(typeof Number('123'))     //number
console.log(Number(true))     //1
console.log(Number(false))     //0
console.log(Number('false'))     //NaN
console.log(Number(''))     //0
console.log(Number(undefined))     //NaN
console.log(Number(null))     //0

console.log(Number('08.970'))     //8.97

• parseInt(),parseFloat()
  
  • parseInt() 转换成整型
  • parseFloat() 转换成浮点型

console.log(parseInt('123.056'))     //123
console.log(parseFloat('123.23'))    //123.23
console.log(parseInt(true))     //NaN

• 精度问题与toFixed()
  
  • 浮点数运算可能会有精度问题
  • toFixed() 参数 保留几位小数

console.log(0.1 + 0.2)    //0.300000000000000004
console.log((0.1 + 0.2).toFixed(2))     //0.30

• Boolean
  
  • Boolean() 将参数转换成 布尔值
    
    • 字符串 -> 布尔型
      
      • 空字符串 -> false
    • 数字 -> 布尔
      
      • 0,NaN -> false
        
        • undefined -> false
        • null -> false

var a;  // undefined
console.log(Boolean(123))    // true 
console.log(Boolean('123'))  // true   
console.log(Boolean(3e10000)) // true    
console.log(Boolean([]))     // true     
console.log(Boolean([1,2,3])) // true    
console.log(Boolean({}))     // true   
console.log(Boolean({name: 'wally'}))  // true  
console.log(Boolean(''))     // false
console.log(Boolean(a))      // false
console.log(Boolean(0))      // false
console.log(Boolean(NaN))    // false   
console.log(Boolean(null))   // false

• Object
  
  • 数组(列表) Array
  • 对象(字典) Object
  • 由一组或多组键值对组成，键值对用：链接，每一组值之间用,分割
  • 获取键对应的值： 对象.键名 或 对象:[‘键名’]
  • 键名一般使用字符串，键值可以是任意数据类型

var obj = {
      name: 'wally',
      age: 17,
      sex: 'man',
      favs: ['篮球', '足球', '排球'],
      lesson: {
        id: 123,
        name: 'web'
      },
      run: function () {
        alert('running')
      }
    }
    console.log(obj.name) // wally
    console.log(obj.favs) // ["篮球", "足球", "排球"]
    for(var i=0;i<obj.favs.length;i++){
      console.log(obj.favs[i])
    }
    console.log(obj.lesson.id) // 123
    obj.run()

• Array
  
  • 数组
  • length属性： 数组包含元素的个数
  • 索引（下标）： 数组[索引] 获取对应位置的元素 索引从0开始

var arr = ['123', 250, true, ['wally', 'age', 17]]
    console.log(arr[0])      // 123
    console.log(arr[3])      // ["wally", "age", 17]
    console.log(arr[3][0])   // wally
    console.log(arr.length)  // 4 

    for(var i=0;i<arr.length;i++){
      console.log(arr[i])
    }

    // 只有一个参数的时候  参数指的是 length
    var arr1 = new Array(4)
    console.log(arr1)

    // 多个值的时候  参数就是数组中的每个元素
    var arr2 = new Array(1,2,3,4) // [1, 2, 3, 4]
    console.log(arr2)

    console.log(typeof arr)  // object

运算符

• 一元运算符
  
  • 只能操作一个值得运算符叫做一元运算符
  • 在没有赋值操作，前置和后置是一样的。
  • 有赋值的情况下：
    
    • 符号前置：先运算后赋值

var a = 3
var b = a++  // a++  => a = a+1
alert(b)  // 3 
alert(a)  // 4
如果将上边的 ++a 改成 a++ ，输出结果为 b=3  a=4
如果将上边的 ++a 改成 a-- , 输出结果为 b=3  a=2
如果将上边的 ++a 改成 --a , 输出结果为 b=2  a=2

var a = 3
alert(a--) //3
alert(a)   //2
如果将上边的 a-- 改成 --a ，结果为 先输出 2，后输出 2
如果将上边的 a-- 改成 a++ , 结果为 先输出 3，后输出 4
如果将上边的 a-- 改成 ++a , 结果为 先输出 4，后输出 4

• 算术运算符
  
  • 加法： 数字 + 字符串 ==> 字符串拼接 数字会先转换成字符串 然后拼接
  • 减法： 减法运算时 字符串会被转唤成数字， 然后再运算
  • 乘法： 乘法运算时 字符串会被转唤成数字， 然后再运算
  • 除法： 除法运算时 字符串会被转唤成数字， 然后再运算
  • 取模： 除不动的情况，就是前面这个数

alert('3' - '1.5')    //1.5
alert(3 - 2)    //1
alert('123' + 20)    //12320
alert('123' - 0 + 20)    //143

alert('3' * '2')     //6
alerrt(1 / 3)     //0.333333333333
alert('3' /2)     //1.5
alert('30' / '10')     //3

alert(9 % 4)     //1
alert(3 % 3)     //0
alert(1 % 3)     //1
alert(7 % 9)     //7

• 关系运算符
  
  • >
  • <
  • >=
  • <=
  • == 值一样即可 数据类型不需要统一
  • === 全等 数据及值都必须一样
  • != 不等于 对应于==
  • !== 不全等 对应于===

alert(2>=2) // true
alert(3>2)  // true

alert(2 == 2)  // true
alert(2===2)   // true

// === 全等 数据及值都必须一样
alert('2' == 2)   // true
alert('2' === 2)  // false

alert( 3 != 2)  // true
alert('2' != 2) // false
alert('2' !== 2) // true 

• 逻辑运算符
  
  • && 与： 全真才真,有假则假
  • || 或： 有真则真,全假才假
  • ! 非： 取反

alert(3>2||3>4)    //true

alert(!false)   //true
alert(!(3 > 2))  //false

• 赋值运算符
  
  • =
  • +=
  • -=
  • *=
  • /=
  • %=

var a = 'abc'
a += 'def'
alert(a)  //abcdef

var a = 20
a *= 3
alert(a)   //60
如果将 *= 改成 /=，则输出结果为 6.66666666666667
如果将 *= 改成 %=，则输出结果为 2

• 三目运算符

// 条件 ? 条件是true走这儿 : 否则走这儿
3>2 ? alert('3>2') : alert('3不大于2')