1.NaN是一个数值，它表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它自己。
2.Infinity表示所有大于1.79769313486231570e+308的值，所以Infinity其实是没有具体值的，它是一个集合。
3.JavaScript中的所有字符都是16位
4.下面列出的值被当做假：
- false
- null
- undefined
- 数字0
- 数值NaN
- 空字符串""
5.其他所有的值都被当做真，包括true，字符"false"
6.for循环有形式：
第一种是常见的形式:for(初始化从句;条件从句;增量从句)
第二种：for in语句，会枚举一个对象所有属性名称（或键名）。在每次循环中，object的下一个属性名字符串被赋值给variable。
通常用来检测object.hasOwnProperty(variable)来确定这个属性名是该对象的成员，还是来自原型链。
用法如下：
1 for(myvar in obj){ 2 if(obj.hasOwnProperty(myvar)){//如果对象独有的属性，将返回true。该方法不会返回原型链 3 …… 4 } 5 }
7.运算符优先级：从上到下：
- . [] ()：提取属性与调用函数
- delete new typeof + - !:一元运算符
- * / %:乘法、除法、取余（实际上的求余运算，尤其显示在两个运算数中存在负数时，求模运算和求余运算的值则不相同）
- + -:加法/连接、减法
- >= <= > <：不等式运算符
- === !==:不等式运算符
- &&:逻辑与
- ||：逻辑或
- ?:三元
8.数字、字符串与布尔值“貌似”对象，但其实是不可变的。数组、函数、正则表达式是对象。
9.字面量：
var empty_object={};
或
var stooge={
"first-name":"Jerome",
"last-name":"Howard"
};
或
var flight = {
airline: "Oceanic",
number: 815,
departure: {
IATA: "SYD",
time: "2004-09-22 14:55",
city: "Sydney"
},
arrival: {
IATA: "LAX",
time: "2004-09-23 10:42",
city: "Los Angeles"
}
};
属性名可以是包括空字符串在内的任何字符串。如果属性名是一个合法的javascript标识符且不是保留字，则不强制要求用引号括住属性名。
尝试检索一个并不存在的成员属性的值会返回undefined，尝试从undefined成员属性中取值会导致TypeError异常，这是可以通过&&运算符避免错误。
例如：
flight.equipment && flight.equipment.model//undefined,第一个是不存在属性，第二个是不存在属性的值
10.原型与继承：
首先定义一个变量：
1 var stooge = { 2 "first-name": "Jerome", 3 "last-name": "Howard" 4 };
当需要创建一个新对象时，可以选择某个对象作为他的原型。这里给Object添加一个create方法，创建一个对象使用stooge对象作为其原型。
1 if(typeof Object.beget!=='function'){ 2 Object.create=function(o){ 3 var f=function(){}; 4 f.prototype=o; 5 return new f(); 6 }; 7 } 8 var another_stooge=Object.create(stooge);
当我们对某个对象作出改变的时候并不涉及该对象的原型：
1 another_stooge['first-name'] = 'Harry'; 2 another_stooge['middle-name'] = 'Moses'; 3 another_stooge.nickname = 'Moe';
原型链接只有在检索值的时候才被用到。如果我们尝试去获取对象的某个属性值，但该对象没有此属性名，那么js会尝试从原型中获取属性值。如果原型对象中也没有属性值，那么就会在该原型对象的原型中寻找，依次类推，直到到达Object.propotype。如果想要查找的属性不存在与原型链中，那么结果就是undefined值。这个过程称为委托。
for in循环会遍历一个对象中所有属性名。该枚举过程会列出所有的属性--包括函数和原型中的属性。如果想要对象中属性的值，就可以使用hasOwnPrototype以及typeof，例如：
1 var name; 2 for(name in another_stooge){ 3 if(typeof another_stooge[name]!=="function"){ 4 document.writein(name+": "+another_stooge[name]); 5 } 6 } 7
以上方法属性名出现的顺序是不确定的。
删除：delete运算符可以用来删除对象的属性。如果对象包含该属性，那么该属性就会被移除，不会触及原型链中的任何对象。而删除对象中的属性可能会让来自原型链中的属性显现出来，例如：
1 another_stooge.nickname // 'Moe' 2 3 // Remove nickname from another_stooge, revealing 4 // the nickname of the prototype. 5 6 delete another_stooge.nickname; 7 8 another_stooge.nickname // 'Curly'
11.减少全局污染：
第一种方法：建立一个唯一的全局变量，其余的全局变量都是它的属性。
1 var MYAPP = {}; 2 3 MYAPP.stooge = { 4 "first-name": "Joe", 5 "last-name": "Howard" 6 }; 7 8 MYAPP.flight = { 9 airline: "Oceanic", 10 number: 815, 11 departure: { 12 IATA: "SYD", 13 time: "2004-09-22 14:55", 14 city: "Sydney" 15 }, 16 arrival: { 17 IATA: "LAX", 18 time: "2004-09-23 10:42", 19 city: "Los Angeles" 20 } 21 };
第二种方法：闭包
12.当函数的实际参数个数超出形式参数个数时，超出的参数会被忽略。如果实际参数过少，缺失的值会被替换为undefined。
13.this在面向对象编程中非常重要，他的值取决于调用的模式。javascript中存在4中调用模式：
第一种：方法调用模式：当一个函数被保存为对象的一个属性时，我们称之为一个方法。当一个方法被调用时，this被绑定到该对象，如果调用表达式包含一个提取属性的动作（包含一个.表达式或者下标表达式），那么他就是被当做一个方法来调用。
例如：
1 var myObject = { 2 value: 0; 3 increment: function (inc) { 4 this.value += typeof inc === 'number' ? inc : 1; 5 } 6 }; 7 8 myObject.increment( ); 9 document.writeln(myObject.value); // 1 10 11 myObject.increment(2); 12 document.writeln(myObject.value); // 3
第二种，函数调用模式：当一个对象并非一个对象的属性的时候，那么它就是被当做一个函数来调用。以此模式调用函数时，this被绑定到全局对象上。这样就无法实现该方法对对象的访问权。有一个解决方法：
如果该方法定义一个变量并给他复制为this，那么内部函数就可以通过新赋值的变量访问到this。
我们把这个新赋值的变量称为that
例如：
1 <script type="text/javascript"> 2 var value=4; 3 var myObject = { 4 value: 0, 5 }; 6 7 8 myObject.double = function ( ) { 9 // var that = this; // Workaround. 10 console.log（this.value）;//0 11 var helper = function ( ) { 12 console.log(this.value);//4 13 }; 14 15 helper( ); // 以函数的形式调用helper 16 }; 17 18 //以方法的形式调用double 19 20 myObject.double( ); 21 document.writeln(myObject.value); // 0 22 </script>
以上代码中，首先以方法的形式调用double，这样如果double中含有this，该this指向myObject,所以第10行输出的是myObject内部的value，值为0。在double方法内部，存在以函数形式调用的helper函数，那么helper函数中的this指向的全局变量，所以会输出全局变量的value值，为4。
可见这样的形式中，helper是无法通过this来访问myObject对象内部的其他属性的。如果将var that=this;添加进去，将double函数内部的this赋值给that变量，这样就然后把helper函数内部的代码改成console.log(that.value);这样就可以指向myObject内部的value了，输出为0.代码如下：
1 <script type="text/javascript"> 2 var value=4; 3 var myObject = { 4 value: 0, 5 }; 6 7 8 myObject.double = function ( ) { 9 var that = this; // Workaround. 10 console.log(this.value);//0 11 var helper = function ( ) { 12 console.log(that.value);//0 13 }; 14 15 helper( ); // Invoke helper as a function. 16 }; 17 18 // Invoke double as a method. 19 20 myObject.double( ); 21 document.writeln(myObject.value); // 0 22 </script>
第三种模式：构造器调用模式，在函数面前使用new来调用，那么背地里会创建一个连接到该函数prototype成员的新对象，this会被绑定到那个新对象上。例如：
1 var Quo=function(string){ 2 this.value="string"; 3 }; 4 5 6 Quo.prototype.get_status=function(){ 7 return this.value; 8 }; 9 10 var myQuo=new Quo("confused"); 11 console.log(myQuo.get_status());//confused
第四种调用模式：apply调用：
apply方法让我们构建一个参数数组传递给调用函数。它润徐我们选择this的值。apply接收两个参数，第一个就是要绑定给this的值，通过设定这个参数可以改变函数的运行时的上下文，就是this的值，如果设置为null或者没有指定该参数，则this指定它本身。
14.柯里化
允许我们把函数与传递给它的参数相结合，产生一个新的函数。
15.数组：
数组的长度是length属性，是没有上界的。length属性的值是在这个数组的最大整数属性名上加1.他不一定等于数组里的属性的个数。例如:
var myArray=[]; myArray.length;//0 myArray[10000]=true; myArray.length;//10001
后置的[]运算将它所包含的表达式转换成一个字符串，使用该表达式的toString()方法，这个字符串将被使用做属性名。
删除数组：
delete运算符可以用来从数组中移除元素，例如：
1 var number=["one","two","three","shi","go“]; 2 delete number[2]; 3 console.log(number);//["one","two","undefined","shi","go"];
使用delete删除之后，会留下一个空洞，因为排在被删除元素之后的元素保留着他们最初的属性。
splice方法可以用来删除数组属性，删除一些元素并替换为其他元素。第一个参数为数组中的一个序号，第二个参数为要删除的元素个数。
1 var number=["one","two","three","shi","go“]; 2 number.splice(2,1); 3 console.log(number);//["one","two","shi","go"]
按照顺序遍历数组属性：
var i;
for(var i=0;i<myArray.length;i++){
console.log(myArray[i]);
}
检测数组还是对象：
var isArray=function(value){
return Object.prototype.toString.apply(value)==="[object Array]";
}
为数组添加方法：
Array.method("reduce",function(f,value){
var i;
for(i=0;i<this.length;i++){//这里的this指调用这个方法的数组
value=f(this[i],value);
}
return value;
});
var data=[4,8,15,16,23,42];
var add=function(a,b){
return a+b;
}
var sum=data.reduce(add,0);//108
构造二维矩阵：
1 Array.matrix=function(m,n,initial){ 2 var i,j,a,mat=[]; 3 for(i=0;i<m;i++){ 4 a=[]; 5 for(j=0;j<n;j++){ 6 a[j]=initial; 7 } 8 mat[i]=a; 9 } 10 return mat; 11 } 12 13 var myMatrix=Array.matrix(4,4,0);
16.正则表达式：
对字符串中的信息实现查找、替换和提取操作。
可用于处理正则表达式的方法有regexp.exec、regexp.test、string.match、string.replace、string.search和string.split
17.RegExp表达式的属性：
- global：如果标识g被使用，值为true
- ignoreCase：如果标识i被使用，值为true
- lastIndex：下一次exec匹配开始的索引。初始值为0
- multline：如果标识m被使用，值为true
- source：正则表达式源码文本
18.一个未被转义的.会匹配除行结束符以外的任何字符。
19.当lastIndex属性值为0时，一个未转义的^会匹配文本的开始，当指定m的时候，他也能匹配行结束符
20.一个未转义的$将匹配文本的结束。当指定了m标识时，他也能匹配行结束符
21.正则表达式分组：
有四种。
第一种：捕获型。
一个捕获型分组是一个被包围在圆括号()中的正则表达式的分支。任何匹配这个分组的字符都会被捕获。每个捕获型分组都被指定了一个数字。
第二种：非捕获型。
非捕获型分组有一个(?:的前缀，只进行简单的匹配，并不会捕获所匹配的文本。不会干扰捕获组的编号。
第三种：向前正向匹配
有一个(?=前缀，类似于非捕获分组，但在这个组匹配后，文本会倒回到她开始的地方，实际上不匹配任何东西。这不是一个好特性。
第四种：向前负向匹配
向前负向匹配分组有一个(?!前缀，类似于向前正向匹配分组，但只有当它匹配失败时才继续向前进行匹配，这不是一个好特性。
22.正则表达式中需要被转义的特殊字符：
- / [ \ ] ^