javascript常用程式碼段

重寫window.setTimeout， 
理解遞迴程式的返回規律， 
擷取長字串， 
取得元素在頁面中的絕對位置， 
統計、去除重複字元（多種方法實現）， 

把有序的陣列元素隨機打亂（多種方法實現）。 

/* 
功能：修改 window.setTimeout，使之可以傳遞引數和物件引數 （同樣可用於setInterval） 
使用方法： 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?" ); 
} 

/** 功能：擷取長字串 
* @param {string} str 要擷取的字串 
* @param {number} size 擷取長度(單位元組長度) 
*/ 
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)); 

/**//* 
功能：取得元素在頁面中的絕對位置（相對於頁面左上角） 
@param {string} node 待求位置的DOM元素 
*/ 
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); 
} 

/**//* 
功能：統計、去除重複字元 
@param str 需要統計的字串 
說明：常用於字串中重複字元，或者陣列中重複的字母、數字等個數統計。 
此處從網上收集兩種典型的型別，分別有兩種實現方法，其他還有許多變種，從不同角度編寫，可搜尋學習。 
待統計的資料，不論是陣列和字串都可以，只用藉助String.split()或 Array.join() 
轉換為函式引數要求的型別即可。 
*/ 
// 型別一：藉助新建物件來儲存資料 
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; 
} 

/**//* 
功能：把有序陣列打亂（產生無序隨機陣列） 
說明：基本的排序演算法大家應該都很清楚。但是在程式設計中也經常用到相反的操作，即把原來有序的陣列元素隨機打亂。 
以下給出三種方法，第一種是以前我自己寫出來的，由於水平差，寫出的程式碼時間複雜度太大， 
於是從網上搜尋一些簡單而且效率高的方法來。 
第二種據說是“洗牌演算法”，想必很多人都聽說過； 
第三種是利用JS的內建sort方法，這種實現起來很簡單。 
*/ 
// 方法1（給大家做失敗的教訓借鑑） 
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);