常用:

let关键字:

1. 作用:
* 与var类似, 用于声明一个变量
2. 特点:
* 在块作用域内有效
* 不能重复声明
* 不会预处理, 不存在提升
3. 应用:
* 循环遍历加监听
* 使用let取代var是趋势

  1. //console.log(age);// age is not defined
  2. let age = 12;
  3. //let age = 13;不能重复声明
  4. console.log(age);
  5. let btns = document.getElementsByTagName('button');
  6. for(let i = 0;i<btns.length;i++){
  7. btns[i].onclick = function () {
  8. alert(i);
  9. }
  10. }

const关键字:

1. 作用:
* 定义一个常量
2. 特点:
* 不能修改
* 其它特点同let
3. 应用:
* 保存不用改变的数据

  1. const sex = '男';
  2. console.log(sex);
  3. //sex = '女';//不能修改
  4. console.log(sex);

变量的解构赋值:

1. 理解:
* 从对象或数组中提取数据, 并赋值给变量(多个)
2. 对象的解构赋值
let {n, a} = {n:'tom', a:12}
3. 数组的解构赋值
let [a,b] = [1, 'atguigu'];
4. 用途
* 给多个形参赋值

  1. let obj = {name : 'kobe', age : 39};
  2. // let name = obj.name;
  3. // let age = obj.age;
  4. // console.log(name, age);
  5. //对象的解构赋值
  6. let {age} = obj;
  7. console.log(age);
  8. // let {name, age} = {name : 'kobe', age : 39};
  9. // console.log(name, age);
  10.  
  11. //3. 数组的解构赋值 不经常用
  12. let arr = ['abc', 23, true];
  13. let [a, b, c, d] = arr;
  14. console.log(a, b, c, d);
  15. //console.log(e);
  16. function person(p) {//不用解构赋值
  17. console.log(p.name, p.age);
  18. }
  19. person(obj);
  20.  
  21. function person1({name, age}) {
  22. console.log(name, age);
  23. }
  24. person1(obj);

模板字符串:

1. 模板字符串 : 简化字符串的拼接
* 模板字符串必须用 `` 包含
* 变化的部分使用${xxx}定义

  1. let obj = {
  2. name : 'anverson',
  3. age : 41
  4. };
  5. console.log('我叫:' + obj.name + ', 我的年龄是:' + obj.age);
  6.  
  7. console.log(`我叫:${obj.name}, 我的年龄是:${obj.age}`);

简化的对象写法:

简化的对象写法
* 省略同名的属性值
* 省略方法的function
* 例如:
let x = 1;
let y = 2;
let point = {
x,
y,
setX (x) {this.x = x}
};

  1. let x = 3;
  2. let y = 5;
  3. //普通额写法
  4. // let obj = {
  5. // x : x,
  6. // y : y,
  7. // getPoint : function () {
  8. // return this.x + this.y
  9. // }
  10. // };
  11. //简化的写法
  12. let obj = {
  13. x, //同名的属性可以省略不写
  14. y,
  15. getPoint(){
  16. return this.x
  17. }
  18. };
  19. console.log(obj, obj.getPoint());

箭头函数:

* 作用: 定义匿名函数
* 基本语法:
* 没有参数: () => console.log('xxxx')
* 一个参数: i => i+2
* 大于一个参数: (i,j) => i+j
* 函数体不用大括号: 默认返回结果
* 函数体如果有多个语句, 需要用{}包围,若有需要返回的内容,需要手动返回
* 使用场景: 多用来定义回调函数

