DIV CSS 佈局教程網

js 與 jQuery 核心知識點整理大全
編輯:關於JavaScript     

想真正讀懂 jQuery 的源碼,或者想在面試中應對自如,光會寫選擇器是不夠的。原始碼裡藏著大量 JavaScript 語言層面的技巧:型別轉換的簡寫、短路運算的妙用、特性偵測的取捨。本文把這些散落的知識點系統梳理成三大區塊,並附上可直接運行的程式碼片段。

一、jQuery 源碼中常見的知識點

1. string 與 number 型別的快捷轉換

字串轉數字、數字轉字串,其實不需要 parseInt 或 toString 這麼正式:

// @param obj 為任意值
function fn(obj){
    //轉為 String 型別
    var s = obj + "";
    //轉為 number 型別
    var n = +obj;
}

面試常考的一題就在這裡:

//加號會把後面的值轉成字串
"64" + 4  // "644"
//減號會把值轉成數字
"64" - 4   // 60

2. bool 型別轉換

兩個驚嘆號可以把任何值強制轉為布林值:

alert(!!0)       // false
alert(!!"33dd") // true

單個驚嘆號則是取反:

alert(!0)         // true
alert(!"222333") // false

3. === 與 == 的差別

=== 是嚴格相等,不做型別轉換;== 則會先進行型別轉換再比較。不少 JavaScript 書籍甚至建議開發者永遠不要使用 == 與 !=。

但 jQuery 源碼中確實出現了 ==,只用在一種情況:同時排除 null 與 undefined。

//這一行同時排除了 null 與 undefined
if (obj != null) {
    // ...
}

4. 偵測物件是否為 window

//null == window 的比較結果為 false
function isWindow(obj){
    return obj != null && obj == window.obj;
}

5. || 與 && 的用法技巧

短路運算是設定預設值最簡潔的手法:

//若 aa 為真值,name 取 aa,否則取 {}
var aa = 5;
name = aa || {};
alert(name);  // 5

this.name = name || {};  // name 存在則用它,否則用 {}

//&& 的邏輯相反
var aa = 5;
name = aa && {};
alert(name);  // {},因為 5 為真值

this.name = bool && [];  // bool 為 true 時取 []

一個常被引用的經典寫法:

(window.foo || (window.foo = "bar"));
alert(window.foo);  // bar

原理很單純:第一次執行時 window.foo 是 undefined,等價於 undefined || bar,結果自然是 bar。

6. setTimeout(fn,0) 與 setTimeout(fn) 的差別

兩者都是延遲執行,但省略第二個參數時,瀏覽器會套用一個內建的延遲量,實測通常比 0 還要慢一些。

function fn(){
    var data = new Date();
    for (var i = 0; i <= 1000; i++) {
        if (i == 1000) {
            console.log("fn=" + data.getTime());
        }
    }
}
function fn1(){
    var data = new Date();
    for (var i = 0; i <= 1000; i++) {
        if (i == 1000) {
            console.log("fn1=" + data.getTime());
        }
    }
}
setTimeout(fn, 0),
setTimeout(fn1);

執行結果如下:

7. 判斷是否為數值

function isNumeric(obj){
    return !isNaN(parseFloat(obj)) && isFinite(obj);
}

8. 判斷是否為空物件

function isEmptyObject(obj){
    var name;
    //只要有一個可列舉屬性,就不是空物件
    for (name in obj) {
        return false;
    }
    return true;
}

9. 偵測物件型別

最可靠的型別判斷方式是借用 Object.prototype.toString,它會回傳 [object Array]、[object Object]、[object Function] 這樣的字串:

// 型別判斷工廠
function isType(type){
    return function(o){
        return Object.prototype.toString.call(o) === '[object ' + type + ']';
    }
}
var isString = isType("String");
var isObject = isType("Object");
var isArray  = isType("Array");

isString("I'm Barret Lee.");  // true
isArray([1, 2, 3]);          // true
isObject({});                  // true

10. jQuery 中 trim 的巧妙處理

