JS2---函数与闭包

JS基本语法之变量的声明

一.零碎知识点

1.js引入网页

1. 外部引入 <script src="" type="text/javascript"></script>   type 可以省略
2.直接内嵌到网页里面   分为上部内嵌和下部内嵌    下部内嵌可以提高网页的性能 

2.定义变量 var 变量名称

①变量在使用之前 切记初始化
②未初始化会报错 undefined / a is not defined 未定义类型
③变量的命名规则：驼峰式

3. 变量的数据类型（面试可能会询问）

number    string    object（数组,对象）   boolean    null    undefined（ function）

    typeOf  检测变量的数据类型
   	  var a=10;
     var b="nihao";
     var c=true;
     var d={};     //对象
     var e=[];     //数组
     var f=null;   //空对象引用
     var g=undefined;
     console.log(typeof a);//number
     console.log(typeof b);//string
     console.log(typeof c);//boolean
     console.log(typeof d);//object
     console.log(typeof e);//object
     console.log(typeof f);//object
     console.log(typeof g);//undefined
     console.log(typeof showname);//function
     function showname(){}

4.值类型和引用类型

①值类型

空间不变，值的类型在不停地替换

②引用类型

例如founction,objict（{}，[ ] , null） 对应引用空间，引用的位置是可以变化的

5.变量会被js 提前声明（给变量一个空间）

二 .函数

1.函数也会被提前声明

2.带返回值的函数

    function showinfo() {
        //执行代码
        return '1';
    }

    var a = showinfo();
      console.log(a);   //a=1

3.带参函数 （ 形参 实参）

   function showname(name, sex, age) {        //形参
        return name;
    }
    var name = showname("张三", "男", 18);     //实参
    console.log(name);

如果函数没有参数列表 传递参数怎么接收参数（***）

argument 参数列表对象

  
    function showData() {

        //arguments 参数列表对象
        //arguments  取值按照集合来取值   key:value  索引
        console.log(arguments[0], arguments[1], arguments.length);//小花，18 , 2
    }

    showData("小花", 18);

4.匿名函数

不带函数名称的函数 --------- 不提前声明

list();     not a  function  报错
var list = function () {
    console.log(arguments); //参数列表对象
    return arguments[0];
}
console.log(list(1, 2, 3));

5.自执行函数

其他函数调用后才会执行，自执行函数不用调用便会自己执行

执行函数自有形参，实参，有返回值（函数有的它都有）

    //  有实参形参   返回值
    var mm = (function (x, y) {
        console.log(x, y);         //1,2
        console.log(arguments);    //arguments[2]:  0:1  1:2
        return x + y;             
    })(1, 2);
    console.log(mm);               //3

    var temp = "object";
    (function () {
        console.log(temp);         //undefined (函数会提前声明)
        var temp = "student";     //函数提前声明给了个空间，将object覆盖住了
        console.log(temp);        //student
    })();

三, js中变量的作用域（作用范围）

局部变量 ：函数定义区

全局变量 ： 整个js

 var a=10;               //全局变量
    function f1() {
        var m=15;        //f1()的局部变量
        console.log(m,a);
    }
    function f2() {
        var m=1;         //f2()的局部变量
        console.log(m,a);
    }
    f1();
    f2()

四.js中的闭包

闭包的概念：
① 使用别人的局部变量
②闭包会大量占用内存 ，会导致网页内存泄露
③尽量避免使用闭包 会将闭包的值存在内存里面

关于闭包的例题

①

        			function f1(){
            var a=10;
            return a;
        }
        function f2(){
            console.log(f1());  //使用了f1中的局部变量a
        }
        f2();                   //10

②

   function f1() {
                var a=1;
                t=function () {
                    a++;
                }
                return function () {
                    console.log(a);
                }
            }
     var a1=f1();             // a1 = return function () { console.log(a); }
                   
        a1();//1
        t();
        a1();//2
        t();
        a1();//3

③

function f1() {
    var n = 999;
    return function f2() {
        return n;
    }
}
console.log(f1()());               //999    第一个括号执行f1函数，第二个括号执行f1返回的f2
console.log(f1());                 // return function f2() { return n; }

④

   function f1(){
        var b=10;
        return function (){
            b++;
            console.log(b);
        }
    }
    f1()();             //11

⑤

  var name="global";                //全局变量
    function foo(){
        console.log(name);
    }
    function fooOuter1(){
        var name="local";            //局部变量，注意作用域，出了作用域后就无效

        foo();
    }
    fooOuter1();   //global

    function fooOuter2(){
        var name="local";
        function foo(){
            console.log(name);//local   // 局部函数取就近
        }
        foo();
    }
    fooOuter2();*/

⑥

function test() {
        var value =2;
        return function (params) {
            console.log(window.value*params);    //6
            console.log(value*params);          //4
        }
    }
    value=3;
    var a = test();
    a(2);
 //js里面定义全局变量  全局方法   都是window属性   浏览器最大对象

⑦

var m=0;
function f2(n){
    temp=function (){
        m+=n;
    }
    temp();
    //方法的重写    
    //tostring   object  String   tostring   重写tostring  会自动执行String 类里面的tostring
    f2.toString=function (){
        console.log(1);
        return m;
    }
    /*console.log(typeof f2.toString());*/
    return f2;
}
console.log(f2(1));          //  1  一次只能写一个，要是在写m的值不为0，是已经运行过的m值
console.log(f2(1)(2));       //  3
console.log(f2(1)(2)(3));    //  6