总是执着想学各种框架，但忘了基础学好才最重要。每次打开菜鸟教程想重温基础内容，然后就像翻开英文字典，永远在abandon...还是需要做个笔记。
一来加深学习印象，二来等下次打开学习可以知道自己上次学到哪里了。就不至于abandon了。
JS可以放在任何地方，通常放在<head> <script></script> </head>中，或者外部引入
JS调试可在Chrome浏览器 --> 开发者工具 --> Console控制台 中使用Console.log(); 打印查看内容
基本语法
每个语句以;结尾，中间语句块使用{...}
//...为行注释，/* ... */为块注释
JavaScript严格区分大小写
数据类型和变量
值类型(基本类型)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol。(Symbol 是 ES6 引入了一种新的原始数据类型，表示独一无二的值。)
引用数据类型：对象(Object)、数组(Array)、函数(Function)。
JS中数值类型不区分整数和浮点数，统一用Number。
字符串用 单引号 双引号
布尔值 true false
比较运算符 > >= ==
要特别注意相等运算符==。JavaScript在设计时，有两种比较运算符：
第一种是==比较，它会自动转换数据类型再比较，很多时候，会得到非常诡异的结果；// false==0 (结果为true)
第二种是===比较，它不会自动转换数据类型，如果数据类型不一致，返回false，如果一致，再比较。// false===0 (结果为false)
由于JavaScript这个设计缺陷，不要使用==比较，始终坚持使用===比较。
另一个例外是NaN这个特殊的Number与所有其他值都不相等，包括它自己 // NaN === NaN; (结果为false)
唯一能判断NaN的方法是通过isNaN()函数 // isNaN(NaN); (结果为true)
最后要注意浮点数的相等比较：
1 / 3 === (1 - 2 / 3); // false
这不是JavaScript的设计缺陷。浮点数在运算过程中会产生误差，因为计算机无法精确表示无限循环小数。要比较两个浮点数是否相等，只能计算它们之差的绝对值，看是否小于某个阈值：
Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true
null表示空，与0和' '不同，0是数值，' '表示长度为0的字符串。
数组
[1,2,3,null,'hello'] 或 new Array(1,2,3);//创建 [1,2,3] 的数组
var arr=[1,2,3,null,'hello']; //arr(0) 返回为1 ,arr(4) 返回为hello
对象
以键-值方式组成的无序集合
var person = {
name: 'Bob',
age: 20,
tags: ['js', 'web', 'mobile'],
city: 'Beijing',
hasCar: true,
zipcode: null
};
获取对象的属性
person.name;//Bob
变量
变量名是大小写英文、数字、$和_的组合，且不能用数字开头，也不能是关键字。
var a; // 申明了变量a，此时a的值为undefined
var $b = 1; // 申明了变量$b，同时给$b赋值，此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null
操作字符串
var s = 'Hello, world!';
s.length; // 13
需要特别注意的是，字符串是不可变的，如果对字符串的某个索引赋值，不会有任何错误，但是，也没有任何效果：
var s = 'Test';
s[0] = 'X';
alert(s); // s仍然为'Test'
JavaScript为字符串提供了一些常用方法，注意，调用这些方法本身不会改变原有字符串的内容，而是返回一个新字符串：
toUpperCase() //转为大写
var s='hello world'; var up=s.toUpperCase();
toLowerCase() //转为小写
indexOf() //搜索指定字符串出现的位置
var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 没有找到指定的子串，返回-1
substring() // 返回指定索引区间的子串：
var s = 'hello, world'
s.substring(0, 5); // 从索引0开始到5（不包括5），返回'hello'
s.substring(7); // 从索引7开始到结束，返回'world'
slice是对应字符串(String)的substring()版本
push()向数组(Array)的末尾添加元素，pop()则是把末尾最后一个元素删除
var arr=[ 1 , 2 ];
arr.push('A' , 'B');
console.log(arr); //输出为[ 1, 2, A, B]
console.log(arr.pop()); // 输出为B
console.log(arr); // 输出为[ 1, 2, A]
unshift ()像数组头部添加元素，shift ()则是把头部第一个元素删除
sort()对元素进行排序，直接调用时则默认顺序排列
var arr=new Array(2, 5, 1, 8);
console.log(arr.sort()); // 显示 1 2 5 8
reverse()则是把顺序反转
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']
splice()从指定位置删除若干元素，再从该位置开始添加一些元素
var arr=['Hello', 'This', 'And', ‘You’, 'Nice', 'To', 'meet'];
arr.splice(1, 3, 'World', '!'); // 表示从下标为1的元素开始，删除3个元素，添加两个元素，即删除了This，And，You
arr; // ['Hello', 'World', '!', 'Nice', 'To', 'meet'];
concat()将两个数组连接起来，返回一个新的数组
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
join()方法能将数组中的每个元素都连接起来
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
多维数组
var arr = [[1, 2, 3], [400, 500, 600], '-'];//该数组包含3个元素，其中头两个元素本身也是Array数组
对象
javascript的对象是一种无序的集合数据类型，由一些键值对组成
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
使用{...}来表示一个对象，属性名：值的方式来表示，使用,来隔开，最后一个不需要加,因为容易造成低版本浏览器的不兼容。
xiaoming.name;//获取到`小明`这个值
xiaoming.weight;//获取到`65`
属性名若是特殊字符，则用' '引号表示起来
var xiaohong = {
name: '小红',
'middle-school': 'No.1 Middle School'
};
获取该特殊属性的方式如下：
xiaohong['middle-school']; //获取到'No.1 Middle School'
xiaohong['name']; xiaohong.name; //这两种方式都获取到值`小红`
当访问一个不存在的属性时，返回为undefined；例如xiaohong.age;将提示undefined
javascript的对象是动态的，即可以自由的为其对象进行增加/删除属性
如上方获取xiaohong.age;将提示undefined。
当给其赋值 xiaohong.age=18; 再输出 xiaohong.age; 则获取到值18
删除属性： delete xiaohong.name;
检测该对象是否拥有该属性可使用in
'name' in xiaohong; //返回true
'age' in xiaohong; //false
使用in判断出的属性也可能是该对象由继承得到的。
要判断该属性是否其自身所拥有，可使用hasOwnProperty()
xiaohong.hasOwnProperty('name'); //true
条件判断
使用if...else
var age = 20;
if (age >= 18) { // 如果age >= 18为true，则执行if语句块
alert('adult');
} else { // 否则执行else语句块
alert('teenager');
}
if...else if...else多行条件判断
var age = 3;
if (age >= 18) {
alert('adult');
} else if (age >= 6) {
alert('teenager');
} else {
alert('kid');
}
循环
for循环
var x = 0;
var i;
for (i=1; i<=10000; i++) {
x = x + i;
}
x; // 50005000
for...in将对象的属性循环出来
var o = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in o) {
console.log(key); // 'name', 'age', 'city'
}
循环数组中的对象属性
var a = ['A', 'B', 'C'];
for (var i in a) {
console.log(i); // '0', '1', '2'
console.log(a[i]); // 'A', 'B', 'C'
}
还有while 循环和do..while 循环
Map和Set
用键值对表示对象时，其属性必须为字符串类型；但实际上Number或者其他数据类型作为键也是非常合理的。所以在ES6中引入了新的数据类型Map
举例
要查找某个同学的分数时，通常如下表示方式
var names = ['Michael', 'Bob', 'Tracy'];
var scores = [95, 75, 85];
给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，Array越长，耗时越长。
如果用Map实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢
var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95
Map有以下的方法
var m = new Map();
m.set('name1',97);
m.set('name2',66);
m.has('name1'); //返回为true，即表示存在该name1的键
m.get('name1'); //返回为 97
m.delete('name1'); //删除name1的键
m.get('name1'); //再获取则显示 undefined
一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：
var m = new Map();
m.set('Adam', 67);
m.set('Adam', 88);
m.get('Adam'); // 88
Set
Set和Map类似，也是一组key的集合，但不存储value
var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3
重复元素在Set中自动被过滤：
var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"}
通过add(key)方法可以添加元素到Set中，可以重复添加，但不会有效果：
s.add(4);
s; // Set {1, 2, 3, 4}
s.add(4);
s; // 仍然是 Set {1, 2, 3, 4}
通过delete(key)方法可以删除元素：
var s = new Set([1, 2, 3]);
s; // Set {1, 2, 3}
s.delete(3);
s; // Set {1, 2}
iterable
遍历数组可以采用下标循环，遍历Map和Set就无法使用下标。为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。
具有iterable类型的集合可以通过for ... of（是ES6的新语法）循环来遍历
var a = ['A','B','C'];
var s = new Set(['A','B','C']);
var m = new Map(['A',1],['B',2],['C',3]);
for (var x of a) { // 遍历Array
console.log(x); //A B C
}
for (var x of s) { // 遍历Set
console.log(x); //A B C
}
for (var x of m) { // 遍历Map
console.log(x[0] + '=' + x[1]); A=1 B=2 C=3
}
相比于前两种循环输出，可以使用forEach()
var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
// element: 指向当前元素的值
// index: 指向当前索引
// array: 指向Array对象本身
console.log(element + ', index = ' + index);
});
// 输出
// A, index = 0
// B, index = 1
// C, index = 2