var ids = [11,22,333];
(function sendRequest(){
    var id = shift();
    if(id){
        $.ajax({url:"/get",data:{id}}).always(function(){
            //do sth
            console.log("finished");
            sendRequest();
        });
    }else {
        console.log("finished");
    }
})();

//遞歸實(shí)現(xiàn)串行請求不堵塞

function getElementById(node,id){
    if(!node) return null;
    if(node.id === id) return node;
    for (var i = 0; index < node.childNodes.length; i++) {
        var found = getElementById(node.childNodes[i],id);
        if(found) return found;       
    }
    return null;
}

//深度優(yōu)先地遞歸遍歷DOM樹查找id

function getElementById(node,id){
     // 遍歷所有的Node
    while(node){
        if(node.id === id) return node;
        node = nextElement(node);
    }
    return null;
}
function nextElement(node){
    if(node.children.length) {
        return node.children[0];
    }
    if(node.nextElementSibling){
        return node.nextElementSibling;
    }
    while(node.parentNode){
        if(node.parentNode.nextElementSibling);
    }
    while(node.parentNode){
        if(node.parentNode.nextElementSibling) {
            return node.parentNode.nextElementSibling;
        }
        node = node.parentNode;
    }
    return null;
}

//深度優(yōu)先地非遞歸遍歷DOM樹查找id

