함수

1. 리셋 함수는 불연속적인 이벤트 처리를 쉽게 한다. 다음은 동기화의 전통적인 예를 살펴보자.

var request = prepare_request();    //  
var response = send_request_sync(request);  //  
display(response);      //  

상술한 예는 동시 발송한 것이다. 만약에 서버의 응답이 너무 느리면 클라이언트가 가사하는 현상이 나타날 수 있기 때문에 우리는 비동기적인 방식으로 클라이언트와 서버 측의 상호작용을 완성해야 한다

var request = prepare_request();    //  
send_request_asyc(request, function (response) {
    display(response);
});
//  send_request_asyc， 

2. 모듈 모듈은 인터페이스를 제공하지만 상태와 실현 함수를 숨긴 함수나 대상이다. 우리는 함수와 패키지로 모듈 모듈을 구성하면 전역 변수의 작용을 완전히 배제할 수 있다. 다음은 실체 문자를 html로 표시하는 예를 살펴보자.

Function.prototype.method = function (name, fun) {
    //  ， 
    if(!this.prototype[name]) {
        this.prototype[name] = fun;
        return this;
    }
}
String.method("deentityify", function () {
    //  
    var entity = {
        quot : '"',
        lt : ""
    }
    //  entity 
    return function () {
        //  & ， ; ， & ; 
        // this 
        return this.replace(/&([^&;]+);/g, function (a,  b) {
            var r = entity[b];
            // alert(a);    // < " > &ddd;
            // alert(alert(b));// lt undefined quot undefined gt undefined ddd
            return typeof r === "string" ? r : a;
        });
    }
}());
document.writeln("<">&ddd;".deentityify());  // &ddd; 

모듈의 일반적인 형식: 개인 변수나 함수를 정의한 함수로 패키지를 이용하여 개인 변수나 함수에 접근할 수 있는 특권 방법을 만들고 마지막으로 이 특권 방법을 되돌려주거나 접근할 수 있는 곳에 저장합니다.다음에 우리는 서열화된 모듈을 만들 수 있다

var serial_maker = function () {
    //  ， 
    var prex = '';
    var seq = 0;
    //  
    return {
        setPrex : function (p) {
            prex = String(p);
        },
        setSeq : function (s) {
            seq = Number(s);
        },
        gensyn : function () {
            var result = prex + seq;
            seq++;
            return result;
        }
    };
};
var maker = serial_maker();
maker.setPrex("U");
maker.setSeq(200);
alert(maker.gensyn());  // U200
maker.setPrex("Q");
alert(maker.gensyn());  // Q200

3. 등급 연결 방법, 예를 들어 수정과 설정, 반환 값이 없습니다. 기본값은undefined입니다. 우리는this로 되돌릴 수 있습니다. 이렇게 하면 이 방법은 등급 연결을 열 수 있습니다. 즉, 같은 대상을 순서대로 호출할 수 있는 많은 방법입니다.

getElement("div").move(200, 200).setBackground("#ccc").....;    // div 

4. 플러그인을 사용하면 함수와 전달된 매개 변수를 결합하여 새로운 함수를 만들 수 있다

var add = function (a, b) {
    return a + b;
}
Function.method("curry", function () {
    var slice = Array.prototype.slice;
    //  ， 10
    var args = slice.apply(arguments);
    alert(args);    // 10
    var that = this;
    alert(this);    //  curry ， a add() 
    return function () {
        alert(this);    // [object Window]
        return that.apply(null, args.concat(slice.apply(arguments)));
    }
});
var add1 = add.curry(10);
alert(add1(100));   // 110

5. 기억 함수는 대상이 이전에 조작한 결과를 기억하게 하여 무의미한 계산을 피할 수 있다.

var fibonacci = function (n) {
    return n < 2 ? n : arguments.callee(n - 1) + arguments.callee(n - 2);
}
var start = Date.now();
for(var i = 0; i <= 30; i++) {
    if (i == 30) {
        document.writeln("// " + i + " : " + fibonacci(i) + "
");
    }
}
var end = Date.now();
document.writeln(" : " + (end - start) + "
"); //  1360

통계에 의하면fibonacci 함수는 453회 호출되었고 우리는 11회 호출되었고 자신은 442회 호출되었기 때문에 이전에 계산한 값을 계산할 수 있기 때문에 우리는 기억의 방식으로 프로그램을 최적화할 수 있다

var fibonacciMemory = function () {
    var meo = [0, 1];
    var fib = function (n) {
        var result = meo[n];
        if(typeof result !== 'number') {
            result = arguments.callee(n - 1) + arguments.callee(n - 2);
            meo[n] = result;
        }
        return result;
    }
    return fib;
}();
var start = Date.now();
for(var i = 0; i <= 400; i++) {
    if (i == 400) {
        document.writeln("// " + i + " : " + fibonacciMemory(i) + "
");
    }
}
var end = Date.now();
document.writeln(" : " + (end - start));

물론 우리는 기억이라는 형식을 일반화할 수 있다

var memoizer = function (memo, fundamental) {
    var shell = function (n) {
        var result = memo[n];
        if (typeof result !== 'number') {
            result = fundamental(shell, n);
            memo[n] = result;
        }
        return result;
    }
    return shell;
};
var fibonacci = memoizer([0, 1], function (shell, n) {
    return shell(n - 1) + shell(n - 2);
});
alert(fibonacci(10));       // 55
alert(fibonacci(100));      // 354224848179262000000
var factorial = memoizer([1, 1], function (shell, n) {
    return shell(n - 1) * n;
});
alert(factorial(5));    // 120
alert(factorial(50));   // 3.0414093201713376e+64