string

    var str = "abcdef";
    str.substring(start,end)  截取。不包含end本身，只有一个参数表示从哪里开始， 负数变0，小数前置。不改变str；
         console.log(str.substring(1,2));  //b
         console.log(str); //abcdef

    str.slice(start，end,)  调用。不包含end本身，只有一个参数表示从哪里开始，负数为倒数第几个。不改变str；
         console.log(str.slice(1,2)); //b
         console.log(str);  //abcdef

    str.substr(start,howmany)    调用。 start为负数：倒数第几个。 howmany为负数：为0. 不改变原str；
         console.log(str.substr(1,2));  //bc
         console.log(str); //abcdef

    str.charAt(index)   用索引值找内容。 找不到返回空字符串。 找到返回内容。；
         console.log(str.charAt(1));  //b

    str.indexOf('a',start)   通过内容找索引值第一次出现的位置。 start为从哪个索引值开始，找到返回索引值，找不到返回 -1；
         console.log(str.indexOf("a",0));   //0 

    str.lastIndexOf("a",start)  通过内容倒序查找索引值。start为从哪个索引值开始，找到返回索引值，找不到返回 -1；
         console.log(str.lastIndexOf("a",4)); // 0

    str.split("")   将字符串以参数分割为数组;
         console.log(str.split("")); //["a", "b", "c", "d", "e", "f"]

    str.toLowerCase()   方法返回一个字符串，该字符串中的字母被转换成小写;
        console.log(str.toLowerCase());

    str.toUpperCase()   方法返回一个字符串，该字符串中的所有字母都被转换为大写字母;
         console.log(str.toUpperCase());
    

    数组的方法
    var arr = [1,2,3,4,5,6,7];

     arr.push(number)      添加到最后，返回添加后的数组的长度，改变原数组;
            console.log(arr.push(9,0,11));  //10
            console.log(arr);        //[1, 2, 3, 4, 5, 6, 7, 9, 0, 11]

    arr.unshift(number)   添加到最前面,返回添加后的数组的长度，改变原数组;
         console.log(arr.unshift(2));   //8
         console.log(arr);              //[2, 1, 2, 3, 4, 5, 6, 7]

    arr.shift()     删除数组第一个，返回被删除的值，改变原数组;
         console.log(arr.shift());   // 1
         console.log(arr);           //[2, 3, 4, 5, 6, 7]

    arr.pop()       删除数组最后一项，返回被删除的内容，改变原数组；
         console.log(arr.pop());        // 7
         console.log(arr);          // [1,2,3,4,5,6]

    arr.reverse   数组翻转,返回处理后的数组并且改变原数组；
         console.log(arr.reverse());   // [7, 6, 5, 4, 3, 2, 1]
         console.log(arr);             //  [7, 6, 5, 4, 3, 2, 1]

    arr.join("分隔符")      数组转化为字符串以哪个符号作为分隔符，如果不写直接转字符串,不改变原数组；
         console.log(arr.join("&"));     //1&2&3&4&5&6&7
         console.log(arr);             //  [1, 2, 3, 4, 5, 6, 7]

    arr.slice(start,end)     调用。不包含end本身，只有一个参数表示从哪里开始，负数为倒数第几个。不改变arr;
         console.log(arr.slice(1,-1));    //[2, 3, 4, 5, 6]
         console.log(arr);             //  [1, 2, 3, 4, 5, 6, 7]

    arr.concat()   数组合并,括号里可以是数组名也可以是内容，不改变原数组；
         console.log(arr.concat(22));      //  [1, 2, 3, 4, 5, 6, 7, 22]
         console.log(arr);                   // [1, 2, 3, 4, 5, 6, 7]

    arr.splice（开始下标,个数,ele1,ele2....） 剪接数组,从哪里开始、删除几个、添加ele...、返回删除项无删除无返回；
    一个参数：从哪里开始，如果是负数是倒数第几个；
    两个参数：从哪里开始，一共几个；
         console.log(arr.splice(1,3,5));    // [2, 3,4]
         console.log(arr);         //  [1, 5, 5, 6, 7]

    arr.forEach(function (item,index,array){   })     遍历，循环。 item：每一项。 index：索引值。 array：数组本身。forEach没有返回值；
         arr.forEach(function(item,index,array){
             console.log(item);    //1 2 3 4 5 6 7
             console.log(index);    //  0 1 2 3 4 5 6
             console.log(array);  //   [1, 2, 3, 4, 5, 6, 7]
         })

    arr.map(function (item,index,array){  })      遍历，循环。 item：每一项。 index：索引值。 array：数组本身。map返回新数组；
         var newArr = arr.map(function(item,index,array){
                 console.log(item);
                 console.log(index);
                 console.log(array);
            });
         console.log(newArr);

    arr.sort()  排序,默认从小到大。  arr.sort(function(a,b){ return a-b})   a-b从小到大 b-a从大到小;
         console.log(arr.sort());

    arr.reverse()：   颠倒数组顺序;
         console.log(arr.reverse());     //[7, 6, 5, 4, 3, 2, 1]

    arr.reduce(function(prev,cur,index,arr){...}}, init)  
         arr 表示将要原数组；
         prev 表示上一次调用回调时的返回值，或者初始值 init(前一项);
         cur 表示当前正在处理的数组元素（当前项）；
         index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
         init 表示初始值。
        常用的参数只有两个：prev 和 cur。
         var sum = arr.reduce(function (prev, cur) {
                 return prev + cur;
             }, 0);
         console.log(sum); // 28

    arr.every(function(item,index,array){...})  用于判断数组中的每一项元素是否都满足条件，返回一个布尔值;
         var isEvery = arr.every(function (item, index, array) {
                 return item > 0;
             });
             console.log(isEvery);   // false

    arr.some(function(item,index,array){...})   用于判断数组中的是否存在满足条件的元素，返回一个布尔值
         var isSome = arr.some(function (item, index, array) {
                 return item > 0;
             });
             console.log(isSome);   // true
    filter(function(item,index,array){...})   用于筛选数组中满足条件的元素，返回一个筛选后的新数组
         var minus = arr.filter(function (item, index, array) {
                 return item > 0;
             });
             console.log(minus);   // [1, 2, 3, 4, 5, 6, 7]

    ① forEach()无返回值，map()和filter()返回新数组，every()和some()返回布尔值
    ② 匿名函数中this指向默认为window，可通过传第二参数来更改之

         只传一个匿名函数
         arr.forEach(function (item, index, array) {
             console.log(this);   //window
         });

         传两个参数
         arr.forEach(function (item, index, array) {
             console.log(this);  // [1, 2, 3, 4, 5, 6, 7]
         }, arr);

如有错误或遗漏请指正，不定期更新。谢谢！