JS函数

创建函数对象

使用构造函数创建一个函数（基本不使用）
语法：var 函数名 = new Function();

var fun = new Function("console.log('1111111');");
fun();//1111111

使用函数声明创建一个函数
语法： function 函数名 ([形参1 , 形参2 , 形参3….形参n] ){语句…}

function fun2(){
    console.log("2222222");
}
fun2();//2222222

使用函数表达式创建一个函数
语法：var 函数名 = function(([形参1 , 形参2 , 形参3….形参n] ){语句…});

var fun3 = function(){
    console.log("3333333");
}   //匿名函数
fun3();//3333333

一个匿名函数加上一个括号变成立即执行函数
（函数执行完立即被调用）往往只会执行一次

(function(){
    alert("hi~");
})();//hi~

fun() - 调用函数（相当于使用函数的返回值）
fun - 函数对象（相当于直接使用函数对象）

函数的参数

可以在函数的()中来指定一个或多个形参（形式参数）
* 多个形参之间使用,隔开，声明形参就相当于在函数内部声明了对应的变量
* 但是并不赋值

调用函数时解析器不会检查实参的类型,
* 所以要注意，是否有可能会接收到非法的参数，如果有可能则需要对参数进行类型的检查
* 函数的实参可以是任意的数据类型

调用函数时，解析器也不会检查实参的数量
* 多余实参不会被赋值
* 如果实参的数量少于形参的数量，则没有对应实参的形参将是undefined

sum(10,30);//40
sum(123,234);//357
sum(true,false);//1
sum(123,"hello");//123hello
sum(123,456,"hello",true,null);//579
sum(123);//NaN

function sum(a,b){
    //console.log("a = "+a);
    //console.log("b = "+b);
    console.log("a + b = "+(a+b));
}

函数的返回值

函数中可以使用return设置函数的返回值
1.在函数中，return后的语句不会执行

function fun(){
    alert("函数开始执行");
    for(var i=0 ; i<5 ; i++){
        if(i == 2){
            //使用return可以结束整个函数
            return;
        }
        console.log(i);
    }
    alert("函数执行结束");
}
//函数开始执行 0 1

2.如果return后不写返回值或者不写return，都会返回undifined
3.rerurn后可以跟任意类型的值（可以是一个对象，也可以是一个函数）

属性

对象的属性值可以是任意数据类型，也可以是一个函数

var per = new Object();
    per.name = "孙悟空";
    per.age = 18;
    per.say = function(){
        console.log("俺老孙来也~");
    };
    console.log(per.name);//孙悟空
    per.say();//俺老孙来也~

当一个函数作为对象的属性保存时，称这个函数是这个对象的方法
调用这个函数就是调用这个对象的方法（method）

var per2 = {
    name:"猪八戒",
    age:18,
    say:function(){
        console.log(per2.name);
    }
};
per2.say();//猪八戒

枚举对象中的属性

for…in语句
for(var 变量 in 对象){}

var obj = {
    name:"孙悟空",
    age:18,
    gender:"男",
};
for(var n in obj){
    console.log("属性名:"+n);//输出属性名
    console.log("属性值:"+obj[n]);//属性值 []中可放变量， .后面不行
}

作用域

作用域指一个变量的作用的范围

全局作用域

• 直接编写在script标签中的JS代码，都在全局作用域
• 全局作用域在页面打开时创建，在页面关闭时销毁
• 在全局作用域中有一个全局对象window，它代表的是一个浏览器的窗口，它由浏览器创建我们可以直接使用

var a = 10;
var b = 20;
var c = "hello";
console.log(c);//hello
console.log(window.c);//hello

• 在全局作用域中：
  创建的变量都会作为window对象的属性保存
  创建的函数都会作为window对象的方法保存
  全局作用域中的变量都是全局变量，在页面的任意的部分都可以访问的到

function fun(){
    console.log("我是fun函数");
}
window.fun();//我是fun函数
window.alert("hello");//hello

变量的声明提前

• 使用var关键字声明的变量，会在所有的代码执行之前被声明（但是不会赋值），但是如果声明变量时不适用var关键字，则变量不会被声明提前

console.log(a);//undifined
var a = 100;
console.log(a);//100
console.log(b);//ReferenceError: b is not defined
b = 10;

函数的声明提前

• 使用函数声明形式创建的函数 function 函数(){}
• 它会在所有的代码执行之前就被创建，所以我们可以在函数声明前来调用函数
• 使用函数表达式创建的函数，不会被声明提前，所以不能在声明前调用

fun();//hhhhhh
function fun(){
    alert("hhhhhh");
}

fun2();//TypeError: fun2 is not a function
var fun2 = function(){
    alert("hi~");
};

函数作用域

• 调用函数时创建函数作用域，函数执行完毕以后，函数作用域销毁
• 每调用一次函数就会创建一个新的函数作用域，他们之间是互相独立的
• 在函数作用域中可以访问到全局作用域的变量，但在全局作用域中无法访问到函数作用域的变量
• 当在函数作用域操作一个变量时，它会先在自身作用域中寻找，如果有就直接使用；如果全局作用域中依然没有找到，则会报错ReferenceError
• 在函数中要访问全局变量可以使用window对象

var a = 10;
var c = 100;
function fun(){
    var b = 20;
    var c = 30;
    console.log(a);//10
    console.log(c);//30
    console.log(window.c);//100
}
fun();//10 30 100
console.log(b);//ReferenceError: b is not defined

在函数中，不使用var生命的变量都会成为全局变量

var c = 10;
function fun3(){
    c = 33;//相当于window.c = 33;
}
fun3();
console.log(c);//33

函数声明也会在函数中所有的代码执行之前执行

function fun4(){
    fun5();
    function fun5(){
        alert("hiii");
    }
}
fun4();//hiii

定义形参就相当于在函数作用域中声明了变量

var e = 23;
function fun6(e){
    alert(e);//undifined
}
fun6();

函数对象的方法

call()和apply()

-这两个方法都是函数对象的方法，需要通过函数对象来调用
当对函数调用call()和apply()时，都会调用函数并执行

function fun() {
    alert("hello");
}
fun.call();//hello
fun.apply();//hello
fun();//hello

在调用call()和apply()可以将一个对象指定为第一个参数，此时这个对象将会成为函数执行时的this

function fun(){
    console.log(this.name);
}
var obj = {
    name:"obj",
    sayName:function(){
        console.log(this.name);
    }
};
var obj2 = {
    name:"obj2"
};
fun.call(obj);//obj
fun.call(obj2);//obj2
obj.sayName();//obj
obj.sayName.call(obj2);//obj2
/*
fun.apply(obj);//obj
fun.apply(obj2);//obj2
obj.sayName();//obj
obj.sayName.apply(obj2);//obj2
*/

• call()方法可以将实参在对象之后依次传递fun.call(obj,2,3);
• apply()方法需要将实参封装到一个数组中统一传递fun.apply(abj,[2,3]);

function fun2(a , b){
    console.log("a = "+a);
    console.log("b = "+b);
    console.log("a + b = " +(a+b));
}
fun2.call(obj , 2 ,3);
fun2.apply(obj , [2 ,3]);