- 解构赋值
从对象或数组中提取数值,赋值于另一个变量。(Destructuring);
// use with object
function say({name='komolei',age=24,sex='male'}){
console.log('arguments',name,age,sex)}
say() // error // 应该改为say({}) // arguments komolei 24 male
say({age:22}) // arguments komolei 22 male
// use with Map or Set
const m = new Map();
m.set('one',{name:'komolei'});
m.set('seconde','dd');
for (let [,value] of m) {
console.log(`value`,value)} // {name:'komolei'} dd
// 这个也不错
function people(){
return {name:'clc',age:22}}
let {name,age}=people();
name // clc
age //22
- symbol //标识
// 1997年前的js原始类型:
// null ,undefined,string,boolean,number,object
// 现在增加一个新的原始类型
// symbol 充当标示符
还有就是
const a=Symbol('a')
// 不能直接使用到模板字符串中,如
console.log(`xixi ${a}`) // error
// 可以通过Sting(a)或a.toString() 进行covert
// 生成方法:
1. Symbol() 2.Symbol.for() // 注册表使用,理解为大范围使用同一个symbol的时候。其是为共享的 3. Symbol.iterator
- set and map 没有则返回undefined ,都有的方法:keys(),values(),entries(),forEach()
哈希表(hash table):是一种以key存储在内存中的数据结构。是根据key来直接访问在内存存储位置的数据结构。
- set: 类似array ,set,add(),delete(),clear(),has()
数组去重:Array.from() //将其变成数组
new Set() //利用set没有重复的值的属性
综上:let a=new Set(Array.from([3,4,5,5]));//a:[3,4,5]
//注意;这个变成了Set construct。so should do this:
let aa=Array.from(new Set([3,3,4,4,5])); //aa:[3,4,5]
- map:类似object ,size,get(),set(),delete(),clear(),has()
const m=new Map() //better key-value way
m.set(name,'komolei')
m.get(name) //komolei
2. support chain invoked
m.set('age',22).set('sex','female')
3. for...of --> keys(),values(),entries(),forEach()
const map=new Map([[{name:'komolei'}],{age:22},22]); // map是个对象。所以定义出差,
改为
const map=new Map([[{name:'komolei'}],{age:22},{xx:22}])
let a=map.keys(); // name,age,22
let b=map.values(); // komolei,22,
let c=map.entries(); //[name:'komolei'],{age:22},22 //上面error
改为
const map=new Map([['p',{name:'komolei'}],[{age:22},{xx:2222}]]);
let a=map.keys() //'p',undefined //error // 应该返回'p',{age:22}
let b=map.values() // {name:'komolei'},{age:22},{xx:2222} //应该返回 {name:'komolei'},{xx:2222}
3. 跟array的相互转化
let a1=[...a] // [p,{age:22}]
- class
js的class是根据原型链来模拟生成的。相当于语法糖。
不同的版本,类的写法不一样
function People(name, age) {
this.name = !name ? 'clc' : name;
this.age = !age ? 24 : age;
// function sayName() {
// return this.name;
// }
// function getAge(){
// return this.age;
// }
this.sayName();
}
People.prototype = { sayName: function () { return this.name }, getAge: function () { return this.age } }
const c = new People('komolei');
// 好吧。忘记es5的继承是怎么写的。复习一下
function Person(sex) {
this.sex=sex;
People.call(this)
}
Person.prototype = new People();
Person.prototype = People.prototype;
reference
class People {
constructor(name, age) {
this.name = name;
this.age = age;
this.value = null;
}
sayName() {
return this.name;
};
getAge() {
return this.age;
}
set(value) {
return this.value = value;
}
// static // 静态方法。是类所拥有的,并不会被实例对象所使用。
// new 出来的对象,并不能调用static开头的方法
static get() {
return this.name.split('').join('!');
}
}
const p = new People('komolei', 24);
console.log(p.sayName());
console.log(People.get());
// 添加私有属性
// 现在只能添加
People.sex={};
// 继承
class Person extends People {
constructor(name, age, sex) {
super(name, age);
this.sex = sex;
}
getSex() {
return this.sex;
}
}
const per=new Person('clc',24,'male');
console.log('person',per.sayName()); //这个sayName()是被继承而来的,来自于People.
- generators(生成器)
// 普通函数以function开头,而generators以function*开头
// 普通函数开始运行时,不能停止,最后会return一个值,而generators以yield作为return的替换,同时运行可以暂停。使用next,进入下一个yield。
function* say(name){
yield 'hello generator'
yield 'yes'
if(name.length>0){yield 'good'}
yield 'say you' }
const s = say('dd'); //初始化 //状态为 suspended
s.next() // hello generator
s.next() // yes
s.next() // 进入判断,得到 good
s.next() // say you
s.next() // undefined // 状态为closed
// 可以解决异步回调地狱 // 跟async和await一样吧。在使用过程中,generators还是用的少。
// 同时generators的本质还是iteration(迭代器)
- string
平常在使用的过程中,字符串的增删改查?增很少,通常是通过+来完成的,但是今天刚刚看见。在string的原型链上还有concat方法。多看书的好处啊
- Proxy(代理)
- 什么是对象?
一堆键值对的聚合。?一堆属性的集合?
当我经常在使用Js的对象的时候,却忘记对象是什么?Mdn说对象,一系列的属性的聚合,一个属性包含一个名和一个对应的值,其中当对应的值是函数的时候,这个属性叫做方法,而不是这个函数叫做方法。不过貌似自己经常叫函数为方法。
- Js
对于Js而言。在初始化对象的时候,在其的内部包含着东西,想想原型链那样。就像我们身上的灵魂一样,看不见,但是组成了我们。
现在通过proxy就能改变内部方法,多么美妙,就跟灵魂的改造一样。曾经触碰不到的宇宙的奥妙,现在通过一扇门向我们敞开。
- example
let target={},handler={};
const proxy = new Proxy(target, handler);
proxy.color='red'; //这个时候 target为{ color:'red'};
// 多么奇怪,我们没有给target进行添加属性,但是它就在了。
// 解析:一般我们对于一个对象进行这样的操作的时候:
let obj={}; obj.name='komolei' //其实obj.name这个operation 是在调用obj中的[[set]]方法
- proxy :将代理的内部所有方法转发到target中去
// 上面的例子中 proxy.color='red'
实际上是proxy.[[set]]()调用了target.[[set]](),就像灵魂的交流一样。
但是有时候,你会发现目标对象不会接收proxy的信息,就像吵架的人一样,一方不听一方说辞一样。
即:target可以设置对象,让proxy无法转发信息到其内部。
- 句柄对象:记得上面说过js的最内部的方法有14种,现在通过句柄对象的方法可以重写这些方法。
let target={},handler={set:function(target,value){
throw new Error('prohibit set') };
let proxy=new Proxy(target,handler);
proxy.color = 'red'; // prohibit set
// 现在我们无法对对象进行set operation了,这就像人生气,没有都不会听进去一样。
- 对象是在js中拥有[[get]],[[set]]等操作的实体
- reflect (反射)
个人理解:JS中的反射,是为了分离obj,因为js中的对象有很多的方法。太杂乱了,分离出来,让灵魂更加纯净。
看了一些,还是这篇推荐一波Reference
网友评论