ES6 部分知识的认知

//ES6字符串模板语法；

let tt = 'tyu'

let text = `你好上岛咖啡精神可嘉福克斯地方是 ${ tt } 时代峰峻神盾局六块腹肌`

//运算

let o = 1;

let u = 2;

let ii = ` ${ o+ u } `;

let tg = `你好上岛咖啡精神可嘉福克斯地方是 ${ ii } 时代峰峻神盾局六块腹肌`

var arr = [ 'u', 'u', 'i', 'ioi', 'ds', 'fs', 'fs', 'gh', 'tgfh'];

if( arr. indexOf( 'i')){

console. log( arr. indexOf( "i"));

} else{

console. log( 2);

}

//arr中是否有U

if( arr. includes( "gh")){

console. log( 1);

} else{

console. log( 2);

}

//tg中结尾是否有U 只针对字符串

if( tg. endsWith( "你")){

console. log( 1);

} else if( tg. endsWith( "肌")){

console. log( 11);

}

else{

console. log( 2);

}

//tg中开头是否有U 只针对字符串

if( tg. startsWith( "你")){

console. log( 1);

} else{

console. log( 2);

}

//字符串复制 repeat()

console. log( tg. repeat( 4));

//进制转换

//二 Bianry

let binary= 0B010101;

console. log( binary);

//八 Octal

let Octal = 00666;

//判断是否为数字

console. log( Number. isFinite( 10));

console. log( Number.MAX_SAFE_INTEGER);

console. log( Number.MIN_SAFE_INTEGER);

//数组去重，重点在于判断条件，新组中是否已存在该数据

var arr1 = [ 'u', 'u', 'i', 'ioi', 'ds', 'fs', 'fs', 'gh', 'tgfh'],

arr2 = [];

for( let i = 0; i< arr1. length; i++){

if(! arr2. includes( arr1[ i])){

arr2. push( arr1[ i]);

} else{

}

}

// console.log(arr2);

//eval()将字符串转换成数组

//from将json转换成数组

// Arr.from()

//主动抛出异常 throw new Error("")

//ES6 的新数据结构 set 特点：自动去重 针对数组

let setArr = new Set( arr);

// console.log(arr);

// console.log(setArr);

for ( val of setArr){

// console.log(val);

}

//增加值 add 查找 has 删除 clear 值的数量size

//weakSet 针对对象 学习的时候并未给出取值方法

let weakSet = new WeakSet();

let obj = { a: '1', b: '2', c: '3'};

weakSet. add( obj);

// console.log(weakSet);

// ES6 map 数据结构 已知的数据结构为 json 、set

// 取值 get 删除特定 delete 删除全部 clear 增加值set 值的数量size 查找 has

var map = new Map();

map. set( obj, 'iii');

console. log( map);

map. set( 'dfff', obj);

console. log( map);

console. log( map. get( 'dfff'));

console. log( map. delete( 'dfff'));

console. log( map);

//proxy 代理 ES6 增强对象和函数 先行执行特性

let obj1 = {

add : function(){

console. log( 3);

},

name: 'tttty'

}

let proxy = new Proxy({

add : function(){

console. log( 3);

},

name: 'tttty'

},{

get : function( target, key, property){

console. log( 2);

return target[ key];

//先行执行get而target为传过来的第一个参数对象

},

set : function( target, key, value, receiver){

console. log( "对proxy的值进行预先处理");

return target[ key] = value; //改变根值，若不返回改变则根植不变

}

});

// so

// console.log(proxy.name);

proxy. add();

//promise 多重回调优化，使用then进行下一步操作

//三步曲

let state = 1;

function step ( resolve, reject){

console. log( '开始');

if( state== 1){

resolve( '完成');

step2() //一层回调

} else{

reject( '出错');

}

}

function step2 ( resolve, reject){

console. log( '开始1');

if( state== 1){

resolve( '完成1');

step3() //二层回调

} else{

reject( '出错1');

}

}

function step3 ( resolve, reject){

console. log( '开始12');

if( state== 1){

resolve( '完成12');

} else{

reject( '出错12');

}

}

//一般写法

function state1(){

step(); //里面有二重回调嵌套，数据结构不够简洁，逻辑不够清晰

}

//使用promise对多重嵌套回调函数进行执行，优点：数据结构简洁，逻辑清晰

new Promise( step)

. then( function( val){

console. log( val);

return new Promise( step2); //返回执行下一步函数，一步错误，就不再执行下一步，

})

. then( function( val){

console. log( val);

return new Promise( step3);

})

. then( function( val){

console. log( val);

});

// ES6 类 此类非element上的target.class

//声明一个类,类里面多个函数不用逗号隔开，直接写就可以了

class Coder {

name( val){

console. log( val);

return val;

}

skill(){

console. log( this. name( 'I miss you too'))

}

//此方法为类的参数，并不是方法的参数

constructor( a, b){

this. a = a;

this. b = b;

}

add(){

return this. a+ this. b;

}

}

//对类进行实例化

let test = new Coder;

//执行

test. name( "ttt");

//类里面的一个方法需要调用另外一个方法，就需要被调用函数做返回值，使调用者获取到返回值进行操作

test. skill();

//用类里面的方法，使用类的参数

let ttt = new Coder( 1, 3);

console. log( ttt. add());

//类和类的继承，作用类似于对象继承，不过比对象继承更简单 例：

// 新声明一个类,继承了Coder类

class hh extends Coder{}

//实例新类

let newClass = new hh;

newClass. name( "kao ");

//ES6的模块化 export 输出 export default 默认输出 import 引入