javascript 알고리즘 최적화

더 읽 기
다른 프로 그래 밍 언어 와 같이 코드 의 쓰기 와 알고리즘 은 자바 script 의 운행 시간 에 영향 을 줍 니 다.다른 프로 그래 밍 언어 와 달리 자바 script 은 사용 가능 한 자원 이 유한 하기 때문에 최적화 기술 이 더욱 중요 합 니 다.
 
하나.for, while, do - while 순환 의 성능 특성 이 비슷 하고 누구 도 누구 보다 빠 르 거나 느 리 지 않 습 니 다.속성 이 알 수 없 는 대상 을 반복 하지 않 으 면 for - in 순환 을 사용 하지 마 십시오.
 
매번 교체 작업 은 인 스 턴 스 나 원형 속성 을 검색 해 야 하기 때문에 for - in 순환 은 매번 교체 할 때마다 더 많은 비용 을 지불해 야 하기 때문에 다른 유형 보다
순환 이 좀 느리다.한 정 된 속성 목록 을 반복 해서 옮 겨 다 니 면 다른 순환 형식 을 사용 하 는 것 이 빠 르 고 다음 모드 를 사용 할 수 있 습 니 다.
 

var props = ["prop1", "prop2"],
var i = 0;
var len = props.length;
while (i < len){
process(object[props[i]]);
i++;
}

 
 
 
둘.순환 성능 을 개선 하 는 가장 좋 은 방법 은 매번 교체 중의 연산 량 을 줄 이 고 순환 교체 횟수 를 줄 이 는 것 이다.
 

//slow
for (var i=0; i < items.length; i++){
process(items[i]);
}
//faster
for (var i=0, len=items.length; i < len; i++){
process(items[i]);
}
//fastest
for (var i=items.length; i--; ){
process(items[i]);
}

 다 프 설 비 는 순환 체 전개 기술 로 한 번 의 교체 에서 실제로 여러 번 의 교체 작업 을 수행 했다.
 
 

var i = items.length % 8;
while(i){
process(items[i--]);
}
i = Math.floor(items.length / 8);
while(i){
process(items[i--]);
process(items[i--]);
process(items[i--]);
process(items[i--]);
process(items[i--]);
process(items[i--]);
process(items[i--]);
process(items[i--]);
}

 
 
셋.일반적으로 switch 는 항상 if - else 보다 빠 르 지만 항상 가장 좋 은 해결 방법 은 아니다.판단 조건 이 비교적 많 을 때, 차 트 법 은 if - else 나 switch 보다 빠르다.
 

//slow
if (value == 0){
return result0;
} else if (value == 1){
return result1;
} else if (value == 2){
return result2;
} else if (value == 3){
return result3;
} else if (value == 4){
return result4;
} else if (value == 5){
return result5;
} else if (value == 6){
return result6;
} else if (value == 7){
return result7;
} else if (value == 8){
return result8;
} else if (value == 9){
return result9;
} else {
return result10;
}

//faster,     (                 （       switch    )
if (value < 6){
if (value < 3){
if (value == 0){
return result0;
} else if (value == 1){
return result1;
} else {
return result2;
}
} else {
if (value == 3){
return result3;
} else if (value == 4){
return result4;
} else {
return result5;
}
}
} else {
if (value < 8){
if (value == 6){
return result6;
} else {
return result7;
}
} else {
if (value == 8){
return result8;
} else if (value == 9){
return result9;
} else {
return result10;
}
}
}
//   
//define the array of results
var results = [result0, result1, result2, result3, result4, result5, result6, result7, result8, result9, result10]
//return the correct result
return results[value];

 
 
