每個專案都會長出一批「到處重複寫的小工具」。本文把這些方法依主題整理成一個 Angela 命名空間下的方法集,涵蓋陣列、Cookie、URL、正則驗證、字串、加密、日期、瀏覽器偵測與型別判斷,可以直接抄進自己的工具庫。
Angela.array = {
// 回傳元素位置,找不到回傳 -1
index: function (t, arr) {
if (arr.indexOf) { return arr.indexOf(t); }
for (var i = arr.length; i--;) { if (arr[i] === t) { return i * 1; } }
return -1;
},
// 取出物件所有的鍵值
getKey: function (data) {
var arr = [], k;
for (k in data) { arr.push(k); }
return arr;
},
// 一維陣列去重
unique: function (array) {
array = array || [];
for (var i = 0, len = array.length; i < len; i++) {
for (var j = i + 1; j < array.length; j++) {
if (array[i] === array[j]) { array.splice(j, 1); j--; }
}
}
return array;
},
max: function (array) { return Math.max.apply(null, array); },
min: function (array) { return Math.min.apply(null, array); },
// 移除某個值(從尾端往前刪,避免索引錯位)
remove: function (array, value) {
var length = array.length;
while (length--) { if (value === array[length]) { array.splice(length, 1); } }
return array;
},
empty: function (array) { (array || []).length = 0; return array; },
removeAt: function (array, index) { array.splice(index, 1); return array; },
// 打亂順序(Fisher-Yates 思路:與隨機位置交換)
shuffle: function (arr) {
var array = (arr || []).concat(), length = array.length, i = length, tmp = null;
while (i--) {
var pos = Math.floor(Math.random() * length);
tmp = array[pos]; array[pos] = array[i]; array[i] = tmp;
}
return array;
}
};
兩個細節值得注意:unique 與 remove 在 splice 之後都要調整索引(j-- 或反向遍歷),否則會漏掉相鄰的重複項;shuffle 用 concat() 先複製一份,避免改動到傳入的原始陣列。
Angela.cookie = {
enable: !!navigator.cookieEnabled,
// 讀取
get: function (name) {
var reg = new RegExp("(^| )" + name + "(?:=([^;]*))?(;|$)");
var val = document.cookie.match(reg);
return val ? (val[2] ? unescape(val[2]) : "") : '';
},
// 寫入(expires 單位為分鐘)
set: function (name, value, expires, path, domain, secure) {
var exp = new Date();
expires ? exp.setMinutes(exp.getMinutes() + parseInt(expires)) : "";
document.cookie = name + '=' + escape(value) +
(expires ? ';expires=' + exp.toGMTString() : '') +
(path ? ';path=' + path : '') +
(domain ? ';domain=' + domain : '') +
(secure ? ';secure' : '');
},
// 刪除:把效期設為過去即可
del: function (name, path, domain, secure) {
if (this.get(name) != null) {
var exp = new Date();
exp.setMinutes(exp.getMinutes() - 1000);
document.cookie = name + '=;expires=' + exp.toGMTString() +
(path ? ';path=' + path : '');
}
}
};
讀取時那個 (^| ) 前綴是必要的:cookie 字串以「分號加空白」分隔,加上邊界比對才不會讓 count 誤中 discount。刪除 Cookie 無法真正移除,只能把過期時間設到過去,而且 path 必須與寫入時一致,否則刪不掉。
Angela.url = {
// 取查詢參數,不傳 url 則從目前網址取
getQuery: function (name, url) {
var u = arguments[1] || window.location.search,
reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)"),
r = u.substr(u.indexOf("?") + 1).match(reg);
return r != null ? r[2] : "";
},
getHash: function (name, url) { /* 同上,改成比對 location.hash */ },
// 解析 URL 的各個組成部分
parse: function (url) {
var a = document.createElement('a');
a.href = url || document.location.href;
return {
source: url,
protocol: a.protocol.replace(':', ''),
host: a.hostname,
port: a.port,
query: a.search,
file: (a.pathname.match(/([^\/?#]+)$/i) || [, ''])[1],
hash: a.hash.replace('#', ''),
path: a.pathname.replace(/^([^\/])/, '/$1'),
relative: (a.href.match(/tps?:\/\/[^\/]+(.+)/) || [, ''])[1],
segments: a.pathname.replace(/^\//, '').split('/')
};
}
};
parse 借用了 <a> 元素來解析網址,是很聰明的技巧——瀏覽器自己就會拆解;今天也可以直接用 new URL(url) 與 URLSearchParams,程式碼更少。
Angela.regExp = {
isNum: function (num) { return !isNaN(num); },
isEmail: function (mail) { return /^([a-z0-9]+[_\-\.]?)*[a-z0-9]+@([a-z0-9]+[_\-\.]?)*[a-z0-9]+\.[a-z]{2,5}$/i.test(mail); },
isIdCard: function (card) { return /^(\d{14}|\d{17})(\d|[xX])$/.test(card); },
isMobile: function (mobile){ return /^0*1\d{10}$/.test(mobile); },
isQQ: function (qq) { return /^[1-9]\d{4,10}$/.test(qq); },
isUrl: function (url) { return /https?:\/\/[a-z0-9\.\-]{1,255}\.[0-9a-z\-]{1,255}/i.test(url); },
isColor: function (color) { return /#([\da-f]{3}){1,2}$/i.test(color); },
isFloat: function (num) { return /^(([1-9]\d*)|(\d+\.\d+)|0)$/.test(num); },
isInt: function (num) { return /^[1-9]\d*$/.test(num); },
isChinese:function (str) { return /^([\u4E00-\u9FA5]|[\uFE30-\uFFA0])+$/gi.test(str); }
};
提醒兩點:手機與身分證的正則只涵蓋格式,不等於真的存在,正式服務仍需靠簡訊驗證碼與後端核對;另外 isNum 用 isNaN 會把空字串與 null 也判成數字,需要更嚴格時應改用 typeof num === 'number' && isFinite(num)。
Angela.string = {
// 重複字串 n 次,並可在尾端附加內容
repeat: function (word, length, end) {
end = end || '';
return new Array(length * 1 + 1).join(word) + '' + end;
},
// 補齊長度,例如把 5 補成 05
addPre: function (pre, word, size) {
pre = pre || '0';
size = parseInt(size) || 0;
word = String(word || '');
return this.repeat(pre, Math.max(0, size - word.length), word);
},
trim: function (text) { return (text || '').replace(/^\s+|\s+$/, ''); },
// 批次取代:傳入 { 欲取代: 取代成 } 的對照表
replace: function (str, re) {
str = str || '';
for (var key in re) { (function(a, b){
str = str.split(a).join(b);
})(key, re[key]); }
return str;
},
// XSS 轉義,依情境選擇不同層級
xss: function (str, type) {
if (!str) { return str === 0 ? "0" : ""; }
switch (type) {
case "html": /* 轉義 HTML 特殊字元並保留換行 */ break;
case "htmlEp": /* 只轉義屬性值中的危險字元 */ break;
case "url": return escape(str).replace(/\+/g, "%2B");
case "script": /* 轉義引號、反斜線與換行 */ break;
case "reg": return str.replace(/[\\\^\$\*\+\?\{\}\.\(\)\[\]]/g, function (a) { return "\\" + a; });
default: /* html + url 雙重處理 */ break;
}
},
// 敏感詞過濾:把命中的字詞換成等長的星號
badWord: function (text, words) {
text = String(text || '');
words = words || [];
var reg = new RegExp(words.join('|'), 'g'), _self = this;
return text.replace(reg, function ($0) {
return _self.repeat('*', String($0 || '').length);
});
}
};
「用等長星號取代」是敏感詞處理的關鍵——保留長度可以讓使用者知道原本有幾個字,又不洩漏內容。xss 那段依情境分級的設計也很值得學:HTML 本文、屬性值、URL、JavaScript 字串、正則各自需要不同的轉義規則,一律用同一種處理反而會出錯。
這部分沿用廣為使用的 CryptoJS 3.1.2 實作,包裝成三個方法:
Angela.encrypt = {
// MD5 哈希(CryptoJS 3.1.2 核心實作,此處省略壓縮後的內部程式碼)
md5: function (words) { /* ... CryptoJS ... */ return CryptoJS.MD5(words).toString(); },
// SHA-1 哈希(同上)
sha1: function (words) { /* ... CryptoJS ... */ return CryptoJS.SHA1(words).toString(); },
// time33 哈希:極輕量,適合做資料分片或簡單雜湊
time33: function (words) {
words = words || '';
for (var i = 0, len = words.length, hash = 5381; i < len; ++i) {
hash += (hash << 5) + words.charAt(i).charCodeAt();
}
return hash & 0x7fffffff;
}
};
使用上的重要提醒:MD5 與 SHA-1 都已被判定不適合安全性用途(碰撞攻擊成熟),只用於校驗資料完整性、快取鍵、分片雜湊等場景。若要儲存密碼,請使用 bcrypt、scrypt 或 Argon2 並加上隨機 salt,而且一定要在後端做——前端雜湊無法取代 HTTPS,因為雜湊值本身就等同密碼。
Angela.date = {
// 判斷某時間是否落在 [s, e] 區間內
isInArea: function (s, e, n) {
var start = this.parse(s), end = this.parse(e),
now = parseFloat(n) || new Date();
start = Math.min(start, end);
end = Math.max(start, end);
return now >= start && now <= end ? true : false;
},
parse: function (date) { return Date.parse(date); },
// 取得星期幾,可自訂前綴與用字
getWeek: function (time, pre, nums) {
time = typeof time == 'string' ? this.parse(time) : (time || new Date());
pre = pre || '星期';
return pre + ('日一二三四五六')[time.getDay()];
},
// 格式化輸出:YYYY-MM-DD HH:II:SS W
format: function (formatType, time, weeks) {
var pre = '0';
formatType = formatType || 'YYYY-MM-DD';
weeks = weeks || '日一二三四五六';
time = time || new Date();
return (formatType || '')
.replace(/yyyy|YYYY/g, time.getFullYear())
.replace(/mm|MM/g, Tydic.string.addPre(pre, time.getMonth() + 1, 2))
.replace(/dd|DD/g, Tydic.string.addPre(pre, time.getDate(), 2))
.replace(/hh|HH/g, Tydic.string.addPre(pre, time.getHours(), 2))
.replace(/ss|SS/g, Tydic.string.addPre(pre, time.getSeconds(), 2))
.replace(/w/g, time.getDay())
.replace(/W/g, weeks[time.getDay()]);
},
// 倒數計時
countDown: function (opt) {
var option = { nowTime: 0, endTime: 0, interval: 1,
called: function (day, hour, minute, second) {},
finaled: function () {} },
opts = Tydic.extend(option, opt), timer = null;
opts.nowTime = opts.nowTime ? this.parse(opts.nowTime) : (new Date()).getTime();
opts.endTime = opts.endTime ? this.parse(opts.endTime) : (new Date()).getTime();
timer = setInterval(loop, opts.interval * 1e3);
function loop() {
var ts = opts.endTime - opts.nowTime, // 剩餘毫秒
dd = parseInt(ts / 8.64e7), // 天
hh = parseInt(ts / 3.6e7 % 24), // 時
mm = parseInt(ts / 6e4 % 60), // 分
ss = parseInt(ts / 1e3 % 60); // 秒
opts.nowTime += opts.interval * 1e3;
if (ts <= 0) { clearInterval(timer); opts.finaled(); }
else { opts.called(dd, hh, mm, ss); }
}
}
};
倒數計時用「固定除數取餘數」拆出天時分秒,比逐一相減清楚很多。實務上要留意:nowTime 用累加方式推進會隨時間累積誤差,改用 Date.now() 每次取真實時間會更準,同時也能避免使用者把系統時間往前調時產生負值。
Angela.browser = {
browsers: {
weixin: /micromessenger(\/[\d\.]+)*/, // 微信內建瀏覽器
mqq: /mqqbrowser(\/[\d\.]+)*/, // 手機 QQ 瀏覽器
uc: /ucbrowser(\/[\d\.]+)*/, // UC
chrome: /(?:chrome|crios)(\/[\d\.]+)*/,
firefox: /firefox(\/[\d\.]+)*/,
safari: /safari(\/[\d\.]+)*/,
ie: /msie\s([\d\.]+)*/
},
coreInit: function () {
var ua = window.navigator.userAgent.toLowerCase();
for (var i in this.browsers) {
var brower = ua.match(this.browsers[i]);
if (brower) {
this.version = (brower[i == 'opera' ? 2 : 1] || '').replace(/[\/\s]+/, '');
this.core = i;
return i;
}
}
},
isWebkit: /webkit/i.test(navigator.userAgent)
};
請把這個方法集當作歷史資料。用 userAgent 字串判斷瀏覽器既不可靠也不可維護(UA 可以被偽造、且各廠商互相模仿),現代做法應該是功能偵測:
if ('addEventListener' in window) { /* ... */ }
if (window.requestAnimationFrame) { /* ... */ }
if (CSS.supports('display', 'grid')) { /* ... */ }
function isNumber(val) { return typeof val === 'number' && isFinite(val); }
function isBoolean(val) { return typeof val === 'boolean'; }
function isString(val) { return typeof val === 'string'; }
function isUndefined(val) { return typeof val === 'undefined'; }
function isNull(val) { return val === null; }
function isObj(str) {
if (str === null || typeof str === 'undefined') { return false; }
return typeof str === 'object';
}
// 判斷陣列的兩種方式
function isArray1(arr) { return Object.prototype.toString.apply(arr) === '[object Array]'; }
function isArray2(arr) {
if (arr === null || typeof arr === 'undefined') { return false; }
return arr.constructor === Array;
}
注意 typeof null === 'object' 這個著名的歷史包袱,所以 isObj 必須先排除 null。另外 isArray2 在跨 iframe 時會失效(不同 window 的 Array 建構子不同),isArray1 則不受影響——這也是為什麼 ES5 之後官方提供了 Array.isArray()。
trim → String.prototype.trim()、repeat → repeat()、padStart 取代 addPre、Object.keys 取代 getKey、Array.from(new Set(arr)) 取代 unique。Tydic.math.randInt、Tydic.extend 屬於同系列的另一支工具庫,搬用時要一併處理或改成內建方法。工具庫的價值不在程式碼本身,而在「把重複出現的判斷與轉換收斂成有名字、有測試的單一入口」。累積幾次之後,你會發現自己寫業務邏輯的速度快了很多。