本系列基于阮一峰老师的《JavaScrip语言入门教程》或《JavaScript教程》记录整理，教程采用知识共享 署名-相同方式共享 3.0协议。这几乎是学习js最好的教程之一(去掉之一都不过分)
最好的教程而阮一峰老师又采用开源方式共享出来，之所以重新记录一遍，一是强迫自己重新认真读一遍学一遍；二是对其中知识点有个自己的记录，加深自己的理解；三是感谢这么好的教程，希望更多人阅读了解
Array、Date、Math等）。然后就是宿主提供的API(比如浏览器提供的BOM、DOM和Web互联网相关的类；Node环境提供文件操作API、网络通信API等)event-driven)和非阻塞式(non-blocking)设计，实现高并发、多任务处理World Wide Web Consortium)制定的var a=1;
undefined，表示"无定义"。同时变量赋值时不写var也有效，但不建议。变量必须先声明再使用，否则会报错not definedvar a = 1;
a = ‘hello‘;
var重新声明一个已存在的变量，是无效的，重新声明时赋值，相当于重新赋值hoisting)identifier)指的是识别各种值的合法名称。比如变量名、函数名。js标识符大小写敏感。标识符的命名规则是：只能以字母、下划线(_)和美元符号($)开头，从第二个字符开始还可以使用数字。Unicode字母。因此中文标识符也可以使用//表示单行注释。/* */表示多行注释var命令，js的区块不构成单独的作用域(scope)if和if...else...结构,根据条件的布尔值判断执行。
switch结构判断表达式的值是否与case相符并执行，如果都不符则执行最后的default，case中break不能少，否则当前case代码块执行完会接着执行下一个case。switch语句部分和case语句部分，都可以使用表达式，这就是js中可以为值的地方，都可以使用表达式的体现，如下：
switch (1 + 3) {
case 2 + 2:
f();
break;
default:
neverHappens();
}
switch语句的值和case语句的值，比较时采用的是严格相等运算符(===)
?:三元运算符：如下，条件true,执行"表达式1"，否则执行"表达式2"，然后获取对应返回值(条件) ? 表达式1 : 表达式2
while 循环：循环条件和代码块，条件为真，就循环执行代码块
for 循环：可以指定循环的起点、终点和终止条件。分为初始化表达式(initialize)、条件表达式(test)、递增表达式(increment)
for (初始化表达式; 条件; 递增表达式) {
语句
}
所有for循环，都可以改写成while循环
for语句的无线循环表示：
for ( ; ; ){
console.log(‘Hello World‘);
}
do...while 循环：先执行一次循环体，再判断条件break语句用于跳出代码块或循环。continue语句用于立即终止本轮循环，并开始下一轮循环label:
语句
true(真)和false(假)undefined：表示“未定义”或不存在，即由于目前没有定义，所以此处暂时没有任何值null：表示空值，即此处的值为空。数值、字符串、布尔值称为原始类型(primitive type)，是最基本的数据类型。对象称为合成类型(complex type)。undefined和null两个特殊值。
对象分为：狭义的对象(object)、数组(array)、函数(function)
typeof运算符返回一个值的数据类型:
number、string、booleanfunction，undefined返回undefined(可以检测未声明的变量)，对象返回object，null返回object// 检测未声明
if (typeof v === "undefined") {
// ...
}
typeof window // "object"
typeof {} // "object"
typeof [] // "object"
typeof null // "object"
instanceof可以区分数组和对象[] instanceof Array // false
[] instanceof Array // true
0；undefined表示"无定义"的原始值，转为数值是NaNNumber(null) // 0
Number(undefined) // NaN
true和false两个真假状态。下面六个值会被转为false,其他的值都是true：
空数组([])和空对象({})对应的布尔值，都是true
1===1.0，是同一个数1 === 1.0 // true
JavaScript 语言的底层根本没有整数，所有数字都是小数（64位浮点数）
0.1 + 0.2 === 0.3 // false
0.3 / 0.1 // 2.9999999999999996
(0.3 - 0.2) === (0.2 - 0.1) // false
Math.pow(2, 53); // 9007199254740992
Math.pow(2, 53) + 1; // 9007199254740992
Math.pow(2, 53) + 2; // 9007199254740994
Math.pow(2, 53) + 3; // 9007199254740996
Math.pow(2, 53) + 4; // 9007199254740996
Number.MAX_VALUE和Number.MIN_VALUENumber.MAX_VALUE // 1.7976931348623157e+308
Number.MIN_VALUE // 5e-324
50(十进制)、0xFF(十六进制)、123e3或123e-3(科学计数法)literal)表示数值时：0o或0O的数值，或者有前导0、且只用到0-7的八个阿拉伯数字的数值。0x或0X的数值。0b或0B的数值。js会自动将八进制、十六进制、二进制转为十进制
0:+0，-0，两者是等价的。唯一区别是+0或-0当作分母时表达式的返回值不相等。NaN表示“非数字”(Not a Number)，比如字符串解析为数字报错时会返回NaN。0除以0得到NaN。NaN只是一个特殊值，类型依旧是NumberNaN不等于任何值，包括它本身NaN === NaN // false
NaN的布尔值为false，NaN与任何数(包括它自己)的运算，得到的都是NaN
Infinity表示“无穷”，表示无法表示正无穷(Infinity)和负无穷(-Infinity)；非0数除以0，得到Infinity。Infinity大于一切数值(除了NaN)，-Infinity小于一切数值(除了NaN)NaN的比较运算会返回false
parseInt()方法将字符串转为整数。字符串转为整数时，会一个个字符依次转换，如果遇到不能转为数字的字符，就不再进行下去，返回已经转好的部分。转换失败返回NaN。解析科学计数法的数字时会出现奇怪的结果
第二个参数表示解析的值的进制
parseInt(‘1000‘, 2) // 8
parseInt(‘1000‘, 6) // 216
parseInt(‘1000‘, 8) // 512
parseFloat()：将一个字符串转为浮点数，可以对科学计数法字符串正确转换isNaN()判断一个值是否是NaN。isNaN()只对数值有效，其他类型值会先转为数值，再判断。对于空数组和只有一个数值成员的数组，isNaN()返回falseisNaN(‘Hello‘) // true
// 相当于
isNaN(Number(‘Hello‘)) // true
NaN是唯一不等于自身的值function myIsNaN(value) {
return value !== value;
}
如果使用isNaN()判断，要同时判断类型：
function myIsNaN(value) {
return typeof value === ‘number‘ && isNaN(value);
}
isFinite()判断是否为正常的数值，判断是参数也会进行类型转换\反斜杠转义\后面只能有换行符，否则报错)var longString = ‘Long long long string‘;
longString // "Long long long string"
也可使用+可以将多个字符串行连接
\)用来表示一些特殊字符，称为转义。如\n换行符；\r：回车键；\t：制表符。如果在字符串中需要包含反斜杠，需要\转义自身。"你好，反斜杠\\"; // "你好，反斜杠\"
‘hello‘.length // 5
Unicode字符集。不仅以Unicode存储字符，而且可以只用Unicode码点，如‘\u00A9‘表示版权符号var s = ‘\u00A9‘;
s // "?"
每个字符在 JavaScript 内部都是以16位（2个字节）的 UTF-16 格式储存。js单位字符长度固定为16位长度
js 对 UTF-16 的支持不完整，只支持两字节的字符，无法识别四字节的字符。比如四字节字符??,浏览器可以正确识别是一个字符，但js无法识别，认为是两个字符。需要特别注意
‘??‘.length // 2
Base64编码：对于ASCII 码0到31的符号无法打印出来，可以使用Base64编码转换为可打印的字符；以文本格式传递二进制数据，也可以使用Base64编码Base64 是一种编码方法，可以将任意值转成 0～9、A～Z、a-z、+和/这64个字符组成的可打印字符。目的是不出现特殊字符，简化程序处理。btoa()：任意值转为 Base64 编码atob()：Base64 编码转为原来的值var string = ‘Hello World!‘;
btoa(string) // "SGVsbG8gV29ybGQh"
atob(‘SGVsbG8gV29ybGQh‘) // "Hello World!"
btoa()和atob()的Base64编码解码不使用非ASCII码的字符，如btoa(‘你好‘)就会报错。处理办法是加一个URI转码，如下function b64Encode(str) {
return btoa(encodeURIComponent(str));
}
function b64Decode(str) {
return decodeURIComponent(atob(str));
}
b64Encode(‘你好‘) // "JUU0JUJEJUEwJUU1JUE1JUJE"
b64Decode(‘JUU0JUJEJUEwJUU1JUE1JUJE‘) // "你好"
如下，对象用大括号，键值对又叫成员，分为"键名"和"键值"，对应"成员的名称"和"成员的值"，键名与键值用冒号分割，键值对逗号分割。
var obj = {
foo: ‘Hello‘,
bar: ‘World‘
};
Symbol值也可以作为键名)。键名要么符合标识名的规则，要么使用引号包含。键名又称为"属性"(property)，属性可以动态创建trailing comma)，也可不加{ foo: 123 }
遇到大括号的歧义时，无法确定是对象还是代码块，JavaScript引擎一律解释为代码块。
可以将大括号放入圆括号中，这样就是表达式
// eval 对字符串求值
eval(‘{foo: 123}‘) // 123
eval(‘({foo: 123})‘) // {foo: 123}
var obj = {
p: ‘Hello World‘
};
obj.p // "Hello World"
obj[‘p‘] // "Hello World"
数值键名不能使用点运算符，使用方括号运算符时数值键名会转换为字符串
8. Object.keys(obj)查看一个对象所有属性或键名
9. delete用于删除对象本身的属性，成功后返回true。且删除不存在的key也返回true。只有属性存在且不能删除时，才返回false。不能删除继承的属性
delete obj.p // true
in运算符检查对象是否包含某个属性。继承时属性也会返回true。hasOwnProperty(key)方法片段是否为对象自身的属性for...in循环用于遍历对象的全部属性enumerable)的属性，会跳过不可遍历的属性。通常都是遍历对象自身的属性，因此可以结合hasOwnProperty方法
var person = { name: ‘阮一峰老师‘ };
for (var key in person) {
if (person.hasOwnProperty(key)) {
console.log(key);
}
}
// name
function 命令——函数的声明(Function Declaration)如下，function 函数名(参数1,...){函数体}
function print(s) {
console.log(s);
}
Function Expression)变量赋值的方式，这个匿名函数又称函数表达式
var print = function(s) {
console.log(s);
};
函数表达式需要在语句的结尾加上分号，表示语句结束。
函数表达式声明函数时，function后面不带有函数名。如果加上函数名也仅在函数体内部有效。
Function 构造函数如下，使用Function构造函数时，可以传递任意数量的参数，只有最后一个参数会被当做函数体
var add = new Function(
‘x‘,
‘y‘,
‘return x + y‘
);
// 等同于
function add(x, y) {
return x + y;
}
return语句表示返回后面表达式的值，并退出当前函数recursion)function声明函数时会被提升到代码头部。但是赋值语句定义函数，在赋值前调用会报错(因为是undefined)toString()方法返回字符串，内容是函数的源码。函数内的注释也会返回。toString()方法返回function (){[native code]}scope)指变量存在的范围。ES5中，JavaScript只有两种作用域：全局作用域(变量在整个程序中一直存在)；函数作用域(变量只在函数内部存在)，函数作用域内同样存在变量提升。ES6新增了块级作用域<script>标签中)，函数外部声明的变量就是全局变量(global variable)。函数内部定义的变量，外部无法读取，称为"局部变量"(local variable)，且函数内部定义的局部变量，在当前函数作用内会覆盖同名全局变量var声明的变量只有在函数内才是局部变量，其他区块内声明仍是全局变量(比如if、while等块内)var a = 1;
var x = function () {
console.log(a); //声明时所在作用域的变量a
};
function f() {
var a = 2;
x();
}
f() // 1
同样，函数体内部声明的函数，作用域绑定函数体内部。
function foo() {
var x = 1;
function bar() {
console.log(x);
}
return bar;
}
var x = 2;
var f = foo();
f() // 1
如上，fon颞部声明的函数bar，bar的作用域为foo函数内部，当在foo外部取出bar执行时，bar中使用的变量x指向的是foo内部(声明时所在作用域)的x，而不是foo外部的x。这就是闭包现象
closure)就是能够读取其他函数内部变量的函数。而js中，只有函数内部的子函数才能读取内部变量，因此闭包简单理解就是"定义在一个函数内部的函数"。本质上，闭包用于将函数内部和函数外部连接起来。理解闭包，要先理解变量的作用域，函数内部可以读取全局变量
var e = "我是全局变量";
function f1() {
console.log(e);
}
f1() // "我是全局变量"
但是，函数外部无法读取函数内部声明的变量。
function f1() {
var n = "我是函数内部变量";
}
console.log(n) // Uncaught ReferenceError: n is not defined
但是，正常无法得到函数内的局部变量，如果想要实现必须通过变通方法：在函数的内部，再定义一个函数。这样函数内部的子函数就可以使用函数内的局部变量，但是函数内无法使用其子函数内的局部变量。这就是js特有的 "链式作用域"结构(chain scope)，子对象会一级一级地向上寻找所有父对象的变量。
父对象的所有变量，对子对象都是可见的，反之则不成立。
这样将子函数作为返回值，就可以在函数外部读取它的内部变量
function f1() {
var n = "我是函数内部变量";
function f2() {
console.log(n); // "我是函数内部变量"
}
return f2;
}
var result=f1();
result(); // "我是函数内部变量"
如上，获取f1的返回值f2函数，而f2可以读取f1的内部变量，这样就可以在外部获取f1内部的变量。闭包就是函数f2
闭包最大的特点，就是它可以"记住"诞生的环境
闭包的用处：
function createIncrementor(start) {
return function () {
return start++;
};
}
var inc = createIncrementor(5);
inc() // 5 // 闭包使得start变量一直在内存中
inc() // 6
inc() // 7
闭包使得函数内部环境一直存在，闭包可以看作是函数内部作用域的一个接口
function Person(name) {
var _age;
function setAge(n) {
_age = n;
}
function getAge() {
return _age;
}
return {
name: name,
getAge: getAge,
setAge: setAge
};
}
var p1 = Person(‘张三‘);
p1.setAge(25);
p1.getAge(); // 25
p1.name; // "张三"
如上，函数Person的内部变量_age，通过闭包getAge和setAge，变成了返回对象p1的私有变量。
比如下面，就是闭包使用的典型例子。通常其在处理循环页面dom元素并添加事件方法时需要特别注意
var funs=[];
for(var i=0;i<5;i++){
funs[i]=function(){
console.log(i);
}
}
funs.forEach(function(f){
f();
})
// 输出 5个5，而不是0,1,2,3,4
利用闭包，可实现将变量i的每一个循环值"保存"，供调用时输出
var funs=[];
for(var i=0;i<5;i++){
(function(i){
funs[i]=function(){
console.log(i);
}
})(i);
}
funs.forEach(function(f){
f();
})
// 输出 0,1,2,3,4
undefined，但只能省略在后面的参数，靠前的参数不能省略)passes by value)。函数参数是复合类型的值(数组、对象、其他函数)，传递方式是传址传递(pass by reference)，此时在函数内部修改参数，会影响原始值arguments对象包含了函数运行时的所有参数，arguments[0]是第一个参数，arguments[1]是第二个参数，以此类推，arguments只能在函数体内部使用。arguments的length属性可以判断函数调用时的参数个数
arguments是对象，只是很像数组。如果想使用数组方法，需要将arguments转为数组。下面是转换为数组的两种方法：
var args = Array.prototype.slice.call(arguments);
// 或者
var args = [];
for (var i = 0; i < arguments.length; i++) {
args.push(arguments[i]);
}
IIFE)：圆括号()运算符跟在函数名后面，表示调用该函数，如果在定义函数之后，立即调用该函数，如下当function出现在行首时，js会将其解释为语句，后面是函数的定义，这是以圆括号结尾就会报错。
function(){ /* code */ }();
function出现在行首就是语句。
// 语句
function f() {}
// 表达式
var f = function f() {}
解决办法就是不要让function出现在行首，让js引擎解释为表达式。这样就可以在定义函数之后立即运行
比如放圆括号中：
(function(){ /* code */ }());
// 或者
(function(){ /* code */ })();
这就是"立即调用的函数表达式"(Immediately-Invoked Function Expression,IIFE)。
IIFE最后的分号是必须的。尤其是两个IIFE写在一起时，如果省略分号，连着的两个IIFE就出出现问题，可能会报错如下，两行之间没有分号，js将它们连在一起解释，将第二行解释为第一行的参数
// 报错 (function(){ /* code */ }()) (function(){ /* code */ }())
任何让解释器以表达式来处理函数定义的方法，都能产生IIFE。
var i = function(){ return 10; }();
true && function(){ /* code */ }();
0, function(){ /* code */ }();
// 甚至
!function () { /* code */ }();
~function () { /* code */ }();
-function () { /* code */ }();
+function () { /* code */ }();
通常，只对匿名函数使用"立即执行的函数表达式"。目的：一是不必为函数命名，避免了污染全局变量；二是 IIFE 内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。
如下，写法二完全避免了污染全局变量
// 写法一
var tmp = newData;
processData(tmp);
storeData(tmp);
// 写法二
(function () {
var tmp = newData;
processData(tmp);
storeData(tmp);
}());
array)是按次序排列的一组值，位置编号从0开始，用方括号表示。比如var arr = [‘a‘, ‘b‘, ‘c‘];var arr = [
{a: 1},
[1, 2, 3],
function() {return true;}
];
arr[0] // Object {a: 1}
arr[1] // [1, 2, 3]
arr[2] // function (){return true;}
typeof返回数组的类型是object数组"对象"的键名，是按次序排列的整数。
var arr = [‘a‘, ‘b‘, ‘c‘];
Object.keys(arr); // ["0", "1", "2"]
js中，对象的键名一律为字符串，数组的键名也是字符串。对象中数值的键名不能使用点结构(object.key)，所以数组元素不能使用.获取
length属性，返回数组元素的个数，即数组长度js使用一个32位整数，保存数组的元素个数。即数组长度最多只有 4294967295 个($2^32 - 1$)个
length属性是可写的。减少length值可用于删除数组元素。length设置为0可用于清空数组。length属性的值等于最大的数字键加1
var arr = [ ‘a‘, ‘b‘, ‘c‘ ];
arr.length // 3
arr.length = 2;
arr // ["a", "b"]
for...in遍历数组(会遍历非数字键)。可使用for或while循环，或forEach方法遍历var a = [1, 2, 3];
// for循环
for(var i = 0; i < a.length; i++) {
console.log(a[i]);
}
// while循环
var i = 0;
while (i < a.length) {
console.log(a[i]);
i++;
}
var l = a.length;
while (l--) {
console.log(a[l]);
}
// forEach方法
a.forEach(function (item) {
console.log(item);
});
hole)var a = [1, , 3 , 4];
a.length // 4
a[1] // undefined
delete a[2];
a[2] // undefined
a.length // 4
数组的空位不影响length属性。数组最后一个元素后面有逗号，不会产生空位。空位返回undefined。delete命令删除一个数组成员会形成空位，且不会影响length
length属性，则这个对象语法上称为"类似数组的对象"(array-like object)。"类似数组的对象"并不是数组，它们不具备数组特有的方法。
如下，obj就是一个类似数组的对象
var obj = {
0: ‘a‘,
1: ‘b‘,
2: ‘c‘,
length: 3
};
obj[0] // ‘a‘
obj[1] // ‘b‘
obj.length // 3
obj.push(‘d‘) // TypeError: obj.push is not a function
"类似数组的对象"的根本特征，就是具有length属性。只要有length属性，就可以认为这个对象类似于数组。但这种length属性不是动态值
典型的"类似数组的对象"是函数的arguments对象，以及大多数DOM元素集，还有字符串。
// arguments对象
function args() { return arguments }
var arrayLike = args(‘a‘, ‘b‘);
arrayLike[0] // ‘a‘
arrayLike.length // 2
arrayLike instanceof Array // false
// DOM元素集
var elts = document.getElementsByTagName(‘h3‘);
elts.length // 3
elts instanceof Array // false
// 字符串
‘abc‘[1] // ‘b‘
‘abc‘.length // 3
‘abc‘ instanceof Array // false
数组的slice方法可以将"类似数组的对象"变成真正的数组。
var arr = Array.prototype.slice.call(arrayLike);
除了转为真正的数组，还可以通过call()把数组的方法放到对象上面，从而让"类似数组的对象"可以使用数组的方法。
Array.prototype.forEach.call(arrayLike, function (value, index) {
console.log(index + ‘ : ‘ + value);
});
这种方法比直接使用数组原生的forEach要慢，所以可以先转为真正的数组，在调用方法
《JavaScript语言入门教程》记录整理：入门和数据类型
原文：https://www.cnblogs.com/codemissing/p/JavaScript_intro_DataType.html