JavaScript the Definitive Guide (2)

// 递归自我调用函数在解决一些问题的时候是很常用的, 而通常情况下我们都会在函数内调用本函数名即可, 但是如果我们需要实现自我调用的函数正好是一个无名函数呢?

// arguments.callee 即调用当前执行的函数

function(x){
return x*arguments.callee(x-1)
}
// 如上, 就实现了一个很简单的>2阶乘计算了

var a = [1,3,4]
a.length = 5
console.log(a)
// output: [1,3,4,undefined x 2]
(function(x){arguments.length = 5;console.log(arguments)})(10,1,2)
// output: [10,1,2]

f.temp = "test"

function f(x){
  console.log(arguments.length);
  console.log(arguments.callee.length);
  console.log(f.temp);
}

f(1,2)

// output: 2 1 "test"

function f(){
  var id = 1;
  return function(){console.log(id++)}
}

f()();f()();f()()
// output: 1,1,1
// 每次我们调用`f()`,都会自动创建一个包含了其局部变量`id`的对象, 而嵌套的函数`f()()`会自动继承母函数的作用域;
// 但每次随着调用结束, 因为没有任何外部引用, 所以创建的对象都会自动的被回收, 如此就导致每次调用`f()()`都会输出1了;

var k = f();
k();k();k()
// output: 1,2,3
// 同样是调用`f()`, 但是我们首先引入了一个新的变量`k`引用`f()`函数; 
// 这样随着`f()`的调用和结束, 其创建的`call`对象(即包含了局部变量id的那个对象)就因为还存在外部引用而得以保留
// 所以后面连续调用`k()`的过程中, 本身的嵌套函数就始终共享着`call`对象的作用域, 如此每次输出的时候都是先获取了局部变量id, 然后在执行`id++`,所以输出为1,2,3

// 不喜欢`f()()`这种调用方式, 也不想单独创建新变量来增加引用? 当然可以, 只需要借助下`anonymous function`即可:

var f = (function(){
    var id = 1;
    return function(){console.log(id++)}
  })();

f();f();f()
// output: 1,2,3
// `anonymous function`是自执行的函数, 这里相当于把之前的`var k = f()`以及`f()`的声明定义合二为一了.

// This function implements a breakpoint. It repeatedly prompts the user
// for an expression, evaluates it with the supplied self-inspecting closure,
// and displays the result.  It is the closure that provides access to the
// scope to be inspected, so each function must supply its own closure.
// 
// Inspired by Steve Yen's breakpoint() function at
// http://trimpath.com/project/wiki/TrimBreakpoint
//
function inspect(inspector, title) {
    var expression, result;

    // You can use a breakpoint to turn off subsequent breakpoints by
    // creating a property named "ignore" on this function.
    if ("ignore" in arguments.callee) return;

    while(true) {
        // Figure out how to prompt the user
        var message = "";
        // If we were given a title, display that first
        if (title) message = title + "\n";
        // If we've already evaluated an expression, display it and its value
        if (expression) message += "\n" + expression + " ==> " + result + "\n";
        else expression = "";
        // We always display at least a basic prompt:
        message += "Enter an expression to evaluate, or just click cancel to see the next step of current calculation.";

        // Get the user's input, displaying our prompt and using the
        // last expression as the default value this time.
        expression = prompt(message, expression);

        // If the user didn't enter anything (or clicked Cancel),
        // they're done and so we return, ending the breakpoint.
        if (!expression) return;

        // Otherwise, use the supplied closure to evaluate the expression
        // in the scope that is being inspected. 
        // The result will be displayed on the next iteration.
        result = inspector(expression);
    }
}

function factorial(n) {
        var inspector = function(x) {
                return eval(x);
        }
        inspect (inspector, "Entering factorial()");
        var result = 1;
        while (n > 1){
                result = result * n;
                n--;
                inspect(inspector, "factorial() loop with current result:"+result);
        }

        inspect(inspector, "Exiting factorial()");
        return result;
}
inspect(function (x) {return eval(x);}, 'Hello')

factorial(5)

// 通过closure, 它就可以检测factorial执行的各个环节, 从而更容易的找到你在不同环节的问题.

var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function(){
    console.log(this);
    return function(){
      return this.name;
    };
  }
};
console.log(object.getNameFunc()());

// output: Object{name:"My Object"}; "The Window"