简单学习es6

symbol

symbol 代表独一无二的值,不能出现重复

// 查看他的类型  typeof   tostring    object.prototype.tostring.call（）
// let s=Symbol();
// console.log(typeof s);

// let f1=Symbol('1');
// let f2 =Symbol('f2');
// console.log(f1===f2);//false  每一个symbol 都是不一样的

//可以将symbol 转成字符串进行拼接 但不能转成数字
// console.log(`zwj+${String(f1)}`);//zwj+Symbol(f1)
// console.log(`2+${Number(f1)}`);
// TypeError: Cannot convert a Symbol value to a number

// 不能添加属性值
// let f1=Symbol();
// let obj={};
// obj.f1='lisi';
// console.log(obj[f1]);//undefined
​
// 当symbol 当属性名的时候，属性要加[];
// let a=Symbol();
// let  obj1={
//     [a]:'444'
// }
// console.log(obj1[a]);//444

set 类似于数组，成员的值都是唯一的，没有重复的值

// set 类似于数组，成员的值都是唯一的，没有重复的值
let s=new Set();
let array=[1,2,3,4,4,32];
array.forEach((item,index)=>{
    s.add(item)
})
console.log(s);
console.log(Array.from(s));
console.log(Object.prototype.toString.call(Array.from(s)));
// 数组类型   Array.from() 转数组    new  set 去重

// ** 数组去重的一种方式 Array.from(new Set())

let ar1=new  Set([1,2,3,4,5,6,7]);
console.log(ar1.size);//7
// Set.prototype.size：返回Set实例的成员总数。

let a=new Set([1,4,3,2,4,3,2,1]);
let b=[...a];
console.log(b);
console.log(typeof b);
​
// [...new Set]和Array.from(new Set())用法一样  后者回答更专业

// [...new Set]和Array.from(new Set())用法一样  后者回答更专业
​
// set的方法
// let a =new Set('ssssssssssdcsdvs');
// console.log(a);
// // 删除  delete
// a.delete('s');
// console.log(a);
// // 是否有该值  has
// console.log(a.has('v'));//true
// // 清空所有 clear 
// a.clear();
// console.log(a);
// // 增  add
// a.add('11');
// console.log(a);

map 本质上是键值对的集合（Hash 结构），但是传统上只能用字符串当作键。

类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现。如果你需要“键值对”的数据结构，Map 比 Object 更合适。

// map
// set   添加键值对
// get 读取键值对
// has   查找键值对
// delete  删除
let map =new Map();
let obj={name:'lisi',age:"19"};
map.set(obj,'content');
console.log(map.get(obj));
console.log(map);
console.log(map.has("1"));//false
map.delete(obj);
console.log(map);
​

Proxy{}

// new Proxy()表示生成一个proxy实例，target 参数表示要拦截的目标对象

// handler参数也是一个对象，用来定制拦截行为。

// get 是获取定义属性名
// set 是截取修改的属性
​
//proxy  get 获取属性
// proxy set 修改属性
// has 和in运算符配合，判断该属性是否存在这个对象
// deleteProperty 拦截删除操作，可以禁止删除

// 1 拦截读取属性行为的例子。
// var proxy = new Proxy({},{
//     get:function(target,propKey){
//         return 35;
//     }
// })
// console.log(proxy.time);
// console.log(proxy.a);
// console.log(proxy.b);
// console.log(proxy.c);
​
/*/*
 * 面代码中，配置对象有一个get方法
 * 来拦截对目标对象属性的访问请求。g
 * et方法的两个参数分别是目标对象和所要访问的
 * 属性。可以看到，由于拦截函数总是返回35，
 * 所以访问任何属性都得到35。/ */ 
​
//  

get方法用于拦截某个属性的读取操作，可以接受三个参数，依次为目标对象、属性名和 proxy 实例本身（严格地说，是操作行为所针对的对象），其中最后一个参数可选。
​
​
var person = {
  name: "张三"
};
​
var proxy = new Proxy(person, {
  get: function(target, propKey) {
    if (propKey in target) {
      return target[propKey];
    } else {
      throw new ReferenceError("Prop name \"" + propKey + "\" does not exist.");
    }
  }
});
​
proxy.name // "张三"
proxy.age // 抛出一个错误
'
​
​
​
get方法可以继承。'

set()

set方法用来拦截某个属性的赋值操作，可以接受四个参数，依次为目标对象、属性名、属性值和 Proxy 实例本身，其中最后一个参数可选。

let validator = {
  set: function(obj, prop, value) {
    if (prop === 'age') {
      if (!Number.isInteger(value)) {
        throw new TypeError('The age is not an integer');
      }
      if (value > 200) {
        throw new RangeError('The age seems invalid');
      }
    }
​
    // 对于满足条件的 age 属性以及其他属性，直接保存
    obj[prop] = value;
    return true;
  }
};
​
let person = new Proxy({}, validator);
​
person.age = 100;
​
person.age // 100
person.age = 'young' // 报错
person.age = 300 // 报错

apply()

apply方法拦截函数的调用、call和apply操作。

apply方法可以接受三个参数，分别是目标对象、目标对象的上下文对象（this）和目标对象的参数数组。

var target = function () { return 'I am the target'; };
var handler = {
  apply: function () {
    return 'I am the proxy';
  }
};
​
var p = new Proxy(target, handler);
​
p()
// "I am the proxy"

has()

has()方法用来拦截HasProperty操作，即判断对象是否具有某个属性时，这个方法会生效。典型的操作就是in运算符。

has()方法可以接受两个参数，分别是目标对象、需查询的属性名。

下面的例子使用has()方法隐藏某些属性，不被in运算符发现。

var handler = {
  has (target, key) {
    if (key[0] === '_') {
      return false;
    }
    return key in target;
  }
};
var target = { _prop: 'foo', prop: 'foo' };
var proxy = new Proxy(target, handler);
'_prop' in proxy // false

construct()

construct()方法用于拦截new命令，下面是拦截对象的写法。

const p = new Proxy(function () {}, {
  construct: function(target, args) {
    console.log('called: ' + args.join(', '));
    return { value: args[0] * 10 };
  }
});
​
(new p(1)).value
// "called: 1"
// 10