自学笔记--es6

面向对象编程；就是把事物分解成为一个个对象，然后由对象之间分工与合作；
面向对象的特性；封装性，继承性，多态性

ES6中的类和对象；
面向对象的特点；
1.抽取对象共有的属性和行为封装成一个模板
2.对类进行实列化，获取类的对象
 

 创建类；
 类定义不会被提升，这意味着，必须在访问前对类进行定义，否则就会报错。
类中方法不需要 function 关键字。
在类里面共有的属性和方法一定要加this使用

 语法；
 class name{ 【创建一个类名是name的类】
     class bady
 }
var a1=new name(); 【将创建的类进行实列化成为一个对象】

类constructor构造函数；
constructor()方法是类的构造函数，用于传递参数，返回实列对象，通过new命令生成对象实列时，自动调用该方法，如果没有显示定义，类内部会自动给我们创建一个constructor()
class name{
                constructor(arg,aa1) { //必须要有constructor()，这个函数； 构造器或着构造函数
                    console.log(arg)
                    
                    this.arg=arg
                    this.aa1=aa1;
                }
                say(){ //类中的方法，多个方法之间不需要添加逗号

                }
            }
            var a1=new name("同盟国")
            var ld=new name(1,23)
            ld.say() //调用里面的方法，也可以加入参数
            console.log(ld)

