ES6开发环境准备及基础语法

Nodejs

Nodejs是服务器端运行JavaScript的开源、跨平台运行环境。
Nodejs原始作者瑞安达尔(Ryan Dahl)，于2009年发布，使用了V8引擎，并采用事件驱动、非阻
塞、异步I0模型。

2010年，npm软件包管理器诞生，通过它，可以方便的发布、分享Nodejs的库和源代码。

Nodejs 4.0引入了ES6语言特性。

我们学习JS，就让它跑在最新版的Nodejs上,为了调试方便，也为了使用最新的ES2017特性。

注释

和C，Java一样

//单行注释

/*
多行注释
多行注释
*/

str = 'hello' + /*注释*/ 'world'
console.log(str)

常量和变量

标识符

标识符必须是字母，下划线，数字和$，但不能以数字开头。标识符区分大小写。

声明

var声明一个变量
let声明一个块作用域中的局部变量
const声明一个常量

js中的变量声明和初始化是可以分开的

var a
let b
console.log(1,a,b)
console.log('-'.repeat(20))//不支持python中的 print('-' * 20)

a = 10
b = 'a string'
console.log(2,a,b)

//const c //常量定义时必须赋值，否则报错
const c = 100
console.log(c)

//c = 200 //常量不允许更改

var y //只是声明，y值为undefined
var x = 5 //规范的声明并初始化，声明全局或局部变量。
z = 6//不规范的初始化，不推荐。在严格模式下会产生异常。在赋值之前不能引用，因为它没有声明。一旦这样赋值就是全局作用域。

function hello(){
    var a //只是声明，a为undefined,作用域在函数中
    a = 100
}
console.log(a) //抛出异常，未声明变量a

//a = 200 //不能声明提升
//let a = 200 // 不能声明提升
//var a = 200 // 能够声明提升，但赋值前操作该变量时，变量为undefined，建议不使用该方法。

var会把变量提升到当前全局或函数作用域。

如果明确知道一个标识符定义后不再修改，应该尽量声明成const常量，减少被修改的风险，减少
Bug。

数据类型

序号	名称	说明
1	number	数值型，包括整型和浮点型
2	boolean	布尔型，true和false
3	string	字符串
4	null	只有一个值null
5	undefined	变量声明末赋值的;对象未定义的属性
6	symbol	ES6新引入类型
7	object类型	是以上基本类型的复合类型，是容器

ES是动态弱类型语言
虽然先声明了变量，但是变量可以重新赋值为任何类型。

/*-----类型转化-----*/
//弱类型
console.log('=========string========')
console.log(a = 1 + 'a',typeof(a))
console.log(a = null + 'a',typeof a)
console.log(a = undefined + 'a',typeof(a))
console.log(a = true + 'a',typeof a)

//数字
console.log('=========number========')
console.log(a = null + 1,typeof a)
console.log(a = undefined + 1,typeof a)//undefined没法转换成一个对应的数字
console.log(a = true + 1,typeof a)
console.log(a = false + 1,typeof a)

// boolean
console.log('==========bool=========')
console.log(a = null + true,typeof a)
console.log(a = null + false,typeof a)
console.log(a = undefined + true,typeof a)//undefined没法转换成一个对应数字
console.log(a = undefined + false,typeof a)//NaN
console.log(a = null & true,typeof a)//&符号在这里是 位与
console.log(a = undefined & true,typeof a)

//短路
console.log('==========bool=========')
console.log(a = null && true,typeof a)// && 逻辑运算符 与
console.log(a = false && null,typeof a)
console.log(a = true && '',typeof a)//字符串类型
console.log(a = 'a' && [],typeof a)//[] object,在这里不等效为空
console.log(a = 'a' && {},typeof a)//{} object，在这里不等效为空

//null
console.log('==========null=========')
console.log(a = null + undefined,typeof a)//NaN

弱类型，不需要强制类型转换，会隐式类型转换。

NaN,即Not a Number,转换数字失败。它和任何值都不等，和自己也不等，只能使用
Number.isNaN(NaN)

console.log(Number.isNaN(undefined + 5))//true

总结:
遇到字符串，加号就是拼接字符串，所有非字符串隐式转换为字符串。
如果没有字符串，加号把其他所有类型都当数字处理，非数字类型隐式转换为数字。undefined特殊,
因为它都没有定义值,所以转换数字失败得到一一个特殊值NaN。
如果运算符是逻辑运算符，短路符,返回就是短路时的类型。没有隐式转换。

除非你十分明确，否则不要依赖隐式转换。写代码的时候，往往为了程序的健壮，请显式转换。