* 箭头函数的特点:
1、简洁
2、箭头函数没有自己的this,箭头函数的this不是调用的时候决定的,而是在定义的时候处在的对象就是它的this
3、扩展理解: 箭头函数的this看外层的是否有函数,
如果有,外层函数的this就是内部箭头函数的this,
如果没有,则this是window。

  1. let fun = function () {
  2. console.log('fun()');
  3. };
  4. fun();
  5. //没有形参,并且函数体只有一条语句
  6. let fun1 = () => console.log('fun1()');
  7. fun1();
  8. console.log(fun1());
  9. //一个形参,并且函数体只有一条语句
  10. let fun2 = x => x;
  11. console.log(fun2(5));
  12. //形参是一个以上
  13. let fun3 = (x, y) => x + y;
  14. console.log(fun3(25, 39));//
  15.  
  16. //函数体有多条语句
  17. let fun4 = (x, y) => {
  18. console.log(x, y);
  19. return x + y;
  20. };
  21. console.log(fun4(34, 48));//
  22.  
  23. setTimeout(() => {
  24. console.log(this);
  25. },1000)
  26.  
  27. let btn = document.getElementById('btn');
  28. //没有箭头函数
  29. btn.onclick = function () {
  30. console.log(this);//btn
  31. };
  32. //箭头函数
  33. let btn2 = document.getElementById('btn2');
  34.  
  35. let obj = {
  36. name : 'kobe',
  37. age : 39,
  38. getName : () => {
  39. btn2.onclick = () => {
  40. console.log(this);//obj
  41. };
  42. }
  43. };
  44. obj.getName();
  45.  
  46. function Person() {
  47. this.obj = {
  48. showThis : () => {
  49. console.log(this);
  50. }
  51. }
  52. }
  53. let fun5 = new Person();
  54. fun5.obj.showThis();

3点运算符:

1. rest(可变)参数
* 用来取代arguments 但比arguments灵活,只能是最后部分形参参数
function add(...values) {
let sum = 0;
for(value of values) {
sum += value;
}
return sum;
}
2. 扩展运算符
let arr1 = [1,3,5];
let arr2 = [2,...arr1,6];
arr2.push(...arr1);

  1. function fun(...values) {
  2. console.log(arguments);
  3. // arguments.forEach(function (item, index) {
  4. // console.log(item, index);
  5. // });
  6. console.log(values);
  7. values.forEach(function (item, index) {
  8. console.log(item, index);
  9. })
  10. }
  11. fun(1,2,3);
  12.  
  13. let arr = [2,3,4,5,6];
  14. let arr1 = ['abc',...arr, 'fg'];
  15. console.log(arr1);

形参默认值:

* 形参的默认值----当不传入参数的时候默认使用形参里的默认值
function Point(x = 1,y = 2) {
this.x = x;
this.y = y;
}

  1. //定义一个点的坐标
  2. function Point(x=12, y=12) {
  3. this.x = x;
  4. this.y = y;
  5. }
  6. let point = new Point(25, 36);
  7. console.log(point);
  8. let p = new Point();
  9. console.log(p);
  10. let point1 = new Point(12, 35);
  11. console.log(point1);

Promise对象:

1. 理解:
* Promise对象: 代表了未来某个将要发生的事件(通常是一个异步操作)
* 有了promise对象, 可以将异步操作以同步的流程表达出来, 避免了层层嵌套的回调函数(俗称'回调地狱')
* ES6的Promise是一个构造函数, 用来生成promise实例
2. 使用promise基本步骤(2步):
* 创建promise对象
let promise = new Promise((resolve, reject) => {
//初始化promise状态为 pending
//执行异步操作
if(异步操作成功) {
resolve(value);//修改promise的状态为fullfilled
} else {
reject(errMsg);//修改promise的状态为rejected
}
})
* 调用promise的then()
promise.then(function(
result => console.log(result),
errorMsg => alert(errorMsg)
))
3. promise对象的3个状态
* pending: 初始化状态
* fullfilled: 成功状态
* rejected: 失败状态
4. 应用:
* 使用promise实现超时处理

