类(Class)是面向对象程序开发设计(OOP，Object-OrientedProgramming)实现信息封装的基础。类是一种用户定义类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
类
classAnimal{
constructor(name){
this.name=name
}
Spack(){
console.log(name)
}
}
classDogextendsAnimal{
constructor(name,age){
super(name);//子类中如果有constructor,就必须有super
this.age=age
}
Spack(){
super.Spack()//如果没有,则重写Spack方法,有则在Spack中添加内容
console.log(age)
}
}
模块化
//导出
varname='Rainbow';
varage='24';
export{name,age};
导入
import{name,age}from'来源';
箭头函数
()=>1
v=>v+1
(a,b)=>a+b
()=>{
alert("foo");
}
e=>{
if(e==0){
return0;
}
return1000/e;
}
模板字符串
letname=Tom
`welcome${name}`
解构赋值
let[foo,[[bar],baz]]=[1,[[2],3]];
foo//1
bar//2
baz//3
[x,y='b']=['a',undefined];//x='a',y='b'
for(let[key,value]ofmap){
console.log(key+"is"+value);
}
延展操作符
functionsum(x,y,z){
returnx+y+z;
}
constnumbers=[1,2,3];
console.log(sum(...numbers));
let[a,b,...c]=[1,2,3,4,5,6,7,]
console.log(a,b,c)//12[3,4,5,6,7]
vararr=[1,2,3];
vararr2=[...arr];//等同于arr.slice()
Promise
varpromise=newPromise(function(resolve,reject){
//...somecode
if(){
resolve(value);
}else{
reject(error);
}
});
promise.then(function(value){
//success
},function(error){
//failure
});
promise.then((value)=>{
//success
},(error)=>{
//failure
});
promise.then((value)=>{
//success
}).catch((err)=>{
//failure
});
Generator函数
function*gen(x){
vary=*yield*x+2;
returny;
}
varg=gen(1);
g.next()//{value:3,done:false}
g.next(2)//{value:2,done:true}
async/await
*async*functionprocess(array){
for*await*(letiofarray){
doSomething(i);
}
}
asyncfunctionprocess(array){
forawait(letiofarray){
doSomething(i);
}
}
正则
/foo.bar/.test('foo\\nbar')//false
/foo.bar/s.test('foo\\nbar')//true
letstr='2019-07-31'
letreg=/(\\d{4})-(\\d{2})-(\\d{2})/
letreg=/(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})/
console.log(str.match(reg).grouPS)
letreg=/^(?<name>welcome)-\\k<name>-\\1$/
letstr=welcome-welcome-welcome
console.log(reg.test(str))
Proxy
letjson={
name,
age
}
letnewJson=newProxy(json,{
set(target,property,value){
if(property=='age'){
if(!Number.isInteger(value)){
<!--thrownewTypeError('年龄是整数')-->
returnfalse
}
}
target[property]=value
returntrue
},
get(target,property){
if(propertyintarget){
console.log(`你访问了${property}属性`)
returntarget[property]
}else{
console.log(`没有这个属性`)
returnnull
}
},
has(target,key){
returnkeyintarget;
},
deleteProperty(target,property){
returntrue
}
})
vartarget=function(){return'Iamthetarget';};
varhandler={
apply:function(){
return'Iamtheproxy';
}
};
varp=newProxy(target,handler);
p()
constDOM=newProxy({},{
get(target,property){
returnfunction(attr={},...children){
consoleel=document.createElement(property)
for(letkeyofObject.keys(attr)){
el.setAttribute(key,attr[key])
}
for(letchildofchildren){
if(typeofchild=='string'){
child=document.createTextNode(child)
}
el.appendChild(child)
}
returnel
}
}
})
letoDiv=DOM.div(
{id:'id1',class:'cl1'},'div','1123',
DOM.ul({},
DOM.li({},111)
DOM.li({},222)
DOM.li({},333)
)
)
类的实质是一种数据类型，类似于int、char等基本类型，不同的是它是一种复杂的数据类型。因为它的本质是类型，而不是数据，所以不存在于内存中，不能被直接操作，只有被实例化为对象时，才会变得可操作。