注意:以上的原则不要死记，忘了就实验，或者显式的类型转换

字符串

将一个值使用单'引号或者"双引号引用起来就是字符串。
ES6提供了反引号定义一个字符串，可以支持多行，还支持插值。

let a = 'abc'
let b = '123'
let c = `line1
line2
line3本行结束会多打印一个换行符
`//支持多行，和python中的"""相似，
console.log(c)

//字符串插值，要求在反引号字符中。如同python3.6后的 f‘’

let name = 'tom',age = 20
console.log(`name:${name},age:${age}`)

转义字符

名称	说明
\0	ASCII中的第一个Null字节，空字节
\b	退格符
\f	换页符
\n	换行符
\r	回车符
\t	Tab (制表符)
\v	垂直制表符
’	单引号
”	双引号
\	反斜杠字符( \ )
\XXX	由从0到377最多三位八进制数XXX表示的Latin-1字符。例如，\251是版权符号的
\xXX	由从00和FF的两位十六进制数字XX表示的Latin-1字符。例如，\xA9是版权符号的十六进制序列
\uXXX	由四位十六进制数字XXXX表示的Unicode字符。例如，\u00A9是版权符号的Unicode序列。见Unicode escape sequences (Unicode转义字符)
\uXXXXX}	Unicode代码点(code point)转义字符。例如，\u{2F804} 相当于Unicode转义字符\uD87E\uDC04的简写

字符串操作方法

let str = '012345aA'
console.log(str.charAt(10))//返回字符串索引为10的字符，超界与负索引返回空
console.log(str[-5])//索引超界或负索引返回undefined
console.log(str.toUpperCase())//字母大写
console.log(str.concat('join'))//字符串拼接，一般都用 + 号
console.log(str.slice(-5))//切片，最多两个参数。支持负索引，不支持步长

let url = 'www.baidu.com'
console.log(url.split('.'))//按给定字符切割，返回数组
console.log(url.substr(4,5))//返回区间[4,4+5]子串，从索引4开始，偏移5个
console.log(url.substring(4,5))//返回区间[4,5)子串，从索引4开始，到索引5结束

console.log(url.indexOf('w'))//返回字符串中该值所在位置的索引，找到一个就返回
console.log(url.indexOf(''))//该情况很特殊，返回索引0，和上例返回值一样
console.log(url.indexOf('222'))//没找到该值，返回-1
console.log(url.indexOf('com',3))//从给定索引处开始找
console.log(url.replace('baidu','aliyun'))//替换字符串中的值，没找到返回原字符串

数值型number

在]S中,数据均为双精度浮点型范围只能在- (2^53 -1)和2^53-1之间，整型也不例外。
数字类型还有三种符号值: +Infinity (正无穷)、-Infinity (负无穷)和NaN (not-a-number非数字)。

二进制0b0010、0B110。
八进制0755。注意0855，将被认作十进制，因为8不在八进制中。ES6中最好使用0o前缀表示八进制。
十六进制0xAA、0Xff。
指数表示1E3 (100) ，2e-2 (0.02)

常量属性赋值

var biggestNum = Number.MAX_VALUE
var smallestNum = Number.MIN_VALUE
var infiniteNum = Number.POSITIVE_INFINITY
var negInfiniteNum = Number.NEGATIVE_INFINITY
var notANum = Number.NaN

console.log(biggestNum)//1.7976931348623157e+308 最大数
console.log(smallestNum)//5e-324 最小数
console.log(infiniteNum)//Infinity 正无穷
console.log(negInfiniteNum)//-Infinity 负无穷
console.log(notANum)//NaN  not a number

数字的方法

方法	描述
Number.parseFloat()	把字符串参数解析成浮点数,和全局方法parseFloat()作用一致
Number.parselnt()	把字符串解析成特定基数对应的整型数字，和全局方法parselnt()作用一致
Number.isFinite()	判断传递的值是否为有限数字
Number.isInteger()	判断传递的值是否为整数
Number.isNaN()	判断传递的值是否为NaN。 Nan唯一判断方式

内置数学对象Math
Math提供了绝对值、对数指数运算、三角函数运算、最大值、最小值、随机数、开方等运算函数，提供了PI值。

console.log(Math.PI)
console.1og(Math.abs(-1))
console.log(Math.log2(16))
console.1og(Math.sqrt(2))
console.log(Math.random()) // (0, 1)

Symbol类型

ES6提供Symbol类型，内建原生类型。

