let

可以一次声明多个变量

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//一次声明多个变量let a;let b,c,d;let e=100;let f=521,g="iloveyou",h=[];console.log(a,b,c,d,e,f,g);</script></body>
</html>

变量不能重复声明

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let a='mylove';let a='cool';console.log(a);</script></body>
</html>

有块级作用域，只要代码块里有效，出了代码块就无效了，块级作用域还有if else while for等

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//var是全局 let是块级{let girls="漂亮";var student="学习";}console.log(student);console.log(girls);</script></body>
</html>

不存在变量提升

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>console.log(song);let song='唱歌';</script></body>
</html>

不影响作用域链

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>{//song的值可以输出来let song='唱歌';function fn(){console.log(song);}fn();}</script></body>
</html>

思考下这个例子

下面两种方法的区别

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title><style>.item{border:1px solid green;width:80px;height:60px;display: inline-block;}</style></head><body><div class="container"><h2 class="page-header">点击切换颜色</h2><div class="item"></div><div class="item"></div><div class="item"></div></div><script>//获取div元素对象let items=document.getElementsByClassName("item");//遍历并绑定事件for(var i=0;i<items.length;i++){items[i].onclick=function(){this.style.background='pink';}}</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title><style>.item{border:1px solid green;width:80px;height:60px;display: inline-block;}</style></head><body><div class="container"><h2 class="page-header">点击切换颜色</h2><div class="item"></div><div class="item"></div><div class="item"></div></div><script>//获取div元素对象let items=document.getElementsByClassName("item");//遍历并绑定事件for(let i=0;i<items.length;i++){items[i].onclick=function(){items[i].style.background='pink';}}</script></body>
</html>

const

值不能修改的量叫做常量

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//声明常量const a=4;console.log(a); //4const b=8;b=9;console.log(b);//Assignment to constant variable</script></body>
</html>

常量一定要赋初始值

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const aconsole.log(a);</script></body>
</html>

一般常量使用大写，小写也不会报错，推荐常量后面跟大写字母

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const EAT="丝瓜炒蛋"console.log(EAT);</script></body>
</html>

常量是块级作用域

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>{const AT="暴富";}console.log(AT);</script></body>
</html>

对于数组和对象的元素修改，不算做对常量的修改，不会报错

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const TEAM=["小学","初中","大学"];TEAM.push('高中');console.log(TEAM);</script></body>
</html>

变量的解构赋值

es6允许按照一定模式从数组和对象中提取值，对变量进行赋值，这就被称为解构赋值

数组解构

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const F4=["欧阳","沈","顾","傲天"];let [ouyang,shen,gu,aotiao]=F4;console.log(ouyang,shen,gu,aotiao);</script></body>
</html>

对象解构

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const zhao={name:"赵本山",age:"63",xiaopin:function(){console.log("我可以演小品");}};let {name,age,xiaopin}=zhao;console.log(name);console.log(age);console.log(xiaopin);xiaopin();</script></body>
</html>

模板字符串

es6引用了新的符号反引号``,作用跟双引号单引号差不多

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let str=`我是一个字符串`;console.log(str,typeof str);</script></body>
</html>

可以直接换行

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let str=`<ul><li>学习</li><li>暴富</li><li>有钱</li></ul>`;console.log(str);</script></body>
</html>

可以变量拼接 `${}`

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let cute="我可爱";let cool=`${cute}有钱`console.log(cool);</script></body>
</html>

对象的简化写法

es6允许在大括号里，直接写入变量和函数，作为对象的属性和方法，函数里的方法可以省略掉：function

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let name="财神";let change=function(){console.log("我会成为有钱人");}//就是这里简化了const school={name,change,//直接在新增的内容进行了省略cute(){console.log("我省略了冒号function");}}console.log(school);</script></body>
</html>

箭头函数

es6允许使用箭头=>定义函数

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//普通函数let fn=function(){}//箭头函数let fn1=(a,b)=>{return a+b;}//调用函数let result=fn1(1,2);console.log(result);</script></body>
</html>

箭头函数this-----this是静态的，this始终指向函数声明时所在作用域下的this的值

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>function getName(){console.log(this.name);}let getName1=()=>{console.log(this.name);}//设置window对象的name属性window.name="暴富";const school={name:"有钱"}//直接调用//getName(); //暴富//getName1();//暴富//call方法调用getName.call(school);//有钱getName1.call(school);//暴富</script></body>
</html>

不能作为构造实例化对象

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let person=(name,age)=>{this.name=name;this.age=age;}let me=new person("财神","无穷岁");console.log(me);</script></body>
</html>

箭头函数里不能使用arguments变量

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let fn=()=>{console.log(arguments);}fn(1,2,3);</script></body>
</html>

箭头函数的简写

1.省略小括号，当形参有且只有一个的时候

2.省略花括号，当代码体只有一条语句的时候,此时return也必须省略，而且语句的执行结果就是函数的返回值

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//省略小括号,当形参有且只有一个的时候let add=n=>{return n+n;}console.log(add(9));//18//省略花括号，当代码体只有一条语句的时候,此时return也必须省略，而且语句的执行结果就是函数的返回值let pow=n=> n*n;console.log(pow(9));//81</script></body>
</html>

箭头函数的适用范围

它适合与this无关的回调，定时器，数组的方法回调

不适合与this有关的回调，比如事件回调，对象的方法，不适合不等于不能哈

箭头函数的的例子1

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title><style>div{width:200px;height:200px;background-color: #00BFFF;}</style></head><body><div id="ad"></div><script>//点击div 2s后颜色变为粉色//获取元素let ad=document.getElementById('ad');//绑定事件ad.addEventListener("click",function(){//保存this的值,//这里this的指向变了，我也不是很懂let _this=this;//定时器setTimeout(function(){//修改背景颜色thisconsole.log(this);_this.style.background="pink";},2000)});</script></body>
</html>

箭头函数的例子2

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//从数组中返回偶数的元素const arr=[1,6,9,10,100,25];//一般方法// const result=arr.filter(function(item){//  if(item%2===0){//        return true;//  }else{//        return false//  }// });//箭头函数方法const result=arr.filter(item=>item%2===0)console.log(result);</script></body>
</html>

箭头函数的的例子3

这个就是没图，因为老师就是说了一下，自己去想吧

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//下面两个this的指向不一样{name:"暴富",getName:function(){this.name;}}{name:"暴富",getName:()=>{this.name;}}</script></body>
</html>

函数参数默认值

es6允许给函数参数赋初始值，有值不使用默认值，没有给值就会使用默认值，一般默认值位置放在最后

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>function add(a,b,c=10){return a+b+c;}let result=add(1,2);console.log(result);</script></body>
</html>

可以与解构赋值结合使用

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//平时一般这样写function connect(options){let host=options.host;let username=options.username;}connect({host:"localhost",username:"money",password:"money",port:3306})//与解构赋值结合起来就是这样的function connect({host="127.0.0.1",username,password,port}){console.log(host);console.log(username);console.log(password);console.log(port);}connect({//假设这里没有写host，而参数写了默认值，默认值就会显示过去//host:"localhost",username:"money",password:"money",port:3306})</script></body>
</html>

rest参数

es6引入rest参数，用于获取函数的实参，用来代替arguments

rest参数必须放在最后

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//es5获取实参function date(){console.log(arguments);}date("学习","有钱","身体健康");//是一个对象 constructor--object//rest参数function date1(...args){console.log(args);}date1("学习","有钱","身体健康");//是一个数组，可以使用数组方法//rest参数必须放在最后function fn(a,b,...args){console.log(a);console.log(b);console.log(args);}fn(1,2,3,4,5,6);</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//如果rest参数不放在最后就会报错function fn1(a,...args,b){console.log(a);console.log(b);console.log(args);}fn1(1,2,3,4,5,6);</script></body>
</html>

扩展运算符

扩展运算符符号和rest符号是一样的，三个点...

扩展运算符能将数组转换为逗号分隔的参数序列

可以进行数组合并、数组克隆

将伪数组转为真正的数组

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//扩展运算符[...]const tfboys=["易烊千玺","王源","王俊凯"]function cold(){console.log(arguments);}console.log(cold(...tfboys));</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const war=["俄罗斯","乌克兰"];const cock=["小公鸡","大公鸡"];//合并数组--数组方法console.log(war.concat(cock));//合并数组---扩展运算符const fly=[...war,...cock];console.log(fly);</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const wind=["狂风","大风","微风"];const fly=[...wind];console.log(fly);</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><div></div><div></div><div></div><script>//将伪数组转为真正的数组const divs=document.querySelectorAll("div");console.log(divs);const divArr=[...divs];console.log(divArr);</script></body>
</html>

Symbol

es6引入了一种新的原始数据类型symbol,表示独一无二的值。它是js语言的第七种数据类型，是一种类似于字符串的数据类型

symbol特点

Symbol的值是唯一的，用来解决命名冲突的问题

Symbol值不能与其他数据进行运算

Symbol定义的对象属性不能使用for..in循环遍历，但是可以使用Reflect.ownKeys来获取对象的所有键名

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//创建Symbol方法1let s=Symbol();console.log(s, typeof s);//创建Symbol方法2let s2=Symbol("财神爷爱我");let s3=Symbol("财神爷爱我");//但是这两个不是一样的console.log(s2===s3);//值为false，不一样//创建Symbol方法3//Symbol.for创建,函数对象,这种方法是唯一的let s4=Symbol.for("财神爷爱我");let s5=Symbol.for("财神爷爱我");console.log(s4===s5);//true//不能与其他数据进行运算let result=s+100;//报错let result=s>100;//报错let result=s+s;//自己相加也会报错//js的7种数据类型 usonb---- your are so niubility//u undefined//s string symbol//o object//n null number//b boolean</script></body>
</html>

Symbol 给对象添加属性和方法

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//向对象中添加方法up downlet game={name:"俄罗斯方块"}//添加方式一//借助sYMNOL完成任务,不会破坏原有的属性方法let methods={up: Symbol(),down: Symbol(),};game[methods.up]=function(){console.log("我可以改变形状");}game[methods.down]=function(){console.log("我可以快速下降");}console.log(game);//添加方式二let youxi={name:"狼人杀",//动态的添加[][Symbol('say')]:function(){console.log("我可以发言");},[Symbol("(zibao)")]:function(){console.log("我可以自爆");}}console.log(youxi);</script></body>
</html>

symbol内置值

除了定义自己使用的Symbol值以外，es6还提供了11个内置的Symbol值（symbol的属性，对象的属性），指向语言内部使用的方法

Symbol.hasInstance	当其他对象使用instanceof运算符，判断是否我该对象的实例时，会调用这个方法
Symbol.isConcatSpreadable	对象的Symbol.isConcatSpreadable属性等于的是一个布尔值，表示该对象用于Array.prototype.concat()时，是否可以展开
Symbol.unscopables	该对象指定了使用with关键字时，哪些属性会被with环境排除
Symbol.match	当执行str.match(myObject)时，如果该属性存在，会调用它，返回该方法的返回值
Symbol.replace	当该对象被str.replace(myObject)方法调用时，会返回该方法的返回值
Symbol.search	当该对象被str.search(myObject)方法调用时，会返回该方法的返回值
Symbol.split	当该对象被str.split（myObject）方法调用时，会返回该方法的返回值
Symbol.iterator	对象进行for..of循环时，会调用symbol.iterator方法，返回该对象的默认遍历器
Symbol.toPrimitive	该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值
Symbol.toStringTag	在该对象上面调用toString方法时，返回该方法的返回值
Symbol.species	创建衍生对象时，会使用该属性

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//1.Symbol.hasInstanceclass Person{static[Symbol.hasInstance](param){console.log(param);console.log("我被用来检测类型了");return true;//这里的结果是什么就返回什么,控制结果}}let o={};console.log(o instanceof Person);//2.Symbol.isConcatSpreadableconst arr=[1,2,3];const arr2=[4,5,6];console.log(arr.concat(arr2));//通过值为true/false来控制是否展开arr2[Symbol.isConcatSpreadable]=false;console.log(arr.concat(arr2));</script></body>
</html>

迭代器

迭代器iterator是一种接口，为各种不同的数据结构提供统一的访问机制，任何数据结构只要部署了迭代器接口，就可以完成遍历操作

es6创造了一种新的遍历命令for of循环，iterator接口主要供for..of消费

原生具备iterator接口的数据（可以for of遍历），Array，Arguments,Set,Map,String,TypedArray,NodeList

工作原理：

创建了一个指针对象，指向当前数据结构的起始位置

第一次调用对象的next方法，指针自动执行数据结构的第一个成员

接下来不断调用next方法，指针一种往后移动，直到指向最后一个成员

每调用next方法返回一个包含value和done属性的对象

注：需要自定义遍历数据的时候，要想到迭代器

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//声明一个数组const xiyou=["唐僧","孙悟空","猪八戒","沙僧"];//使用for...of 遍历数组for(let v in xiyou){console.log(v);}console.log(xiyou);//获取xiyou对象let iterator=xiyou[Symbol.iterator]();console.log(iterator)//里面就有next方法//调用对象的next方法,迭代器的原理console.log(iterator.next())console.log(iterator.next())console.log(iterator.next())console.log(iterator.next())console.log(iterator.next())</script></body>
</html>

迭代器应用

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const banji={name:"终极一家",stus:["鬼龙","鬼凤","贞子","盟主"],//必须写这一步骤[Symbol.iterator](){//索引变量let index= 0;//let _this=this;//需要返回对象,指针方法，里面是对象(根据原理写)return {next:function(){if(index < _this.stus.length){//还需要控制一下，不然就一直跑，可以申明变量indexconst result={value:_this.stus[index],done:false}//下标自增index++;//返回结果return result;}else{return {value:undefined,done:true}}}};}}//目的：使用for of遍历对象,并且返回数组stus成员for(let v of banji){console.log(v);}</script></body>
</html>

生成器

生成器函数是es6提供的一种异步编程解决方案，语法行为与传统函数完全不同

生成器其实就是一个特殊函数，它作用就是进行异步编程
异步编程就是在函数和函数名之间有个*号
执行是通过iteartor.next执行才能打印出函数里的console语句

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//生成器其实就是一个特殊函数，它作用就是进行异步编程//之前异步编程用的是纯回调函数 比如node fs ajax mongodb//生成器就是多异步编程的解决方案之一//异步编程就是在函数和函数名之间有个*号//执行是通过iteartor.next执行才能打印出函数里的console语句function * gen(){console.log("hello hello");    }let iterator=gen();//console.log(iterator);iterator.next();</script></body>
</html>

生成器函数可以出现yield语句，yield是函数代码的分割符，yield需要通过多个iteartor.next执行输出console.log语句内容

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//生成器函数可以出现yield语句，yield是函数代码的分割符，yield需要通过多个iteartor.next执行输出console.log语句内容function * gen(){console.log("hello hello");yield "一只没有耳朵";console.log("hell hell");yield "一只没有尾巴";console.log("he he");yield "真奇怪真奇怪";}let iterator=gen();//console.log(iterator);iterator.next();iterator.next();iterator.next();iterator.next();</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>function * gen(){yield "一只没有耳朵";yield "一只没有尾巴";yield "真奇怪真奇怪";}let iterator=gen();console.log(iterator.next());console.log(iterator.next());console.log(iterator.next());console.log(iterator.next());//遍历// for(let v of gen()){//     console.log(v);// }</script></body>
</html>

生成器函数参数

直接看例子吧

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>function * gen(arg){//arg形参console.log(arg);let one=yield 111;console.log(one);let two=yield 222;console.log(two);let three=yield 333;console.log(three);}//执行获取迭代器对象let iterator=gen('AAA');//next方法可以传入实参，就是yield语句返回结果console.log(iterator.next());console.log(iterator.next('BBB'));console.log(iterator.next('CCC'));console.log(iterator.next('DDD'));</script></body>
</html>

生成器函数实例1

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//js是单线程，异步也是单线程，ajax,request都是异步的//目标--1s后控制台输出111,2s后输出222,3s后输出333//定时器实现效果----但是如果太多了不好调试，互相嵌套，这种就是回调地狱// setTimeout(()=>{//   console.log(111);//     setTimeout(()=>{//      console.log(222);//         setTimeout(()=>{//          console.log(333);//         },3000)//   },2000)// },1000)//生成器函数实现---解决了回调地狱的问题function one(){setTimeout(()=>{console.log(111);iterator.next();},1000)}function two(){setTimeout(()=>{console.log(222);iterator.next();},2000)}function three(){setTimeout(()=>{console.log(333);iterator.next();},3000)}//生成器函数function *gen(){yield one();yield two();yield three();}//调用生成器函数let iterator=gen();iterator.next();</script></body>
</html>

生成器函数实例2

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//模拟获取数据,有了用户才能有订单，有了订单才能有商品//1--用户数据，2----订单数据，3---商品数据function getUser(){setTimeout(()=>{let data="用户数据";//调用next方法，并将数据传入iterator.next(data);},1000)}function getOrders(){setTimeout(()=>{let data="订单数据";iterator.next(data);},1000)}function getGoods(){setTimeout(()=>{let data="商品数据";iterator.next(data);},1000)}function * gen(){let users=yield getUser();console.log(users);let orders=yield getOrders();console.log(orders);let goods=yield getGoods();console.log(goods);}//调用生成器let iterator=gen();iterator.next()</script></body>
</html>

promise

promise是es6引入的异步编程的新解决方案，语法上promise是一个构造函数

用来封装异步操作并可以获取成功或失败的结果

promise构造函数：promise(excutor){}

Promise.prototype.then方法

Promise.prototype.catch方法

下面简单演示下

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//实例化Promise对象const p=new Promise(function(resolve,reject){setTimeout(function(){//成功调用resolve//let data="数据库中的用户数据";//resolve(data);//失败调用rejectlet  err="数据读取失败";reject(err);},1000)})//成功resolve调用promise对象的then方法,失败调第二个函数p.then(function(value){console.log(value);},function(reason){console.log(reason);})</script></body>
</html>

promise封装读取文件1

前提：电脑上需要安装node

vs的控制台弄出来的方法是同时按住 ctrl+~(波浪键)

1.html是我其他的东西，与这个例子无关

//引入fs模块
const fs = require("fs");//测试-----调用方法读取文件,看能否正常读取到
//fs.readFile('./resources/为学.md',(err,data)=>{//如果失败，则抛出错误// if(err) throw err;//如果没有出错，则输出内容
//  console.log(data.toString());
//})//使用promise封装
const p=new Promise(function(resolve,reject){// 为了测试错误情况，把后缀md改为mdaa,正常后缀名为mdfs.readFile('./resources/为学.mdaa',(err,data)=>{//判断如果失败if(err) reject(err);//如果成功resolve(data);});
});p.then(function(value){console.log(value.toString());
},function(reason){console.log("读取失败");
})

promise封装AJAX请求

接口地址废了，我也没加载成功 https: //api.apiopen.top/getJoke

就是这些内容，不需要其他的

下面是普通代码

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//接口地址：https://api.apiopen.top/getJoke//1.创建对象const xhr=new XMLHttpRequest();//2.初始化xhr.open("GET","https://api.apiopen.top/getJoke");//3.发送xhr.send();//4.绑定事件，处理响应结果xhr.onreadystatechange=function(){//判断if(xhr.readyState==4){//判断响应码 200-299if(xhr.status>=200 && xhr.status<300){//表示成功console.log(xhr.response);}else{//如果失败,视频里就是errorconsole.error(xhr.status)}}}</script>
</body>
</html>

下面是封装代码

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//接口地址：https://api.apiopen.top/getJokeconst p=new Promise((resolve,reject)=>{//1.创建对象const xhr=new XMLHttpRequest();//2.初始化xhr.open("GET","https://api.apiopen.top/getJoke");//3.发送xhr.send();//4.绑定事件，处理响应结果xhr.onreadystatechange=function(){//判断if(xhr.readyState==4){//判断响应码 200-299if(xhr.status>=200 && xhr.status<300){//表示成功resolve(xhr.response);}else{//失败reject(xhr.status)}}}})//指定回调//第一个函数成功，第二个失败//成功失败就是把接口写对或写错p.then(function(value){console.log(vale);},function(reason){console.log(reason);})</script>
</body>
</html>

promise的then方法

Promise.prototype.then

回调的执行特点，setTimeout里的内容是谁决定返回结果是什么

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦resolve("用户数据");//reject("出错啦");},1000)});//调用then方法p.then(value=>{console.log(value);},reason=>{console.warn(reason);})</script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦// resolve("用户数据");reject("出错啦");},1000)});//调用then方法p.then(value=>{console.log(value);},reason=>{console.warn(reason);})</script>
</body>
</html>

then方法的返回结果

调用then方法,then方法的返回结果是Promise对象,对象状态由回调函数的执行结果决定

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//实例化Promise对象const p=new Promise(function(resolve,reject){setTimeout(function(){//成功调用resolve//let data="数据库中的用户数据";//resolve(data);//失败调用rejectlet  err="数据读取失败";reject(err);},1000)})//成功resolve调用promise对象的then方法,失败调第二个函数p.then(function(value){console.log(value);},function(reason){console.log(reason);})</script></body>

1.如果回调函数中返回的结果是非Promise类型的属性，状态为成功，返回值为对象的成功的值

不写return，状态也为成功resolved

这个不知道为啥我错了，PromiseState哪里对应的应该是resolved，好像fulfilled是对的

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦resolve("用户数据");//reject("出错啦");},1000)});//调用then方法,then方法的返回结果是Promise对象,对象状态由回调函数的执行结果决定const result=  p.then(value=>{console.log(value);return "我爱你";},reason=>{console.warn(reason);})console.log(result);</script>
</body>
</html>

2.如果回调函数中返回的结果是promise类型的属性，内部返回promise状态决定then方法promise状态

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦resolve("用户数据");//reject("出错啦");},1000)});//调用then方法,then方法的返回结果是Promise对象,对象状态由回调函数的执行结果决定const result= p.then(value=>{console.log(value);return new Promise((resolve,reject)=>{//这次这里的结果决定了返回值PromiseResult的结果是ok/errresolve('ok');});},reason=>{console.warn(reason);});console.log(result);</script>
</body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦resolve("用户数据");//reject("出错啦");},1000)});//调用then方法,then方法的返回结果是Promise对象,对象状态由回调函数的执行结果决定const result = p.then(value=>{console.log(value);//是promise对象//这次这里的结果决定了返回值PromiseResult的结果是ok/errreturn new Promise((resolve,reject)=>{reject("error");})},reason=>{console.warn(reason);})console.log(result);</script></body>
</html>

throw

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{//这里的内容是resolve就是第一个函数内容用户数据，内容为reject，就是第二个函数内容出错啦resolve("用户数据");//reject("出错啦");},1000)});//调用then方法,then方法的返回结果是Promise对象,对象状态由回调函数的执行结果决定const result = p.then(value=>{console.log(value);//是promise对象//抛出错误throw new Error("出错啦!");},reason=>{console.warn(reason);})console.log(result);</script></body>
</html>

then方法可以链式调用

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//创建promise对象const p=new Promise((resolve,reject)=>{setTimeout(()=>{resolve("用户数据");//reject("出错啦");},1000)});//链式调用p.then(value=>{},reason=>{}).then(value=>{},resaon=>{})//链式调用还可以简写p.then(value=>{}).then(value=>{})console.log(result);</script></body>
</html>

promise实践

普通写法，建立三个文件为学.md, 悯农.md, 悯农二.md

//引入fs模块
const fs=require("fs");fs.readFile('./resources/为学.md',(err,data1)=>{fs.readFile('./resources/悯农.md',(err,data2)=>{fs.readFile('./resources/悯农二.md',(err,data3)=>{let result=data1+'\r\n' +data2+'\r\n'+data3;console.log(result);})})
})

promise做法

//引入fs模块const fs=require("fs");//使用promise做,不会产生回调地狱，链式调用，封装多个异步
const p=new Promise((resolve,reject)=>{fs.readFile("./resources/为学.md",(err,data)=>{resolve(data);})
});
p.then(value=>{// console.log(value.toString());return new Promise((resolve,reject)=>{fs.readFile("./resources/悯农.md",(err,data)=>{resolve([value,data]);
})
})
}).then(value=>{return new Promise((resolve,reject)=>{fs.readFile("./resources/悯农二.md",(err,data)=>{//压入value.push(data);resolve(value);
})
})
}).then(value=>{console.log(value.join('\r\n'));
})

promise对象catch方法

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>const p=new Promise((resolve,reject)=>{setTimeout(()=>{//修改p对象的状态为失败，并设置失败的值reject("出错啦");},1000)    })//then方法报错//p.then(function(value){},function(reason){//  console.error(reason)//})//catch方法报错p.catch(function(reason){console.log(reason);})</script></body>
</html>

set集合

es6提供了新的数据结构set。

它类似于数组，但成员的值都是唯一的，集合实现了iterator接口，所有可以使用扩展运算符合for..of进行遍历

集合的属性和方法：

size 返回集合的元素个数

add 增加一个新元素，返回当前集合

delete 删除元素，返回boolean值

has 检测集合中是否包含某个元素，返回boolean值

set集合声明

关键字new 跟set

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//声明一个setlet s=new Set();console.log(s,typeof s);//set声明并传入初始参数//set集合 会自动去重let s2=new Set(['大事',"小事","小事","好事","坏事"]);console.log(s2);</script></body>
</html>

集合方法

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let s2=new Set(["大事","小事","小事","好事","坏事"]);//元素个数sizeconsole.log(s2.size);//4//添加新的元素adds2.add("喜事");console.log(s2);//5//删除元素deletes2.delete("坏事");//3console.log(s2);//检测has,true有s2.has("好事");console.log(s2);//true//清空clear//s2.clear();//console.log(s2);//set（0）{}//遍历 for offor(let v of s2){console.log(v);}</script></body>
</html>

集合实践

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>let arr=[1,2,3,4,5,4,3,2,1];//1.数组去重let result=[...new Set(arr)];console.log(result);//2.交集 两个数组共同有的let arr2=[4,5,6,5,6];//先去重再判断减少无意义的一些步骤let result2=[...new Set(arr)].filter(item=>{let s2=new Set(arr2);//4 5 6if(s2.has(item)){return true}else{return false}})//简写// let result2=[...new Set(arr)].filter(item=>new Set(arr2).has(item));console.log(result2);//3.并集  两个数组合并起来的结果,去重后的let union=[...new Set([...arr,...arr2])];console.log(union);//4.差集 这个要看以谁为主，就是谁没有的let diff=[...new Set(arr)].filter(item=>!(new Set(arr2).has(item)))console.log(diff);</script></body>
</html>

Map的介绍与API

ES6提供了map数据结构。它类似于对象，也是键值对的集合。但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。Map也实现了iterator接口，所有可以使用扩展运算符和for...of..进行遍历

map的属性和方法

size 返回map的元素个数

set 增加一个新元素，返回当前map

get 返回键名对象的键值

has 检测map中是否包含某个元素，返回boolean值

clear 清空集合，返回undefined

用new 关键字+Map声明

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//声明Maplet m=new Map();//添加元素,键:值m.set("name","财神")m.set("change",function(){console.log("我会暴富的,身体健康");})let city={wind:"CUTE"};m.set(city,["北京","上海","天津"]);console.log(m);//size个数console.log(m.size);//delete 删除console.log(m.delete("name"));//get 获取console.log(m.get("change"));//第二种方式获取console.log(m.get(city));//清空//console.log(m.clear());//遍历for(let v of m){console.log(v);}</script></body>
</html>

class

class介绍

es6提供了引入了class类这个概念，作为对对象的模板。

通过class关键字，可以定义类。

class声明类

constructor定义构造函数初始化

extends继承父类

super调用父级构造方法

static定义静态方法和属性

父类方法可以重写

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//es6能做的，es5基本也能做到，不过es6更简洁//es5function Phone(brand,price){this.brand=brand;this.price=price;}//添加方法Phone.prototype.call=function(){console.log("我可以打电话！！！")}//实例化对象let xiaomi=new Phone("小米",3999);xiaomi.call();console.log(xiaomi);</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//es6能做的，es5基本也能做到，不过es6更简洁//es6--classclass Phone{//构造方法constructor(brand,price) {this.brand=brand;this.price=price;}//方法必须使用必须是这种简写的，不能使用es5的对象完整形式，call(){console.log("闪充5分钟，通话两小时");}}let oppo=new Phone("oppo",2999);oppo.call();console.log(oppo);</script></body>
</html>

static定义静态方法和属性

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//实例对象时实例对象，函数对象是函数对象，它们的属性不同的//实例对象和构造函数的原型是通的function Phone(){}//phone.name/change是属于函数对象的，不属于实例对象，这样的我们称为静态成员，在面向对象里，它是属于类的，而不属于实例对象Phone.name="手机";Phone.change=function(){console.log("我可以改变世界");}Phone.prototype.size="5.5inch";let nokia=new Phone();console.log(nokia.name);//undefinedconsole.log(nokia.size);nokia.change();</script></body>
</html>

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//对于static标注的属性和方法，它属于类不属于实例对象，关键字就是staticclass Phone{//静态属性static name="手机";static change(){console.log("我可以改变世界");}}let nokia=new Phone();console.log(nokia.name);console.log(Phone.name);</script></body>
</html>

class的类继承

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>class Phone{//构造方法constructor(brand,price) {this.brand=brand;this.price=price;}//父类的成员属性call(){console.log("我可以打电话");}}class SmartPhone extends Phone{//构造方法constructor(brand,price,color,size) {super(brand,price);this.color=color;this.size=size;}photo(){console.log("拍照");}playGame(){console.log("玩游戏");}}const xiaomi=new SmartPhone("小米",1980,"白色","4.7inch")console.log(xiaomi);xiaomi.call();xiaomi.photo();xiaomi.playGame();</script></body>
</html>

子类对父类方法的重写

子类跟父类有同样的名字

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>class Phone{//构造方法constructor(brand,price) {this.brand=brand;this.price=price;}//父类的成员属性call(){console.log("我可以打电话");}}class SmartPhone extends Phone{//构造方法constructor(brand,price,color,size) {super(brand,price);this.color=color;this.size=size;}call(){console.log("我可以进行视频通话");}}const xiaomi=new SmartPhone("小米",1980,"白色","4.7inch")xiaomi.call();</script></body>
</html>

class中的getter和setter设置

get通常对对象的动态属性进行封装

set可以添加更多的控制和判断

es6的数值扩展

Number.EPSILON

Number.isFinite 检测一个数值是否为有限数,true为有限

Number.isNaN 检测一个数值是否为NaN,false不是NaN

Number.parseInt Number.parseFloat 字符串转整数

Number.isInteger 判断一个数是否为整数,true为整数

Number.trunc 将数字的小数部分抹掉

Math.sign 判断一个数到底为正数负数还是零,正数返回1，负数返回-1，0返回0

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//0 Number.EPSILON是js表示的最小精度//EPSILON属性的值接近于2.2204460492503130808472633361816E-16//用在浮点数运算上,值小于EPSILON的值，就认为是相等的function equal(a,b){if(Math.abs(a-b)<Number.EPSILON){return true}else{return false}}console.log(0.1+0.2==0.3);//falseconsole.log(equal(0.1+0.2,0.3));//true//1.二进制和八进制//二进制以0b开头let b=0b010;console.log(b);//2//八进制以0o开头let o=0o777;console.log(o);//511//十进制let d=100;console.log(d);//100//十六进制let x=0xff;console.log(x);//255//2.Number.isFinite 检测一个数值是否为有限数,true为有限console.log(Number.isFinite(100));//true//3.Number.isNaN 检测一个数值是否为NaN,false不是NaNconsole.log(Number.isNaN(123));//false//4.Number.parseInt Number.parseFloat 字符串转整数console.log(Number.parseFloat('5211314love'))//5211314console.log(Number.parseFloat("3.1415926神奇"));//3.1415926//5.Number.isInteger 判断一个数是否为整数,true为整数console.log(Number.isInteger(5));//trueconsole.log(Number.isInteger(2.5));//false//6.Number.trunc 将数字的小数部分抹掉console.log(Math.trunc(3.5));//3//7.Math.sign 判断一个数到底为正数 负数 还是零,正数返回1，负数返回-1，0返回0console.log(Math.sign(100));//1console.log(Math.sign(0));//0console.log(Math.sign(-100));//-1</script></body>
</html>

Es6的对象方法扩写

object.is判断两个值是否完全相等

object.assign对象的合并,如果同名，后面的会把前面的内容覆盖

object.setPrototypeof设置原型对象,可以建议不这样做，还是开始就设置好最好

<!DOCTYPE html>
<html><head><meta charset="utf-8"><title></title></head><body><script>//1.object.is判断两个值是否完全相等console.log(Object.is(120,120));//true,作用跟===很像,但有一点不像console.log(Object.is(NaN,NaN));//trueconsole.log(NaN===NaN);//false//2.object.assign对象的合并,如果同名，后面的会把前面的内容覆盖const config1={host:"localhost",port:3306,name:"root",password:"root",test:"test"}const config2={host:"http://at.com",port:4408,name:"at.com",password:"money"}console.log(Object.assign(config1,config2));//3.object.setPrototypeof设置原型对象,可以建议不这样做，还是开始就设置好最好//object.getPrototypeof//获取原型对象const cute={name:"冰淇淋"}const cool={yoga:["甜的","苦的","辣的"]}Object.setPrototypeOf(cute,cool);console.log(cute);Object.getPrototypeOf(cute);console.log(cute);</script></body>
</html>

模块化

模块化是指将一个大的程序文件，拆分为许多小的文件，然后将小文件组合起来。

模块化的好处

防止命名冲突

代码复用

高维护性

模块化规范产品

es6之前规范的有

CommonJS--------NodeJs Browserify

AMD-------requireJS

cmd-----seaJS

浏览器使用es6模块引入模块

模块功能主要由两个命令构成：export和import

export命令用于规定模块的对外接口

import命令用于输入其他模块提供的功能

es6分别暴露

export

export let school="暴富学校";export function teacher(){console.log("暴富学习可以让学生暴富");
}

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script type="module">//引入m1.js模块内容import * as m1 from "./m1.js";console.log(m1);</script>
</body>
</html>

统一暴露

export{..,..}

//统一暴露
let school="财神学校";function findJob(){console.log("工作八小时不加班双休薪资6500+工作内容应付的来有身体锻炼的好公司");
}export {school,findJob};

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script type="module">//引入m2.js模块内容import * as m2 from "./m2.js";console.log(m2);</script>
</body>
</html>

默认暴露

export default{

.....

}

//默认暴露
export default{school:"天使学校",change:function(){console.log("我们来实现你的暴富愿望");}
}

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script type="module">//引入m2.js模块内容import * as m3 from "./m3.js";console.log(m3);//调用记得加上defaultm3.default.change();</script>
</body>
</html>

es6引入模块--通用导入方式

就是前面三个暴露案列的import * as xx from ....

es6引入模块--解构赋值形式

这个案列比较特殊，需要起别名

m1.js

export let school="暴富学校";export function teacher(){console.log("暴富学习可以让学生暴富");
}

m2.js

//统一暴露
let school="财神学校";function findJob(){console.log("工作八小时不加班双休薪资6500+工作内容应付的来有身体锻炼的好公司");
}export {school,findJob};

m3.js

//默认暴露
export default{school:"天使学校",change:function(){console.log("我们来实现你的暴富愿望");}
}

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><script type="module">//解构赋值形式import{school,teacher} from "./m1.js";console.log(school);console.log(teacher);//但是解构赋值重名会报错，所以我们可以使用别名import {school as cute,findJob} from "./m2.js";console.log(cute,findJob);//默认暴露也是通过起别名，把default给起别名import {default as cool} from "./m3.js";console.log(cool);//简便形式，只针对默认暴露import m3 from "./m3.js";console.log(m3);</script>
</body>
</html>

浏览器使用es6模块方法二，通过src引入文件

建立内容文件，这里是m1.js,m2.js,m3.js

创建app.js文件，也就是入口文件

在一个.html文件通过src引入app.js，通过live serve运行（live serve暂时用这个，避免报错）

export let school="暴富学校";export function teacher(){console.log("暴富学习可以让学生暴富");
}

//统一暴露
let school="财神学校";function findJob(){console.log("工作八小时不加班双休薪资6500+工作内容应付的来有身体锻炼的好公司");
}export {school,findJob};

//默认暴露
export default{school:"天使学校",change:function(){console.log("我们来实现你的暴富愿望");}
}

app.js

//入口文件
//模块引入
import * as m1 from "./m1.js";
import * as m2 from "./m2.js";
import * as m3 from "./m3.js";console.log(m1);
console.log(m2);
console.log(m3);

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body>
//通过src引入app.js<script src="./app.js" type="module"></script>
</body>
</html>

babel对es6模块化代码进行转换

通过babel转化将浏览器新的特性语法变为es5语法

安装语句

npm init --yes //初始化

npm i babel-cil babel-preset-env browserify -D //安装包

npx babel src/js -d dist/js --presets=babel-preset-env //转为es5

npx browserify dist/js/app.js -o dist/bundle.js //打包

app.js,m1、m2、m3.js的代码跟上个例子一样，再建立一个home.html页面，然后通过ctrl+~打开终端(编辑器vs),再一次输入上代码。

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head>
<body><!-- <script src="dist/js/app.js"></script> --><!-- 打包后 --><script src="dist/bundle.js"></script>
</body>
</html>

然后再改app.js里的代码

//入口文件
//模块引入
import * as m1 from "./m1.js";
import * as m2 from "./m2.js";
import * as m3 from "./m3.js";// console.log(m1);
// console.log(m2);
// console.log(m3);// 加载效果不变，因为引用的是dist----bundle.js下面的文件
m1.teacher();
m2.findJob();
m3.default.change();

想要加载效果改变，要重新在终端运行两句代码

npx babel src/js -d dist/js --presets=babel-preset-env

npx browserify dist/js/app.js -o dist/bundle.js

es6模块引入 npm包例子

安装jquery

在终端输入npm i jquery，然后改变home.html代码

//入口文件
//模块引入
import * as m1 from "./m1.js";
import * as m2 from "./m2.js";
import * as m3 from "./m3.js";// console.log(m1);
// console.log(m2);
// console.log(m3);// 加载效果不变，因为引用的是dist----bundle.js下面的文件
// m1.teacher();
// m2.findJob();
// m3.default.change();//用jquery修改背景颜色为粉色
import $ from "jquery";//等同于 const $ =require("jquery");
$("body").css("background","pink")

然后在终端运行两句语句

npx babel src/js -d dist/js --presets=babel-preset-env //转为es5

npx browserify dist/js/app.js -o dist/bundle.js //打包

参考资料

尚硅谷Web前端ES6教程，涵盖ES6-ES11_哔哩哔哩_bilibili

基础知识 | es6的知识点相关推荐

中原工学院计算机二级证书,中原工学院@计算机等级考试二级MS_Office基础知识(常考知识点记忆).doc...
中原工学院@计算机等级考试二级MS_Office基础知识(常考知识点记忆)剖析计算机的发展.类型及其应用领域.计算机(computer)是一种能自动.高速进行大量算术运算和逻辑运算的电子设备. 速度 ...
python基础知识点总结-python基础知识，python知识点汇总大一
阶段一:Python开发基础 Python全栈开发与人工智能之Python开发基础知识学习内容包括:Python基础语法.数据类型.字符编码.文件操作.函数.装饰器.迭代器.内置方法.常用模块等. 阶 ...
java arraylist add时默认调用tostring_Java基础知识之ArrayList知识点总结
本文包含常见的ArrayList的基本知识.在一些主题下也自然地引出了Colletion类的一些相关知识. 一.ArrayList的底层数据结构 ArrayList底层是使用一个Object[]数组来 ...
计算机软件编程基础知识,计算机程序设计基础知识点
计算机科学和软件工程的关系是一个有争议的话题,随后关于什么是"软件工程",计算机科学又该如何定义的争论使得情况更加混乱.下面是小编整理的关于计算机程序设计基础知识点,欢迎大家参考! ...
oracle数据库基础知识总结,oracle知识点总结(一)
关键字: oracle,database Oracle SQL(Oracle 9i 9.2.0.1.0) 一.DataBase 保存数据,以表的形式表现数据二.SQL SQL(structure q ...
公共基础知识中计算机知识点,公共基础知识：计算机技术考点？
3.计算机的性能指标 (1)内存容量计算机的内存容量通常是指随机存储器(RAM)的容量,是内存条的关键性参数.一般而言,内存容量越大越有利于系统的运行.系统对内存的识别是以Byte(字节)为单位,每 ...
小学计算机学科知识与能力,学科知识与能力：计算机基础知识模块知识点分析...
学科知识与能力:计算机基础知识模块知识点分析来源于浙江教师教育网中公教师通过对全国教师资格考试考情的分析,总结出全国教师资格考试<信息技术学科知识与能力>计算机基础知识模块的知识点,并提 ...
那些值得回味的MySQL的基础知识
那些值得回味的MySQL的基础知识 MySQL零碎知识点整理题记: 在如今甚是流行的MySQL中有些基础的知识却是我们日常工作中处理问题容易忘却的一部分,所以不能忘了本,那么我们现在就去回忆那些曾经 ...
A股交易接口类的基础知识
A股交易接口类的基础知识-ES6+类 constructor构造函数类通过class关键字来定义一个类. 类可以有自己的构造函数constructor,当我们通过new关键字创建一个实例时,构造函数 ...

基础知识 | es6的知识点

let