（未排版）
JavaScript发展史：
网景公司凭借浏览器Navigator成为web时代开启时第一大互联网公司
以前的客户端输入验证操作是要发送到服务器端，由服务器端语言来完成输入验证的，为了解决这个问题，也为了给html和css添加动态效果，设计了JavaScript语言
后来微软模拟JavaScript开发了JScript
后来几个公司联合ECMA组织制定了ECMAscript标准
ECAMscript是一种语言标准
JavaScript是ECMAscript标准的一种实现

数据类型:
原始类型包括五种数据类型:
数值（number）
字符串（string）
布尔值（boolean）
undefined
null
合成类型只有一种值：对象（object）。但是，严格地分，又可以分成三个小类型:
对象（object）
数组（array）
函数（function）
1.JavaScript不区分整数和浮点数，统一为Number类型
整数：123
JavaScript内部，所有数字都是以64位浮点数形式储存，即使整数也是如此。所以，1与1.0是相等的，而且1加上1.0得到的还是一个整数，不会像有些语言那样变成小数。
1 === 1.0 // true
1 + 1.0 // 2
浮点数：1.23
科学计数：1.23e3
负数：-99
NaN：非数字
Infinity：无限大
2.字符串
3.布尔值
4.比较运算符
==
===
NaN===NaN//false
isNaN(NaN)//true
浮点数的相等比较：1/3===（1-2/3）//false
应该使用两个数的绝对值之差小于某个阈值：
Math.abs(1/3-（1-2/3）)<0.0000001//true
5.null undefined

6. 数组

变量：
变量如果不用var声明为全局变量
严格模式下（strict model）不允许没有var声明，在strict模式下运行的JavaScript代码，强制通过var申明变量，未使用var申明变量就使用的，将导致运行错误。
启用strict模式的方法是在JavaScript代码的第一行写上：

'use strict'

这是一个字符串，不支持strict模式的浏览器会把它当做一个字符串语句执行，支持strict模式的浏览器将开启strict模式运行JavaScript。

字符串：
多行字符串：用"\n"

alert("这是\n多行\n字符串");

最新的ES6标准新增了一种多行字符串的表示方法，用反引号 ... 表示：

alert(`多行
字符串
测试`);

Paste_Image.png

字符串的连接用加号：“+”
ES6模板字符串：
ES6新增了一种模板字符串，表示方法和上面的多行字符串一样，但是它会自动替换字符串中的变量：（插值）

var name = '小明';
var age = 20;
alert(`你好, ${name}, 你今年${age}岁了!`);

操作字符串
声明字符串：

var s = "this is a string";

获取字符串的长度：

console.log(s.length);//16

获取字符串某个位置的字符：

console.log(s[0]);//"t"

字符串是不可改变的：

s[0]="f";
console.log(s);//this is a string

返回大写的字符串：

var s = "string";
var t = s.toUpperCase();//返回新的字符串，原来字符串不变

返回小写字符串：

var s = "SRTing";
var t = s.toLowerCase();//返回新的字符串，原来字符串不变

获得字符串中指定字符串的索引：

var s = "this is a string";
console.log(s.indexOf('is'));//5

获得指定位置的字符串：

var s = "this is a string";
console.log(s.substring(5,7));//"is"， 从索引5开始到索引7不包括7的字符串
console.log(s.substring(10));//"string"，从索引10开始到字符串结束的字符串

数组：
使用delete命令删除一个值，会形成空位。
delete命令不影响length属性。
声明一个数组：

var array = [1,2,'30','jane'];

获得数组中某个元素：

var array = [1,2,'30','jane'];
console.log(array[1]);//2

修改数组：

var array = [1,2,'30','jane'];
array[1]=3;
console.log(array);//[1,3,'30','jane'];

索引赋值超过数组长度，会改变数组：

var array = [1,2,'30','jane'];
array[5]=5;
console.log(array);//[1,2,'30',undefined,undefined,5];

从数组尾部添加和删除数组元素：

var array = [1,2,'30','jane'];
array.push(4);
console.log(array);//[1,2,'30','jane',4]
array.pop();
console.log(array);//[1,2,'30','jane']

从数组头部添加和删除数组元素：

var array = [1,2,'30','jane'];
array.unshift(['a','b']);
console.log(array);//['a','b',1,2,'30','jane'];
array.shift();
console.log(array);//['b',1,2,'30','jane'];

连接两个数组：

var array = [1,2,'30','jane'];
var a2=[3,4];
var a3=array.concat(a2);//返回新数组，原数组不变

用符号连接数组元素形成字符串：

var array = ['I','am','jane'];
var s=array.join('-');//返回一个字符串s='I-am-jane';

获得数组元素的索引：

var array = [1,2,'30','jane'];
console.log(array.indexOf('jane'));//3
console.log(array.indexOf(30));//undefined

截取部分数组元素：

var array = [1,2,'30','jane'];
var a2 = array.slice(1,3);//从索引1开始到索引3不包括索引3为止，返回新数组：a2=[2,'30'];

排列数组：

var array = ['f','a','b'];
array.sort();//修改原来数组：array=['a','b','f'];

倒置数组：

var array = [1,2,'30','jane'];
array.reverse();//修改原来的数组：array=['jane','30',2,1];

删除几个数组元素并替换为另外的元素（有可能改变原数组长度）：

