JavaScript常用代码段

使用方法：  setTimeout(回调函数,时间,参数1,...,参数n) （FF已经原生支持，IE不支持）

var  __sto  =  setTimeout;    
window.setTimeout  =  function(callback,timeout,param){    
    var  args  =  Array.prototype.slice.call(arguments,2);    
    var  _cb  =  function(){    
            callback.apply(null,args);    
    }    
    __sto(_cb,timeout);    
}    
function  aaaaa(a,b,c){    
    alert(a  +  b  +  c);    
}          
window.setTimeout(aaaaa,2000,5,6,7); 

var ninja = { 
    yell: function(n){ 
        return n > 0 ? ninja.yell(n-1) + "a" : "hiy"; 
    } 
}; 
alert(ninja.yell(4))//结果为：hiyaaaa;
var samurai = { yell: ninja.yell }; 
//var ninja = {}; // 此处 注释与否 对结果有影响
try { 
       alert(samurai.yell(4)); 
} catch(e){ 
       alert("Uh, this isn't good! Where'd ninja.yell go?" ); 
} 

var subStr = function(str, size){
    var curSize = 0, arr = [];
    for(var i = 0, len = str.length; i < len; i++){
        arr.push(str.charAt(i));            
        if (str.charCodeAt(i) > 255){
            curSize += 2;
            if(size === curSize || size === curSize - 1){
                return arr.join('');
            }
        }else{
            curSize++;
            if(size === curSize){
                return arr.join('');
            }
        }
    }
};
var str = '#%*……&#什么东西1234abcd 还不够长';
alert(str.length);
alert(str.substr(0, 15));
alert(subStr(str, 15));

function getAbsPosition(node) {
    var t = node.offsetTop;
    var l = node.offsetLeft;
    while (node = node.offsetParent) {
        t += node.offsetTop;
        l += node.offsetLeft;
    }
    alert("top=" + t + "\n" + "left=" + l);
}

类型一：借助新建对象来保存数据

var count1 = function (str) {
    var map = {}, maxCount = 0, maxChar, undefined, i = str.length;
    while (i--) {
        var t = str.charAt(i);
        map[t] == undefined ? map[t] = 1 : map[t] += 1;
        if (map[t] > maxCount) {
            maxChar = t;
            maxCount = map[maxChar];
        }
    }
    return "字符：" + maxChar + "次数：" + maxCount;
}

function s_0(a) { // 此处参数应为数组类型
    var b = {}, c = [], i;
    for (i = 0; i < a.length; i++){
        if (!b[a[i]]) {
            c[c.length] = a[i], b[a[i]] = true;
        }
    }
    return c;
}

类型二：正则表达式匹配统计

var count2 = function (str) {
    var most = str.split('').sort().join('').match(/(.)\1*/g); //排列重复字符
    most = most.sort(function (a, b) { return a.length - b.length }).pop(); //按出现频繁排序
    return most.length + ': ' + most[0];
}

function s_1(a) {
    var a = a.join(""), b = [];
    while (a.length > 0)
            a = a.replace(new RegExp((b[b.length] = a.charAt(0)), "g"), "");
    return b;
}

function randArray(num) {
    var rands = [];
    var ra = parseInt(num * Math.random());
    rands.push(ra);
    for (var r = 0; r < num - 1; r++) {
        ra = parseInt(num * Math.random());
        for (var m = 0; m < rands.length; m++) {
            while (rands[m] == ra) {
                ra = parseInt(num * Math.random());
                m = -1;
            }
        }
        rands.push(ra);
    }
    //alert(rands);
    return rands;     
}

方法2：

选择两个[0...array.Length)之间的随机数，把它们做下标的两个元素交换位置（这样乱序效率高）

说明：这是“洗牌算法” 有人证明打乱的效果如下：
随机交换nums/2次的效果很差，平均约1/3的对象还在原来的位置
随机交换nums次才基本可用，平均约15%的对象还在原来的位置

随机交换nums*2次才真正可用，平均约2%的对象还在原来的位置

function daluan(nums) {
    var array=[];
    for (var i = 0; i < nums; i++) {
        array[i] = i;
    }
    for (var i = 0; i < nums; i++) {
        var rand = parseInt(nums * Math.random());
        var temp = array[i];
        array[i] = array[rand];
        array[rand] = temp;
    }
    return array;
}        

方法3：

让比较函数随机传回-1或1就可以了（这样乱序效率可能不高）

var testArray3=[1,2,3,4,5,6,7,8,9,10,22,33,55,77,88,99]; 
testArray3.sort(function(){return Math.random()>0.5?-1:1;}); 
alert(testArray3); 

本文来自投稿，不代表站三界导航立场，如若转载，请注明出处：https://www.zhansanjie.com/article/details/8302.html