以下是日常開發中反覆用到的幾段小代碼,每段前面都標註了功能與參數要求,難度不高因此不再逐行註解。
目錄:
重寫 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?" );
}
遞迴的拼接是「從內往外」長出來的:最內層先回 hiy,每退一層補一個 a。而一旦把 ninja 重新賦值為空物件,函式體內對 ninja.yell 的查詢就會落空——這也說明了為什麼依賴外部變數名的遞迴比依賴自身引用更脆弱。
/**
* 功能:截取長字符串
* @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);
}
// 類型一:借助新建對象來保存數據
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;
}
兩種類型的思路不同:類型一用雜湊表一次遍歷完成計數,時間複雜度是 O(n);類型二先用 sort 把相同字符聚攏,再用正則 (.)\1* 一次抓出連續段,程式碼短但多了一次排序成本。
// 方法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);
}
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);
方法一每次取新值都要回頭比對整個已生成列表,元素一多就明顯變慢,留著當反面教材。方法三是三者中最短的一行寫法,但隨機比較函式違反了排序對比較器的一致性假設,各引擎的結果分布並不均匀,正式環境建議用 Fisher–Yates(也就是方法二的思路,但每輪只與剩餘區間交換)。