新版瀏覽器早已原生支援 String.prototype.trim,但 jQuery 多做了一層判斷,原因是某些環境下的原生實作無法處理全形空白(\uFEFF\xA0):

var core_version = "1.0",
    core_trim = core_version.trim;

function trim( text ){
    //原生 trim 可用,且能正確處理全形空白
    core_trim && !core_trim.call("\uFEFF\xA0")
    ? function (text) {
        return text == null ? "" : core_trim.call(text);
    }
    //否則退回正則實作
    : function (text) {
        var whitespace = "[\\x20\\t\\r\\n\\f]",
            rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g");
        return text == null ? "" : (text + "").replace(rtrim, "");
    };
}

同一段源碼裡還有個實用的小工具 nodeName,用來取得節點名稱或比對名稱是否相符。注意 IE 下 nodeName 是全大寫的(例如 DIV),所以兩邊都要轉小寫:

nodeName: function(elem, name){
    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
}

11. 在陣列或類陣列中搜尋指定值

/**
 * 檢查陣列中是否存在傳入的值。
 * 存在則回傳索引位置,不存在則回傳 -1。
 * @elem 需檢索的值
 * @arr  目標陣列
 * @i    可選的起始索引,省略時從頭開始
 */
function inArray(elem, arr, i){
    var len;
    if (arr) {
        //瀏覽器原生支援 indexOf 時直接借用
        if ([].indexOf) {
            return [].indexOf.call(arr, elem, i);
        }
        len = arr.length;
        //i 為負數時,從尾端 len + i 的位置開始
        i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
        for (; i < len; i++) {
            //雙重檢查,避免稀疏陣列誤判
            //例如 ar = []; ar[1] = 1; ar[0] = undefined;
            //此時 0 in ar 為 false,但 ar[0] === undefined 為 true
            if (i in arr && arr[i] === elem) {
                return i;
            }
        }
    }
    return -1;
}

二、JavaScript 原型鏈常見知識點

1. hasOwnProperty() 方法

這個方法自 Object 繼承而來,可以判斷某個屬性是來自物件本身,還是來自原型鏈。只有當屬性存在於物件實例上時才回傳 true。

function Person(){
    this.age = 25;
    this.job = "web";
}
Person.prototype = {
    name: 'pingfan',
    sayName: function(){
        alert(this.name);
    }
};
var person1 = new Person();

alert(person1.hasOwnProperty("age"));  // true,來自建構函式
alert(person1.hasOwnProperty("name"));  // false,來自原型

person1.name = 'ping';
alert(person1.hasOwnProperty("name"));  // true,已成為實例屬性

2. 用 instanceof 確保只初始化一次

這是常見的單例寫法:如果呼叫時沒有使用 new,就幫呼叫者補上。

function shiCha(opt){
    //只初始化一次
    if (!(this instanceof shiCha)) {
        return new shiCha(opt);
    }
}
var shicha = shiCha();

3. Array.prototype.slice.call(arguments)

看到 Array.prototype.slice.call(arguments, 1) 這種寫法常讓人摸不著頭緒。它其實是借用陣列的 slice 把類陣列物件轉成真陣列,第二個參數是起始索引。

function sliArray(array){
    //取出索引 1 到索引 2 的元素
    return Array.prototype.slice.call(array, 1, 3);
}
alert(sliArray([1, 2, 3, 4, 5, 6]));  // 2,3

4. 用空物件 F 做中介,實作效率最佳的繼承

//以空函式作為媒介,避免直接 new 父類別帶來的開銷
function inhert(C, P){
    var F = function(){};
    F.prototype = P.prototype;
    C.prototype = new F();
    C.prototype.constructor = C;
}

三、JavaScript 常用方法集

1. 常見的陣列操作

陣列去重:

Array.prototype.unqie = function(){
    var arr = this, len = this.length, obj = {}, newArr = [];
    while (len--) {
        if (obj[arr[len]] !== arr[len]) {
            obj[arr[len]] = arr[len];
            newArr.push(arr[len]);
        }
    }
    return newArr.reverse();
}

取最大值,這裡提供三種思路:

