常用的ES2015中的字符串、数值、数组的拓展方法

一、字符串的拓展

1、使用for ... of循环字符串中的字符

for(let a of 'java') {
      console.log(a);
}
// j
// a
// v
// a

2、利用includes、startsWith、endsWith三种方法检测字符串中是否含有某些字符（串），根据是否存在返回布尔值
传统中只能使用indexOf方法检测

const value = 'hello world!';

console.log(value.includes('w'));
console.log(value.startsWith('he'));
console.log(value.endsWith('d!'));
// true
// true
// true

当然，这几个方法都支持第二个参数，作为搜索开始的位置，但是endsWith()方法的第二个参数是指前n的字符：

console.log(value.includes('w',2));
console.log(value.startsWith('he',1));
console.log(value.endsWith('he',2));
// true
// false
// true

3、利用repeat()方法重复字符串，这个方法接受一个数字作为重复的次数，如果是小数则采用舍的方式，这个方法不会对原来的字符串进行修改
传统的方法使用符号+进行重复

const s = 'js';
const v = s.repeat(2);
console.log(v);
// jsjs

4、使用模板字符串来简化字符串的拼接，模板字符串为了区分普通的字符串使用反引号括起来，使用${}作为占位符标识
传统方法使用符号+来拼接，如：

let lang = 'js';
let s = lang + ' is powerful';

如果字符串太长，还可以将字符串划分为数组中的一个个元素，使用join()方法拼接，这样的好处是方便代码的组织

let lang = 'js;
let  s = [lang, ' is', ' powerful'].join('');

使用模板字符串可以更加方便和简洁，如：

let lang1 ='js';
let lang2 = 'java';
function str(value) {
    return `${value} is powerful`;
}
let s1 = str(lang1);
let s2 =  str(lang2);

当然模板字符串中还可以嵌套模板字符串，使用函数等等。

二、数值的拓展

1、使用0b表示二进制数，使用0o表示八进制数
传统中定义使用零0开头表示八进制数如071就是表示57，用0x表示十六进制数，但是ES5中说明了严格模式中规定不能用0开头表示八进制，ES6中则更加明确说明使用0b开头表示，使用Number方法可以将这些转化为10进制，同时这些进制的数字进行计算都是返回10进制数

let n = 071;
Number(n);
// 57
071 + 01;
// 58
0b10 + 0b10;
// 4

2、使用Number.isFinite()方法来检测一个数是否有限，使用Number.isNaN()方法来检测一个变量是否是数字
传统中isFinite()方法和isNaN()方法已经部署到了全局对象中，使用Infinity来表示正无限，-Infinity来表示负无限，如下：

let n = 12;
isNaN(n);
// false
isFinite(n);
// true

这个与传统方法不同的是，传统方法使用时会先调用类型转换，而Number新增的这两个方法首先检测参数是否是数字，不是数字一律返回false

isNaN('NaN');
// true
isFinite('12');
// true
Number.isNaN('NaN');
// false
Number.isFinite('12');
// false

3、Number.parseInt()和Number.parseFloat()方法
这里和传统的全局方法parseInt()和parseFloat()一致，这样做的目的是减少全局方法，逐步模块化
4、利用Number.isInteger()方法判断一个数是否是整数
传统方法中我们可以使用Math.floor()或者是Math.ceil()方法来处理数字后与原数字对比来判断是否为整数。

let n = 12;
console.log(n === Math.floor(n));
// true
console.log(n === Math.ceil(n));
// true
console.log(Number.isInteger(n));
// true

同样，由于JavaScript内部储存数据并不会区分浮点数与整数，因此12和12.0使用这个方法同样都是返回true，都认为是整数。

console.log(Number.isInteger(12.0));
// true

三、Math对象拓展

1、利用Math.trunc()方法来舍去一个数字的小数部分，返回整数部分。
传统方法中我们需要判断这个数字大于0还是小于0，大于0采用Math.floor()方法处理，小于0使用Math.ceil()方法处理，因为这两个方法一个表示入，一个表示舍

function trunc(num) {
    if(num >= 0) {
        return Math.floor(num);        
    } else {
        return Math.ceil(num);
    }
}
let n1 = 4.5;
let n2 = -4.5;
console.log(trunc(n1));
// 4
console.log(trunc(n2));
// -4
console.log(Math.trunc(n1));
// 4
console.log(Math.trunc(n2));
// -4

