a:通过关键字 function定义声明的语句就是函数 function sun(){ } b:函数是一个代码块的集合
a:参考变量命名
a:普通调用 function sun(){ } sun()
b:事件中调用 <p onclick="sun()"></p>
c:表达式中调用（输出方法中调用） function sun(){ var n=1; return n; } alert(sun()) console.log(sun()) document.write(sun())
d:超链接调用（不常用，了解就行） <a href=''></a>
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> <a href="javascript:sun()">点击</a> </body> <script type="text/javascript"> // function sun(){ // alert(1231) // } // function sun(){ // var n=1; // return n; // } // alert(sun()) // function f(){ // var a=1; // var b=2; // return a+b; // } // alert(f()) // function f1(){ // var n=1; // function f2(){ // alert(n); // } // return f2; // } // alert(f1()()) </script> </html>a:实参 1:arguments.length 获取的是实参的长度 2:arguments[num] 获取某一个实参元素 3:函数的实参可以是任何类型 b:形参 1：函数名.length 获取的是形参的长度
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // function People(a,s,d,f){ // alert(People.length) // } // People(); function People(){ alert(arguments.length) } People('html','css','js'); </script> </html>arguments 存在于函数中，本身是一个对象，同时是函数的一个属性，主要作用于实参。 return 返回关键字后面的值，把值给到了函数，比用输出方法。 举例：
function sun(){ var n=1; return n; } alert(sun())概念：递归调用：就是自己调用自己的过程。
递归的本质：实现循环
三要素：初值;条件;步长;执行语句。
举例1： function fac(num){ if(num==1){ return num; }else{ return num*fac(num-1); } } alert(fac(5));举例2：
function f(n){ if(n==1||n==2){ return 1; } return f(n-1)+f(n-2); } alert(f(5)); <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // 求阶乘 5! // 5 4 3 2 1 // function fac(num){ // if(num==1){ // return num; // }else{ // return num*fac(num-1); // 5*fac(4) // 5*4*f(3) // 5*4*3*f(2) // 5*4*3*2*1 // } // // } // alert(fac(5)) // 斐波那契数列 // 1 1 2 3 5 8 13 21 34 55 89 144... // 1 2 3 4 5 6 7 8 9 10 11 12 // function f(n){ // if(n==1||n==2){ // return 1; // } // return f(n-1)+f(n-2); // } // alert(f(4)); </script> </html>a:创建全局变量的3种写法： 1. 在函数体外变量命名 2. 在函数体内或者函数外变量命名不加关键字 var 3. window对象下命名变量 举例： window.a=1 4. 只要不是被函数的花括号包围，在其他语句中的变量都是全局变量。
b:在函数体内加关键字var创建的变量是局部变量
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> <button id="btn">点击</button> </body> <script type="text/javascript"> // var a=1; // b=2; // window.c=3; // function f(){ // alert(a) // alert(b) // alert(c) // } // var a=1; // // function d(){ // var aa=2; // function g(){ // // } // } // window.d() // var aaa=3; // window.alert(1) // var obtn=window.document.getElementById('btn'); // obtn.οnclick=function(){ // window.alert() // } // console.log(window) function sun(){ for(var i=0;i<5;i++){ for(var j=0;j<=i;j++){ } } } sun() alert(i); alert(j) </script> </html>简单类型和复杂类型。 简单： number string null undefined boolean 复杂： 函数 数组 字符串 对象 日期…
基本类型和引用类型。 基本： number string null undefined boolean 引用： 函数 数组 字符串 对象 日期…
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // var a=1; // var b=1; // b=3; // alert(a);//1 // alert(b);//3 // var arr1=['html','css','js']; // var arr2=arr1; // arr2[1]='哈哈'; // alert(arr1)//html,哈哈,js // alert(arr2)//html,哈哈,js // 1:基本类型被赋值后双方互不影响. // 2:引用类型在被赋值的时候,赋值的只是一个引用地址,不是具体值. // // function sun(){ // var a=1; // var b=2; // alert(a+b) // } // sun() // var o1={ // name:'jack', // age:12, // job:'学生' // } // var o2=o1; // o2.name='tom'; // alert(o1.name)//tom // var a=b=10; // (function(){ // var a=b=20 // })(); // // alert(a); // var foo={ // n:1 // }; // var bar=foo; // foo.x=foo={n:2}; // alert(foo.x); </script> </html>栈内存： 值和地址==》基本类型 堆内存：值==》引用类型
a：js解析代码分为2种。 1. 首先预解析（叫编译过程） 2. 在执行js代码（从上到下，从左到右）
b：预解析？ js解析代码的时候，会先提前读取带有关键字 var 和 function 的全局类型；
c：声明和定义？ var num=12; 在基本类型里面，声明在前，定义在后！（先声明后定义） function fun(){ alert(1) } fun(); 对于函数来说，声明和定义同时执行。
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // 1:浏览器解析代码的时候,优先读取关键字 var 和function 的变量函数,读取完,在按照从上往下/从左往右的顺序解析其他js代码. // alert(a) // var a=4; // asd() // function asd(){ // alert(1) // } //fgh is not a function // var fgh=function(){ // alert(123) // } // fgh(); // var c=5; // alert(c) // alert a) // var a=2; // var c = 1; // function d() { // alert(c); // var c = 3; // } // d(); // var a = 10; // function test() { // a = 100; // alert(a); // alert(this.a); // var a; // alert(a); // } // window.test(); // var a = 100; // function fn1() { // alert(a); // // var a = 10; // } // alert(fn1());// // var x = 1; // function fn(n){ // n = n+1; // return n; // }; // x = fn(x); // alert(x)//2 1 报错 undefined // (function(){ // alert(a) // a++; // var a=20; // // })(); // console.log(a); b(); var a = 6; function b() { alert(a); a = 666; } var a = 66; </script> </html>1.语法检查 2.预编译 3.逐行解释执行
每一个函数都有自己的作用域链条，作用域链就是在内部查找一个变量属性， 内部有直接输出，内部没有会查找函数外是否有这个变量属性，函数外没有接着在整个 widow下查找，这样一层一层查找的顺序，就是作用域链！ 举例：
var a=1; function person(){ var a=2; function p1(){ var a=3; alert(a) } p1() function p2(){ alert(a) } p2() } person() <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // function sun(){ // alert(a) // } // sun() // var a=10; // // function peop(){ // alert(a) // } // peop() // var b=10; // function sum(){ // alert(a) // } // sum() //1:预解析 把带有关键字 var fun 提升 //2:从左往右,从上往下 //3：就近原则 function person(){ function p1(){ var a=3; alert(a) } p1() function p2(){ alert(a) } p2() var a=4; } person() </script> </html>a:什么是闭包函数？ 函数嵌套函数，函数内部的函数被称之为闭包函数.（son函数就是闭包） 举例：
function sum(){ var v=3; function son(){ alert(v) } return son; } var a=sum(); alert(a) <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> </body> <script type="text/javascript"> // var a=1; // function sun(){ // alert(a) // var b=3; // // } // sun() // alert(b) // function sum(){ // var v=3; // function son(){ // return v; // } // return son; // } // var a=sum(); // alert(a()) //1:闭包读取内部变量 // function sum(){ // var v=3; // function son(){ // function smn(){ // alert(v) // } // return smn; // } // return son; // } // sum()()(); //2:闭包可以让变量始终保持在内存中 function f1(){ var n=1; f2=function(){ n+=1;//n=n+1 } function f3(){ alert(n) } return f3; } var f4=f1(); f4();//1 f2() f4();//2 f2(); f4();//3 // function a(){ // var n=1; // var b=2; // alert(n+b) // } // var s=a(); // alert(s); </script> </html>b:闭包的用途 1. 通过闭包函数可以读取函数内部的变量（往上看） 2. 可以让变量始终保持在内存中
由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包， 否则会造成网页的性能问题，在 IE 中可能导致内存泄露
垃圾回收机制这个名词就是对内存中的全局局部变量什么时候释放内存的一个统称。 全局：直到你关闭浏览器或者页面，全局变量才会释放自己的内存。 局部：在函数执行过程中，局部变量才会占内存，其他情况不占内存。
如果你把父函数当作对象（object）使用， 把闭包当作它的公用方法（Public Method）， 把 内部变量当作它的私有属性（private value）， 这时一定要小心，不要随便改变父函数内 部变量的值
利用构造函数解决闭包中的内存泄漏。
