js笔记整理2

函数：
代码的复用（写一遍，多次使用）把特定功能打包。
function 告诉后面的是函数
function 名字（多个参数）{
执行语句
}

比方说每天7点，12点，23点都要喊十声“好好学习，努力赚钱”那么如果不用函数的话，每次都要在时间的后面加上这一句话。

var time=7；
for（var a=1；a=10；a++）
{     console.log("好好学习，努力赚钱")   }

var time=12；
for（var a=1；a=10；a++）
{     console.log("好好学习，努力赚钱")   }

var time=23；
for（var a=1；a=10；a++）
{     console.log("好好学习，努力赚钱")   }

但是如果用了函数的话，就可以避免这一现象。

function slogan（）{
     for（var a=1；a<=10; a++）{
         console.log("好好学习，努力赚钱")；
     }
}
var time=7;
slogan();
var time=12;
slogan();
var time=23;
slogan()；

返回值：

function add(x,y){
    var z = x+ y;
    return z;    //返回z值给函数add
}

然后调用该方法
add(1,2)
要想获取1加2的值，则
var rs = add(1,2);
add函数通过return获取到z值3。

function slogan(num,time){}
函数中有两个值，若time没有传参。则会返回undefind。
解决方法：（自己定义time的值）
1、if(time == undefind) time = 7
2、time = time || 7

动态参数：
arguments是一个对象。Javascript并没有重载函数的功能，但是Arguments对象能够模拟重载。Javascrip中每个函数都会有一个Arguments对象实例arguments，它引用着函数的实参，可以用数组下标的方式"[]"引用arguments的元素。arguments.length为函数实参个数，arguments.callee引用函数自身。

一般来说，下面的加法运算只能运算两个数字，为了解决多个数字相加，运用到了动态参数。

function add(x,y){
   var arguments = [1,2,4,5,23];
   x = arguments[0];
   y = arguments[1];
   return x + y;
}    
var rs = add();
console.log(rs);    //此时输出的结果只有3。

解决方法：（所有的数字都相加了）

function add(){
   var z = 0;
   for(var i = 0;i<arguments.length; i++){
   z += arguments[i];
}
   return z;
}    
var rs = add(1,2,4,5,23);
console.log(rs);    

arguments.lenth 数组的长度
z +=arguments[i] 1到i相加等于z

作用域 可访问变量的集合：变量可以被使用的地方
全局作用域（函数外定义的，所有地方都能被访问）。

function add() {
   y = 100;  //虽然此时y在函数内，但是没有var，默认为全局变量
   console.log(“局部变量” + y);
}
add();    //调用add函数输出y
console.log(“全局变量” + y);    //由于y此时是全局变量，在函数外可以直接输出。

局部作用域（函数内定义的，函数里面能被访问到）。

function add() {
   var y = 100;  //局部变量
   console.log(“局部变量” + y);
}
add();    //调用add函数输出y
console.log(“全局变量” + y);    //由于y此时是局部变量，在函数外无法直接输出。

预解析：浏览器获得js文件时，不会立刻去解析代码，而是全篇快速扫描一遍，主要是将变量预先解析。也就是把变量的声明提前

console.log(“x =” + x);
var x = 10;
add();
function add(){
   console.log(“add”)
}

该结果会输出x(undefind)和add。
因为会预解析var x；和 function add();到最前面。然后预解析add()函数内容，到函数前面。

console.log(“y1 = ” + y);
add();
console.log(“y2 =” + y);
function add(){
   y = 10;
   console.log(“add():y=” + y);
}

由于y1在add()函数之前输出了，此时add()函数内部还没有预解析y，所以y1(undefind),y2为10。

闭包：解决变量的私有化问题
假设需要一个计数器，每次调用counter加1.

function add(){
   var counter = 0;
   counter++; 
}
add();
add();

此时会出现一个问题，由于counter是一个局部变量，每次调用并不能使counter一直加1。若改为全局变量则可以达到目的。但是全局变量谁都可以修改、访问。
所以此时使用闭包，使局部变量具有全局变量的生命周期。
普通的函数闭包：

function add(){
var counter = 0;   //局部变量
plus = function (){    //全局的
   counter++;   //全局变量的生命周期，但还是局部变量。
console.log(“counter = ”+ counter );
}
}

add();  //counter的初始化
plus();  //输出1
plus();  //输出 2
console.log(counter);  //counter的值不能成功输出，因为它还是局部变量。

标准的函数闭包（函数的立即执行）：函数的声明和函数执行放在一起。函数一般是先申明再执行。(add)();,前面是定义函数，后面是执行函数。如下例所示：

var plus = (function() {
      var counter = 0;
      return function () {
         counter++;
         console.log(counter);
      };
})();      //(一个标准的函数闭包)
plus();   //counter为1
plus();   //counter为2