类的继承；【继承夫类中的属性和方法，，如果实列化子类输出一个方法，先看子类有没有这个方法，有就执行，
没有就去看父类中的方法执行，按照就近原则继承】
语法；
class fa{//夫类}
class son extends fa{子类继承夫类}
使用；var a1=new son();
a1.方法；

super关键字；用于访问和调用对象夫类上的函数，可以调用父类的构造函数，也可以调用父类的普通函数【在调用父类的构造函数时必须先使用super调用父类在写其他的代码】
class Father{
                constructor(x,y) {
                    this.x=x
                    this.y=y;
                    
                }
                sa(){
                    console.log(this.x+this.y)
                }
            }
            class son extends Father{
                constructor(x,y) {
                   super(x,y) //调用了夫类中的构造函数，，必须要传入参数才能在父类里面计算结果
                    
                }
                    as(){super.sd() //调用了父类中的sd方法减少了代码的书写}
            }
            var  a2=new son(2,5);
            a2.as();

暂时性死区;，在代码块内，使用 let 命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”
【在一个对象中想要使用其他的方法和变量需要使用this来调用】
this指向问题；
1.在constructor()方法里面的this指向的是整一个类的对象，和实列化以后的对象一样
2.方法函数里面的this指向它的调用者，就是实列化之后的对象名

静态成员和实列成员；
1.实列成员就是构造函数内部通过this添加的成员，，实列成员只能通过实列化对象来访问
2.静态成员就是在构造函数本身上添加的成员，，静态成员只能通过构造函数访问

es5里面新增的方法；
array.forEach()；；遍历数组
列如；
  a1.forEach((value,index,arr) => {
            console.log('数组元素是'+value)
            console.log('数组元素的索引号是'+index);
            console.log('数组本身'+arr);
        });

array.filter()；；遍历数组，可以在里面添加一些条件，然后返回一个新的数组
 var newarr=  a1.filter((value,index)=>{
return value>3
        })
        console.log(newarr);

array.some()；；用于检测数组中的元素是否满足指定的条件，并返回一个布尔值【只要找到目标元素就不循环剩下的元素】
var max=a1.some((value,index)=>{
    return value>5
})
console.log(max);

array.reduce()；；用来将数组里面的各项数据相加
 const number3=num.reduce((number,item)=>{
      return number+item
  },0)【number就是第二个参数0，item就是数据里面的各项数据，如果没有数据就返回number0，有数据就累计相加】

forEach和some的区别：：如果查询数组中唯一的元素, 用some方法更合适,在some 里面 遇到 return true 就是终止遍历 迭代效率更高

string.trim()；；自动去除字符串两边的空格
a1.trim()

Object.keys(对象名)；；获取对象自身的所有属性，并返回一个数组
const arr=Object.keys(对象名)

Object.defineProperty(对象名，属性名，{属性值})；；添加一个对象的属性或着是修改对象的属性值

闭包；【值有权访问另一个函数的作用域中的变量的函数，，一个作用域可以访问另外一个函数内部的局部变量】
   var a1= (function(){    //()()使用这个形式表示函数立即执行，就不需要调用了
            var sta=13
            var totle=0
            return{
                pri:function(n){
if(n<=3){
    totle=sta
}
else{totle=sta+(n-3)*5}
         return totle       },
yd:function(){

}
            }
        })()
       console.log(a1.pri(5));

递归；【如果一个函数在内部可以调用其本身，那么这个函数就是递归函数】函数内部自己调用自己
注意；；递归里面必须要加退出条件，不然会发生死循环报错
 function a1(n){
           if(n==1){
               return 1
           }
           return n*a1(n-1)
       }
       console.log(a1(5));

正则表达式；是用于匹配字符串里面字符组合的模式，，正则表达式也是一个对象

箭头函数；
语法；参数 => 函数
列；
var f = (a,b) => {
 let result = a+b;
 return result;
}
f(6,2);

注意；当箭头函数要返回对象的时候，为了区分于代码块，要用 () 将对象包裹起来
var f = (id,name) => ({id: id, name: name});
f(6,2);  // {id: 6, name: 2}

this；当this使用在箭头函数里面时，他是指向箭头函数外面的对象里面的内容；
var Person1 = {
    'age': 18,
    'sayHello': function () {
      setTimeout(()=>{
        console.log(this.age);
      });
    }
};
var age = 20;
Person1.sayHello();  // 18

函数的扩展；【在设置参数的时候直接赋值，调用的时候，如果没有设置参数则就用默认设置的值】
function Point(x = 0, y = 0) {
 this.x = x;
 this.y = y;
}
const p = new Point();

构造函数和原型；
利用构造函数创建对象；
function star(name,arg){
    this.name=name;
    this.arg=arg;
    this.sing=function(){
        console.log("哈哈哈哈")；
    }
}
var id=new star("得到"，12)； //构造对象
ld.sing() //使用
ld.arg;
star.sex="男"//在外面添加属性
console.log(star.sex); //只能通过函数调用，不能通过对象的实列化来调用
1.构造函数中的属性和方法我们称为成员，成员可以添加
2.实列成员就是构造函数内部通过this添加的成员就是实列成员
3.实列成员只能通过实列化的对象来访问,不可以通过构造函数来访问实列成员
4.静态成员；在构造函数本身上添加的成员

Es6模块化；
在脚手架里面的pacege.josn文件里面添加开头 "type":"module", 就可以使用模块化的东西了

模块化的基本语法；
1.默认导出与默认导入
导出【可以在外面随意导入使用】
export default 默认导出的成员【成员变量，成员方法的名字】
export default{a1,a2()} ,,以对象的方时导入

导入
import 接收名称 from '模块标识符'【路径】

注意；在每一个js文件之中只能使用一次export default否则会报错

2.按需导出与按需导入
导出； 
export 导出的名字
export let a1=12
export let a2=23

导入；
import {a2,a1} from '路径'

注意； 
1.每一个模块之中可以使用多次按需导出
2.按需导入的成员名称必须和按需导出的名称一致
3.按需导入时，可以使用as关键字进行重命名【在导入的时候进行，，a2 as a4】
4.按需导入和默认导入一起使用

3.直接导出并执行模块中的代码
import '路径'
在文件里面直接写执行程序的代码，然后在直接导出文件，就能够自动执行了

promis的作用和概念
promise的基本概念；
1.promise是一个构造函数【可以new一个实列出来，，canst p=new promise() ,,代表一个异步操作】
p.then(成功的回调函数，失败的回调函数) 方法用来预先指定成功和失败的回调函数【】
列； p.then(result=>{},error=>{}) 【官方规定成功的回调函数时必须要选的，失败的回调函数可以选也可以不选】

回调地狱；多层回调函数的相互嵌套，就形成了回调地狱
promise异步读取文件的内容
fs.readFile('读取文件的路径','文件的编码【utf8】').then（rr1=>{成功时执行的函数},error=>{失败时执行的函数})【第一个参数是读取成功的结果，第二个参数是读取成功的结果】
安装then-fs这个包才能使用fs这个函数；
步骤；
1.npm i then-fs
2.import fs from 'then-fs'

通过.catch()方法捕获错误【使用的是try{}.catch(err){}语句；；先执行try里面的语句。如果里面的代码执行成功就不执行catch的语句，，如果执行错误就执行catch的语句，
参数err，就是返回来的错误信息】
.catch((err)=>{
    console.log(err.message) //如果发生错误就打印错误的位置【一般放在最后的位置，如果前面产生错误，那么在最后都会打印出来】
})
promise.all()方法；会发起并行的promise异步操作，等所有的异步操作全部结束后才会执行下一步的 .then操作

基于promise封装读文件的方法
方法的封装要求；
1.方法的名称要定义为getFile
2.方法接收一个形参fpath，表示要读取文件的路径
function getFile(fpath){ //在调用时只要传入一个路径就能返回一个promise对象

3.方法的返回值为promise实列对象
return new promise(
    function(){
        fs.readFile(fpath,'utf8',(err,dataStr)=>{

        })
    }
)}

getFile('路径').then('成功的函数','失败的函数')

async与await的基本使用；【在使用中两个都必须在一起使用，不能分开】
async function getFile(){
    const r1=await fs.readFile('路径','utf8')
    console.log(r1)
    const r2=await fs.readFile('路径','utf8')
    console.log(r2)
}
getFile() 【这样就是直接拿到文件的值，而并不是拿到一个promise对象】
注意事项； 
1.如果方法之中用到了await这个关键字，那么就必须使用async这个关键字，否则就会报错

js里面的模块化；；
导出；；
module.exports={导出的变量名，韩数名，对象名}

导入；；
const  obj=require('js文件路径')

使用；；
obj.变量名