（正则、数值、数组、对象）的扩展

正则、数值、数组、对象

一、正则扩展

• 提供了  u  修饰符，对占两个字符特殊字进行正则识别；

 

let result=/𠮷{2}/u.test('𠮷𠮷');
console.log(result);

 

• 提供了  y  修饰符，当匹配过一次后继续往下匹配；

let text='xxx_xx_xx_',
    patt=/x+_/y;
console.log(patt.exec(text));
console.log(patt.exec(text));
console.log(patt.exec(text));

•  y  修饰符的  stikcy  属性，用来检测是否存在 y  修饰符

console.log(patt.sticky);

• flags  属性，用于返回正则使用修饰符的名称

console.log(patt.flags);

•  .   表示匹配所有，除了终止符，比如回车\n 换行\n 等等，使用 s 修饰符匹配

let text='x\nyz',
    patt=/x.+yz/s;
console.log(patt.test(text));

• 修饰符替换

// ES6 支持修饰符替换，之前的这种写法会直接报错；
let regex=new RegExp(/xyz/iu,'g')
console.log(regex.flags);

二、数值的扩展

• ES6 明确二进制、八进制和十六进制分别用 0b、0o、0x 作为前缀；

 console.log(number(value('0b00')));
 console.log(number(value('0o00')));
 console.log(number(value('0x00')));

• ES6 提供了 Number.isFinitel()、Number.isNaN()判断无穷大和 NaN；

非数值为false 数值为true
 console.log(Number.isFinite(100));
 NaN为true,其余为false
 console.log(Number.isNaN(100));

• ES6 提供了 Number.parseInt()、Number.parseFloat()转换整型和浮点型；

 console.log(Number.parseInt('5.555a'));
 console.log(Number.parseFloat('5.555b'));

• ES6 提供了 Number.isInteger()，来判断参数是否是一个整型；

 console.log(Number.isInteger('10'));

• ES6 提供了一个常量，值特别小，用于判断是否得到正确结果

 console.log((0.1+0.2+0.3).toFixed(20));
 console.log(Number.EPSILON);
 console.log(Number.EPSILON.toFixed(30));
 console.log((0.1+0.2+0.3)<Number.EPSILON);

• ES6+新增了一个指数运算符 **，并且可以进行赋值运算；

 console.log(2**3);  //16  三个2相乘
 let num=2;
 num **=5;
 console.log(num);   //32  五个2相乘

三、数组的扩展

1. 运算符扩展

• ES6 提供了(...)三个点将一个数组转换为逗号分割来进行处理

function add(x,y){
    return x+y;
}
console.log(add(...[10,20]));

• 求最大值

console.log(Math.max(...[1,2,3]));

• 合并数组

console.log([...[1,2],...[3,4]]);

        2.方法的扩展

• ES6 提供了 Array.of()方法，它的主要目的是弥补 Array()的不足

ES6声明数组
let items=Array.of(3,2,1);
console.log(items);

• ES6 提供了 Array.from()方法，将类似数组的对象或遍历转换成真正的数组

let obj={
    0:'name',
    1:'age',
    2:'gender',
    length:3
};
console.log(Array.from(obj));
PS：对象转换成数组要求比较严格：
    (1).key 必须是数值或字符串数字； 
    (2).length 设置长度，而且 key 在范围内；
(1).DOM 的 NodeList 集合;
let nl=document.querySelectorAll('p');

• ES6 提供了 find()和 findIndex()方法，用于查找数组中第一个匹配的值

let items=[10,20,30,40,50];
console.log(items.find(value=>value>19));

• ES6 提供了 fill()方法，可以填充重写数组中的元素值

let items=[10,20,30,40,50];
console.log(items.fill('a',2,3)); //索引2开始 索引3结束

• ES6 提供了 copyWithin 方法，从数组内部复制值，然后粘贴指定位置

let items=[10,20,30,40,50];
//从索引 0 开始复制值 
//然后把值从索引 2 开始粘贴 
//参数 3 设置结束粘贴索引值
console.log(items.copyWithin(2,0));

四、对象的简写

• 对象字面量中属性初始值实现简写

function fn(name,age){
    return{
        name,age
    }
}
console.log(fn('Mr.Lee',100));

• 对象字面量中方法的简写方式

let obj={
    fn(){
        return 'fn'
    }
};
console.log(obj.fn());

• 允许对象字面量中，使用表达式进行属性名称的拼装操作

拼装组合属性
let obj={
    // 拼装组合属性
    ['user'+'Name']:'Mr.Lee',
    //有空格的情况下
    ['user' + ' Age'] : 100,
    //字符串属性
    'user Gender' : '男'
};
console.log(obj.userName);
console.log(obj['userName']);
console.log(obj['user Age']);
console.log(obj['user Gender']);

• ES6 提供了在对象字面量中使用可计算(动态)属性名称

//通过变量 myName 动态更改 obj 属性名 
//问题是当变量值更改了，属性名就失效了 
let myName = 'name'; 
let obj = { 
    name : 'Mr.Lee'
};
console.log(obj[myName]); 
//使用[myName]可计算属性名 
//实现了真正的动态计算 
let myName = 'name'; 
let obj = {
     [myName] : 'Mr.Lee' 
};
console.log(obj[myName]);

• ES6 在对象字面量方法上，也可以使用拼装名称

let obj = {
    ['f' + 'n']() {
        return 'fn';
    }
};
console.log(obj.fn());

五、对象的新增方法

• ES6 提供了 Object.is()方法来解决“===”中一些恒等中的缺点

console.log(Object.is(100, '100'));   //false，必须恒等
console.log(Object.is({}, {}));  //false，指向不同
console.log(Object.is(+0, -0));   //false
console.log(Object.is(NaN, NaN));   //true
console.log(NaN === NaN);   //false
console.log(+0 === -0);   //true

• ES6 提供了 Object.assign()方法可以合并指定对象至目标对象内部

/...传参，合并所有对象，返回给参数一的目标对象
console.log(Object.assign(obj1, obj2, obj3));
//第一个对象得到合并后的结果；
console.log(obj1);

// PS： (1).如果属性有相同，后面的源对象内容会覆盖之前的属性值； 
//      (2).如果直接传非对象内容，会转换为对象； 
//      (3).如果传入的是 undefined 和 null 会报错；

• ES6 提供了 Object.getPrototypeOf()和 Object.setPrototypeof()方法

let obj = {
    fn() {
        return 'fn';
    }
};
let obj2 = {
    fn() {
        return 'fn2';
    }
};
//以 obj 对象为原型 
let f = Object.create(obj)
//检测是 obj 是否 f 的原型对象 
console.log(Object.getPrototypeOf(f) === obj);
//输出原型对象的 fn console.log(f.fn()); 
//设置 f 的原型对象为 obj2 
Object.setPrototypeOf(f, obj2);
console.log(Object.getPrototypeOf(f) === obj2);
console.log(f.fn());

• ES6 提供了 super 关键字，用于原型中方法的继承功能

let obj = {
    fn() {
        return 'fn';
    }
};
let f = {
    fn() {
        return super.fn() + ', extend!';
    }
};
//设置 obj 是 f 的原型 
Object.setPrototypeOf(f, obj);
console.log(f.fn());
//可以再设置以 f 为原型 
let h = Object.create(f);
console.log(h.fn());