// 做法一:迴圈比較
Array.prototype.arrMax = function(){
    var arr = this, len = this.length, max = arr[0];
    for (var i = 1; i < len; i++) {
        if (max < arr[i]) { max = arr[i]; }
    }
    return max;
}

// 做法二:排序後取尾項
Array.prototype.arrMax = function(){
    var arr = this;
    arr.sort(function(a, b){ return a - b; });
    return arr[arr.length - 1];
}

// 做法三:Math.max 搭配 apply
Array.prototype.arrMax = function(){
    return Math.max.apply(null, this);
}

alert([1, 2, 3, 4, 5, 6, 9, 8, 7, 9].arrMax());

取最小值同理:

// 迴圈比較
Array.prototype.arrMin = function(){
    var arr = this, len = this.length, min = arr[0];
    for (var i = 1; i < len; i++) {
        if (min > arr[i]) { min = arr[i]; }
    }
    return min;
}

// 排序後取首項
Array.prototype.arrSortMin = function(){
    var arr = this;
    arr.sort(function(a, b){ return a - b; });
    return arr[0];
}

// Math.min 搭配 apply
Array.prototype.arrSortMin = function(){
    return Math.min.apply(null, this);
}

alert([1, 2, 3, 4, 5, 6, 9, 8, 7, 9].arrSortMin());

複製陣列:

Array.prototype.copy = function() {
    return [].concat(this);
};

移除指定元素(一次只能移除一項,若要移除多項請先自行去重):

Array.prototype.remove = function(value){
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i] == value) {
            this.splice(i, 1);
            break;
        }
    }
    return this;
}

2. 操作 document.location 的方法集

pFan.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] : "";
    }
    //取得 hash 中的參數
    , getHash: function (name, url) {
        var u = arguments[1] || location.hash;
        var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
        var r = u.substr(u.indexOf("#") + 1).match(reg);
        if (r != null) { return r[2]; }
        return "";
    }
    //解析 URL 的各個組成部分
    , parse: function (url) {
        var a = document.createElement('a');
        url = url || document.location.href;
        a.href = url;
        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('/')
        };
    }
};

3. 常用正則表達式

pFan.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) { //是否為 QQ 號
        return /^[1-9]\d{4,10}$/.test(qq);
    }
    , isTel: function (tel) { //是否為電話號碼
        return /^\d{3,4}-\d{7,8}(-\d{1,6})?$/.test(tel);
    }
    , isUrl: function (url) { //是否為網址
        return /https?:\/\/[a-z0-9\.\-]{1,255}\.[0-9a-z\-]{1,255}/i.test(url);
    }
    , isColor: function (color) { //是否為 16 進位顏色值
        return /#([\da-f]{3}){1,2}$/i.test(color);
    }
    //id:身分證字號;now:對照時間;allowAge:法定年齡
    , isAdult: function (id, allowAge, now) {
        var age = 0, nowDate = 0;
        allowAge = parseFloat(allowAge) || 18;
        now = typeof now == 'string' ? new Date(now) : (now || new Date());

        if (!this.isIdCard(id)) { return false; }
        //15 位身分證
        if (15 == id.length) {
            age = '19' + id.slice(6, 8);
        } else {
            age = id.slice(6, 14);
        }
        age = ~~age;
        nowDate = ~~(Tydic.date.format('YYYYMMDD', now));
        if (nowDate - age < allowAge * 1e4) { return false; }
        return true;
    }
    , 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);
    }
};

4. 操作 className 的方法集

PFan.conClass = {
    hasClass: function(){
        return ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
    },
    addClass: function(){
        if (!hasClass(ele, cls)) ele.className += " " + cls;
    },
    removeClass: function(){
        if (hasClass(ele, cls)) {
            var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
            ele.className = ele.className.replace(reg, ' ');
        }
    }
}

5. 字串處理方法

這裡包含 HTML 轉義、重複字串、補零、去空白,以及一套完整的 XSS 過濾與敏感詞處理:

