javascript常见手写代码


算法,深复制,事件代理。。。

全排列

function swap(arr,i,j) { 
    if(i!=j) {          
        var temp=arr[i]; 
        arr[i]=arr[j]; 
        arr[j]=temp; 
    } 
} 
var count=0; 
function show(arr) { 
    document.write("P<sub>"+ ++count+"</sub>: "+arr+"<br />"); 
} 
//此方法最主要是交换的思路
function perm(arr) {   
     (function fn(n) { //为第n个位置选择元素
        for(var i=n;i<arr.length;i++) { 
            swap(arr,i,n);
             if(n+1<arr.length-1) //根据下标a(b+1) 不是最后一项,判断数组中剩余的待全排列的元素是否大于1个
                 fn(n+1); //从第n+1个下标进行全排列
             else
                 show(arr); //显示一组结果
             swap(arr,i,n); 
         } 
     })(0); 
 } 
 perm(["e1","e2","e3",'e4']); 

HASH表去重

Array.prototype.unique2 = function()
{
    var n = {},r=[]; //n为hash表,r为临时数组
    for(var i = 0; i < this.length; i++) //遍历当前数组
    {
        if (!n[this[i]]) //如果hash表中没有当前项
        {
            n[this[i]] = this[i]; //存入hash表
            r.push(this[i]); //把当前数组的当前项push到临时数组里面
        } else if(typeof(n[this[i]]) !== typeof(this[i])) { r.push(this[i])}//num和string不算重复:如'2'和2
    }
    return r;
}

快排

 //定义位置交换的方法
        function swap (arr, index1, index2) {
            var temp = arr[index1];
            arr[index1] = arr[index2];
            arr[index2] = temp;
        };
        //划分过程
        function partition (arr, left, right) {
            var pivot = arr[Math.floor((right + left) / 2)],  // 中轴的值。
                    i = left,
                    j = right;
            while (i <= j) {
                    // 先从左边开始,当遇到比中轴大的值停止向前
                    while (arr[i] < pivot) { 
                        i++;
                    }
                    while (arr[j] > pivot) {
                        j--;
                    }
                    //直到左边遇到>中值的,右边遇到<中指的,便交换
                    if (i <= j) {
                        swap(arr, i, j);
                        i++;
                        j--;
                    }
            }
            //返回左指针的位置
            return i;
        };
        //递归调用quick
        function quick (arr, left, right){
            var index;
            //主流程直到分割到数组长度为1时结束
            if (arr.length > 1) {
                index = partition(arr, left, right);
                //这里用if来将分割的左右两部分分别执行quick
                if (left < index - 1) {
                    quick(arr, left, index - 1);
                }
                if (index < right) {
                    quick(arr, index, right);
                }
             }
            return arr;  // 结束位置
        }

笔试输入


var readline = require('readline');

rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

var K = 1; // 输入K行
var inputs = [];
rl.on('line', function(data) {
    // 获取输入
    inputs.push(data.trim());
    if (K == inputs.length) { //
        // 处理
        var result = deal(inputs);

        // 输出结果
        console.log(result);
        // 清0
        inputs.length = 0;

    }
});

堆排序

//调整函数
function headAdjust(elements, pos, len){
  //将当前节点值进行保存
  var swap = elements[pos];

  //定位到当前节点的左边的子节点
  var child = pos * 2 + 1;

  //递归,直至没有子节点为止
  while(child < len){
    //如果当前节点有右边的子节点,并且右子节点较大的场合,采用右子节点
    //和当前节点进行比较
    if(child + 1 < len && elements[child] < elements[child + 1]){
      child += 1;
    }

    //比较当前节点和最大的子节点,小于则进行值交换,交换后将当前节点定位
    //于子节点上
    if(elements[pos] < elements[child]){
      elements[pos] = elements[child];
      pos = child;
      child = pos * 2 + 1;
    }
    else{console.log(elements); 
      break;
    }
    elements[pos] = swap;console.log(elements); 
 }
}

//构建堆
function buildHeap(elements){
  //从最后一个拥有子节点的节点开始,将该节点连同其子节点进行比较,
  //将最大的数交换与该节点,交换后,再依次向前节点进行相同交换处理,
  //直至构建出大顶堆(升序为大顶,降序为小顶)
  for(var i=elements.length/2; i>=0; i--){
    headAdjust(elements, i, elements.length);
  }
}

function sort(elements){
  //构建堆
  buildHeap(elements);

  //从数列的尾部开始进行调整
  for(var i=elements.length-1; i>0; i--){
    //堆顶永远是最大元素,故,将堆顶和尾部元素交换,将
    //最大元素保存于尾部,并且不参与后面的调整
    var swap = elements[i];
    elements[i] = elements[0];
    elements[0] = swap;

    //进行调整,将最大)元素调整至堆顶
    headAdjust(elements, 0, i);
  }
}

手写事件代理

function delegateEvent(interfaceEle, selector, type, fn) {
    if(interfaceEle.addEventListener){
    interfaceEle.addEventListener(type, eventfn);
    }else{
    interfaceEle.attachEvent("on"+type, eventfn);
    }
     
    function eventfn(e){
    var e = e || window.event;    
    var target = e.target || e.srcElement;
    if (matchSelector(target, selector)) {
            if(fn) {
                fn.call(target, e);
            }
        }
    }
}
/**
 * only support #id, tagName, .className
 * and it's simple single, no combination
 */
function matchSelector(ele, selector) {
    // if use id
    if (selector.charAt(0) === "#") {
        return ele.id === selector.slice(1);
    }
    // if use class
    if (selector.charAt(0) === ".") {
        return (" " + ele.className + " ").indexOf(" " + selector.slice(1) + " ") != -1;
    }
    // if use tagName
    return ele.tagName.toLowerCase() === selector.toLowerCase();
}
//调用
var odiv = document.getElementById("oDiv");
delegateEvent(odiv,"a","click",function(){
    alert("1");
})

手写深复制(兼容数组和对象)

function clone(obj) {
    var copy;

    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) return obj;

    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }

    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = clone(obj[i]);
        }
        return copy;
    }

    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr]);
        }
        return copy;
    }

    throw new Error("Unable to copy obj! Its type isn't supported.");
}

待更新——完善注释

声明:高翔的博客|版权所有,违者必究|如未注明,均为原创|本网站采用BY-NC-SA协议进行授权

转载:转载请注明原文链接 - javascript常见手写代码


大家好:我是练习时常两年半的前端练习生