let sym1 = Symbo1()
let sym2 = Symbol('key1')
let sym3 = Symbol('key1')
console.1og(sym2 == sym3) // false, symbol值是唯-- 的

1、作为对象的属性key

let s = Symbol()
let t = 'abc'
let a={
	[s]:'xyz',// symbo1做key,注意要使用中括号，这个key一定唯一
	t:'ttt',
	[t]:'111' //中括号内可计算
}
console.log(a)
console.log(a[s])
a[s] = 2000
console.log(a[s])
console.log(a)
/*
{ t: 'ttt', abc: '111', [Symbol()]: 'xyz' }
xyz
2000
{ t: 'ttt', abc: '111', [Symbol()]: 2000 }
*/

2、构建常量

//以前用法
var COLOR_RED ='RED';
var COLOR_ORANGE = 'ORANGE';
var COLOR_YELLOW = 'YELLOW';
var COLOR_GREEN = 'GREEN';
var COLOR_BLUE = 'BLUE'; 
var COLOR_VIOLET = 'VIOLET';

//现在
const COLOR_RED = Symbol();
const COLOR_ORANGE = Symbol();
const COLOR_YELLOW = Symbol();
const COLOR_GREEN = Symbol();
const COLOR_BLUE = Symbol();
const COLOR_VIOLET = Symbol();

运算符

算数运算符

+ - * / %等运算符和Python一样

console.log(1/2) // 0.5自然除
console.log(1/0)
console.log(5 % 3)
console.log(parseInt(1/2)) // 0
console.log(parseInt(3/2)) // 1
console.log(parseInt(-1/2),-1/2)
console.log(parseInt(-3/2),-3/2)
console.log(Math.floor(-1/2),-1/2)
console.log(Math.floor(-3/2),-3/2)
console.log(Math.floor(3/2)) // 1
console.log(Math.ceil(3/2)) // 2
console.log(Math.round(-2.5))
console.log(Math.round(-1.5))
console.log(Math.round(-0.5))
console.log(Math.round(0.5))
console.log(Math.round(1.5))
console.log(Math.round(2.5))

Math.round()

• 6入，取绝对值更大的值。1.6取2，-1.6取-2
• 4舍，取绝对值更小的值。1.4取1, -1.4取-1
• 5，取数轴向右离自己最近的整数。

++ 和 --
单目运算符，代表变量自增、自减
i++先用i，用完之后再自增加1
++i i先自增，再使用i

let i = 0
let a = i++
console.1og(a,i) //打印什么
console.log(a,i++) //打印什么
a = -i++
console.1og(a,++i) //打印什么

挑战题

i = 0;
let a = ++i+i+++i+++i;
console.log(a); //答案是几?

此题来自C、C++、Java的面试题
1、单目运算符优先级高于双目运算符
2、加号+是双目运算符，两边的表达式必须先计算好

i = 0;
let a = ++i+i+++i+++i; //等价于(++i) + (i++) + (i++) +i
console.log(a); // 1+1+2+3

比较运算符

>,<,>=,<=没有什么区别
!=,==
!==,===

== 宽松相等，进行类型转换，
===严格相等，不进行类型转换

console.log(100 > 200)//false
console.log(100 > '200')//false,
console.log(100 > '20')//true
console.log(100 > '2a')//false数字和该类字符串是没法比较大小的
console.log(100 < '2a')//false数字和该类字符串是没法比较大小的
console.log('20' > '100')//true
console.log('1b' > '1a')//true

//宽松比较
console.log(100 == '100')//true

//严格比较
console.log(100 == '100')//false

上例中，我们起先以为是隐式转换为字符串，但是后来发现是转换为数字，当100和‘2a’比较时就犯难了。

使用宽松比较的时候，尽可能确保比较的类型相同，否则会引起隐式转换，而且隐式转换的规则很复杂不好把控。
如果不知道类型是否一致,但是就是要求一定要相等， 那么请使用=和!。
建议比较的时候，一律使用=和!。

逻辑运算符

&&,||,!与，或，非

这些运算符和其它高级语言都一样，支持短路。

位运算

&,|,^,~,<<,>>位于，位或，异或，取反，左移，右移，和python意义一样

三元运算符

条件表达式？真值：假值

等价于简单的if...else结构

if(条件表达式){
	真值
}
else{
	假值
}

console.log(('3' > 30)?0:1)

逗号操作符

js运行多个表达式写在一起

let a = 4 + 4, b = true, c = a > 20?'t':'f';
console.log(a)//8
console.log(c)//f

function test(){
	return 1,a + b, c = ++a//定义全局c，在严格模式下会报错不建议这样写
}