2、利用Math.sign()判断一个数字的正负
传统方法中需要和0做对比之后根据结果处理。
Math.sign()方法使用的时候同样会先做类型转化之后再做判断，Math.sign()方法有可能返回5个值：
正数：返回+1
负数：返回-1
0：返回0
-0：返回-0
其他：返回NaN

// 传统模拟
function sign(num) {
  x = +x; // 转化为一个数字，遇到不能转化的非数字返回NaN
  if (x === 0 || isNaN(x)) {
    return x;
  }
  return x > 0 ? 1 : -1;
}

Math.sign('12');
// 1
Math.sign(-12);
// -1
Math.sign(0);
// 0
Math.sign(-0);
// -0
Math.sign('12js');
// NaN

3、利用Math.cbrt()方法来求一个数的立方根
传统方法中我们需要使用Math.abs()方法将其转换为绝对值之后利用Math.pow()方法求绝对值的立方根，之后根据原始值的正负返回正负值。
同样这个方法执行的时候会先调用类型装换。

// 传统模拟
function cbrt(num) {
    let  n = Math.pow(Math.abs(num), 1/3);
    return num >= 0 ? n : -n;
}

Math.cbrt(-1);
// -1
Math.cbrt(8);
// 2

四、数组的拓展

1、利用Array.from()方法将类数组对象和set、map数据结构转化为一个真正的数组的对象
传统方法中将一个有length属性的类数组对象转化为数组的对象会使用Array.slice.call()来转化，如：

const  a = {
'0': 'a',
length: 1
};
const b = [].slice.call(a);
// ['a'] 

类数组对象键值对中键必须是以0,1,2这样命名，同时也必定需要length属性
类数组对象经典的就是arguments对象，还有DOM操作中得到的节点也是，将这些类数组对象转化为数组后就可以放心的使用数组的所有方法了，尤其是forEach()、map()、reduce()这些迭代器方法。

function a(){
    console.log(Array.isArray(arguments));
    console.log(Array.isArray(Array.from(arguments)));
}
a();
// false
// true

2、利用Array.of()方法将一组数值转化为一个数组
传统方法中我们初始化一个数组一半采用字面量法，构造函数方法基本不会用到，主要是因为构造函数方法根据参数的多少，行为是不一致的。当参数只有一个时返回的是一个length属性为参数值的数组，而当参数为两个或者两个以上时，返回的就是这些值组成的一个数组，而Array.of()方法就可以行为一致，始终返回这些参数组成的数组。

let a = new Array(3);
// [ , , ]
let b = new Array(2,3);
// [2,3]

显然，传统上将arguments对象转化为数组即可模拟Array.of()这个方法

function arrayOf(){
  return [].slice.call(arguments);
}

3、利用数组实例方法find()来查找出符合条件的第一个成员，find()方法的参数是一个回调函数，类似于forEach()等方法的回调函数，这个函数的第一个参数是元素，第二个参数是位置，第三个参数是这个数组，find()方法返回第一个返回值为true的数组元素，如果数组中没有返回为true的元素，则返回undefined。
传统中这种迭代器方法还有forEach()、every()、some()、map()、filter()、reduce()、reduceRight()方法，传统中需要模拟这个方法则需要使用循环来逐个判断。

[1,2,3,4,-5,6].find((ele) => ele < 0);
// -5
[1,2,3,4,5].find((ele) => ele>3);
// 4

4、使用数组实例方法findIndex()来查找出符合条件的第一个成员的索引值，参数依旧是一个回调函数，如果数组中没有符合条件的元素，则返回-1。
传统方法中依旧是需要使用循环来逐个判断。

[1,2,3,4,-5,6].findIndex((ele) => ele < 0);
// 4
[1,2,3,4,5].findIndex((ele) => ele>3);
// 3
[1,2,3,4,5].findIndex((ele) => ele<0);
// -1

5、使用数组实例方法includes()来判断数组中是否存在某个元素
与字符串方法includes一样，有则返回true，无则返回false
传统方法中需要使用indexOf来根据索引值来判断。

// 传统方法模拟
function includes(arr, ele) {
    return arr.indexOf(ele) > -1 ? true : false;
}