var array = [1,2,'30','jane'];
array.splice(0,3,'mike','yan');//修改原来数组，从索引0开始，3个数组元素，替换为后面参数的元素：array=['mike','yan','jane'];
array.splice(0,3);//修改原来数组，只删除，不添加：array=['jane'];
array.splice(0,0,'mike');//修改原来数组，只添加，不删除，从索引0开始，删除0个元素，添加Mike：array=['mike','jane'];

多维数组：

var arr = [['a','b'],[4,5,6]];
console.log(arr[0]);//['a','b'];
console.log(arr[1][1]);//5;

对象：
访问不存在的对象属性，返回undefined
给不存在的属性赋值，添加这个属性
使用in检测是否有这个属性（会向上查找原型链，可以检测到继承的属性，例如toString）：

var xiaoming ={
name:'xiaomign';
}
'name' in xiaoming;//true
'age' in xiaoming;//false
'toString' in xiaoming;//true

使用hasOwnProperty()方法，检测非继承的属性

var xiaoming ={
name:'xiaomign';
}
xiaoming.hasOwnProperty('name');//true
xiaoming.hasOwnProperty('toString');//false

对象的属性之间用逗号分隔，ECMAScript 5规定最后一个属性后面可以加逗号（trailing comma），也可以不加。
ECMAScript 3不允许添加逗号，所以如果要兼容老式浏览器（比如IE 8），那就不能加这个逗号。
数值键名不能使用点运算符（因为会被当成小数点），只能使用方括号运算符。
查看一个对象本身的所有属性，可以使用Object.keys方法。

var o = {
  key1: 1,
  key2: 2
};
Object.keys(o);
// ["key1", "key2"]

删除一个属性，需要使用delete命令。

var o ={p:"nn"};
Object.keys(o);//["p"];
delete o.p;
o.p;//undefined
Object.keys(o);//[];

如果删除一个不存在的属性，delete不报错，而且返回true。
delete命令只能删除对象本身的属性，不能删除继承的属性

JavaScript把null、undefined、0、NaN和空字符串''视为false，其他值一概视为true

for 循环：

for( var i in arr) {
...//i 是数组索引，arr是一个数组
}
for (var key in o) {
...//key 是对象的属性，o是对象
}

对象的键只能是字符串，为了使键可以是其他数据类型，ES6引入了Map数据类型：
生成一个Map：

//wrong:
var m = new Map();
m=[['mike',65],['jane',80]];

//correct:
var m = new Map([['mike',65],['jane',80]]);

添加元素：

m.set('alen',40);
m.get('jane');//80
m.has('jane');//true;
m.delete('jane);
m.has('jane');//false

一个key对应一个value，对相同的key重复赋值，会把前面的赋值冲掉

数组中元素可以重复，Set数据类型（ES6新增的数据类型）中元素不可以重复：
生成一个Set：

var s = new Set();//空的Set
var s2 = new Set([1,2,3,3]);//s2:Set { 1,2,3 }

添加，删除Set的元素

s2.add(5);//s2:Set{ 1,2,3,5 }
s2.delete(5);//s2:Set{ 1,2,3 }

为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。
具有iterable类型的集合可以通过新的for ... of循环来遍历。

var a = ['A', 'B', 'C'];
var s = new Set(['A', 'B', 'C']);
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
for (var x of a) { // 遍历Array
    alert(x);
}
for (var x of s) { // 遍历Set
    alert(x);
}
for (var x of m) { // 遍历Map
    alert(x[0] + '=' + x[1]);
}

更好的方式是直接使用iterable内置的forEach方法，它接收一个函数，每次迭代就自动回调该函数。
数组：

var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
    // element: 指向当前元素的值
    // index: 指向当前索引(可以省略）
    // array: 指向Array对象本身（可以省略）
    alert(element);
});

Map:

//Map的回调函数参数依次为value、key（可以省略）和map（可以省略）本身：
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
    alert(value);
});

Set:

Set与Array类似，但Set没有索引，因此回调函数的前两个参数都是元素本身：
var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {//后两个参数可以省略
    alert(element);
});

var m = 1;
var n = 2;
if (m !== 1) 
if (n === 2) console.log('hello');    
else console.log('world');

相当于：

if (m !== 1) {
    if (n === 2) {
        console.log('hello');    
    } else {
        console.log('world');
    }
}

undefined,null,false,0,NaN,""（空字符串）是false
空数组（[]）和空对象（{}）对应的布尔值，都是true

parseInt方法可以将字符串或小数转化为整数。如果字符串头部有空格，空格会被自动去除。
将字符串转为整数的时候，是一个个字符依次转换，如果遇到不能转化为数字的字符，就不再进行下去，返回已经转好的部分。
如果字符串的第一个字符不能转化为数字（正负号除外），返回NaN。
parseInt方法还可以接受第二个参数（2到36之间），表示被解析的值的进制。
如果第二个参数不是数值，会被自动转为一个整数。通过，这个整数只有在2到36之间，才能得到有意义的结果，超出这个范围，则返回NaN。如果第二个参数是0、undefined和null，则直接忽略。

parseFloat方法用于将一个字符串转为浮点数。
如果字符串包含不能转化为浮点数的字符，则不再进行转化，返回已经转好的部分。

字符串默认只能写在一行内，分成多行将会报错。
如果长字符串必须分成多行，可以在每一行的尾部使用反斜杠。
它是ECMAScript 5新添加的，老式浏览器（如IE 8）不支持，其次，反斜杠的后面必须是换行符，而不能有其他字符（比如空格），否则会报错。

var longString = "Long \
long \
long \
string";
longString
// "Long long long string"