console.log(test())//9，return值位逗号表达式最后一部分的值
console.log(c)//9

其它

名称	说明
instanceof	判断是否属于指定类型
typeof	返回字符串类型，全小写
delete	delete操作符,删除一个对象(an object)或一个对象的属性(an object’s property)或者一个数组中某一个键值(an element at a specified index in an array)。
in	如果指定的属性在对象类，这返回true

console.log('a' instanceof String)//false
console.log(1 instanceof Number)//false

a = new String('b')
console.log(a instanceof String)//true
console.log(new Number(1) instanceof Number)//true
console.log(a instanceof Object)//true

console.log(typeof 'a')//返回小写字符串string
console.log(typeof a)//object

instanceof要求必须明确使用类型定义变量，就是对象必须是new关键字声明创建的。它可以用于继承关系的判断。
typeof就是返回对象的类型名称的字符串。

delete删除对象、属性、数组元素

x = 42;
var y = 43;
let z = 60;
myobj = new Number();
myobj.h = 4;// create property h
console.log(delete x);// returns true (can delete if declared implicitly)
console.log(delete y);// returns false (cannot delete if declared with var)
console.log(delete z);// returns false
console.log(delete Math.PI); // returns false (cannot delete predefined properties)
console.log(delete myobj.h); // returns true (can delete user-defined properties)
console.log(delete myobj);// returns true (can delete if declared implicitly)
console.log('----------------')

var trees = new Array( "redwood", "bay", "cedar", "oak", "maple");
for (var i=0;i<trees.length;i++)
console.log(trees[i])
console.log('===============')
delete trees[3]; // 数组中元素被删除，但空着的位置是undefined
for (var i=0;i<trees.length;i++)
console.log(trees[i])

in 判断属性是否在对象内

let trees = new Array("redwood", "bay", "cedar", "oak", "maple");
console.log(0 in trees);//returns true ，0在数组对象的index中
console.log(3 in trees);// returns true， 3在数组对象的index中
console.log(6 in trees);// returns false, 6不在数组对象的index中
console.log("bay" in trees); // return false, bay不是属性，它是值
console. log("length" in trees); // returns true, length是 对象的属性
console.log('---------')

delete trees[3];
console.log(3 in trees);// return false
for(var i=0; i<trees . length;i++)
    console.log(trees[i]);
console.log('------------')// Custom objects

let mycar = {
    color: "red",
    year: 1998
};
console.log("color" in mycar); // returns true
console.log("model" in mycar); // returns false
console.log('year' in mycar) // true

运算符优先级

运算符由高到低，顺序如下

.	[]
()	new
! ~ -(负) +(正) ++ -- typeof void delete
* / %
+ -
<< >> >>>
< <= > >= in instanceof
== != === !==
&
^
|
&&
||
?:
= += -= *= /= %= <<= >>>= &= ^= |=
,

单目>双目>三目>赋值>逗号
逗号运算符优先级最低，比赋值语句还低。
记不住， 就使用括号。

表达式

基本表达式，和Python差不多

解析式也和Python的相似，但在ES6中非标准不推荐使用
生成器推荐使用生成器函数，ES6开始支持

function * inc(){
	let i = 0,j = 7
	while (true){
		yield i++
		if (!j--) return 100
	}
}

let gen = inc()
for (let i=0;i<10;i++)
	console.log(gen.next())

每次调用next()方法返回一个对象，这个对象包含两个属性: value 和done, value属性表示本次yield表达式的返回值，done 属性为布尔类型。done是false表示后续还有yield语句执行， 如果执行完成或者return后，done为true。

/ %

<< >> >>>
< <= > >= in instanceof
== != === !==
&
^
|
&&
||
?:
= += -= *= /= %= <<= >>>= &= ^= |=
,

单目>双目>三目>赋值>逗号
逗号运算符优先级最低，比赋值语句还低。
记不住， 就使用括号。

### 表达式

基本表达式，和Python差不多

解析式也和Python的相似，但在ES6中非标准不推荐使用
生成器推荐使用生成器函数，ES6开始支持

```js
function * inc(){
	let i = 0,j = 7
	while (true){
		yield i++
		if (!j--) return 100
	}
}

let gen = inc()
for (let i=0;i<10;i++)
	console.log(gen.next())

每次调用next()方法返回一个对象，这个对象包含两个属性: value 和done, value属性表示本次yield表达式的返回值，done 属性为布尔类型。done是false表示后续还有yield语句执行， 如果执行完成或者return后，done为true。