let
let a="Hello ES6";
console.log(a);
// 块级作用域
{
let a="Hello osoLife";
console.log(a);
}
// 要点:
1.let是对变量的声明,const是对常量的声明。
2.let声明的变量只在变量声明时所在的代码块内有效。
3.let不允许在同一个作用域重复声明变量。
const
// const声明的变量只可以在声明时赋值,不可随便更改
解构赋值(数组、对象、字符串、函数)
数组
let [a,b,c]=['我','爱','你'];
alert(b);
// 嵌套
let [a,[b,c]]=['我',['爱','你']];
alert(b);
// 空缺
let [a,,d]=['我',['爱','你'],'osoLife'];
alert(d);
// 多余变量
let [a,,d,e]=['我',['爱','你'],'osoLife'];
alert(e); // undefined
// 默认值(如果有以赋值的为准)
let [a,,d,e='moli']=['我',['爱','你'],'osoLife'];
alert(e); // moli
对象
// 方式一:
let obj=new Object();
obj.uid=1;
obj.uname='osoLife';
let {uname:name,uid:id}=obj; // 顺序改变无影响
alert(name); // osoLife
// 方式二:
let obj=new Object();
obj.uid=1;
obj.uname='osoLife';
let uid,uname;
({uid,uname}=obj)
alert(uname);
let obj=new Object();
obj.uid=1;
obj.uname='osoLife';
let uid,uname;
// 必须有小括号,两侧{}会被解读为语句块
({uname}=obj)
alert(uname); // osoLife
// 嵌套
let obj=new Object();
obj.uid=1;
obj.uname='osoLife';
obj.arr=['我','爱','你'];
let uid,uname,arr,a,b,c;
({arr:[a,b,c]}=obj);
alert(c); // 你
// 默认值
let obj=new Object();
obj.uid=1;
obj.uname='osoLife';
obj.arr=['我','爱','你'];
let uid,uname,arr,a,b,c,d;
({arr:[a,b,c,d='haha']}=obj);
alert(d); // haha
字符串
let [a,b,c,d,e,f,g]='osolife';
alert(e); // i
函数的参数
let obj=new Object();
obj.uname='osoLife';
obj.uage=18;
function analysis({uname,uage}) {
alert(uname);
alert(uage);
}
analysis(obj);
<!--参数中数组、字符串、默认值、缺位均支持-->
Arrow Functions
var double=(x)=>x*2;
console.log(double(10));
let fn=function() {
return 1;
}
// 使用箭头函数改写上面的代码
let fn=()=>1;
// 单参数
// x 默认值是2
let fn=(x=2)=>x*x;
alert(fn(3)); // 9
// 多参数
let fn=(a,b)=>a+b;
alert(fn(2,3)); // 5
// 无返回值
let fn=(a,b)=>{console.log(a+b);};
fn(2,3); // 5
// 多行
let fn=(a,b)=>{
console.log(a+b);
return a*b;
}
console.log(fn(2,3));
要点:
箭头函数内部没有constructor和prototype,不支持new操作,函数中的this始终指向定义时的this,而非执行时。
Promise
// 传统实现异步操作是采用回调函数
// Promise对象是一个新的异步操作解决方案。Promise对象具有三种状态:Pending(等待)、Resolved(已完成)和Rejected(未完成)。
// Promise对象状态的改变只有两种可能:Pending转变为Resolve或者Pending转变为Rejected。
var p=new Promise(
function(resolve,reject) {
setTimeout(resolve("hello Promise"),2000);
}
);
p.then(function(msg){
console.log('after 2 second '+msg);
});
assign
// 将原对象的内容拷贝到目标对象中
var obj={
key:'val'
};
var copy=Object.assign({},obj);
console.log(copy);
obj.key='new val';
console.log("===========================");
console.log(obj);
console.log(copy);
class
class Greeter {
constructor(message) {
this.message=message;
}
greet() {
console.log(this.message);
}
}
var greeter=new Greeter('Hello');
greeter.greet();
var Polygon=class {
constructor(width,height) {
this.width=width;
this.height=height;
}
say() {
console.log("i am polygon");
}
}
var p=new Polygon();
p.say();
class Point {
constructor(x,y) {
this.x=x;
this.y=y;
}
static distance(a,b) {
const dx=a.x-b.x;
const dy=a.y-b.y;
return Math.sqrt(dx*dx+dy*dy);
}
}
const p1=new Point(2,2);
const p2=new Point(3,3);
// 静态方法(可以通过类名调用)
console.log(Point.distance(p1,p2));
// 继承
class Animal {
constructor(name) {
this.name=name;
}
speak() {
console.log(this.name+' animal');
}
}
class Dog extends Animal {
speak() {
console.log(this.name+' dog');
}
}
let dog=new Dog('旺旺');
dog.speak();
model模块
// 所谓的模块就是一个独立的文件,文件与文件之间是相互封闭的。
// import
// 方法一:
// ES5
var name=require('Test.js');
// ES6
import {name} from 'Test.js';
// 方法二:整体导入并取别名为xx
import * as xx from 'Test.js';
// export
export var name='osoLife';
// 继承
// 要点:require和import的区别
1.require相当于module.exports的传送门,module.exports后面的内容是什么,require的结果就是什么,对象、数字、字符串、函数......再把require的结果赋值给某个变量。
2.require理论上可以用在代码的任何地方,甚至不需要赋值给某个变量之后再使用,比如:
require('./a')(); // a模块是一个函数,立即执行a模块函数
var data=require('./a').data; // a模块导出的是一个对象
var a=require('./a')[0]; // a模块导出的是一个数组
3.import是编译时的(require是运行时的),它必须放在文件的开头,在性能上比require好。
// Test.js
var name="osoLife"
let url="www.osoLife.com";
const year=2017;
export {name,url,year}
export function add(a,b) {return a+b;}
export class Person {constructor() {console.log('person');}}
// Child.js
// 继承
export(name,url,year,add,Person) from 'Test.js'
export class Student {constructor(){console.log('student');}}
网友评论