javascript 容易忘记的知识点

var arr = [1,2,3,4,5]
    //reduce(function(total,currentItem,(currentIndex),(arr)){/*code..*/},initialValue)
    var sum = arr.reduce(function(sum,item,index,arr){
        return sum+item
    },4);
    console.log(sum) //19
    var str = '/a/bcd/e'
    //如果没有找到对应字符，则返回-1 ,判断数组或字符串中是否存在某个mjz8499元素
    //对大小写敏感
    console.log(str.lastIndexOf('/',4)) //=>2  //从下标为4的字符开始查找/,输出2
    console.log(str.indexOf('/',4)) //=> 6 区别：lastIndexOf返回的下标是从指定的起始位置开始算，而indexOf是从0开始算，如果找不到都返回-1

    //对数组也适用
    var arr = ['a','b','c','ab'];
    var index = arr.indexOf('ab',2)  // => 3

    //Array prototype
    function my_max(){
        var max = this[0]
        for(var i = 1; i < this.length; i++){
            if(this[i] > max){
                max = this[i]
            }
        }
        return max
    }
    Array.prototype.max = my_max;
    var array = [1,3,4,2]
    var arr = new Array(7, 1, 3, 11, 25, 9);
    // console.log(arr.max())

    //Array from 把字符串或伪数组转换为数组
    var charArr = Array.from('abc') //=>['a', 'b', 'c']
    var obj = {
        0: 'd',
        1: 'e',
        2: 'f',
        'length': 3
    }
    var objArr = Array.from(obj)// => ['d','e','f']

    var arr = Array.from([1,2,3], function(x){
        // console.log(x) //1 2 3
    }) 
    //箭头函数
    arr = Array.from([1,2,3],x => x*10) // => [10,20,30]

    //Array of
    var a1 = Array.of(1,2,3) //=> [1,2,3]
    //使用Array.of与new Array之间的差异
    var a2 = Array.of(3) //[3] a2.length = 1  a2[0] = 3
    var a3 = new Array(3) //[undefined×3] a3.length = 3

    //Array.concat
    var a, b, c, d;
    a = new Array(1,2,3)
    b = 'dog'
    c = new Array(42, 'cat')
    d = a.concat(c) //=>[1,2,3,42,'cat']
    d = a.concat(c,b) //=> [1,2,3,'dog',42,'cat']
    //参数可以为多个

    //Array.fill
    //arr.fill(value,start,end)
    //start可选，默认为0，end可选，默认arr.length
    var a = [0,0,0].fill(7,1,2); //=> [0,7,0]
    a = [0,0,0].fill(7,1) //[0,7,7]
    a = [0,0,0].fill(7) //=>[7,7,7]

    //Array.filter
    //返回值为回调函数返回true的所有值的新数组
    var arr = [5,'a',10,'b',true]
    var result = arr.filter(function(value){
        return (typeof value === 'string')
    }) //=> ['a', 'b']

    //Array.join
    var arr = new Array(1,2,3)
    var joinarr = arr.join('-') // => "1-2-3"
    joinarr = arr.join() // => "1,2,3"
    joinarr = arr.join("") // => "123"
    joinarr = arr.join(" ") // => "1 2 3"


    //Array.pop
    var arr = [1,2,3]
    var a = arr.pop(); // => 3 arr = [1,2]
    a = arr.push(5,6,7); // => 4 返回arr的长度

    //Array.reverse
    var arr = [1,2,3]
    a = arr.reverse(); //=> [3,2,1]   arr= [3,2,1]



    //Array.slice
    arr = [1,2,3,4]
    a = arr.slice(1,3)//=>[2,3] arr不变
    a = arr.slice(1) //=>[2,3,4] 省略end,默认到数组结尾
    a = arr.slice(-2) //[3,4] 参数为负数时，实际值为该参数+arr.length

    //Array.splice
    var myarr = [1,2,3,4,5]
    var result = myarr.splice(2,2,'a','b') // result => [3,4] , myarr=>[1,2,'a','b',5]
    result = myarr.splice(2,0,'c')  // myarr=>[1,2,'c','a','b',5] , result = []
    //返回切割掉的数组
    result = myarr.splice(1,3)  //myarr=>[1,'b',5] , result = [2,'c','a']

    //Array.some  判断数组中的任意元素是否满足指定的回调函数的条件
    arr = [1,2,3,4,5]
    res = arr.some(function(value,index){
        return value%2 == 0;
    }) // => true

    //Array.sort
    arr = new Array(4,11,2,10,3,1)
    res = arr.sort(); //res,arr=>[1,10,11,2,3,4] 按照ASCII码排序 arr已排序好

    //使用一个比较函数作为排序参数
    arr = new Array(4,11,2,10,3,1)
    res = arr.sort(function(first, second){
        if (first == second) return 0;  //= 就是0
        if (first < second) return -1;  //< 负值
        else return 1;  //>正值
    }) // res,arr => [1,2,3,4,10,11]

    //Array.toString
    arr = [1,2,3,4]
    res = arr.toString() // "1,2,3,4"

    //Array.shift 从数组中移除第一个元素并返回该元素
    var arr = [1,2,3]
    a = arr.shift(); //=> 1 arr=[2,3]

    //Array.unshift 在数组开头插入新元素,返回新数组长度

    arr = [1,2,3]
    a = arr.unshift(0) //arr=>[0,1,2,3] a=>4

    //Array.valueOf 无参数  //获取对象原始值
    arr = [1,2,3,4]
    res = arr.valueOf();  //res=>[1,2,3,4] arr === res =>true

    //Array.keys 返回数组的索引值
    var k = ["a", "b", "c"].keys();
    // k.next().value => 0
    // k.next().value => 1
    // k.next().value => 2


    function myfun(){
        this.name = 'calor';
    }
    var obj = new myfun; //obj.constructor == myfun => true

    //所有js对象都有一个只读的prototype属性，可将属性和方法添加到原型中，但不能为对象分配其他原型，但是，可以向用户定义的对象分配新的原型

    //Object.create
    var newObj = Object.create(null, {
        size: {
            value: 'large',
            enumerable: true
        },
        shape: {
            value: 'round',
            enumerable: true
        }
    });

    //Object.getPrototypeOf() //返回对象的原型
    function Square(width, height) {
        this.width = width;
        this.height = height;
    }
    var mysquare = new Square(3,4);
    var proto = Object.getPrototypeOf(mysquare)
    proto.color = 'red';
    // 判断proto是否存在mysquare的原型链中
    res = proto.isPrototypeOf(mysquare)

    var arr = [1,2,3]
    obj = {'a':1,"b":2}


    //String.charAt()返回指定索引处的字符
    "abcd".charAt(2) //=>'c'

    //String.EndsWith(ch) //判断字符串是否以字符或子字符串ch结尾
    "abcd".endsWith("cd") // true

    //String.includes(ch) 判断ch是否包含在String中
    "abcd".includes("bc") //=> true

    //String.repeat(n)  //将字符串重复n次
    "abc".repeat(2) //=>"abcabc"

    //String.replace(reg,str)//将String中满足正则表达式reg的字符或字符串替换为str
    "aBbc".replace(/b/ig,"d"); //"addc", /b/ig中，i表示忽略大小写，g表示全局，如果没有g，则只替换掉第一个

    //String.search(ch) 返回ch在String中的第一次出现的位置
    "abcd".search('c') //=>2
    "abBd".search(/b/i) //=>1

    //String.substr(start, length) //获取从指定位置开始并具有指定长度的子字符串,length缺省为String.length,为0或负数返回一个空字符串
    "abcd".substr(1,2) //=> "bc"
    "abcd".substr(1,0) //=> ""
    "abcd".substr(1,-1) //=> ""
    "abcd".substr(1) //=> "bcd"

    //String.substring(start,end) 返回位于String中指定位置的子字符串,其中start和end顺序没有强制，以其中较小的值作为String的起点，如果值为NaN或负数，则将被替换为0
    "abcd".substring(1,3) //=>"bc"
    "abcd".substring(3,1) //=>"bc"
    "abcd".substring(-1,3) // => "abc"
    "abcd".substring('a',3) //=> "abc" ,因为Number('a') = NaN

    function myfun (a,b,c,d){
        // console.log(arguments.length) //在没有调用该函数之间打印0，调用之后打印4
        // console.log(myfun.length) //调用前后都打印4

    }
    myfun(1,2,3,4); //所以两者的区别就是arguments是在函数被调用了才会有结果，而直接使用functionName.length是一直都存在的

    //Function.callee属性 返回正在被执行的Function对象，可用做匿名函数递归
    (function Foo(){
        // console.log(arguments.callee) //=>Foo(){...}
    })();

    //Function.caller属性 获取调用当前函数的函数 只有当函数正在执行时才被定义

    //apply, call, bind
    var obj = {
        name: 'calor',
        say: function(age){
            // console.log('i am '+this.name)
            // console.log("age:"+age)
        }
    }
    var obj2 = {
        name: 'Tom'
    }
    obj.say.apply(obj2,[20]); //=> i am Tom age:20
    obj.say.call(obj2,20); //=> i am Tom age:20
    obj.say.bind(obj2)(21); //=> i am Tom age:21
    obj.say.bind(obj2,[21])(); //=> i am Tom age:21
    obj.say.bind(obj2)([21]); //=> i am Tom age:21