function bubbleSort(arr){
    var i = 0,
        j = 0;
    for (var i = 1; i < arr.length; i++) {
      for (j=0; j<=arr.length-i; j++){
        var temp = 0;
        // ">"從小到大排序
        // "<"從大到小排序
        if(arr[j] > arr[j+1]){
            temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
      }
    }
    return arr;
}

// 冒泡排序

function quick(arr,l,r){
    if(l < r){
        var i = l,j = r,x = arr[i];
        while(i<j){
            while(i<j && arr[j]>x)
            j--;

            if(i<j)
              //這里用i++福稳，被換過來的必然比x小，賦值后直接讓i自加蒸苇，不用再比較迎瞧，可以提高效率
              arr[i++] = arr[j];

            while(i<j && arr[i]<x)
                i++;

            if(i<j)
              //這里用j--刚盈，被換過來的必然比x大钠至，賦值后直接讓j自減钟沛，不用再比較矾柜，可以提高效率
              arr[j--] = arr[i];
        }
        arr[i] = x;

        quickSort(arr,l,i-1);
        quickSort(arr,i+1,r);
    }
}

//快速排序

function palindrome(str) {
    return str === str.split('').reverse().join('')
}

function palindrome(str) {
    // \W匹配任何非單詞字符窄刘。等價于“[^A-Za-z0-9_]”窥妇。
    var re = /[\W_]/g;
    // 將字符串變成小寫字符,并干掉除字母數(shù)字外的字符
    var lowRegStr = str.toLowerCase().replace(re,'');
     // 如果字符串lowRegStr的length長度為0時，字符串即是palindrome
    if(lowRegStr.length===0) return true;
    // 如果字符串的第一個和最后一個字符不相同都哭，那么字符串就不是palindrome
    if(lowRegStr[0]!=lowRegStr[lowRegStr.length-1]) return false;
    //遞歸
    return palindrome(lowRegStr.slice(1,lowRegStr.length-1));
}

// 判斷回文字符串

function getMostFreq(str) {
  if(str.length == 1) {
    return str;
  }
  var dict = {}
  for (var i = 0; i < str.length; i++) {
    if(dict[str[i]]){
        ++dict[str[i]]
    }else{
        dict[str[i]] = 1
    }
  }

  var count = 0
  var maxValue
  for (key in dict){
    if (dict[key] > count) {
        maxValue = key
        count = dict[Key]
    }
  }
  console.log(count,maxValue)
}

//統(tǒng)計(jì)字符串里出現(xiàn)出現(xiàn)頻率最多的字符

function randomStr(len) {
    var dict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    var str = ''
    for (var i = 0; i < len; i++) {
      str +=dict[random(0,62)]  
    }
    return str   
}

//生成一個長度為 n 的隨機(jī)字符串秩伞，字符串字符的取值范圍包括0到9，a到 z欺矫，A到Z

function unique(arr){
    var obj = {}
    var result = []
    for (var i in arr){
        if(!obj[arr[i]]){
            obj[arr[i]] = true;
            result.push(arr[i]);
        }
    }
    return result;
}

function unique(arr){
    return Array.from(new Set(arr));
}

function uniqueArray(arr){
    for(var i = 0;i < arr.length-1;i++){
        for(var j = i+1; j<arr.length; j++){
            if(arr[j] === arr[i]){
                arr.splice(j--,1);
            }
        }
    }
    return arr;
}

// 數(shù)組去重

function getMaxProfit(arr){
    var min = arr[0],
    var max = arr[0];
    for (var i = 0; i < arr.length; i++){
        if(arr[i] < min) min = arr[i];
        if(arr[i] > max) max = arr[i];
    }
    return max-min;
}

//數(shù)組中最大差值


function match(node,selector){
    if(node === document) return false;
    switch(selector.matchType){
        //如果是類選擇器
        case "class":
          return node.className.trim().split(/+/).indexOf(selector.value)>=0;

        // 如果是標(biāo)簽選擇器
        case"tag":
          return node.tagName.toLowerCase()===selector.value.toLowerCase();

        defualt:
          console.log("unknown selector match type");
    }
}

function nextTarget(node,selector){
    if(!node || node === document) return null;
    switch(selector.relation){
        case"descendant":
          return{node:node.parentNode,hasNext:true};
        case"child":
          return {node:node.parentNode,hasNext:false};
        case"sibling":
          return {node:node.previousSibling,hasNext:true};
        default:
          console.log("unknown selector relation type");
        //hasNext表示當(dāng)前選擇器relation是否允許繼續(xù)找下一個節(jié)點(diǎn)
    }
}

function querySelector(node,selectors){
    while(node){
        var currentNode = node;
        if(!match(node,selectors[0])){
            node = nextElement(currentNode);
            continue;
        }
        var next = null;
        for (var i = 0; i < selectors.length-1; i++) {
            var matchIt = false;
            do{
                next = nextTarget(node,selectors[i]);
                node = next.node;
                if(!node) break;
                if(match(node,selectors[i+1])){
                    matchIt = true;
                    break;
                }
            }while(next.hasNext);
            if(!matchIt) break;
        }
        if(matchIt && i === selectors.length - 1){
            return currentNode;
        }
        node = nextElement(currentNode);
    }
    return null;
}

// 復(fù)雜選擇器的查DOM

var lastHouses = new Map();
function filter House(houses){
    var remainHouses = [],
    var newHouses = [];
    houses.map(house => lastHouses.has(house.id)?remainHouses.push(house):newHouses.push(house));
    newHouses.map(house => lastHouses.set(house.id,house));
    return {remainHouses,newHouses};
}

// 重復(fù)值處理

function randomIndex(arr){
    for(var i =0; i<arr.length;i++){
        var swapIndex = parseInt(Math.random()*(arr.length-i))+i;
        var tmp = arr[i];
        arr[i] = arr[swapIndex];
        arr[swapIndex] = tmp;
    }
}

// 數(shù)組元素隨機(jī)分布

$(window).on("resize",adjustSlider);

$(window).on("resize",function(){
    throttling(adjustSlider);
});
function throttling(method,throttlingTime){
    if(typeof method.tId === "undefined"){
        method.tId = 0;
        method.call(context,data);
        return;
    }
    //第一次觸發(fā)立刻執(zhí)行
    var tId = method.tId;
    if(!tId){
        method.tId = setTimeout(function(){
            method();
            method.tId = 0;
        },throttlingTime || 500);
    }
}

// 節(jié)流纱新，使事件觸發(fā)不會太快，如500ms觸發(fā)一次