* 使用promise封装处理ajax请求
let request = new XMLHttpRequest();
request.onreadystatechange = function () {
}
request.responseType = 'json';
request.open("GET", url);
request.send();

  1. //创建一个promise实例对象
  2. let promise = new Promise((resolve, reject) => {
  3. //初始化promise的状态为pending---->初始化状态
  4. console.log('1111');//同步执行
  5. //启动异步任务
  6. setTimeout(function () {
  7. console.log('3333');
  8. //resolve('atguigu.com');//修改promise的状态pending---->fullfilled(成功状态)
  9. reject('xxxx');//修改promise的状态pending----->rejected(失败状态)
  10. },1000)
  11. });
  12. promise.then((data) => {
  13. console.log('成功了。。。' + data);
  14. }, (error) => {
  15. console.log('失败了' + error);
  16. });
  17. console.log('2222');
  18.  
  19. //定义一个请求news的方法
  20. function getNews(url) {
  21. //创建一个promise对象
  22. let promise = new Promise((resolve, reject) => {
  23. //初始化promise状态为pending
  24. //启动异步任务
  25. let request = new XMLHttpRequest();
  26. request.onreadystatechange = function () {
  27. if(request.readyState === 4){
  28. if(request.status === 200){
  29. let news = request.response;
  30. resolve(news);
  31. }else{
  32. reject('请求失败了。。。');
  33. }
  34. }
  35. };
  36. request.responseType = 'json';//设置返回的数据类型
  37. request.open("GET", url);//规定请求的方法,创建链接
  38. request.send();//发送
  39. })
  40. return promise;
  41. }
  42.  
  43. getNews('http://localhost:3000/news?id=2')
  44. .then((news) => {
  45. console.log(news);
  46. document.write(JSON.stringify(news));
  47. console.log('http://localhost:3000' + news.commentsUrl);
  48. return getNews('http://localhost:3000' + news.commentsUrl);
  49. }, (error) => {
  50. alert(error);
  51. })
  52. .then((comments) => {
  53. console.log(comments);
  54. document.write('<br><br><br><br><br>' + JSON.stringify(comments));
  55. }, (error) => {
  56. alert(error);
  57. })

Symbol:

前言:ES5中对象的属性名都是字符串,容易造成重名,污染环境
Symbol:
概念:ES6中的添加了一种原始数据类型symbol(已有的原始数据类型:String, Number, boolean, null, undefined, 对象)
特点:
1、Symbol属性对应的值是唯一的,解决命名冲突问题
2、Symbol值不能与其他数据进行计算,包括同字符串拼串
3、for in, for of遍历时不会遍历symbol属性。
使用:
1、调用Symbol函数得到symbol值
let symbol = Symbol();
let obj = {};
obj[symbol] = 'hello';
2、传参标识
let symbol = Symbol('one');
let symbol2 = Symbol('two');
console.log(symbol);// Symbol('one')
console.log(symbol2);// Symbol('two')
3、内置Symbol值
* 除了定义自己使用的Symbol值以外,ES6还提供了11个内置的Symbol值,指向语言内部使用的方法。
- Symbol.iterator
* 对象的Symbol.iterator属性,指向该对象的默认遍历器方法(后边讲)

  1. window.onload = function () {
  2. let symbol = Symbol();
  3. console.log(typeof symbol);
  4. console.log(symbol);
  5.  
  6. // 用作对象的属性(唯一)
  7. let obj = {username: 'kobe', age: 39};
  8. obj[symbol] = 'hello';
  9. obj[symbol] = 'symbol';
  10. console.log(obj);
  11. for(let i in obj){
  12. console.log(i);
  13. }
  14. }

Iterator遍历器:

概念: iterator是一种接口机制,为各种不同的数据结构提供统一的访问机制
作用:
1、为各种数据结构,提供一个统一的、简便的访问接口;
2、使得数据结构的成员能够按某种次序排列
3、ES6创造了一种新的遍历命令for...of循环,Iterator接口主要供for...of消费。
工作原理:
- 创建一个指针对象,指向数据结构的起始位置。
- 第一次调用next方法,指针自动指向数据结构的第一个成员
- 接下来不断调用next方法,指针会一直往后移动,直到指向最后一个成员
- 每调用next方法返回的是一个包含value和done的对象,{value: 当前成员的值,done: 布尔值}
* value表示当前成员的值,done对应的布尔值表示当前的数据的结构是否遍历结束。
* 当遍历结束的时候返回的value值是undefined,done值为false
原生具备iterator接口的数据(可用for of遍历)
1、Array
2、arguments
3、set容器
4、map容器
5、String

  1. window.onload = function () {
  2. // 自定义iterator生成指针对象
  3. function mockIterator(arr) {
  4. let nextIndex = 0;
  5. return {
  6. next: function () {
  7. return nextIndex<arr.length?{value: arr[nextIndex++], done: false}:{value: undefined, done: true}
  8. }
  9. }
  10. }
  11.  
  12. let arr = [1,2,3,4,5];
  13. let iteratorObj = mockIterator(arr);
  14. console.log(iteratorObj.next());
  15. console.log(iteratorObj.next());
  16. console.log(iteratorObj.next());
  17.  
  18. // 使用解构赋值以及...三点运算符时会调用iterator接口
  19. let arr1 = [1,2,3,4,5];
  20. let [value1, ...arr2] = arr1;
  21. // yield*语句
  22. function* generatorObj() {
  23. yield '1'; // 可遍历数据,会自动调用iterator函数
  24. yield '3';
  25. }
  26. let Go = generatorObj();
  27. console.log(Go.next());
  28. console.log(Go.next());
  29. console.log(Go.next());
  30.  
  31. // 原生测试 数组
  32. let arr3 = [1, 2, 'kobe', true];
  33. for(let i of arr3){
  34. console.log(i);
  35. }
  36. // 字符串 string
  37. let str = 'abcdefg';
  38. for(let item of str){
  39. console.log(item);
  40. }
  41.  
  42. }

Generator函数

概念:
1、ES6提供的解决异步编程的方案之一
2、Generator函数是一个状态机,内部封装了不同状态的数据,
3、用来生成遍历器对象
4、可暂停函数(惰性求值), yield可暂停,next方法可启动。每次返回的是yield后的表达式结果
特点:
1、function 与函数名之间有一个星号
2、内部用yield表达式来定义不同的状态
例如:
function* generatorExample(){
let result = yield 'hello'; // 状态值为hello
yield 'generator'; // 状态值为generator
}
3、generator函数返回的是指针对象(接11章节里iterator),而不会执行函数内部逻辑
4、调用next方法函数内部逻辑开始执行,遇到yield表达式停止,返回{value: yield后的表达式结果/undefined, done: false/true}
5、再次调用next方法会从上一次停止时的yield处开始,直到最后
6、yield语句返回结果通常为undefined, 当调用next方法时传参内容会作为启动时yield语句的返回值。

  1. // 小试牛刀
  2. function* generatorTest() {
  3. console.log('函数开始执行');
  4. yield 'hello';
  5. console.log('函数暂停后再次启动');
  6. yield 'generator';
  7. }
  8. // 生成遍历器对象
  9. let Gt = generatorTest();
  10. // 执行函数,遇到yield后即暂停
  11. console.log(Gt); // 遍历器对象
  12. let result = Gt.next(); // 函数执行,遇到yield暂停
  13. console.log(result); // {value: "hello", done: false}
  14. result = Gt.next(); // 函数再次启动
  15. console.log(result); // {value: 'generator', done: false}
  16. result = Gt.next();
  17. console.log(result); // {value: undefined, done: true}表示函数内部状态已经遍历完毕
  18.  
  19. // 对象的Symbol.iterator属性;
  20. let myIterable = {};
  21. myIterable[Symbol.iterator] = function* () {
  22. yield 1;
  23. yield 2;
  24. yield 4;
  25. };
  26. for(let i of myIterable){
  27. console.log(i);
  28. }
  29. let obj = [...myIterable];
  30. console.log(obj);
  31.  
  32. console.log('-------------------------------');
  33. // 案例练习
  34. /*
  35. * 需求:
  36. * 1、发送ajax请求获取新闻内容
  37. * 2、新闻内容获取成功后再次发送请求,获取对应的新闻评论内容
  38. * 3、新闻内容获取失败则不需要再次发送请求。
  39. *
  40. * */
  41. function* sendXml() {
  42. // url为next传参进来的数据
  43. let url = yield getNews('http://localhost:3000/news?newsId=2');
  44. yield getNews(url);
  45. }
  46. function getNews(url) {
  47. $.get(url, function (data) {
  48. console.log(data);
  49. let commentsUrl = data.commentsUrl;
  50. let url = 'http://localhost:3000' + commentsUrl;
  51. // 当获取新闻内容成功,发送请求获取对应的评论内容
  52. // 调用next传参会作为上次暂停是yield的返回值
  53. sx.next(url);
  54. })
  55. }
  56.  
  57. let sx = sendXml();
  58. // 发送请求获取新闻内容
  59. sx.next();