넷.브 라 우 저의 호출 스 택 사 이 즈 는 재 귀 알고리즘 이 자바 script 에서 의 응용 을 제한 하고 스 택 오류 로 인해 다른 코드 도 정상적으로 실행 되 지 못 합 니 다.스 택 에 넘 치 는 오류 가 발생 하면 방법 을 교체 알고리즘 으로 수정 하거나 탭 법 을 사용 하면 중복 작업 을 피 할 수 있 습 니 다.
 
 
JavaScript 엔진 이 지원 하 는 재 귀 수량 은 JavaScript 호출 스 택 크기 와 직접 연 결 됩 니 다.Internet Explorer 만 예외 입 니 다.
호출 스 택 은 사용 가능 한 시스템 메모리 와 관련 이 있 으 며, 다른 브 라 우 저 는 고정 적 인 호출 스 택 제한 이 있 습 니 다.대부분의 현대 브 라 우 저의 호출 스 택 사 이 즈 는 구식 보다 맑 습 니 다.
뷰 어 는 커 야 합 니 다 (예 를 들 어 Safari 2 호출 스 택 사 이 즈 는 100). 재 귀 를 너무 많이 사용 하여 최대 호출 스 택 사 이 즈 를 초과 하면 브 라 우 저 에서 오류 가 발생 하고 다음 정 보 를 팝 업 합 니 다.
 
• Internet Explorer: “Stack overflow at line x”
• Firefox: “Too much recursion”
• Safari: “Maximum call stack size exceeded”
• Opera: “Abort (control stack overflow)”
크롬 은 호출 스 택 이 넘 치 는 오 류 를 표시 하지 않 는 유일한 브 라 우 저 입 니 다.
 
재 귀 모드 1: 함수 가 자신 을 호출 합 니 다.
 

function recurse(){
recurse();
}
recurse();

 재 귀 모드 2: 정교 모드, 두 함수 가 서로 호출 합 니 다.
 
 
 
 

function first(){
second();
}
function second(){
first();
}
first();

 
 
재 귀적 으로 실현 할 수 있 는 모든 알고리즘 은 교체 로 실현 할 수 있다.
 

//javascript       
function merge(left, right){
var result = [];
while (left.length > 0 && right.length > 0){
if (left[0] < right[0]){
result.push(left.shift());
} else {
result.push(right.shift());
}
}
return result.concat(left).concat(right);
}
function mergeSort(items){
if (items.length == 1) {
return items;
}
var middle = Math.floor(items.length / 2),
left = items.slice(0, middle),
right = items.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}

//uses the same mergeSort() function from previous example
function mergeSort(items){
if (items.length == 1) {
return items;
}
var work = [];
for (var i=0, len=items.length; i < len; i++){
work.push([items[i]]);
}
work.push([]); //in case of odd number of items
for (var lim=len; lim > 1; lim = (lim+1)/2){
for (var j=0,k=0; k < lim; j++, k+=2){
work[j] = merge(work[k], work[k+1]);
}
work[j] = []; //in case of odd number of items
}
return work[0];
}
                      ，                。                        。

 
 
탭:
제 표 는 캐 시 이전 계산 결 과 를 통 해 후속 계산 에 중복 사용 되 어 중복 작업 을 피 할 수 있 습 니 다.이것 은 표를 재 귀 알고리즘 에서 유용 한 기술 로 만 들 었 다.

//slow
function factorial(n){
if (n == 0){
return 1;
} else {
return n * factorial(n-1);
}
}
var fact6 = factorial(6);
var fact5 = factorial(5);
var fact4 = factorial(4);

//  
function memfactorial(n){
if (!memfactorial.cache){
memfactorial.cache = {
"0": 1,
"1": 1
};
}
if (!memfactorial.cache.hasOwnProperty(n)){
memfactorial.cache[n] = n * memfactorial (n-1);
}
return memfactorial.cache[n];
}
var fact6 = memfactorial(6);
var fact5 = memfactorial(5);
var fact4 = memfactorial(4);

 표 작성 과정 은 모든 재 귀 함수 에 따라 약간 다 르 지만 전체적으로 같은 모델 을 가지 고 있다.함수 의 탭 과정 을 더욱 쉽게 하기 위해 서 는
memoize () 함수 패키지 기본 기능 을 정의 할 수 있 습 니 다.예 를 들 면:

function memoize(fundamental, cache){
cache = cache || {};
var shell = function(arg){
if (!cache.hasOwnProperty(arg)){
cache[arg] = fundamental(arg);
}
return cache[arg];
};
return shell;
}
//memoize the factorial function
var memfactorial = memoize(factorial, { "0": 1, "1": 1 });
//call the new function
var fact6 = memfactorial(6);
var fact5 = memfactorial(5);
var fact4 = memfactorial(4);