前端数据类型总结

    {
      function aa() {
        var a = b = c = 123    // b，c 变为全局变量
        console.log(a, b, c)   // 123, 123, 123
      }
      aa()
      console.log(a, b, c)     // undefined, 123, 123 
    }


 {
    var a = '100'
    var b = ''
    var c = 0
    var d = "0" //字符串为真
    var e = null
    var f = undefined
    var g = 100
    var h = NaN
    if (a) {
      console.log('"100"', 'ture')
    } else {
      console.log('"100"', 'false')
    }
    if (b) {
      console.log('空', 'ture')
    } else {
      console.log('空', 'false')
    }
    if (c) {
      console.log('0', 'ture')
    } else {
      console.log('0', 'false')
    }
    if (d) {
      console.log('"0"', 'ture')
    } else {
      console.log('"0"', 'false')
    }
    if (e) {
      console.log('null', 'ture')
    } else {
      console.log('null', 'false')
    }
    if (f) {
      console.log('undefined', 'ture')
    } else {
      console.log('undefined', 'false')
    }
    if (g) {
      console.log('100', 'ture')
    } else {
      console.log('100', 'false')
    }
    if (h) {
      console.log('NaN', true)
    } else {
      console.log('NaN', false)
    }
}


    {
      console.log(isNaN(123))           // false
      console.log(isNaN(-1.23))         // false
      console.log(isNaN(5 -2))          // false
      console.log(isNaN(0))             // false
      console.log(isNaN('limingyang'))  // true
      console.log(isNaN('222'))         // false
      console.log(isNaN('222/222/222')) // true
      console.log(typeof NaN)           // 'number'
      console.log(parseInt('aaaa'))     // NaN
      console.log(parseFloat('aaaa'))   // NaN
    }


    {
      var a = 100
      console.log(!!a)  // true


      console.log(10 && 0) //0
      console.log('' || 'abc')  // abc
      console.log(window.abc)   //undefined
      console.log(!window.abc) //true


      console.log(null)
      console.log(undefined)
      console.log(!null)      // true
      console.log(!undefined) // true


      console.log(!null === !undefined)  // true
      console.log(null == undefined)     // true
      console.log(undefined == '')       // false


    }


    {
      let num = 123
      let num1 = '123'
      console.log(num != num1)
      console.log(num !== num1)
    }


    {
      let obj = {
        b: 100
      }


      console.log(obj.a == null)   // ture   等价于obj.a === null || obj.a === undefined   Jquery源码推荐写法
    }


    {
      // 内置函数
      console.log(Object, Array, Boolean, Number, String, Function, Date, RegExp, Error)
      // 内置对象
      console.log(Math, JSON)


    }


    {
      // 数组判断
      console.log([], ![], [] == ![], [] == false, ![] == false, [] == null)
    }


    {
      // 对象判断
      let obj = new Object()
      let obj1 = new Object()
      console.log(obj == obj1) // false
    }


    {
      console.log('2222222222')
      console.log(Number(undefined)) // NaN
      console.log(Number(null))      //  0
      console.log(Number('abc'))     // NaN
      console.log(Number('123'))     // 123
    }


   {
      // toString
      let num = 123
      console.log(num.toString() + 11)  // "123" + 11  => "12311"


      let a1 = true
      console.log(a1.toString() + "this is true")


      console.log(a2.toString())
    }


    {
      // Array：返回数组对象本身
      var array = ["CodePlayer", true, 12, -5];
      document.writeln( array.valueOf() === array ); // true
      
      // Date：当前时间距1970年1月1日午夜的毫秒数
      var date = new Date(2013, 7, 18, 23, 11, 59, 230);
      document.writeln( date.valueOf() ); // 1376838719230
      
      // Number：返回数字值
      var num =  15.26540;
      document.writeln( num.valueOf() ); // 15.2654
      
      // 布尔：返回布尔值true或false
      var bool = true;
      document.writeln( bool.valueOf() === bool ); // true
      // new一个Boolean对象
      var newBool = new Boolean(true);
      // valueOf()返回的是true，两者的值相等
      document.writeln( newBool.valueOf() == newBool ); // true
      // 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型
      document.writeln( newBool.valueOf() === newBool ); // false
    }


    {
      let str = '123456789'
      console.log(typeof(str))  
      console.log(str.length)   
      console.log(str.indexOf('4'))  // 3 str.indexOf('4', 2) 从第二位开始查找
      console.log(str.charAt(3))     // 4


      let str1 = 'abcdefgh'
      console.log(str1.charAt(0))    //
      console.log(str1.charCodeAt(0), str1.charCodeAt(1), str1.charCodeAt(2)) // 97 98 99


      // 数字排序
      function charAtSort (a, b) {
        return a - b
      }


      // 字母排序
      function charCodeAtSort(a, b) {
        return a.charCodeAt(0) - b.charCodeAt(0)
      }


      let arr = [3, 4, 6, 2, 6, 2, 4, 1, 6]
      console.log(arr.sort(charAtSort))


      let arr1 = ['q','w','e','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l','z','x','c','v','b','n','m']
      console.log(arr1.sort(charCodeAtSort))
    }


     {
      let str = 'abcdef'
      let str1 = 'ghijklmn'
      console.log(str.split('c'))        // ['ab', 'def']  第二个参数为分割次数
      let strx = 'abcd'
      let arrx = ['a', 'b', 'c', 'd']
      console.log(arrx.slice(1, 3))  // ['b', 'c']
      console.log(strx.slice(1, 3))  // 'bc'
      //slice 即可用于数组，又可用于字符串
      console.log(str.slice(2) + 3)      // "cdef" + 3 => "cdef3" 
      console.log(str.slice(2, 4))       // "cd" 
      console.log(str.substring(2))      // "cdef"
      console.log(str.substring(2, 4))   // "cd"
      console.log(str.substr(2))         // "cdef"
      console.log(str.substr(0, 2))      // "ab" 第二位为截取长度


      console.log(str.slice(-3))         // "def"  slice 从-3开始截取后面的元素
      console.log(str.slice(3, -1))      // "de"   slice 从3开始，末位从后开始计算
      console.log((str.slice(3, -3)) === '')   // 当从尾计算到首位前面时，结果为空字符串，type仍为string


      console.log(str.substring(-3))      // "abcdef" 将负数转换为0
      console.log(str.substring(3, -1))   // "abc" subtring会自动转换两个参数的大小位置，改为(-1, 3) 即 （0, 3）


      console.log(str.substr(-3))         // "def" 与slice相似
      console.log(str.substr(-3, -1) === '')   // 当第二个参数为负数，结果为空字符串，type为string


      console.log(str.toUpperCase())      //大写
      console.log(str.toLowerCase())      //小写


      console.log(str.split('').join('-'))  // 'a-b-c-d-e-f'
      let arr = ['abc', 'def', 'ghi', 'jkl']
      let arr1 = [123, 456, 789, 0]
      console.log(arr.join(''))            //  连接数组中的元素
      console.log(arr1.join('') === arr1.join('').toString())  // '1234567890'
      console.log(arr.reverse())           // 数组元素反排序
      console.log(arr.concat(arr1))        //concat用于连接数组
      console.log(arr.slice())


      let arr = [1,2,3,4,5,6,7]
      console.log(arr.splice(2, 2))  // [3, 4]
      console.log(arr)               // [1, 2, 5, 6, 7]
      console.log(arr.splice(2, 2, 'ddd'))    // [5, 6]
      console.log(arr)              // [1, 2, 'ddd', 7]
      console.log(arr.splice(-1, 1, 'a'))     // [7]
      console.log(arr)                 // [1, 2, 'ddd', 'a']


      //数组命名方式
      let arr2 = new Array()
      let arr3 = new Array(3)
      let arr4 = new Array('a', 'ddd', 'eefds')
      let arr5 = []
      let arr6 = ['3', 'wef', 'sdf', 44]
    }


      //数组删减
    {
      let arr = ['a', 'b', 'c', 'd']
      arr.push(1)
      console.log(arr)
      arr.unshift(2)
      console.log(arr)
      arr.pop()
      arr.pop()
      console.log(arr)
      arr.shift()
      console.log(arr)
      arr.shift()
      console.log(arr)
    }


    //数组替换
    {
      let arr = ['ab', 'bb', 'cd', 'ab', 'cc', 'ab', 'dd', 'ab']
      console.log(arr.indexOf('ab'))
      while (arr.indexOf('ab') !== -1) {
        arr.splice(arr.indexOf('ab'), 1, '**')
      }
      console.log(arr)


      while (arr.indexOf('**') !== -1) {
        arr.splice(arr.indexOf('**'), 1)
      }
      console.log(arr)   
    }


    // map 和 forEach, filter
     {
      let arr = [1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']
      arr.forEach(function (item) {
        if (item == 6) {
          arr[arr.indexOf(item)] = 7
        }
      })


      console.log(arr)


      let arr1 = arr.map(function (item) {
        return  item + 'a'
      })
      console.log(arr1)


      let arr2 = ['a', 'b', 'c', 'd']
      let arr3 = arr2.filter(function (item) {
        if (item == 'b') {
          return "**"
        }
      })
      console.log(arr3)
    }


    //every() some() 返回true或false
    {
      let arr = ['**', 'aaa', 123, 'abc', '-', 46, 'AAA']
      console.log(arr.every(function (item) {
        return typeof item == 'string'
      }), 'every()')
    }


    {
      let arr = ['**', 'aaa', 123, 'abc', '-', 46, 'AAA']
      console.log(arr.some(function (item) {
        return typeof item == 'number'
      }), 'every()')
    }


/**********************************************************************************************************/


/*
    改变原数组的：


    pop：删除最后一个并返回，改变原数组
    push：向数组末尾添加元素，并返回新的长度，改变原数组
    unshift：向数组开头添加元素，并返回新的长度，改变原数组
    reverse：颠倒数组顺序，改变原数组
    shift：将第一个元素删除并且返回，空即为undefined，改变原数组
    splice:splice(start,length,item)新增删除替换数组元素，返回被删除数组，无删除则不返回，改变原数组
    sort：对数组排序，改变原数组




    不改变原数组的：


    concat：连接多个数组，返回新的数组，不改变原数组
    join：将数组中所有元素以参数作为分隔符放入一个字符串，不改变原数组
    slice：slice(start,end)，返回选定元素，不改变原数组


    Number 和 parseInt parseFloat 区别:


    Number():可以用于任何数据类型转换成数值；
    parseInt()、parseFloat():专门用于把字符串转换成数值；


    isNaN 用于检测值是否 不是数字




*/
    
/**********************************************************************************************************/


// 题型


// 一  数组与字符串相互转换


    {
      // 字符串倒序
      let str = 'www.limingyang.com'
      console.log(str.split('').reverse().join(''))


      // 字符串倒序
      let str1 = ''
      for (let i = str.length; i > 0; i--) {
        str1 += str.substring(i-1, i)
      }
      console.log(str1)
    }


    {
      //数组去重
      let arr = [1, 2, 3, 4, 3, 2, 4, 3, 2, 5, 6, 7, 8, 3, 5, 7, 3, 10, 9]
      for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
          if (arr[i] === arr[j]) {
            arr.splice(j, 1)
          }
        }
      }
      console.log(arr, '数组去重')      
    }


    {
      //查找字符串中的数字并替换
      let str = 'abc234efghi'
      let arr = str.split('')
      for (let i = 0; i < str.length; i++) {
        if (!isNaN(parseInt(arr[i]))) {
          arr.splice(i, 1, '[' + arr[i] + ']')
        }
      }
      str = arr.join('')
      console.log(str)
    }


    {
      //随机生成100个100到900之前的随机不重复整数
      let arr = []
      let len = 100
      let num = Math.round(Math.random()*900 + 100)
      arr[0] = num
      for (let i = 1; i < 100; i++) {
        let num = Math.round(Math.random()*900 + 100)
        let flag = 0
        for (let j = i - 1; j >= 0; j--) {
          if (num === arr[j]) {
            flag = 1
          }
        }
        if (flag === 1) {
          i--
        } else {
          arr[i] = num
        }


      }


      console.log(arr)
    }


    {
      // 排序算法
      // 1.sort排序
      function compare (a, b) {//
        return a - b
         if (a > b) {
          return 1
         } else if (a < b) {
          return -1
         } else {
          return 0
         }
      }


      let arr = [5, 1, 2, 6, 3, 8]
      console.log(arr.sort(compare))




      // 冒泡排序


      let arr = [42, 20, 17, 13, 28, 14, 23, 15]
      function nin (s) {
        var tmp = ''
        for (let i = 0; i < s.length - 1; i++) {
          for (let k = s.length - 1; k > i; k--) {
            if (s[k] < s[k-1]) {
              tmp = s[k]
              s[k] = s[k-1]
              s[k-1] = tmp
            }console.log(s, 'bbb')
          }console.log(s, 'aaaaa')
        }
        console.log(s)
      }


      nin(arr)
    }


    {
      //（1）替换的参数data为字面量对象，用toString()不能将其转成字符串，此处用JSON.stringify()将其序列化为字符串，注意我们要的是json字符串里的内容,故不要忘了去除“外包装”{}后再存储成数组。 
      // （2）json字符串里的键值都带有”“,我们要的是”“里的内容，故还要去”“操作，但数字值有一般不带”“，所以还要筛选出不是数字的值再操作，此处的易错点在于从一串包含数字的字符串中找出数字来是不能直接typeof parseInt(s)的，原因是parseInt()后非数字字符返回NaN,数字字符则返回数字本身，而typeof NaN和typeof 数字,得到的都是number,也不能用是否等于NaN来判断，因为NaN和数字都不等于NaN，所以此处要用isNaN()来分辨出NaN和数字，即非数字字符和数字。 
      // （3）去除字符串的“外包装”常用slice()或substring() 
      // (4)对字符串的某一部分操作可直接用正则表达式处理，也可以用split()将其转换成数组，再用splice()操作，最后用join()恢复成字符串。
      var desc = '我是{name},我今年{age}岁,我在{city}市'; 
      var data1 = {name: "张三", age: 25, city: "北京"}; 
      var data2 = {name: "李四", age: 29, city: "上海"};
      console.log(desc, data1, data2)
      function result (dpl, data) {
        var a = b = c = []
        var res = []
        a = dpl.split(',')
        console.log(a)
        console.log(JSON.stringify(data))
        b = JSON.stringify(data).slice(1, this.length - 1).split(',')
        console.log(b)
        let b_len = b.length
        for (let i = 0; i < b.length; i++) {
          res[i] = b[i].split(':')[1]
          //console.log(res[i], 'dddddd')
          if (isNaN(parseInt(res[i]))) {
            res[i] = res[i].slice(1, this.length - 1)
          }


          //方法一
          c = a[i].split('')
          let start = a[i].indexOf('{')
          let end = a[i].indexOf('}')
          c.splice(start, end - start + 1, res[i])
          a[i] = c.join('')


          //方法二
          //var reg = /\{.*\}/
          //a[i] = a[i].replace(reg.res[i])
        }
        console.log(res, 'res')
        console.log(a.join(','), 'a')
        return a.join(',')
      }


      result(desc, data1)
    }