pFan.string = {
    codeHtml: function (content) { //轉義 HTML 特殊字元
        return this.replace(content, {
            '&': "&amp;", '"': "&quot;", "'": "&#39;",
            '<': "&lt;", '>': "&gt;", ' ': "&nbsp;",
            '\t': "&#09;", '(': "&#40;", ')': "&#41;",
            '*': "&#42;", '+': "&#43;", ',': "&#44;",
            '-': "&#45;", '.': "&#46;", '/': "&#47;",
            '?': "&#63;", '\\': "&#92;", '\n': "<br>"
        });
    }
    //重複字串
    , repeat: function (word, length, end) {
        end = end || '';
        length = ~~length;
        return new Array(length * 1 + 1).join(word) + '' + end;
    }
    //補齊前綴,例如替數字補 0
    , addPre: function (pre, word, size) {
        pre = pre || '0';
        size = parseInt(size) || 0;
        word = String(word || '');
        var length = Math.max(0, size - word.length);
        return this.repeat(pre, length, word);
    }
    //去除兩端空白
    , trim: function (text) {
        return (text || '').replace(/^\s+|\s+$/, '');
    }
    //去除左側空白
    , ltrim: function (s) {
        return s.replace(/^(\s*)/, "");
    }
    //去除右側空白
    , rtrim: function (s) {
        return s.replace(/(\s*)$/, "");
    }
    //取出並執行字串中的 script 內容
    , evalscript: function (s) {
        if (s.indexOf('<script') == -1) return s;
        var p = /<script[^>]*?>([^\x00]*?)<\/script>/ig;
        var arr = [];
        while (arr = p.exec(s)) {
            var p1 = /<script[^>]*?src="([^>]*?)"[^>]*?(reload="1")?(?:charset="([\w\-]+?)")?><\/script>/i;
            var arr1 = p1.exec(arr[0]);
            if (arr1) {
                appendscript(arr1[1], '', arr1[2], arr1[3]);
            } else {
                p1 = /<script(.*?)>([^\x00]+?)<\/script>/i;
                arr1 = p1.exec(arr[0]);
                appendscript('', arr1[2], arr1[1].indexOf('reload=') != -1);
            }
        }
        return s;
    }
    //清除 script 內容
    , stripscript: function (s){
        return s.replace(/<script.*?>.*?<\/script>/ig, '');
    }
    //批次字串替換
    , replace: function (str, re) {
        str = str || '';
        for (var key in re) {
            replace(key, re[key]);
        };
        function replace(a, b) {
            var arr = str.split(a);
            str = arr.join(b);
        };
        return str;
    }
    //XSS 轉義,依場景選擇不同策略
    , xss: function (str, type) {
        if (!str) { return str === 0 ? "0" : ""; }
        switch (type) {
            case "html": //過濾 HTML 內容中的 XSS
                return str.replace(/[&'"<>\/\\\-\x00-\x09\x0b-\x0c\x1f\x80-\xff]/g, function (r) {
                    return "&#" + r.charCodeAt(0) + ";";
                 }).replace(/ /g, "&nbsp;").replace(/\r\n/g, "<br />").replace(/\n/g, "<br />").replace(/\r/g, "<br />");
                break;
            case "htmlEp": //過濾節點屬性中的 XSS
                return str.replace(/[&'"<>\/\\\-\x00-\x1f\x80-\xff]/g, function (r) {
                    return "&#" + r.charCodeAt(0) + ";";
                 });
                break;
            case "url":
                return escape(str).replace(/\+/g, "%2B");
                break;
            case "miniUrl":
                return str.replace(/%/g, "%25");
                break;
            case "script":
                return str.replace(/[\\"']/g, function (r) {
                    return "\\" + r;
                 }).replace(/%/g, "\\x25").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
                break;
            case "reg":
                return str.replace(/[\\\^\$\*\+\?\{\}\.\(\)\[\]]/g, function (a) {
                    return "\\" + a;
                 });
                break;
            default:
                return escape(str).replace(/[&'"<>\/\\\-\x00-\x09\x0b-\x0c\x1f\x80-\xff]/g, function (r) {
                    return "&#" + r.charCodeAt(0) + ";";
                 }).replace(/ /g, "&nbsp;").replace(/\r\n/g, "<br />").replace(/\n/g, "<br />").replace(/\r/g, "<br />");
                break;
        }
    }
    //敏感詞過濾:words 為陣列,如 ['你妹', '我丟']
    , 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);
        });
    }
};

