JavaScript 언어 정수 함수 편 (3)

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 : "<", 
        gt : ">"
    }
    //            entity         
    return function () {
        //    &  ， ;  ，         &  ;     
        // this           
        return this.replace(/&([^&;]+);/g, function (a, b) {
            var r = entity[b];
            // alert(a); // &lt; &quot; &gt; &ddd;
            // alert(alert(b));// lt undefined quot undefined gt undefined ddd
            return typeof r === "string" ? r : a;
        });
    }
}());
document.writeln("&lt;&quot;&gt;&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) + "<br/>");
    }
}
var end = Date.now();
document.writeln("      : " + (end - start) + "<br/>"); //   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) + "<br/>");
    }
}
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