async函数:

async函数(源自ES2017)
概念: 真正意义上去解决异步回调的问题,同步流程表达异步操作
本质: Generator的语法糖
语法:
async function foo(){
await 异步操作;
await 异步操作;
}
特点:
1、不需要像Generator去调用next方法,遇到await等待,当前的异步操作完成就往下执行
2、返回的总是Promise对象,可以用then方法进行下一步操作
3、async取代Generator函数的星号*,await取代Generator的yield
4、语意上更为明确,使用简单,经临床验证,暂时没有任何副作用

  1. async function timeout(ms) {
  2. return new Promise(resolve => {
  3. setTimeout(resolve, ms);
  4. })
  5. }
  6.  
  7. async function asyncPrint(value, ms) {
  8. console.log('函数执行', new Date().toTimeString());
  9. await timeout(ms);
  10. console.log('延时时间', new Date().toTimeString());
  11. console.log(value);
  12. }
  13.  
  14. console.log(asyncPrint('hello async', 2000));
  15.  
  16. // await
  17. async function awaitTest() {
  18. let result = await Promise.resolve('执行成功');
  19. console.log(result);
  20. let result2 = await Promise.reject('执行失败');
  21. console.log(result2);
  22. let result3 = await Promise.resolve('还想执行一次');// 执行不了
  23. console.log(result3);
  24. }
  25. awaitTest();
  26.  
  27. // 案例演示
  28. async function sendXml(url) {
  29. return new Promise((resolve, reject) => {
  30. $.ajax({
  31. url,
  32. type: 'GET',
  33. success: data => resolve(data),
  34. error: error => reject(error)
  35. })
  36. })
  37. }
  38.  
  39. async function getNews(url) {
  40. let result = await sendXml(url);
  41. let result2 = await sendXml(url);
  42. console.log(result, result2);
  43. }
  44. getNews('http://localhost:3000/news?id=2')

class:

1. 通过class定义类/实现类的继承
2. 在类中通过constructor定义构造方法
3. 通过new来创建类的实例
4. 通过extends来实现类的继承
5. 通过super调用父类的构造方法
6. 重写从父类中继承的一般方法

  1. class Person {
  2. //调用类的构造方法
  3. constructor(name, age){
  4. this.name = name;
  5. this.age = age;
  6.  
  7. }
  8. //定义一般的方法
  9. showName(){
  10. console.log(this.name, this.age);
  11. }
  12. }
  13. let person = new Person('kobe', 39);
  14. console.log(person, person.showName());
  15.  
  16. //定义一个子类
  17. class StrPerson extends Person{
  18. constructor(name, age, salary){
  19. super(name, age);//调用父类的构造方法
  20. this.salary = salary;
  21. }
  22. showName(){//在子类自身定义方法
  23. console.log(this.name, this.age, this.salary);
  24. }
  25. }
  26. let str = new StrPerson('weide', 38, 1000000000);
  27. console.log(str);
  28. str.showName();

