ES6新特性详解-优快云博客

本文链接：https://blog.youkuaiyun.com/smalCat/article/details/79206162
//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 引入
ES6 部分知识的认知
