函数属性和方法

在JavaScript中，函数是一等公民，它们不仅可以被调用，还拥有属性和方法。函数作为对象，可以动态添加属性，也能通过内置方法改变行为或上下文。理解这些特性对编写灵活、高效的代码至关重要。

函数的属性

name 属性

函数的name属性返回函数声明时的名称，匿名函数或箭头函数会根据上下文推断名称：

function greet() {}
console.log(greet.name); // "greet"

const sayHi = function() {};
console.log(sayHi.name); // "sayHi"

const arrow = () => {};
console.log(arrow.name); // "arrow"

length 属性

length表示函数定义时的形参数量，不包含默认参数或剩余参数：

function sum(a, b, c = 10) {}
console.log(sum.length); // 2

function merge(...args) {}
console.log(merge.length); // 0

prototype 属性

构造函数通过prototype实现继承：

function Person(name) {
  this.name = name;
}
Person.prototype.sayName = function() {
  console.log(this.name);
};
const john = new Person('John');
john.sayName(); // "John"

caller 属性

非严格模式下，caller返回调用当前函数的函数引用：

function outer() {
  inner();
}
function inner() {
  console.log(inner.caller); // 输出outer函数体
}
outer();

函数的方法

call() 和 apply()

改变函数执行时的this绑定，call接受参数列表，apply接受数组：

const obj = { value: 10 };

function multiply(n, m) {
  return this.value * n * m;
}

console.log(multiply.call(obj, 2, 3)); // 60
console.log(multiply.apply(obj, [2, 3])); // 60

bind()

创建新函数并永久绑定this值，支持柯里化：

const module = {
  x: 42,
  getX: function() { return this.x; }
};

const unboundGetX = module.getX;
console.log(unboundGetX()); // undefined

const boundGetX = unboundGetX.bind(module);
console.log(boundGetX()); // 42

// 柯里化示例
function add(a, b) {
  return a + b;
}
const add5 = add.bind(null, 5);
console.log(add5(3)); // 8

toString()

返回函数源代码字符串，包括注释和空格：

function foo() {
  // 这是一个测试函数
  return 'bar';
}
console.log(foo.toString());
// 输出完整函数定义：
// "function foo() {
//   // 这是一个测试函数
//   return 'bar';
// }"

自定义函数属性

函数作为对象可以添加自定义属性，实现状态记忆等功能：

function counter() {
  counter.count = (counter.count || 0) + 1;
  return counter.count;
}

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter.count); // 2

高阶函数特性

函数作为参数

function operate(num, operation) {
  return operation(num);
}

function double(x) { return x * 2; }
function square(x) { return x * x; }

console.log(operate(5, double)); // 10
console.log(operate(5, square)); // 25

返回函数的函数

function createMultiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

const triple = createMultiplier(3);
console.log(triple(7)); // 21

箭头函数的特殊性

箭头函数没有自己的this、arguments、super或new.target绑定：

const obj = {
  value: 1,
  regular: function() {
    return this.value;
  },
  arrow: () => this.value
};

console.log(obj.regular()); // 1
console.log(obj.arrow()); // undefined

函数参数对象

arguments 对象

传统函数内部可访问类数组的arguments对象：

function logArgs() {
  console.log(arguments.length);
  console.log(arguments[0]);
}
logArgs(1, 2, 3); // 输出3和1

剩余参数

ES6引入的剩余参数是真正的数组：

function sum(...numbers) {
  return numbers.reduce((acc, val) => acc + val, 0);
}
console.log(sum(1, 2, 3)); // 6

立即执行函数(IIFE)

创建独立作用域的常见模式：

(function() {
  const privateVar = 'secret';
  console.log(privateVar); // "secret"
})();

// 带参数的IIFE
(function(message) {
  console.log(message); // "Hello"
})('Hello');

函数缓存优化

利用函数属性实现记忆化：

function fibonacci(n, memo = {}) {
  if (n in memo) return memo[n];
  if (n <= 2) return 1;
  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
}

console.log(fibonacci(50)); // 12586269025