一、 重要：js中的function函数声明、函数表达式
// 函数声明
// Ex: 会在代码执行之前提前加载到作用域中，即js解析器会优先读取，确保在所有代码执行之前声明已经被解析；所以可以在定义之前调用。
function test(){
document.write("test() invoke!" + "<br>");
}
// 函数表达式
// Ex: 在代码执行到那一行的时候才会有定义；定义之后才能调用。
var t2 = function(){
document.write("t2() invoke!" + "<br>");
}
//函数声明：会在代码执行之前提前加载到作用域中
test("1"+name); // test() invoke!14
var name =1;
function test(name){
document.write("test() invoke!" + name + "<br>");
}
name=2;
test("2"+name); //test() invoke!22
//函数表达式：在代码执行到那一行的时候才会有定义
var t2;
//t2(); // t2 is not a function
test("21"+name); //test() invoke!212
name =3;
test("22"+name); //test() invoke!223
t2 = function(){
document.write("t2() invoke!" + "<br>");
}
t2(); //正确 t2() invoke!
name=4;
test("3"+name); //test() invoke!34
分析：
1. 为什么是 test() invoke!14?
Js顺序逐行解析完后，name=4， 所以是 test() invoke!14
2. 执行test("2"+name);前 name =2;
// 函数表达式后面可以加括号立即调用该函数，函数声明不可以，只能以fnName()形式调用
fnName();
function fnName(){
...
}//正常，因为‘提升’了函数声明，函数调用可在函数声明之前
fnName();
var fnName=function(){
...
}//报错，变量fnName还未保存对函数的引用，函数调用必须在函数表达式之后
var fnName;
fnName();
fnName =function(){
...
}//报错，变量fnName还未保存对函数的引用，函数调用必须在函数表达式之后
var fnName=function(){
alert('Hello World');
}();//函数表达式后面加括号，当javascript引擎解析到此处时能立即调用函数
function fnName(){
alert('Hello World');
}(1);//不会报错，但是javascript引擎只解析函数声明，忽略后面的括号，函数声明不会被调用
function(){
console.log('Hello World');
}();//语法错误，虽然匿名函数属于函数表达式，但是未进行赋值操作，
//所以javascript引擎将开头的function关键字当做函数声明，报错：要求需要一个函数名
// 问题： 它们之间的区别是什么？都会解析到就立即调用，是只参数位置不同。
(function test(arg){
document.write(arg + "<br>");
}("111")); //传说中推荐写法
(function test(arg){
document.write(arg + "<br>");
})("222"); //Jquery写法
二、 Js中的私有作用域 和闭包
资料：http://www.jb51.net/article/24101.htm
闭包：在内部定义的函数和变量只能在此范围内有效。形成是否是私有变量的概念。
var i=3;
function init(pa){
alert("外层init："+i+","+pa);
}
(function(pa) {
//私有作用域
var i=2;
//i=2;//这不是私有变量，会修改外层的i
function init(){
alert("内层init："+i+","+pa);
}
init(); //内层init：2,lyn
})('lyn');
init("vergil");//外层init：3,vergil
闭包含义：
闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
什么是闭包：
function f1(){
var n=999;
add=function(){//没用var声明，表示是全局变量。 匿名表达式
n+=1;
}
function f2(){
document.write(n+"<br>");
}
return f2;
}
var result=f1();//result指向的是f1()的返回值,不是f1，二是f2的匿名
result();// 999
add();
result();// 1000
f2函数就是闭包，f2可以访问f1的内部变量n。
函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。
原因：在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后被垃圾回收机制（garbage collection）回收。
当内部函数在定义它的作用域的外部被引用时,就创建了该内部函数的闭包；
如ex，f2定义在f1内部，但在f1的外部被引用了，既result();
如果内部函数引用了外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被释放,因为闭包需要它们.
如ex，f2函数内部使用了外部的n；在var result=f1();调用完后。result指向f2，f1()结束调用。但此时不会释放局部变量n；因为n还被f2所用。
闭包注意事项：
1） 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。
解决方法: 在退出函数之前，将不使用的局部变量全部删除。
2） 闭包会在父函数外部，改变父函数内部变量的值。
所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。
通过Jquery源码理解闭包/私有变量：
// Jquery的定义可以理解为：
(function(){
var a=...
})(jQuery);
// 此时，保护了内部的a不会被外部/全局变量修改。
几个理解js闭包的示例：
1、
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
return function(){
return this.name;
};
}
};
alert(object.getNameFunc()()); //The Window
解析： object.getNameFunc()()实质， var temp = object.getNameFunc();
temp() 等价于 window.temp(); // 此时调用的this是window，即全局变量
2、
function outerFun()
{
var a=0;
function innerFun()
{
a++;
alert(a);
}
}
innerFun(); //error
解析：outerFun外部无法调用内部方法。
3、
function outerFun()
{
var a=0;
function innerFun()
{
a++;
alert(a);
}
return innerFun; //注意这里
}
var obj1=outerFun();
obj1(); //1
obj1(); //2
var obj2=outerFun();
obj2(); //1
obj2(); //2
解析： JS对象之间是独立的
三、 Js中的私有变量 （结合闭包理解）
资料：http://www.cnblogs.com/zhaobing/archive/2014/07/10/3836698.html
1. 特权函数构造器
name属性在每个对象中都有一份，不会引起共享错误，getName和setName方法是用闭包形式访问name变量，这样避免了外部环境对Person的name变量的访问，只能通过函数对Person的name变量访问;
function Person(name){
this.getName = function(){
return name;
};
this.setName = function(value){
name = value;
};
}
var person = new Person('Lyn');
document.write(person.getName()+"<br>"); //Lyn
person.setName('Vergil');
document.write(person.getName()+"<br>"); //Vergil
//构造函数模式实现私有变量（通过闭包实现）
function Person(nameStr){
var name = nameStr;//私有变量
this.age = 15;//公有变量
this.getName = function(){
return name;
};
this.setName = function(value){
name = value;
};
this.getInfo = function(){
document.write(name + " " +this.age + "<br //Lyn 15>");
};
}
var p1 = new Person('Lyn');
var p2 = new Person('Vergil');
p1.getInfo(); //Lyn 15
p2.getInfo(); //Vergil 15
p1.setName('VergiLyn');
p1.getInfo(); //VergiLyn 15
p2.getInfo(); //Vergil 15
问题： 每次调用时都会创建函数对象，耗费资源，函数不可以共享。
2. 静态变量 （其实就是单例）
//静态私有变量
(function() {
var name = "NULL";//静态私有，被所有实例所共享
//js中不加var其实就是定义全局变量
Person = function(value) { //默认为全局变量了 ，可以被外部访问
name = value;
};
Person.prototype.getName = function() {
return name;
};
Person.prototype.setName = function(value) {
name = value;
};
})();
var person1 = new Person("Lyn");
document.write(person1.getName()+ "," + name+"<br>"); //"Lyn",""
person1.setName("Dante");
document.write(person1.getName()+ "," + name +"<br>"); //"Dante",""
var person2 = new Person("Vergil");
document.write(person1.getName()+","+name+"<br>"); //"Vergil",""
document.write(person2.getName()+","+name+"<br>"); //"Vergil",""
document.write(sss); //error：sss undefined
注意：可以访问到name，但值并不是想象中的Lyn、Dante，也不是初始值"NULL"或者undefined。
忘记当初这js在哪测试的了，但我在写的时候去w3s和runoob测试了下，貌似结果不一样。
四、 Js中的true/false
false：undefined、null、false、""、0
typeof undefined // undefined
typeof null // object
null === undefined // false
null == undefined // true
五、 Js中的 typeof
typeof 一般只能返回如下几个结果：
number,boolean,string,function,object,undefined
ex:
typeof "John" // 返回 string
typeof 3.14 // 返回 number
typeof false // 返回 boolean
typeof [1,2,3,4] // 返回 object
typeof {name:'John', age:34} // 返回 object
六、 Js中的 === 、==
// ===：类型 和 值 全相等；
// ==：只比较值相等；
null === undefined // false
null == undefined // true
var o = new Object("s"); //object
var s = "s"; //string
/** 注意Jquery提供的方法的趋避 */
document.write($.type(o) + "<br>");// string
document.write((typeof o ) + "<br>");// object
document.write($.type(s) + "<br>");// string
document.write((typeof s ) + "<br>");// string
document.write((o == s) + "<br>"); // true
document.write((o === s) + "<br>"); // false
七、 Js中的call / apply
call / apply的作用是一样的，都是js内置。
区别： 参数形式不一样；
*.call(obj,arg1...)
*.apply(obj,argArray)
作用：
Ex:
var temp = new TempObj();
var lyn = new LynObj(1,"vergilyn");
temp.tempMethod(lyn,arg1,arg2)
TempObj()中存在方法tempMethod(arg1,arg2)
LynObj()中不存在，现在用LynObj对象的this去调用TempObj的tempMethod()方法。
即，temp内部的this指针不指向temp而是lyn。
八、 重要：js中的prototype
函数运行时会先去本体的函数中去找，如果找到则运行，找不到则去prototype中寻找函数。（或者可以理解为prototype不会克隆同名函数）
访问顺序，先 本体 -> 原型链prototype ；当在本体找到同名时，就调用了，不会再去寻找prototype的了。
var LynObj = function(id,name){
this.name = name;
this.id = id;
this.show=function(){
alert("本体中同名的show():"+this.name);
}
}
//LynObj的原型 要写在 new LynObj()之前
LynObj.prototype={
age:24,
id:-1,
show:function(){}, //本体中有，不会调用此方法
add:function(a1,a2){
alert("add: " + a1 + " + " + a2 +" = " + (a1+a2));
}
};
var lyn = new LynObj(1,"vergilyn");
lyn.show(); //本体中的同名show()：vergilyn
alert(lyn.age); //24
alert(lyn.id); //1,对象本身的，不是prototype中的
lyn.add(2,4); //add: 2 + 4 = 6
问题： 1、 如果想调用prototype中的同名方法， 以上写法是不可以的。
解决：
var TempObj = function(){ //为了能调用prototype中的全部属性/方法
this.age = 24;
this.name = "dante";
this.show = function(){
alert("prototype中同名的show():"+this.name);
},
this.add = function(a1,a2){
alert("add: " + a1 + " + " + a2 +" = " + (a1+a2));
}
};
LynObj.prototype= new TempObj();
var temp = new TempObj()
var lyn = new LynObj(1,"vergilyn");
lyn.show(); //本体中的同名show()：vergilyn
alert(lyn.age); //24
alert(lyn.name);//vergilyn
lyn.add(2,4); //add: 2 + 4 = 6
temp.show.call(lyn);//prototype中同名的show():vergilyn
/* call 或者 apply 是js内置； 把temp中的this改为lyn对象，调用show()
* 区别: call(obj,arg1...)， apply(obj,argArrays)
*/
九、 JS中的for-in / in， 形式 for(name in obj) / name in obj
for-in：循环遍历对象/数组，name表示对象的属性/数组的下标。
in：判断name是否是obj的直接属性。返回true/false
注：in判断的是直接属性，见ex
var obj = {"a1":{"b1":"b1","b2":"b2"},"a2":"a2","a3":"a3"};
for(name in obj){
document.write(name + ":" + obj[name] + "<br>");
// a1:[Object] a2:a2 a3:a3
}
var arr = [1,3,5];
for(index in arr){
document.write(index + ":" + arr[index] + "<br>");
//0:1 1:3 2:5
}
document.write(("b1" in obj) + "<br>"); // false
document.write(("b1" in obj.a1) + "<br>"); // true
document.write(("a3" in obj) + "<br>"); // true
document.write(("a4" in obj) + "<br>"); // false
// "1" / 1 都表示下标 js的2中调用 obj.name 等价于 obj[name]
document.write(("1" in arr) + "<br>"); // true
document.write((1 in arr) + "<br>"); // true
十、 Jquery的扩展extend
1、 jQuery.extend: jQuery类的 类方法;对jQuery类扩展， 只需 jQuery.extend(...)；
/** 为jQuery类扩展的一些类方法。Jquery部分源码 */
jQuery.extend({
expando:"jQuery"+(version+Math.random()).replace( /\D/g, "" ),
isFunction: function( obj ) {
return jQuery.type( obj ) === "function";
},
isEmptyObject: function( obj ) { //判断是不是empty对象，
var name; // name = undefined
for ( name in obj ) {return false;}
return true;
}
)}
2、 jQuery.fn.extend: 因为 jQuery.fn = jQuery.prototype； 所以定义了jQuery的对象方法; 对jQuery对象扩展，只需 jQuery.fn.extend(...)；
jQuery.fn.extend( {
filter: function( selector ) {
return this.pushStack( winnow( this, selector || [], false ) );
},
not: function( selector ) {
return this.pushStack( winnow( this, selector || [], true ) );
}
)}
特别：
1. 根据实际的参数，判断是对jQuery的扩展(不管是类/对象)，还是这是个工具类。
2. 区分深复制/浅复制的区别。
深复制：会递归处理对象中的对象。
浅复制：(可理解为)把对象中的对象当作是属性。
// jQuery-1.12.3 sourcecode：
jQuery.extend = jQuery.fn.extend = function() {
var src, copyIsArray, copy, name, options, clone,
target = arguments[ 0 ] || {}, //arguments js函数内置属性， 表示函数实际接收到的参数。类似数组，实质不是数组
i = 1,
length = arguments.length,
deep = false; //是否深复制
// Handle a deep copy situation
// Lyn：判断深复制情况 ； arguments[0] true深复制 false浅复制
/** 深复制 浅复制 区别： 深复制会递归处理复杂对象
* ex：
* var dest={};
* var result=$.extend( true/false, dest,
{ name: "John", location: {city: "Boston",county:"USA"} },
{ last: "Resig", location: {state: "MA",county:"China"} } );
* 深复制： dest = {name:"John",last:"Resig",
* location:{city:"Boston",state:"MA",county:"China"}}
*
* 浅复制： dest = {name:"John",last:"Resig",
* location:{state:"MA",county:"China"}}
*
*/
if ( typeof target === "boolean" ) {
deep = target;
target = arguments[ i ] || {};//i默认1
i++;
}
// Handle case when target is a string or something (possible in deep copy)
// 当target不是object 或者 function 时，设置成{} 空内容的对象
if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
target = {};
}
// 判断是不是对jQuery自身进行扩展。
// jQuery.extend() : 扩展jQuery类
// jQuery.fn.extend(): 扩展jQuery对象
if ( i === length ) {
target = this; //this指 jQuery(类) 或者 jQuery.fn(jQuery实际的对象)；所以，此if表示判断对jQuery自身的扩展(类/对象)
i--;
}
for( ; i < length; i++ ) {//因为数组循环,所以arguments后面的值覆盖之前的
// Only deal with non-null/undefined values
if ( ( options = arguments[ i ] ) != null ) {
//同时赋值临时变量options
// Extend the base object ****核心的继承逻辑 for循环****
for ( name in options ) {
src = target[ name ]; //可以理解为 json的 target.name
copy = options[ name ];
// Prevent never-ending loop 防止无限循环
if ( target === copy ) {
//目标对象和要拷贝的对象 恒相等，就(不复制)执行下一个循环
continue;
}
//Recurse if we're merging plain objects or arrays递归如果我们合并对象/数组
if ( deep && copy
&& ( jQuery.isPlainObject(copy)
|| (copyIsArray = jQuery.isArray(copy))
//同时赋值临时变量copyIsArray
)
) { //深复制 用递归处理合并的如果是 对象 或 数组
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray( src ) ? src : [];
} else {
clone = src && jQuery.isPlainObject( src ) ? src : {};
}
// Never move original objects, clone them 从不移动原始对象， 把新的克隆进去
// Lyn: 递归处理 对象 或 数组
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values 不增加一个undefined的值
} else if ( copy !== undefined ) { //浅复制
target[ name ] = copy;
}
}
}
}
return target;//返回自定义的目标对象，
// 注：因为target = arguments[0/1]所以参数0/1如果是对象，其对象结构会被改变
// 或者 为了扩展jQuery，Jquery对象被改变
};
来源：https://www.cnblogs.com/VergiLyn/p/5994773.html