ES6
创建类 ES6
```
class Star { // 创建一个类
constructor(names){ // 类的内置函数
this.names = names; // 赋值给this
this.main; // 通过this调用下面的自定义函数
}
main(){
console.log(this.names) // 内置直接调用
}
}
let aa = new Star("哈哈"); // 利用创建的类
console.log(aa.main) // 也可以通过外面调用main
```
```
element.insertAdjacentHTML('位置',文本的HTML内容) // 插入元素ES6才有
位置有以下几个内置对象
beforebegin // 插入元素到前面
afterbegin // 插入元素儿子的第一个节点前面
beforeend // 插入元素到儿子的最后一个节点后面
afterend // 插入元素到后面
```
创建对象 ES5
new Object()
var hero = new Object(); //创建空对象
hero.xue = 100；
hero.name = '张飞'；
hero.wuqi = '刀'；
对象字面量
var hero = {
blood: 100,
name: '张飞'
weapon：'剑'
}
工厂函数 创建多个对象
function createHero(name, blood, weapon) {
var o = new Object();
o.name = name;
o.blood = blood;
o.weapon = weapon;
o.attack = function () {
console.log(this.weapon + ' 攻击敌人');
}
return o;
}
构造函数 ES5
```
function Creat(name,blood){
this.name = name;
this.blood = blood;
}
Creat.prototype.main = function (){ // 创建原型对象
console.log("我是" + this.name)
}
console.log(Creat.constructor) // 打印原型对象的属性
```
构造函数的名字，第一个字母要大写，构造函数不需要返回，创建对象也不需要声明对象变量，调用的时候要用new来调用
构造函数名.constructor;可以查看该构造函数的源代码，用打印方式输出
constructor 一般常用于引用，比如B构造函数调用了A构造函数的原型对象，那么原型对象指向的是A，需要改变引用就要用constructor来 = B
instanceof 判断某个对象变量是否是某个构造函数的实例，就判断这个对象是不是这个构造函数创建的
使用方法：判断的变量变量名 instanceof 构造函数名 返回true或false
构造函数名.prototype 返回构造函数原型
构造函数名.prototype.对象变量名 = 对象变量数值 在原型构造函数里面增加一个新的对象，使全部调用的对象变量变动，追加的这种匿名函数都会使用一个内存地址，并不像原型内部包括的那种每次调用都进行创建，如果在原型中有需要追加的对象变量，那么调用时，优先输出原型中的，如果原型中没有才会调用追加的原型对象，追加类似替补,读取时，所有调用的对象变量，共用一个，但是如果对对象变量名进行赋值，那么会创建一个新的，替换掉原型的，所以只能预先设置，进行读取，后续无法修改
在构造函数内只有一个函数方法的时候，可以用prototype，如果多个，就需要
__proto__ === prototype
构造函数名.prototype.init 构造函数初始化样式
函数名.bind(变量) 用来改变函数中，this的指向，例如以下
```
var a = '123';
function fn(){
console.log(a);
}
var a = setInterval(function(console.log(this)){}.bind(b)),1000)
fn() //输出内容是123 上面这个代码，是在定时器内改变指向
var b = '456'
var fns = fn.bind(o);
fns(); //输出的内容就是456
```
自调用函数的时候，如果有多个自调用，尾部加一个分号，用来结束语句，防止代码出问题
压缩代码后，勾选混淆，会把变量变短
继承
```
class Abc{ // ES6
constructor(){
}
aa(){
console.log("打印这里")
}
}
class Dce extends Abc { // 复制对象(继承)
constructor(){ // 获取函数是就近原则，先看自己，再看父级
super.aa() // 调用父级中的构造函数,如果使用父级的普通函数，就需要传递
}
}
var dce = new Dce();
console.log(dec.aa()) // 打印测试
```
B对象复制A对象时，B对象如果有相同类型的对象跳过，继续遍历复制，这就是继承对象
函数名.call(this指向的变量,函数变量) 跟bind一样，只是前者返回一个新的函数，这个是直接调用函数，改变指向
借用构造函数的方法，只能继承属性，无法继承方法，方法要是写在构造函数内可以，要是放在原型对象里面就不行
```
function Person(name,age,sex)(){
this.name = name;
this.age = age;
this.sex = sex;
}
function Student(name,age,sex,score){
Person.call(this,name,age,sex); //这就是在借用另外一个构造函数的代码
this.score = score; //实现这个构造函数只要给变量就可以，节省代码
}
var s1 = new Student('张三',18,'男',100)
```
ES5 增加的数组方法
```
var arr = [10,12,88,"blue"]
arr.forEach(function(value,index,array){ // 数组遍历
// value 数组中每个成员的值
// index 数组中每个成员的索引
// arrar 数组本身
}) //↓ 创建新的数组,可以过滤成员
var newArr = arr.filter(function(value,index){
return value >= 10; // 返回大于10的数组成员,组成新的数组
})
if(arr.some(function(value){ // 对数组中进行查找,并返回false
return value == "blue"; // 只查找到第一个就跳出
})){
}
```
ES5中对象Objcet增加和修改
```
var obj = {
name: "你好",
id: "2",
sex: "女"
}
var arr = Object.keys(obj) //把objcet中的属性获取到后赋值给arr数组
//Object.defineProperty("目标对象","需要修改的属性","")
Object.defineProperty(obj,"num",{ //如果里面有num则修改,没有则增加
value:1000, // 设置num的值为1000
writable:false, // 锁死这个属性，之后无法修改
enumerable:false, // 是否遍历时,可以被发现
configurable:false // 是否可以被删除和修改
})
```
组合继承
组合方法跟继承call一样，只是原型对象也要借用，通过以下方法来调用
```
Student.prototype = new Person(); //让B构造函数的原型对象和A的相等，来调用
Student.prototype.constructor = Student; //让B原型对象指向B，原来是A，借来不变
```
var fn = new Function('a','b','console.log(a + b)')
fn(1,2) //结果就是3,这样子一行代码就可以，但是速度会慢，需要多次解析
函数内部的this，是由函数调用的时候来确定其指向的
call、bind、apply
call可以借用其他类型的方法，例如 对象借用数组的方法，需要对象为伪数组
数组借用对象的方法，实际应用就是减少代码，通过内置方法来达到目的，提高速度
bind，改变函数的指向
call，调用函数，顺带改变指向
apply，可以直接展开数组中的对象，顺带改变指向，带调用
被借用函数.apply(指向函数，借用函数) 一般是数组，或者对象，其他没有层叠分明
闭包
就是嵌套函数中，最内部的函数调用外层函数的这个过程叫做闭包，如果最内层没有调用外部函数的变量或者对象，将不会产生闭包现象，闭包可以有效的减少代码
递归
递归的真正用途是，把两个对象进行复制，让B复制A，包含深度复制
正则表达式
? 关闭贪婪模式
RegExp(模式pattern,flag忽略大小写) flag（i忽略大小写，g全局匹配）
```
var a = new RegExp('([\S\s]*?)','i') //第一种创建方法
var b = 'asbasdag'
a.test(b)
var re = /([\S\s]*?)/ig //第二种创建方法 /中间是正则表达式/这里放大小写和全局
var rr = 'asdgahaha' //正则方式.提取(文本)，与String对象的方式相互转换
re.test(rr) //返回的是false或者true
re.exec(rr) //返回匹配内容，类型为数组,一定要全局匹配，不然只返回第一个匹配
//这种方式，如果匹配为多个，需要循环来调用，循环第一次提取1,循环2，提取2，以此类推
rr.match(re) //文本.提取(正则方式)，返回所有匹配内容，也一样要全局
rr.split('分隔符') //切割的用法，返回数组
rr.split(' ').join(); //这种方法也可以替换文本中的空格，先分割，后合并数组成员
rr.replace(替换前内容,替换后内容)； //只替换一个内容
rr.replace(这里可以使用正则表达式，全部替换要加全局,替换后内容)
rr.replace(/,|，/g,'.') //全选，匹配两种，然后全部替换为点
rr.trim() //只替换前后内容，开头与结尾
```
RegExp对象
test() 匹配
exec() 提取
String对象
match() 提取
replace() 替换
split() 切割
search()
```
var 全局变量 在函数内,作用域就是函数内,函数外则全局
let 局部变量 {在这里有效} 需要先声明后在使用,var可以先使用在声明
const 常量 如果是数组,则可以修改数组成员的值,但不可以增加和减少成员,且不可以重新赋值
```
箭头函数
```
const sn = () => { // 标准写法
}
sn
const sn = (a,b) => a + b; // 两个以上形参的写法
相当下面这个函数
function sn(a,b){
return a + b;
}
const sn = a => console.log(a) // 一个形参的可以更省略
```
剩余参数
```
function main(a,...b){ // 加3个点,多余的实参将合并到形参中,为数组
console.log(a)
console.log(b)
}
main(1,2,3,4,5)
let a = [1,2,3,4,5]
let [a1,...a2] = a; // a1= 1, a2 = [2,3,4,5] 剩余数组赋值给a2
console.log(...a) // 打印数组内的成员为文本
let b = [6,7,8];
let c = [...a,...b] // 合并数组1
a.push(...b) // 合并数组2
```
```
var array = {
"0": "张三",
"1": "李四",
"2": "王五"
}
var arr = Array.from(array) // 还可以在第二个参数放一个函数处理数组
console.log(arr) // 将objcet 变成一个真的数组
```
数组的一些方法
```
arr.find() 返回在测试函数中通过测试的数组中第一个元素的值
arr.findIndex() 返回在测试函数中通过测试的数组中第一个元素的索引
includes() 与indexOf用法一样，只是返回的是true和false
```
字符串的方法
```
let name = `张三`;
let sayHello = `我的名字叫${name}`; // 可以直接给文本内放变量
let re = {
name: "张三",
age: 20
}
let html = ` // 可以直接调用对象里没的文本
<div>${re.name}<\div>
<div>${re.age}<\div>
`;
```
startsWith() 和 endsWith()
```
let str = 'AbcdeF'; 用来判断首字母和尾字母是否是判断的字母,返回逻辑
str.startsWith('Abc') // 返回 true
str.endsWith('f') // 返回 false
```
repeat()
```
let str = "ABC";
str.repeat(3) // 返回 ABCABCABC 设置几就是重复几次生成一个新文本
```
set 结构去重
```
let arr = new Set(['a','b','a','b','c']);
log(arr.size) // 返回去重后的 abc
Set 的方法有几个
add(value) // 添加某个值,返回Set结构本身
delete(value) // 删除某个值,返回一个布尔值
has(value) // 返回一个布尔值,判断是否是Set成员
clear() // 清空所有成员,无返回
arr.add('s').add('k')
arr.delete('s');
arr.has('f');
arr.clear()
arr.forEach(value => { // value为形参
console.log(value)
})
```