ES6之字符串，数组扩展

字符串的扩展

includes

判断字符串中有没有指定字符串，返回布尔值

includes(’‘指定字符’’，开始查找的位置(可选))

   let str = "asdgf426";
   console.log(str.includes('dg'));//true
   console.log(str.includes('sd',3));//false

startsWith

判断字符串是不是以指定字符作为开头

   let str = 'http://hao123.com';
        if(str.startsWith('http://')){
            alert('普通网址');
        }else if(str.startsWith('https://'){
            alert('加密网址');
        }else if(str.startsWith('git://'){
            alert('git地址');
        }else if(str.startsWith('svn://'){
            alert('svn地址');
        }else{
            alert('其他');
        }

endsWith

判断字符串是不是以指定字符作为结尾

    let str = '.txt';
    if(str.endsWith('.txt')){
        alert('文本文件');
    }else if(str.endsWith('.jpg')){
        alert('图片');
    }else{
        alert('其他');
    }

repeat

repeat方法返回一个新字符串，表示将原字符串重复n次。
repeat(num);
num：取整，不能是负数或者Infinity
如果repeat的参数是字符串，则会先转换成数字
但是，如果参数是 0 到-1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到-1 之间的小数，取整以后等于-0，repeat视同为 0。

   'x'.repeat(3) // "xxx"
   'hello'.repeat(2) // "hellohello"
   'na'.repeat(0) // ""
   'na'.repeat(-1)// RangeError
   'na'.repeat(-0.9) // ""，不报错

padStart,padEnd(ES7中)

按照指定字符串补全字符串的指定长度
参数：1长度，2指定字符
如果省略第二个参数，默认使用空格补全长度。
padStart(length,“指定字符”)
padEnd(length,“指定字符”)

    let str = "addf";
    str.padStart(6,"e");//eeaddf
    'x'.padEnd(5, 'ab') // 'xabab'
    'abc'.padStart(10, '0123456789')// '0123456abc'
    'x'.padStart(4) // '   x'
    'x'.padEnd(4) // 'x   '

模板字符串（``）

添加变量用 ${}

        let a = 12;
        let str = `a${a}bc`;//反单引号
        console.log(str);//a12bc

        let title = '标题';
        let content = '内容';
        let str = '<div>\
            <h1>'+title+'</h1?\
            <p>'+content+'</p>\
            </div>';//普通方法
        let str2 = `<div>
        <h1>${title}</h1>
        <p>${content}</p>
        </div>`;//模板字符串
        

数组的扩展

Array.of()

Array.of 方法用于将一组值，转换为数组。
Array.of基本上可以用来替代Array()或new Array()，并且不存在由于参数不同而导致的重载。它的行为非常统一。

Array.of总是返回参数值组成的数组。如果没有参数，就返回一个空数组。

   Array.of(3, 11, 8) // [3,11,8]
   Array.of(3) // [3]
   Array(3) // [, , ,]
   Array.of() // []
   Array.of(undefined) // [undefined]

Array.from()

Array.from方法用于将两类对象转为真正的数组。类似数组的对象和可遍历的对象。

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

copeWithin

在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。改变原数组，但是原数组的长度不变。

Array.prototype.copyWithin(target, start = 0, end = this.length)

• target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
• start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
• end（可选）：到该位置前停止读取数据之前，默认等于数组长度。如果为负值，表示从末尾开始计算。

     // 将3号位复制到0号位
   [1, 2, 3, 4, 5].copyWithin(0, 3, 4);// [4, 2, 3, 4, 5]
    // -2相当于3号位，-1相当于4号位
   [1, 2, 3, 4, 5].copyWithin(0, -2, -1);// [4, 2, 3, 4, 5]
   let arr = [1,2,3,4,5,6,7,8];
   arr.copyWithin(3,1,3);//1,2,3,2,3,6,7,8

fill

按照指定字符，填充数组。将数组的每一项都变成指定字符
fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置之前。

   let arr = [1,2,3,4,5,6];
   arr.fill("f");//["f","f","f","f","f","f"]
   ['a', 'b', 'c'].fill(7, 1, 2);// ['a', 7, 'c']

注意，如果填充的类型为对象，那么被赋值的是同一个内存地址的对象，而不是深拷贝对象。

   let arr = new Array(3).fill({name: "Mike"});
   arr[0].name = "Ben";
   console.log(arr);// [{name: "Ben"}, {name: "Ben"}, {name: "Ben"}]

filter

过滤器,根据返回值过滤原数组

        let arr3 = ["zhu",1,2,3,"zhu"];
        let arr1 = arr3.filter(function(item,index){
            return typeof item === "number";
        });
        console.log(arr1);//[1,2,3]

find和findIndex

find:用于找出第一个符合条件的数组成员。先遍历数组,参数函数返回true,停止查找,返回当前项.如果没有符合条件的成员，则返回undefined

    let arr3 = ["zhu",1,2,3,"zhu"];
    let arr1 = arr3.find(function(item){
           return typeof item === "number";
     });
     console.log(arr1);//1

findIndex:返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

    let arr3 = ["zhu",1,2,3,"zhu"];
    let i = arr3.findIndex(function(item){
           return typeof item === "string";
     });
     console.log(i);//0

includes

方法返回一个布尔值，表示某个数组是否包含给定的值，
该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。

    [1, 2, 3].includes(4)     // false
    [1, 2, NaN].includes(NaN) // true
    [1, 2, 3].includes(3, 3);  // false
    [1, 2, 3].includes(3, -1); // true

reduce

汇总,求数组的和

    let arr = [12,54,26,258];
    let result = arr.reduce(function(tmp,item,index){//中间结果（12，66，92，350），（54，26，258），下标
        if(index!=arr.length-1){
            return tmp+item;
        }else{
            return (tmp+item)/arr.length;
        }
    });
    alert(result);

keys和entries和values

用于遍历数组,可以用for…of循环进行遍历，
唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

  for (let index of ['a', 'b'].keys()) {
    console.log(index);
  }
  // 0
  // 1

  for (let elem of ['a', 'b'].values()) {
    console.log(elem);
  }
  // 'a'
  // 'b'

  for (let [index, elem] of ['a', 'b'].entries()) {
    console.log(index, elem);
  }
  // 0 "a"
  // 1 "b"

map

function myfun_1(arr){
 var array = [];
  arr.map( item => {
    array.push(item*item);
  });
  console.log(array);
}
function myfun_2(arr){
 var array = [];
  arr.map( function(item){
  array.push(item*item);
 });
  console.log(array);
}

var arr3 = [1,2,3,4,5];
myfun_1(arr3);    //[1,4,9,16,25]
var arr1 = [5,2,1,3,4];
myfun_1(arr1);  //[25,4,1,9,16]
var arr2 = [3,4,5,1,2,6];
myfun_2(arr2);  //[9,16,25,1,4,36]

forEach,map,filter都在对象内接收一个函数,这个函数都可以接收三个参数,
第一个表示为每次遍历出的元素(item)
第二个表示遍历时的索引(index)
第三表示当前正在遍历的数组(arr)

空位

数组的空位:数组的某个索引位置没有任何值,undefined不是空位
判断一个数组中某一位置是不是空位用 in

   Array(3);//3个空位的数组
   let arr = [,,,,,];//五个空位
   0 in [undefined, undefined, undefined] // true
   0 in [, , ,] // false,3个空位