6. 加密方法集

這一段整合了 CryptoJS 3.1.2 的 MD5 與 SHA1 實作,並額外提供一個輕量的 time33 哈希演算法。MD5 與 SHA1 屬單向雜湊,適合完整性校驗,但正式環境請務必改用加鹽或更現代的 bcrypt、PBKDF2 等方案來保存密碼。

pFan.encrypt = {
    md5: function (words) { //MD5 雜湊演算法
        /* Crypto-JS 3.1.2, https://code.google.com/p/crypto-js */
        var CryptoJS = function (s, p) {
            var m = {}, l = m.lib = {}, n = function () { },
                r = l.Base = {
                 extend: function (b) {
                     n.prototype = this;
                     var h = new n;
                     b && h.mixIn(b);
                     h.hasOwnProperty("init") || (h.init = function () {
                         h.$super.init.apply(this, arguments)
                     });
                     h.init.prototype = h;
                     h.$super = this;
                     return h
                 },
                 create: function () {
                     var b = this.extend();
                     b.init.apply(b, arguments);
                     return b
                 },
                 init: function () { },
                 mixIn: function (b) {
                     for (var h in b) b.hasOwnProperty(h) && (this[h] = b[h]);
                     b.hasOwnProperty("toString") && (this.toString = b.toString)
                 },
                 clone: function () {
                     return this.init.prototype.extend(this)
                }
               },
            /* 其餘 WordArray、Hex、Latin1、Utf8、BufferedBlockAlgorithm 等
               基礎模組與 MD5 四輪壓縮函式,此處從略,實作與官方版本一致 */
            return m
            }(Math);
            /* MD5 核心:包含 p / m / l / n 四個輪函式與 64 步壓縮迴圈 */
            return CryptoJS.MD5(words).toString();
        }
    //SHA1 雜湊演算法,結構與 MD5 相同,同樣來自 CryptoJS
    , sha1: function (words) {
        /* CryptoJS 3.1.2 SHA1 實作,此處從略 */
        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;
    }
}

7. 日期方法集

pFan.date = {
    //回傳目前時間戳
    getTimeStamp: function(){
        return new Date().getTime().toString();
    },
    //將時間戳(秒)轉為可讀日期
    getLocalTime: function(nS) {
        return new Date(parseInt(nS) * 1000).toLocaleString().substr(0, 17);
    },
    //取得星期幾;pre 為前綴,nums 為中文數字對照表
    getWeek: function (time, pre, nums) {
        time = typeof time == 'string' ? this.parse(time) : (time || new Date());
        pre = pre || '星期';
        nums = nums || '日一二三四五六';
        return pre + nums[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(/yy|YY/g, Tydic.string.addPre(pre, time.getFullYear() % 100, 2))
            .replace(/mm|MM/g, Tydic.string.addPre(pre, time.getMonth() + 1, 2))
            .replace(/m|M/g, time.getMonth() + 1)
            .replace(/dd|DD/g, Tydic.string.addPre(pre, time.getDate(), 2))
            .replace(/d|D/g, time.getDate())
            .replace(/hh|HH/g, Tydic.string.addPre(pre, time.getHours(), 2))
            .replace(/h|H/g, time.getHours())
            .replace(/ii|II/g, Tydic.string.addPre(pre, time.getMinutes(), 2))
            .replace(/i|I/g, time.getMinutes())
            .replace(/ss|SS/g, Tydic.string.addPre(pre, time.getSeconds(), 2))
            .replace(/s|S/g, time.getSeconds())
            .replace(/w/g, time.getDay())
            .replace(/W/g, weeks[time.getDay()]);
    }
}

以上就是 jQuery 與 JavaScript 常用知識點的整理。這些片段單看都不難,但能否在需要時脫手而出,才是真正拉开差距的地方。建議挑幾個實際放進自己的工具函式庫,用過一次就會記住。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved