-
定义：
JavaScript函数是指一个特定的代码块，可能包含多条语句，可以通过名字来供其他语句调用以执行函数包含的代码语句。
例如我们有一个特定的功能需要三条语句实现：
statement1;
statement2;
statement3;
可是每次想实现这个功能的时候就需要写这三句话，很麻烦，我们可以把这三条语句打包为一个函数：
function doSomething() {
statement1;
statement2;
statement3;
}
这样每次想实现功能的时候我们就调用一下函数就可以了，调用函数通过函数名称()的形式调用：
`doSomething();`
-
函数的声明方式
ECMAScript规定了三种声明函数方式
（1）构造函数
首先函数也是对象的一种，我们可以通过其构造函数，使用new来创建一个函数对象。(一般不使用)
var sayHello = new Function("console.log('hello world');");
（2）函数声明
使用function关键字可以声明一个函数
function sayHello() {
console.log('hello')
}
// 函数调用
sayHello()
声明不必放到调用的前面（可以放在全局作用域里面的任何位置）例如：
sayHello() //hello jirengu
sayHello() //hello jirengu
//调用了两次
var a = 1;
function sayHello() {
console.log('hello')
console.log('jirengu')
}
（3）函数表达式
//把命名函数function()赋值给了变量sayHello
var sayHello = function() {
console.log('hello');
} // 这就是函数表达式，相当于把functions(){console.log('hello');} 这个值赋值给sayName。
sayHello()
声明必须要放到调用的前面
- 参数
可以通过参数得到一些变动的东西。例如：
function sayHello(name) // 这个name就是参数 {
console.log('hello' + name)
} //注意声明这个函数的时候它并不会去执行，当下面去调用的时候才会执行
sayHello('若愚') // 可以得到hello 若愚
sayHello('饥人谷') // hello 饥人谷
多个参数
函数在定义的时候可以写多个参数(调用的时候实参如‘饥人谷’，2，‘boy’和形参name，age,sex是按照顺序一一对应的)
function printInfo(name, age, sex) {
console.log(name);
console.log(age);
console.log(sex);
}
printInfo('饥人谷'，2，'boy')
arguments //是一个类数组对象
在函数内部，你可以使用arguments对象获取到该函数的所有传入参数。（即像类数组一样可以通过下标的方式来获取里面的值，但是它本身又不是数组，没有数组的特性，所以它叫类数组对象（比如一些对象我们可以通过下标0，1，2，3去获取对应的值，另外对象里面还有length这个属性，length这个属性的值就是对象里面的属性的数量，对于这种对象它叫类数组对象））
function printPersonInfo(name,age,sex) {
console.log(name);
console.log(age);
console.log(arguments[0]); //这个arguments[0]对应的就是下面的2·。而2对应的形参就是name。
}
printInfo( 2, 'boy')
重载
其他语言的重载范例
int sum(int nul1, int num2) {
return num1 + num2;
}
float sum(float num1, float num2) {
return num1 + num2;
}
sum(1,2);
sum(1.5, 2.4);
// 会自动匹配所需要的参数
在JS中
没有重载！同名函数会覆盖。但可以在函数体针对不同的参数调用执行相应的逻辑。
function printPeopleInfo(name, age, sex) {
if(name) {
console.log(name);
}
if(age) {
console.log(age);
}
if(sex) {
console.log(sex);
}
}
pfintPeopleInfo('Byron', 26);
printPeopleInfo('Byron' 26, 'male');
// 模拟重载
- 返回值
有时候我们希望在函数执行后得到一个结果供别人使用，可以通过return来实现。
function sum(a, b) {
a++;
b++;
return a + b;
}
var result = sum(2, 3);
console.log(result);
注意点：
a. 如果不写return语句，函数也会默认给我们返回undefined。
b. 函数在执行过程中，只要遇到return就会立即结束退出函数体。
function fn(a) {
if(a < 0) {
return; // 如果a<0的话，执行到这里，整个函数退出，下面的不再执行
}
//下面没用else，但效果一样
a++;
return a + a;
}
c. 函数的返回值和console.log()是两个不同的东西，千万不要这样：
function getAge(age) {
return console.log(age); // 这样写返回的值就是undefined，到时后赋值的时候赋的值就是undefined.
} //不要这样写，console.log()的作用是调试代码的，在控制台中展示，但在控制台中展示并不是一个函数的返回值，它的功能只不过是把一个文字，一个字符串展示到控制台。而返回值必须通过return方式把它return出去，再给它赋给另外一个变量。
所以
console.log()任何东西的结果都是
undefined。
可以这样写：
function getAge(age) {
console.log(age);
return age;
}
var age = getAge(20)
- 声明前置
var和function的声明前置
在一个作用域下，var声明的变量和function声明的函数会前置。
虽然我们这样写：
console.log(a); //undefined
var a = 3;
console.log(a); //3
sayHello();
function sayHello() {
console.log('hello');
}
但是实际运行的时候是这样的：
var a; //先把var 声明放在前面
function sayHello() {
} //然后依次把函数声明放在前面
然后再去做其他的事：
console.log(a)
a = 3
sayHello()
输出结果：
特殊：如果a和sayHello同名。即：
console.log(sayHello);
var sayHello = 3;
console.log(sayHello); // 3
sayHello(); //function sayHello() {console.log('hello'); }
function sayHello() {
console.log('hello');
}
实际运行：
var sayHello;
function sayHello(){}
console.log(sayHello)
sayHello = 3
sayHello() //这个时候因为已经把3赋值给了sayHello，输出的时候sayHello已经不是一个函数，这时会报错。
- 函数表达式
console.log(fn); //undefined
fn(); //报错
var fn = function() {}
函数表达式和var一个变量没有什么区别：先有，再用。
函数内部的声明前置：
function fn() {
console.log(a) //undefined
var a = 3;
console.log(a);
}
fn()
实际运行：
var a;
console.log(a) //undefined
a = 3;
console.log(a) //3
当命名冲突时：先前置，再覆盖
var fn = 3;
function fn(){}
console.log(fn); // 3
前置：
var fn
function fn(){}
fn = 3
console.log(fn)
function fn(){}
var fn = 3;
console.log(fn); // 3
先声明前置：
function fn(){}
var fn
fn = 3
console.log(fn) // 3 有重名的第二个会覆盖第一个。
- 参数重名：
function fn(fn) {
console.log(fn);
var fn = 3;
console.log(fn);
}
fn(10); // 10 3
实际运行：
function fn(10) {
// var fn = 10
var fn
console.log(fn)
fn = 3
console.log(fn)
}
-
作用域
在JS中只有函数作用域，没有块作用域。
function fn() {
var a = 1;
if(a > 2) {
var b = 3;
}
console.log(b);
}
fn(); // undefined
console.log(a); // 因为在局部作用域有这个a，而全局作用域中没有这个a，所以会报错："ReferenceError: a is not defined"
-
var
（1）声明一个已经存在的变量
function fn() {}
var fn
console.log(fn)
var a = 1
var a
var a
console.log(a) // 1
var重复声明一个已经存在的变量，原变量值不变。
（2）不加var作用
function fn() {
a = 1; // 不要这样直接去赋值，要先去声明。
}
-
函数的递归
自己调用自己；
设定终止条件；
优点：算法简单；
缺点：效率低。
fn();
console.log(a); // 1
可以看到不写var会声明一个全局的变量，这是我们在编程中应该要避免的，即使真的需要全局变量，也应该在最外层作用域使用var声明。
例1：
function factor(n) {
if(n === 1) {
return 1
}
return n* factor(n-1) // 5*4*3*2*1
}
factor(5)
// factor(5) == 5 * factor(4)
例子2：
求1+2+_+n的值
function sum(n) {
if(n === 1) {
return 1 // 必须设置一个终止条件
}
return n + sum(n-1)
}
sum(10)
-
立即执行的函数表达式
作用： 隔离作用域
// 这个小括号是把它变成一个表达式 ，计算表达式优先级( function() {
var a = 1; // 可以在里面声明任何变量，而且和外面声明的变量没有任何关系。不会产生全局变量污染问题。
} ) () 后面这个小括号是调用这个函数表达式
conosle.log(a); //undefined
var a = 2;
var b = 3;
其他写法：
( function fn1() {} )();
//在数组初始化器内只能是表达式
[ function fn2() {} ];
//逗号也只能操作表达式
1，function fn3() {};
!function() {
var a = 1;
}() // 执行的结果是false
文章著作权归饥人谷_sunny和饥人谷所有，转载须说明来源