es6常用的的更多相关文章

  1. ES6常用语法

    ECMAScript 6(以下简称ES6)是JavaScript语言的下一代标准.因为当前版本的ES6是在2015年发布的,所以又称ECMAScript 2015. 也就是说,ES6就是ES2015. ...

  2. ES6常用新特性

    https://segmentfault.com/a/1190000011976770?share_user=1030000010776722 该文章为转载文章!仅个人喜好收藏文章! 1.前言 前几天 ...

  3. ES6常用特性总览

    以前看过一遍es6,今天面试时被问到了一个很简单的es6特性,竟然没回答上来,特来重温一下es6,做个总结性笔记. 一.什么是es6 es6是新版本JavaScript语言的标准,在2015年6月发布 ...

  4. ES6常用对象操作

    ES6常用对象操作 一. const 简单类型数据常量 // const实际上保证的,并不是变量的值不得改动,而是变量指向的那个内存地址不得改动.对于简单类型的数据(数值.字符串.布尔值),值就保存在 ...

  5. ES6常用语法总结

    ECMAScript 6(以下简称ES6)是JavaScript语言的下一代标准.因为当前版本的ES6是在2015年发布的,所以又称ECMAScript 2015.也就是说,ES6就是ES2015.虽 ...

  6. es6常用基础合集

    es6常用基础合集 在实际开发中,ES6已经非常普及了.掌握ES6的知识变成了一种必须.尽管我们在使用时仍然需要经过babel编译. ES6彻底改变了前端的编码风格,可以说对于前端的影响非常巨大.值得 ...

  7. ES6常用语法简介import export

    ES6常用语法简介import export let与var用法区别 //var var a = []; for (var i = 0; i < 10; i++) { a[i] = functi ...

  8. es6常用功能与异步详解(JS高级面试题)

    callback hell方法的使用 可读性不友好 function loadImg(src,callback,fail){ var img = document.createElement('img ...

  9. ES5与ES6常用语法教程之 ②解构语法糖、声明变量异同

    js常用语法系列教程如下 es5与es6常用语法教程(1) es5与es6常用语法教程(2) es5与es6常用语法教程(3) es5与es6常用语法教程(4) es5与es6常用语法教程(5) es ...

  10. vue学习(一)ES6常用语法

    1 ES6常用语法 1.1 变量提升 例① # 变量提升 <div id="app"> </div> <script> console.log( ...

随机推荐

  1. Python第六天 类型转换

    Python第六天   类型转换 目录 Pycharm使用技巧(转载) Python第一天  安装  shell  文件 Python第二天  变量  运算符与表达式  input()与raw_inp ...

  2. scheme实现最基本的自然数下的运算

    版权申明:本文为博主窗户(Colin Cai)原创,欢迎转帖.如要转贴,必须注明原文网址 http://www.cnblogs.com/Colin-Cai/p/9123363.html 作者:窗户 Q ...

  3. 微信小程序——页面跳转及传参

    小程序页面跳转 微信小程序的页面跳转依然是以传统的请求转发和请求重定向为主,tabbar的存在,有TAB页面的跳转. 为了微信小程序的简介方便,规定页面路径只能是十层,应尽量避免过多的交互方式. 1. ...

  4. 明天研究下jpa直接像django一样生成

    https://blog.csdn.net/yztezhl/article/details/79390714 自动生成 教程-- https://blog.csdn.net/mxjesse/artic ...

  5. perf + Flame Graph火焰图分析程序性能

    1.perf命令简要介绍 性能调优时,我们通常需要分析查找到程序百分比高的热点代码片段,这便需要使用 perf record 记录单个函数级别的统计信息,并使用 perf report 来显示统计结果 ...

  6. ASP+中文显示之两种解决方法

    作者刚開始写ASP+程序时候碰到的第一个比較大的问题就是中文显示问题,执行后发现ASP+从数据库中读  取出来的中文所有变成了?????,有点相似jsp中的这个频率出现最高的中文显示问题了,查了资料发 ...

  7. 苹果绿RGB值

    ESL的值为:85,123,205 RGB的值为:199,237,204 ESL和RGB只需填一个即可,另一个会自动调整~

  8. 好程序员web前端分享18个用CSS制作出来的东西

    好程序员web前端分享18个用CSS制作出来的东西,与流行的看法相反,CSS不仅仅是用来提供一个WEB页面的基本风格,以使它看起来更有吸引力.还有很多其他的事情,CSS也可以做的很好.由于它创建动画和 ...

  9. Linux内核入门到放弃-无持久存储的文件系统-《深入Linux内核架构》笔记

    proc文件系统 proc文件系统是一种虚拟的文件系统,其信息不能从块设备读取.只有在读取文件内容时,才动态生成相应的信息. /proc的内容 内存管理 系统进程的特征数据 文件系统 设备驱动程序 系 ...

  10. ES ik分词器使用技巧

    match查询会将查询词分词,然后对分词的结果进行term查询. 然后默认是将每个分词term查询之后的结果求交集,所以只要分词的结果能够命中,某条数据就可以被查询出来,而分词是在新建索引时指定的,只 ...