const
使用const声明的常量必须赋值、赋值后不可再更改
const定义的常量如果是引用类型 可以改变对象内属性
es6中class类
基本使用：
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
showName() {
console.log(this.name)
}
}
var p = new Person('kobe', 39);
继承:
class Chinese extends Person {
子类继承父类，若有自己独有的属性和方法，应该重写constructor构造器，
构造器中应传入父类公共的属性，将 super()函数写入constructor中并位于第一位，
并将父类属性传入super()函数中，此时 super() 就相当于父类中构造器constructor
constructor(name, age, IdNumber) {
super(name, age);
this.IdNumber = IdNumber;
}
showName() {//父类方法重写
console.log(this.name,this.age,this.grade);
}
}
var p = new Chinese('ss', 12, 45);
p.showName();
可以使用super直接调用父类的方法 super.say();
class son extends Father {
say() {
console.log(super.say() + '儿子')
}
}
三点运算符 ...value
函数中使用
function fn(...value) { value是一个真数组 将参数归为一个数组中
console.log(value);
for (var i = 0; i < value.length; i++) {
console.log(value[i]);
}
}
fn(1, 30); // 结果：[1, 30]
数组中使用
var arr1=[1,6];
var arr2 = [2,3,4,5];
让arr2插入到arr1中
arr1 = [1,...arr2,6];
console.log(arr1);// 1 2 3 4 5 6
var arr=[1,2,3];
console.log(...item) 1 2 3
导入、导出
export const num = 'xxx'
export function...
export default ....
import {} from 'xxx'
import xxx from 'xxx'
形参默认值
function Point(x = 0, y = 0) {
this.x = x;
this.y = y;
}
var p1 = new Point(10, 20);
console.log(p1); // Point {x: 10, y: 20}
var p2 = new Point();
console.log(p2);// Point {x: 0, y: 0}
字符串扩展
var str = 'ab';
console.log(str.includes('b'));//true
console.log(str.startsWith('a'));//true
console.log(str.endsWith('b'));//true
console.log(str.repeat(3)); //ababab
数值扩展
------、数值扩展
Number.isFinite() -- 是否是有限数
console.log(Number.isFinite(123));//true
console.log(Number.isFinite(Infinity));//false
Number.isNaN()--是否是非数字
console.log(Number.isNaN(123));//false
console.log(Number.isNaN(NaN));//true
Number.isInteger()--是否是整数
console.log(Number.isInteger(123));//true
console.log(Number.isInteger(123.56));//false
Number.parseInt()--将字符串转换为整数
console.log(Number.parseInt('123.abs'));//123
Math.trunc()--直接去除小数部分
console.log(Math.trunc(343.56));//343
数组扩展
Array.from()//将伪数组转为真数组
Array.of(v1,v2,v3)//将一系列数值转为数组
[].find(function( item ,index ){ return item > 4; });//找出第一个满足条件返回true的数值
[].findIndex(function( item ,index ){ return item > 4; });//找出第一个满足条件返回true的数值的下标
对象扩展
console.log(0 == -0 );//true
console.log(NaN == NaN );//false NaN与任何数都不相等
Object.is(s1,s2);//判断两个对象是否相等 以字符串为标准判断的
Object.is( 0 , -0) ;//false
Object.is( NaN , NaN);//true
Object.assign(目标对象, 源对象, 源对象,源对象...);//将源对象的属性复制到目标对象上
直接操作__proto__属性
var obj1 = {};
var obj2 = {grade: 5};
obj1.__proto__ = obj2;
console.log(obj1.grade);//5
Promise
基本使用
Promise是ES6提供的一种处理异步编程的对象 目的是以一种优雅的方式解决回调地狱
有了promise对象，可以将异步操作以同步的流程表达出来，
避免层层嵌套的回调地狱 Promise是一个构造函数 通过实例化方式使用
示例：
const p = new Promise((resolve,reject)=>{
setTimeOut(()=>{
if..
resolve('成功');
else..
reject('失败');
},3000)
});
p.then((data)=>{},err=>{})
(promise会立即执行 应该将其放在方法中)
多层嵌套
new Promise((resolve, reject) => {
resolve('aaa');
// reject('失败了')
}).then((data) => {
console.log(data + '第一层处理结果')
return new Promise((resolve, reject) => {
resolve(data + '第二层请求');
})
}).then((data) => {
console.log(data)
return new Promise((resolve, reject) => {
resolve(data + '第三层');
})
}).then((data) => {
console.log(data)
}).catch(() => {
console.log('错误回调')
})
同时处理多次异步请求
Promise.all([
new Promise((resolve, reject) => {
setTimeout(() => {
resolve('11')
}, 1000)
}),
new Promise((resolve) => {
setTimeout(() => {
resolve('22')
}, 2000)
})
]).then((results) => {
console.log(results)
})
set、map
https://blog.csdn.net/zm17671443092/article/details/108586989
