JavaScript函数（1）：定义函数、使用参数

定义函数

1）声明函数

function funName([args]){}     //常规函数
function (args){}             //匿名函数

匿名函数（函数直接量）可以作为一个函数表达式。当把函数结构作为一个值赋给变量后，变量就可以作为函数被调用，此时变量就指向那个匿名函数

示例1

var f = function(a, b) {
	return a + b;
}
alert(f(2, 3)) //返回5

示例2

alert(
	(function(a, b) {
		return a + b;
	})(2, 3)
)

2）构造函数

var funName=new Function(p1,p2,...,pn,body)

构造器Function()的参数类型都是字符串，p1~pn表示参数列表，body表示函数结构体语句

示例 求a+b+c的和

var f1 = new Function("a", "b", "c", "return a+b+c")
console.log("f1:", f1(1, 2, 3), f1('1', '2', '3')) //f1: 6 123
//前者是三个数字进行相加，后者是三个字符串进行相加
var f2 = new Function("a,b,c", "return a+b+c")
console.log("f2:", f2(1, 2, 3)) //f2: 6
var f3 = new Function("a,b", "c", "return a+b+c")
console.log("f3:", f3(1, 2, 3)) //f3: 6

3）比较定义函数的方法

a、函数作用域
使用Function()构造器创建的函数具有全局作用域，而function语句和函数直接量定义的函数都有局部作用域（函数作用域）

示例

var n = 1; //全局变量，作用域为当前文档
function f() {
	var n = 2; //局部变量仅作用于函数体内
	function f1() {
		console.log("f1:", n)
	}
	var f2 = new Function("console.log('f2:', n)")
	return [f1, f2]
}
f()[0]()  //调用f1，打印f1: 2
f()[1]()  //调用f2，打印f2: 1

b、解析方式
function语句和函数直接量定义的函数一般是先解析后执行，解析之后再次执行不需要重新解析，具有静态特性，效率高
Function构造器定义的函数不是提前解析，每次运行时都需要动态编译一次，具有动态特性，效率低

c、可用性
函数仅需要调用一次时，适合使用函数直接量的方式创建
Function构造器和函数直接量定义的函数不需要额外的变量，直接参与表达式运算，节约了资源。function语句定义的函数会占用系统资源
Function构造器的函数主体以字符串形式表示，不适合复杂语句，出现语法错误也不容易发现

使用参数

实参与形参
a、 JavaScript函数可用包含零个或多个形参，形参的个数可用通过length属性获得

function f(a, b) {}
console.log(f.length)  //2

b、 JavaScript中实参与形参的个数可以不相同。实参少于形参，多出的形参默认为undefined；实参多于形参，多余的实参会被函数忽略

//实参少于形参
function f1(a, b, c) {
	console.log(a + b, c, a + b + c)
}
f1(1, 2) //3 undefined NaN
//实参多余形参
function f2(a, b) {
	console.log(a + b)
}
f2(1, 2, 3) //3

c、 私有变量与形参发生冲突时，私有变量拥有较大的优先权

function f(a) {
	var a = "我的优先权高"
	console.log(a)
}
f(5)   //我的优先权高

arguments对象
arguments对象表示参数集合，他是一个伪数组，用有与数组相似的结构，可以通过数组下标的形式访问函数实参值，但是没有基础Array的原型方法

示例1 arguments对象只能在函数体内使用，作为函数的属性而存在。可以通过点运算符访问，也可以直接访问（arguments对象在函数体内是可见的）

function f() {
	for (var i = 0; i < arguments.length; i++) {   //或i< f.arguments.length
		console.log("参数" + i + ":", arguments[i])
	}
}
f(1, 2, 3, 4)

示例2 使用arguments对象可以随时便捷实参值

function f() {
	for (var i = 0; i < arguments.length; i++) {
		arguments[i] += i
		console.log("参数" + i + ":", arguments[i])
	}
}
f(1, 2)

示例3 通过arguments对象的length属性，可以改变函数实参的个数。length增大，多出的实参为undefined；length减小，丢弃对应的实参

function f() {
	for (var i = 0; i < arguments.length; i++) {
		arguments.length=4
		console.log("参数" + i + ":", arguments[i])
	}
}
f(1, 2)

使用callee回调函数
arguments对象包含一个callee属性，他引用当前arguments对象所属的函数，使用该属性可以在函数体内调用函数自身

示例1 比较形参与实参的个数是否相同

function f(x, y) {
	var a = arguments.length
	var b = arguments.callee.length //或 b=f.length
	if (a == b) {
		console.log(x + y)
	} else {
		throw new Error("传递的参数不匹配")
	}
}
f(1, 2)

示例2 斐波那契数列

function fib(num){
	num=parseInt(num)
	if (num==1 || num==2){
		return 1
	}else{
		return fib(num-1)+fib(num-2)
	}
}
console.log(fib(5))

function fib(num) {
	return (
		function(num) {
			num = parseInt(num)
			if (num == 1 || num == 2) {
				return 1
			} else {
				return arguments.callee(num - 1) + arguments.callee(num - 2)
			}
		}
	)(num)
}
console.log(fib(5))

在匿名函数中，callee属性比较有用，可以用来设计函数迭代操作