王福朋老師-zepto設計和源碼分析 ~~~ /* Zepto v1.1.6 - zepto event ajax form ie - zeptojs.com/license */ var Zepto = (function() { var undefined, key, $, classList, // 獲取數組的slice 和 filter（返回數組中的滿足回調函數中指定的條件的元素）方法 emptyArray = [], slice = emptyArray.slice, filter = emptyArray.filter, document = window.document, elementDisplay = {}, classCache = {}, cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1, 'opacity': 1, 'z-index': 1, 'zoom': 1 }, // 取出html代碼中第一個html標簽（或注釋），如取出 <p>123</p><h1>345</h1> 中的 <p> fragmentRE = /^\s*<(\w+|!)[^>]*>/, // 匹配 <img /> <p></p> 不匹配 <img src=""/> <p>123</p> singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, // 單標簽 tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, // body html rootNodeRE = /^(?:body|html)$/i, // 大寫字母 capitalRE = /([A-Z])/g, // special attributes that should be get/set via method calls // 應該通過方法調用來設置/獲取的特殊屬性 methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'], adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ], table = document.createElement('table'), tableRow = document.createElement('tr'), // 指定特殊元素的 容器 containers = { 'tr': document.createElement('tbody'), 'tbody': table, 'thead': table, 'tfoot': table, 'td': tableRow, 'th': tableRow, // 除了上面指定的，其他所有元素的容器都是 div '*': document.createElement('div') }, // interactive ？？？ readyRE = /complete|loaded|interactive/, // 匹配一個包括（字母、數組、下劃線、-）的字符串 simpleSelectorRE = /^[\w-]*$/, class2type = {}, toString = class2type.toString, zepto = {}, camelize, uniq, tempParent = document.createElement('div'), // 屬性轉換為 camalCase 格式。 // $.fn.prop 方法用到了 propMap = { 'tabindex': 'tabIndex', 'readonly': 'readOnly', 'for': 'htmlFor', 'class': 'className', 'maxlength': 'maxLength', 'cellspacing': 'cellSpacing', 'cellpadding': 'cellPadding', 'rowspan': 'rowSpan', 'colspan': 'colSpan', 'usemap': 'useMap', 'frameborder': 'frameBorder', 'contenteditable': 'contentEditable' }, // 判斷是否是arr的函數 isArray = Array.isArray || function(object){ return object instanceof Array } // 上文定義 zepto = {} // 判斷 element 是否符合 selector 的選擇要求 zepto.matches = function(element, selector) { // selector有值，element有值，element是普通DOM節點 if (!selector || !element || element.nodeType !== 1) return false // elem.matchesSelector('.item') // 判斷當前的 elem 是否符合傳入的 selector 的要求 var matchesSelector = element.webkitMatchesSelector || element.mozMatchesSelector || element.oMatchesSelector || element.matchesSelector if (matchesSelector) return matchesSelector.call(element, selector) // 瀏覽器不支持 matchesSelector // fall back to performing a selector: var match, parent = element.parentNode, temp = !parent // 上文定義 tempParent = document.createElement('div'), // 如果沒有parent，parent賦值為一個div，然后將當前元素加入到這個div中 if (temp) { parent = tempParent; tempParent.appendChild(element); // (parent = tempParent).appendChild(element); 這種寫法不易讀 } // 通過 qsa 獲取匹配的元素，判斷其中有沒有 element match = ~zepto.qsa(parent, selector).indexOf(element) if (temp) { // 如果沒有parent時，之前執行過 tempParent.appendChild(element); // 此時要移除子元素 tempParent.removeChild(element); } // temp && tempParent.removeChild(element) // 這種寫法不易讀 // 返回最終的匹配結果，經過 qsa 判斷的結果 return match } function type(obj) { return obj == null ? String(obj) : // null undefined class2type[toString.call(obj)] || "object" // 下文定義： // // Populate the class2type map // $.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { // class2type[ "[object " + name + "]" ] = name.toLowerCase() // }) } function isFunction(value) { return type(value) == "function" } // window的特點：window.window === window function isWindow(obj) { return obj != null && obj == obj.window } // document.nodeType === 9 // elem.DOCUMENT_NODE 也等于 9 （這里直接判斷是不是9也行？？？） function isDocument(obj) { return obj != null && obj.nodeType == obj.DOCUMENT_NODE } function isObject(obj) { return type(obj) == "object" } // 判斷是否是最基本的object：Object.getPrototypeOf(obj) == Object.prototype function isPlainObject(obj) { return isObject(obj) && !isWindow(obj) && Object.getPrototypeOf(obj) == Object.prototype } // 數組或者對象數組 function likeArray(obj) { return typeof obj.length == 'number' } // 篩選數組，踢出 null undefined 元素 function compact(array) { return filter.call(array, function(item){ return item != null }) } // 下文定義： // $.fn = { // concat: emptyArray.concat, // $.fn.concat.apply([], array) —— 無論 array 是不是數組，都將返回一個數組， // 例如 $.fn.concat.call([], 'abc') 返回的是 ['abc'] function flatten(array) { return array.length > 0 ? $.fn.concat.apply([], array) : array } // camelize 已在上文定義 // 用于 css 的 camalCase 轉換，例如 background-color 轉換為 backgroundColor camelize = function(str){ return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) } // 將 lineHeight 轉換為 line-height 格式 function dasherize(str) { return str.replace(/::/g, '/') .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') .replace(/([a-z\d])([A-Z])/g, '$1_$2') .replace(/_/g, '-') .toLowerCase() } // uniq變量已經在前面定義 // 用來將 [1,1,2,2,3,3] 替換為 [1,2,3] uniq = function(array){ return filter.call(array, function(item, idx){ return array.indexOf(item) == idx }) } // 上文定義 classCache = {} function classRE(name) { return name in classCache ? classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)')) // classCache 存儲的數據是這樣的： // { // abc: /(^|\s)abc(\s|$)/, // 能匹配 'abc' 或 ' abc ' 或 ' abc' 或 'abc ' // xyz: /(^|\s)abc(\s|$)/, // ... // } } // 傳入一個 css 的 name 和 value，判斷這個 value 是否需要增加 'px' function maybeAddPx(name, value) { // dasherize(name) 將 lineHeight 轉換為 line-height 格式 // !cssNumber[dasherize(name)] 判斷轉換出來的 css name 是否再這個數組之外 return (typeof value == "number" && !cssNumber[dasherize(name)]) ? // 如果 value 是數字，并且 name 不在 cssNumber 數組之內，就需要加 'px'，否則不需要 // 例如 'width'、'font-size' 就需要加 'px'， 'font-weight' 就不需要加 value + "px" : value // 前文定義---------------------- // cssNumber = { // 'column-count': 1, // 'columns': 1, // 'font-weight': 1, // 'line-height': 1, // 'opacity': 1, // 'z-index': 1, // 'zoom': 1 // }, // function dasherize(str) { // return str.replace(/::/g, '/') // .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') // .replace(/([a-z\d])([A-Z])/g, '$1_$2') // .replace(/_/g, '-') // .toLowerCase() // } } // 獲取一個元素的默認 display 樣式值，可能的結果是：inline block inline-block table .... （none 轉換為 block） // $.fn.show 方法中用到了 function defaultDisplay(nodeName) { var element, display // 前文定義 elementDisplay = {} if (!elementDisplay[nodeName]) { // 如果 elementDisplay 對象中，沒有存儲 nodeName 的信息 // 則新建一個 nodeName 元素，添加到 body 中 element = document.createElement(nodeName) document.body.appendChild(element) // 獲取它的默認的 display 樣式信息。 display = getComputedStyle(element, '').getPropertyValue("display") // 接著馬上移除元素！！！ element.parentNode.removeChild(element) // 'none' 換成 'block'，另外還可能是 'inline' 'inline-block' 'table' 等等... display == "none" && (display = "block") // 存儲下來 elementDisplay[nodeName] = display // 下文定義 // var nativeGetComputedStyle = getComputedStyle; // window.getComputedStyle = function(element){ // try { // return nativeGetComputedStyle(element) // } catch(e) { // return null // } // } // 解釋： // 如果瀏覽器支持 getComputedStyle 則使用，如果不支持，就返回 null // getComputedStyle(elem, '偽類，如 :link') 返回一個 CSSStyleDeclaration 對象，里面存儲了元素的樣式信息，可以通過 getPropertyValue('name') 方法獲取 } // 最終返回 display 結果 return elementDisplay[nodeName] } // 返回一個元素的子元素，數組形式 function children(element) { // 有些瀏覽器支持 elem.children 獲取子元素，有些不支持 return 'children' in element ? // 上文定義 slice = [].slice // slice.call(likeArr) 可以將對象數組轉換為真正的數組 slice.call(element.children) : // 瀏覽器不支持 elem.children 只能通過 elem.childNodes 獲取子元素 // 只去 node.nodeType == 1 的子元素，通過 $.map 拼接成數組 // $.map 下文定義的， $.map = function (elements, callback) {....} // $.map 作用：針對 elements（對象數組或數組），對每個元素都經過 callback 函數的過濾，并將過濾通過的元素，push到一個新數組中，返回新數組 $.map(element.childNodes, function(node){ if (node.nodeType == 1) return node }) } // 上文定義 zepto = {} // 上文定義 zepto.matches = function(element, selector) { /* 判斷elem是否符合selector的要求 */ } // `$.zepto.fragment` takes a html string and an optional tag name // to generate DOM nodes nodes from the given html string. // The generated DOM nodes are returned as an array. // This function can be overriden in plugins for example to make // it compatible with browsers that don't support the DOM fully. zepto.fragment = function(html, name, properties) { /* 參數： @html: 待處理的html字符串 @name: 通過 name 可在 containers 中查找容器節點，如果不傳入，取得的容器默認為 div @properties: 節點屬性對象 */ var dom, nodes, container // 上文定義：singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, // 匹配 <img /> <p></p> 不匹配 <img src=""/> <p>123</p> // 如果 html 是單標簽，則直接用該標簽創建元素 // RegExp.$1 表示正則中的第一個括號匹配的內容，在此即 (\w+) 匹配的內容， // A special case optimization for a single tag if (singleTagRE.test(html)) dom = $(document.createElement(RegExp.$1)) if (!dom) { // 說明 html 不是單標簽，dom未被賦值 // 上文定義 tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, // 單標簽 // 將 <p/>或<p />，替換為 <p></p>，將<p abc/>替換為<p>abc</p> // <input/> （在 tagExpanderRE 中定義）的不替換 if (html.replace) html = html.replace(tagExpanderRE, "<$1></$2>") // fragmentRE = /^\s*<(\w+|!)[^>]*>/, // 取出html代碼中第一個html標簽（或注釋），如取出 <p>123</p><h1>345</h1> 中的 <p> // 如果 name 未傳入，則賦值為 html 的第一個標簽 if (name === undefined) name = fragmentRE.test(html) && RegExp.$1 // 上文定義 // // 指定特殊元素的 容器 // containers = { // 'tr': document.createElement('tbody'), // 'tbody': table, // 'thead': table, // 'tfoot': table, // 'td': tableRow, // 'th': tableRow, // // 除了上面指定的，其他所有元素的容器都是 div // '*': document.createElement('div') // }, if (!(name in containers)) name = '*' container = containers[name] container.innerHTML = '' + html // 轉變為字符串的快捷方式 // 遍歷 container 的子元素（先轉換為數組形式） // 返回的同時，將每個子元素移除。 // $.each 返回的是一個數組，因為第一個參數就是數組 slice.call(container.childNodes) dom = $.each(slice.call(container.childNodes), function(){ container.removeChild(this) }) } // 賦值屬性 if (isPlainObject(properties)) { // 先將dom轉換為 zepto 對象 nodes = $(dom) $.each(properties, function(key, value) { // 上文定義： // // 應該通過方法調用來設置/獲取的特殊屬性 // methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'], if (methodAttributes.indexOf(key) > -1) nodes[key](value) // 滿足 methodAttributes 的，通過方法賦值 else nodes.attr(key, value) // 否則，通過屬性復制 }) } // 最終返回的dom可能有兩種形式 // 第一，如果 html 是單標簽，則dom被復制為一個zepto對象 dom = $(document.createElement(RegExp.$1)) // 第二，如果 html 不是單標簽，則dom被復制為一個DOM節點的數組 return dom } // 上文定義 zepto = {} // 上文定義 zepto.matches = function(element, selector) { /* 判斷elem是否符合selector的要求 */ } // 上文定義 zepto.fragment = function(html, name, properties) { /* 通過html字符串獲取文檔碎片 */ } // `$.zepto.Z` swaps out the prototype of the given `dom` array // of nodes with `$.fn` and thus supplying all the Zepto functions // to the array. Note that `__proto__` is not supported on Internet // Explorer. This method can be overriden in plugins. zepto.Z = function(dom, selector) { dom = dom || [] // 將 dom 隱式原型強制改為 $.fn // 下文 zepto.Z.prototype = $.fn 因此，dom.__proto__ = $.fn 即 dom.__proto__ = zepto.Z.prototype 可以不較真的認為 zepto.Z 就是一個構造函數（但感覺這么設計，有些蹩腳） dom.__proto__ = $.fn dom.selector = selector || '' return dom } // `$.zepto.isZ` should return `true` if the given object is a Zepto // collection. This method can be overriden in plugins. zepto.isZ = function(object) { // 上文 dom.__proto__ = $.fn // 下文 zepto.Z.prototype = $.fn // 可知：dom.__proto__ === $.fn === zepto.Z.prototype // 因此，zepto對象都符合 object instanceof zepto.Z return object instanceof zepto.Z } // `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and // takes a CSS selector and an optional context (and handles various // special cases). // This method can be overriden in plugins. zepto.init = function(selector, context) { var dom // If nothing given, return an empty Zepto collection if (!selector) return zepto.Z() // Optimize for string selectors else if (typeof selector == 'string') { // 字符串的情況，一般有兩種： // 第一，一段 html 代碼，旨在通過zepto生成dom對象 // 第二，一段查詢字符串，旨在通過zepto查找dom對象 // 將查詢結果存儲到 dom 變量中 selector = selector.trim() // If it's a html fragment, create nodes from it // Note: In both Chrome 21 and Firefox 15, DOM error 12 // is thrown if the fragment doesn't begin with < // 上文定義： // // 取出html代碼中第一個html標簽（或注釋），如取出 <p>123</p><h1>345</h1> 中的 <p> // fragmentRE = /^\s*<(\w+|!)[^>]*>/, if (selector[0] == '<' && fragmentRE.test(selector)) // 第一，RegExp.$1取出來的就是第一個標簽名稱，即正則中 (\w+|!) 對應的內容 // 第二，此時的 context 應該傳入的是css屬性對象（這里會產生歧義，老版的不會傳入 context） dom = zepto.fragment(selector, RegExp.$1, context), selector = null // If there's a context, create a collection on that context first, and select // nodes from there // 如果 selector 不是html字符串標簽，并且 context 有值，則從context中查找 // find 應該是在 $.fn 中定義的，有待解讀？？？ else if (context !== undefined) return $(context).find(selector) // If it's a CSS selector, use it to select nodes. // 除了以上情況，就從整個 document 執行 qsa 的查找 else dom = zepto.qsa(document, selector) } // If a function is given, call it when the DOM is ready // 如果是函數，則dom ready時執行， // ready方法應該在 $.fn 中定義，有待解毒 else if (isFunction(selector)) return $(document).ready(selector) // If a Zepto collection is given, just return it // 傳入的參數本身就已經是 zepto 對象，則直接返回 else if (zepto.isZ(selector)) return selector else { // compact函數：踢出數組中 == null 的元素 // normalize array if an array of nodes is given if (isArray(selector)) dom = compact(selector) // 如果傳入的是object，直接強制塞進一個數組 // Wrap DOM nodes. else if (isObject(selector)) dom = [selector], selector = null // 及時清空 selector 不妨礙下面的判斷 // 從此往下，感覺和上文 selector 是字符串的情況下，重復了 // ？？？？？？？？ // fragmentRE.test 即判斷字符串是否是 html 標簽開頭（即是否是html fragement） // If it's a html fragment, create nodes from it else if (fragmentRE.test(selector)) //此時，context 也是屬性集合，不是容器！！！ //（這里會產生歧義，老版的不會傳入 context） dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null // 及時清空 selector 不妨礙下面的判斷 // If there's a context, create a collection on that context first, and select // nodes from there else if (context !== undefined) return $(context).find(selector) // And last but no least, if it's a CSS selector, use it to select nodes. else dom = zepto.qsa(document, selector) } // 最終，還是通過 zepto.Z 創建了對象 // 這里的 dom，其實就是一個數組 // create a new Zepto collection from the nodes found return zepto.Z(dom, selector) } // `$` will be the base `Zepto` object. When calling this // function just call `$.zepto.init, which makes the implementation // details of selecting nodes and creating Zepto collections // patchable in plugins. $ = function(selector, context){ return zepto.init(selector, context) } // $ 最終被這個匿名函數所返回，并復制給了全局的 Zepto 變量 // 全局的 zepto 變量暴露給了 window，并且可能有一個別名—— $ // 此 $ 非彼 $ // 對于初學者來說，這里肯定非常繞（還不如把這里的 $ 改改名字） function extend(target, source, deep) { // key 在上文已經定義，否則就污染全局變量了 for (key in source) // 深度遞歸，首先必須 deep 參數為 true // 其次，source[key] 必須是數組或者對象，才有必要深度遞歸（否則沒必要） if (deep && (isPlainObject(source[key]) || isArray(source[key]))) { // source[key] 是對象，而 target[key] 不是對象 // 則 target[key] = {} 初始化一下，否則遞歸會出錯的 if (isPlainObject(source[key]) && !isPlainObject(target[key])) target[key] = {} // source[key] 是數組，而 target[key] 不是數組 // 則 target[key] = [] 初始化一下，否則遞歸會出錯的 if (isArray(source[key]) && !isArray(target[key])) target[key] = [] // 執行遞歸 extend(target[key], source[key], deep) } // 不滿足以上條件，說明 source[key] 是一般的值類型，直接賦值給 target 就是了 else if (source[key] !== undefined) target[key] = source[key] } // Copy all but undefined properties from one or more // objects to the `target` object. $.extend = function(target){ // 一般傳入的參數會是： // (targetObj, srcObj1, srcObj2, srcObj1...) // (true, targetObj, srcObj1, srcObj2, srcObj1...) // arguments 是對象數組，slice.call 會返回真正的數組（此處返回從第二項開始） var deep, args = slice.call(arguments, 1) // 第一個參數是boolean，這里會把第二個參數當做 target，其他的作為 source if (typeof target == 'boolean') { deep = target target = args.shift() } // 將所有的 source 添加到 target 中 args.forEach(function(arg){ extend(target, arg, deep) }) return target // 感覺這樣設計是比較好，很好的將業務和底層進行了分離（雖然比較簡單）： // 核心方法再 function extend(...){...} 中定義， // 而 $.extend 方法中做一些外圍的判斷和處理，最終調用 extend 函數去執行 } // `$.zepto.qsa` is Zepto's CSS selector implementation which // uses `document.querySelectorAll` and optimizes for some special cases, like `#id`. // This method can be overriden in plugins. zepto.qsa = function(element, selector){ /* @element: 容器 @selector: 選擇器 */ var found, maybeID = selector[0] == '#', maybeClass = !maybeID && selector[0] == '.', // ID或class形式：返回 selector.slice(1) 即ID或者class的值 // 否則：返回 selector，如通過 tagName 查詢 nameOnly = maybeID || maybeClass ? selector.slice(1) : selector, // Ensure that a 1 char tag name still gets checked // 是否是一個簡單的字符串（可能是一個復雜的選擇器，如 'div#div1 .item[link] .red'） isSimple = simpleSelectorRE.test(nameOnly) // 上文定義： // // 匹配一個包括（字母、數組、下劃線、-）的字符串 // simpleSelectorRE = /^[\w-]*$/, // 以下代碼的基本思路是： // 1. 優先通過 ID 獲取元素； // 2. 然后試圖通過 className 和 tagName 獲取元素 // 3. 最后通過 querySelectorAll 來獲取 return (isDocument(element) && isSimple && maybeID) ? // 這是最簡單的形式：容器是document、選擇器是一個id // 因為 getElementById 只能在 document 上用，所以這里單獨拿出來 ( (found = element.getElementById(nameOnly)) ? [found] : [] ) : (element.nodeType !== 1 && element.nodeType !== 9) ? // 容器不是一般元素，也不是document，直接返回 [] [] : // 將獲取的所有元素集合，都轉換為數組 slice.call( isSimple && !maybeID // isSimple情況下，nameOnly 只可能是 className 或者 tagName // getElementsByClassName 和 getElementsByTagName 可以在 elem 上用，而且比 querySelectorAll 速度快 // 所以，只要elem容器有值，盡量單獨拿出來處理 ? maybeClass ? element.getElementsByClassName(nameOnly) : // If it's simple, it could be a class element.getElementsByTagName(selector) // Or a tag // 最后其他情況，只能通過 querySelectorAll 來處理 : element.querySelectorAll(selector) // Or it's not simple, and we need to query all ) } // 根據 selector 篩選 nodes // 并將 nodes 封裝為 zepto 對象 // $.fn.filter 下文定義 function filtered(nodes, selector) { return selector == null ? $(nodes) : $(nodes).filter(selector) } // 判斷 parent 是否包含 node $.contains = document.documentElement.contains ? // 瀏覽器支持 contains 方法 function(parent, node) { return parent !== node && parent.contains(node) } : // 不支持 contains 方法 function(parent, node) { while (node && (node = node.parentNode)) if (node === parent) return true return false } // 如果 arg 是函數，則改變函數的執行環境和參數 // 如果不是，直接返回 arg // $.fn.html 方法就用到了 function funcArg(context, arg, idx, payload) { return isFunction(arg) ? arg.call(context, idx, payload) : arg } // 設置屬性 function setAttribute(node, name, value) { value == null ? node.removeAttribute(name) : node.setAttribute(name, value) } // 設置或獲取 node 的 className // 考慮 svg ？？？？ // access className property while respecting SVGAnimatedString function className(node, value){ var klass = node.className || '', svg = klass && klass.baseVal !== undefined // 獲取 if (value === undefined) return svg ? klass.baseVal : klass // 設置 svg ? (klass.baseVal = value) : (node.className = value) } // 將字符串變成響應的對象或者值，例如源代碼的注釋： // "true" => true // "false" => false // "null" => null // "42" => 42 // "42.5" => 42.5 // "08" => "08" // JSON => parse if valid // String => self function deserializeValue(value) { try { return value ? // value『有值』的情況： value == "true" || // 如果 value == 'true'，那么這個表達式本身就返回 true ，導致整個函數返回true // value !== 'true' 的情況： ( value == "false" ? false : // "null" => null value == "null" ? null : // "null" => null +value + "" == value ? +value : // 數字："42" => 42 "42.5" => 42.5 （ 但是 '08' 卻不符合這個條件 ） /^[\[\{]/.test(value) ? $.parseJSON(value) : // '[...]' 或者 '{...}' value // 其他 ) // value『無值』的情況： undefined / '' / flase / 0 / null : value } catch(e) { return value } } // 將上文定義的函數，暴露給 $ 對象（其實 $ 是一個 function） $.type = type $.isFunction = isFunction $.isWindow = isWindow $.isArray = isArray $.isPlainObject = isPlainObject $.isEmptyObject = function(obj) { var name for (name in obj) return false return true } $.inArray = function(elem, array, i){ return emptyArray.indexOf.call(array, elem, i) } $.camelCase = camelize $.trim = function(str) { return str == null ? "" : String.prototype.trim.call(str) } // plugin compatibility $.uuid = 0 $.support = { } $.expr = { } // 重新組織 elements 對象（數組、對象或者對象數組），針對每一個元素，都用 callback 進行檢驗 // 檢驗通過后，將元素push進一個新數組，并返回 $.map = function(elements, callback){ var value, values = [], i, key // 數組，或者對象數組 if (likeArray(elements)) for (i = 0; i < elements.length; i++) { // 遍歷，經過 callback 驗證，push到結果中 value = callback(elements[i], i) if (value != null) values.push(value) } // 對象 else for (key in elements) { // 遍歷，經過 callback 驗證，push到結果中 value = callback(elements[key], key) if (value != null) values.push(value) } // 返回數組 // flatten 函數上文定義的，作用：無論 values 是否是數組，都將返回一個正確的數組。例如，傳入 'abc' ，返回 ['abc'] return flatten(values) } // 遍歷 elements 所有元素（數組、對象數組、對象），執行 callback 方法，最終還是返回 elements // 注意1：callback.call(elements[i], i, elements[i]) 函數執行的環境和參數 // 注意2：=== false) return elements 一旦有函數返回 false，即跳出循環，類似 break // 注意3：無論哪種情況，最終返回的還是 elements $.each = function(elements, callback){ var i, key if (likeArray(elements)) { for (i = 0; i < elements.length; i++) if (callback.call(elements[i], i, elements[i]) === false) return elements } else { for (key in elements) if (callback.call(elements[key], key, elements[key]) === false) return elements } return elements } // 上文定義：filter = emptyArray.filter // 篩選數組 $.grep = function(elements, callback){ return filter.call(elements, callback) } if (window.JSON) $.parseJSON = JSON.parse // Populate the class2type map $.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { class2type[ "[object " + name + "]" ] = name.toLowerCase() /* 上文將 class2type 賦值為 {} 最終將 class2type 賦值為： { '[object boolean]': 'boolean', '[object number]': 'number', '[object string]': 'string', ... } 存儲這個數據是為了方便的獲取一些對象的類型， 例如 Object.prototype.toString.call([]) 返回的是 '[Object Array]' 那么即可根據這個獲取 [] 的類型是 'array' */ }) // Define methods that will be available on all // Zepto collections $.fn = { // 為何要這么多數組的方法？ // 因為一個 zepto 對象，本身就是一個數組 // Because a collection acts like an array // copy over these useful array functions. forEach: emptyArray.forEach, reduce: emptyArray.reduce, // 方法何用？？？？ push: emptyArray.push, sort: emptyArray.sort, indexOf: emptyArray.indexOf, concat: emptyArray.concat, // `map` and `slice` in the jQuery API work differently // from their array counterparts map: function(fn){ // $.map 上文定義的， $.map = function (elements, callback) {....} // $.map 作用：針對 elements（對象、對象數組或數組），對每個元素都經過 callback 函數的過濾，并將過濾通過的元素，push到一個新數組中，返回新數組 // 最后，用 $ 封裝返回 return $( // $.map 返回的是一個數組 $.map(this, // 針對每一個元素，都執行傳入的函數，如果函數返回的 !=null 就將插入到新返回的數組 function(el, i){ return fn.call(el, i, el) } ) ) /* $('div').map(function(key, value){ return value.id; // 或者 return this.id; }) 這個結果就是 $(['div1', 'div2' ...]) */ }, slice: function(){ // 直接數組的slice方法，并將結果用 $ 封裝返回 return $(slice.apply(this, arguments)) }, // 在 zepto.init 函數中，當傳入的函數是函數時，就用到了 ready // else if (isFunction(selector)) return $(document).ready(selector) ready: function(callback){ // need to check if document.body exists for IE as that browser reports // document ready when it hasn't yet created the body element // 下文定義：readyRE = /complete|loaded|interactive/, if (readyRE.test(document.readyState) && document.body) callback($) else document.addEventListener('DOMContentLoaded', function(){ callback($) }, false) // 返回當前對象 return this }, get: function(idx){ return idx === undefined ? slice.call(this) : // 未傳參數，直接返回一整個數組 // 有參數，則試圖返回單個元素（大于0，小于0 兩種情況） this[ idx >= 0 ? idx : idx + this.length ] }, // 將zepto集合變為純數組 toArray: function(){ return this.get() }, size: function(){ return this.length }, // 將元素從這個DOM樹中移除 remove: function(){ return this.each(function(){ if (this.parentNode != null) this.parentNode.removeChild(this) }) }, each: function(callback){ // [].every ES5中Array的新特性。循環數組每個元素，返回是否符合callback函數的要求 // every 函數返回的是 false 或者 true（不過這里返回什么無所謂，執行就可以了） emptyArray.every.call(this, function(el, idx){ return callback.call(el, idx, el) !== false }) // 最后返回本身對象 return this }, filter: function(selector){ // not函數下文定義 // 如果給not傳入的參數是函數，則返回不符合這個函數規則的元素的數組（用 $ 封裝） if (isFunction(selector)) return this.not(this.not(selector)) // 上文定義：zepto.matches 判斷elements是否符合 selector 的要求 // zepto.matches = function(element, selector) {...} return $(filter.call(this, function(element){ // 利用 [].filter 方法做篩選，利用 zepto.matches 做判斷 return zepto.matches(element, selector) })) }, // $('div') 可能只有三個 div 節點，那么 $('div').add('p') 再三個 div 節點的基礎上，增加三個 p 節點 add: function(selector,context){ // uniq函數——數組去重，例如：用來將 [1,1,2,2,3,3] 替換為 [1,2,3] return $(uniq(this.concat($(selector,context)))) }, is: function(selector){ // 注意：這里只對 this[0] 第一個元素做判斷了，其他的元素不管了 return this.length > 0 && zepto.matches(this[0], selector) }, not: function(selector){ var nodes=[] // 存儲最后返回的結果 // 如果參數是函數 if (isFunction(selector) && selector.call !== undefined) this.each(function(idx){ // 遍歷對象的所有元素，對每個元素都執行傳入的函數 // 當函數返回 false 時（即不符合函數的規則），則將當前元素push到結果中，等待返回 if (!selector.call(this,idx)) nodes.push(this) }) // 如果參數不是函數 else { // 為 excludes 賦值 var excludes = // 如果 selector 是字符串（css選擇器），則用filter過濾，將結果存儲到 excludes 中 typeof selector == 'string' ? this.filter(selector) : // 如果 selector 不是字符串 // 如果是數組或者對象數組（并且 selector.item 是函數？？？），則生成數組，賦值給 excludes (likeArray(selector) && isFunction(selector.item)) ? slice.call(selector) // 否則直接生成 zepto 對象，賦值給 excludes : $(selector) // 至此，excludes 中就存儲了通過 selector 查找出來的元素 // [].forEach 是ES5的新特性 this.forEach(function(el){ // 取出 excludes 中不包含的元素，push到結果中 if (excludes.indexOf(el) < 0) nodes.push(el) }) } // 返回最后的結果，用 $ 封裝 return $(nodes) }, has: function(selector){ // 經過 filter 函數處理，返回的是一個處理后的值 return this.filter(function(){ return isObject(selector) ? // 如果 seletor 是 object（可能是elem節點），則用 $.contains 判斷 $.contains(this, selector) : // 否則（selector是css選擇字符串）則返回find后的size（如果 size === 0 即相當于返回 false） $(this).find(selector).size() // $.fn.find 在下文定義 }) }, eq: function(idx){ // 取出指定index的元素 // 可支持 -1、0、1、2 …… return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1) }, first: function(){ var el = this[0] // 不是 object 則直接返回 // 是 object 類型，則用 $ 封裝 （因為時刻都要支持鏈式操作！！！） return el && !isObject(el) ? el : $(el) }, last: function(){ var el = this[this.length - 1] return el && !isObject(el) ? el : $(el) }, find: function(selector){ // result 存儲返回結果 var result, $this = this // 如果沒有參數，就返回一個空的 zepto 對象 if (!selector) result = $() // 如果selector是對象 else if (typeof selector == 'object') result = $(selector).filter(function(){ var node = this return emptyArray.some.call($this, function(parent){ return $.contains(parent, node) }) }) // 如果 selector 不是對象（即是css選擇器）： // 如果只有一個元素，則使用 qsa 判斷，結果經過 $ 封裝后賦值給 result else if (this.length == 1) result = $(zepto.qsa(this[0], selector)) // 如果有多個元素，則使用 map 遍歷所有元素，使用 qsa 針對每個元素判斷，符合條件即返回（map將返回包含符合條件的元素的新數組，并 $ 封裝，支持鏈式操作！！） else result = this.map(function(){ return zepto.qsa(this, selector) }) // 返回最終結果 return result }, // 從元素本身開始，逐級向上級元素匹配，并返回最先匹配selector的元素 closest: function(selector, context){ var node = this[0], collection = false // 如果 selector 是對象，則用 $ 封裝后，賦值給 collection if (typeof selector == 'object') collection = $(selector) while ( // while循環的判斷條件： // 第一，node有值（node一開始被賦值為對象的第一個元素） // 第二，collection有值（傳入的selector是對象）則collection包含node；collection無值（傳入的selector是字符串，css選擇），則node滿足selector條件 // 滿足第一個條件，不滿足第二條件，則循環繼續（node試圖賦值為node.parentNode）；否則，循環跳出（說明已經找到了符合條件的父節點） node && !( collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector) ) ) // node賦值成 node.parentNode // 前提條件是：node != context && node 不是 document，如果是這兩個條件之一，那就不繼續賦值 node = node !== context && !isDocument(node) && node.parentNode // 返回最終結果 return $(node) }, // 獲取對象集合每個元素所有的祖先元素。 $('h1').parents() => [<div#container>, <body>, <html>] parents: function(selector){ var ancestors = [], nodes = this while (nodes.length > 0) // 可能需要執行多次 while 循環 // 每次執行 $.map 函數都會對 nodes 重新賦值，然后再判斷是否需要繼續循環 // 因為要獲取每個元素的所有祖先元素，所以要多次循環 nodes = $.map(nodes, function(node){ // 使用 $.map（返回符合條件的元素的新數組，并用 $ 封裝）遍歷所有元素 if ((node = node.parentNode) && !isDocument(node) && ancestors.indexOf(node) < 0) { // 將符合條件的元素push到結果中 // 條件：不能是 document，結果中元素不能重復。否則不執行push ancestors.push(node) // 返回的 node ，將拼接出新數組，重新復制給 nodes，然后試圖繼續執行 while 循環 return node } }) // 如果css選擇器參數給出，過濾出符合條件的元素 return filtered(ancestors, selector) }, // 獲取對象集合中每個元素的直接父元素。如果css選擇器參數給出。過濾出符合條件的元素。 parent: function(selector){ // pluck 函數在下文定義 // parent 函數，只獲取第一級父節點即可 return filtered(uniq(this.pluck('parentNode')), selector) }, // 獲得每個匹配元素集合元素的直接子元素，可通過 selector 過濾 children: function(selector){ return filtered( this.map(function(){ return children(this) }), selector ) }, // 獲得每個匹配元素集合元素的子元素，包括文字和注釋節點 contents: function() { return this.map(function() { return slice.call(this.childNodes) }) }, // 獲取對象集合中所有元素的兄弟節點，可通過 selector 過濾 siblings: function(selector){ return filtered(this.map(function(i, el){ // 獲取兄弟節點 return filter.call(children(el.parentNode), function(child){ return child!==el }) }), selector) }, empty: function(){ return this.each(function(){ this.innerHTML = '' }) }, // `pluck` is borrowed from Prototype.js pluck: function(property){ // 獲取自定義屬性，返回值，拼接數組 return $.map(this, function(el){ return el[property] }) }, show: function(){ // 返回當前對象，保證可鏈式操作 return this.each(function(){ // 第一步，針對內聯樣式，將 none 改為空字符串，如 <p id="p2" style="display:none;">p2</p> this.style.display == "none" && (this.style.display = '') // 第二步，針對css樣式，如果是 none 則修改為默認的顯示樣式 if (getComputedStyle(this, '').getPropertyValue("display") == "none") this.style.display = defaultDisplay(this.nodeName) // show 方法是為了顯示對象，而對象隱藏的方式有兩種：內聯樣式 或 css樣式 // this.style.display 只能獲取內聯樣式的值（獲取屬性值） // getComputedStyle(this, '').getPropertyValue("display") 可以獲取內聯、css樣式的值（獲取 renderTree 的值） // 因此，這兩步都要做判斷， }) }, replaceWith: function(newContent){ // 先在前面插入，然后將當前對象移除 return this.before(newContent).remove() }, wrap: function(structure){ // 是否是函數 var func = isFunction(structure) if (this[0] && !func) var dom = $(structure).get(0), // 何時用 clone ？ // 第一，dom.parentNode 說明 dom 在文檔結構中，不 clone 就會被移動 // 第二，this.length > 1 說明當前對象有多個元素，每個元素都要添加，所有要clone clone = dom.parentNode || this.length > 1 return this.each(function(index){ // 借用 wrapAll 方法來做包裝 $(this).wrapAll( func ? structure.call(this, index) : clone ? dom.cloneNode(true) : dom ) }) }, // 在所有匹配元素外面包一個單獨的結構 wrapAll: function(structure){ if (this[0]) { // 先將 structure 插入到文檔結構 $(this[0]).before(structure = $(structure)) var children // drill down to the inmost element // 通過循環，將 structure 重新賦值為當前 structure 的最深處的一個子元素 while ((children = structure.children()).length) structure = children.first() // 將所有子元素都包裹進 structure $(structure).append(this) } // 返回當前對象 return this }, wrapInner: function(structure){ // 是否是函數 var func = isFunction(structure) // 返回對象自身，保證鏈式操作 return this.each(function(index){ var self = $(this), contents = self.contents(), // 是函數，即獲取函數執行的返回結果；否則直接用 structure 參數 dom = func ? structure.call(this, index) : structure // 如果當前元素有內容，則通過內容 wrapAll。無內容，則直接用自身的 append 增加 contents.length ? contents.wrapAll(dom) : self.append(dom) }) }, unwrap: function(){ // 通過 this.parent() 獲取每個元素的父節點（集合） // 遍歷這個父節點的集合 this.parent().each(function(){ // 將當前父節點替換為它的子節點 $(this).replaceWith($(this).children()) }) // 返回對象自身，保證鏈式操作 return this }, clone: function(){ // 通過 this.map 循環對象， // 針對每個元素都返回它的clone 這個 this 和前面的 this 不一樣 // 返回新數組（用 $ 封裝） return this.map(function(){ return this.cloneNode(true) }) }, hide: function(){ return this.css("display", "none") }, // 切換顯示和隱藏 toggle: function(setting){ /* @setting true : 強制切換為 show false : 強制切換為 hide */ return this.each(function(){ var el = $(this) // 條件判斷： // 如果 setting === undefined 則看 el.css("display") == "none" // 如果 setting !== undefined 則看 !!setting ;(setting === undefined ? el.css("display") == "none" : setting) ? el.show() : // 如果 true 則顯示 el.hide() // 如果 false 則隱藏 }) }, // 借助 previousElementSibling 屬性 prev: function(selector){ return $(this.pluck('previousElementSibling')).filter(selector || '*') }, // 借助 nextElementSibling 屬性 next: function(selector){ return $(this.pluck('nextElementSibling')).filter(selector || '*') }, html: function(html){ return // 情況1：有參數，賦值，并返回自身 0 in arguments ? this.each(function(idx){ var originHtml = this.innerHTML // 傳入的 html 參數允許是一個字符串，也允許是一個函數 // 通過 funcArg 函數： // 1.如果 html 是字符串，則返回html // 2.如果 html 是函數，則執行執行函數（傳入 idx、originHtml），返回函數執行結果 $(this).empty().append( funcArg(this, html, idx, originHtml) ) }) : /* 插播： function funcArg(context, arg, idx, payload) { return isFunction(arg) ? arg.call(context, idx, payload) : arg } */ // 情況2：無參數，取值 (0 in this ? this[0].innerHTML : // 直接取第一個元素的 innerHTML null ) }, text: function(text){ return // 情況1：有參數，賦值，并返回自身 0 in arguments ? this.each(function(idx){ // funcArg的應用，和html方法中一樣 var newText = funcArg(this, text, idx, this.textContent) this.textContent = newText == null ? '' : ''+newText }) : // 情況2：無參數，取值 (0 in this ? this[0].textContent : null) // 直接借用 textContent 屬性 }, attr: function(name, value){ var result return // 情況1：無第二個參數，讀取值（讀取值只能讀取第一個元素的值） (typeof name == 'string' && !(1 in arguments)) ? (!this.length || this[0].nodeType !== 1 ? undefined : /* 注釋： this[0]是一個DOM節點，有『屬性』也有『特性』 result = this[0].getAttribute(name) 試圖獲取 DOM節點屬性 name in this[0] 判斷是不是js對象的屬性 然后，該返回哪一個就返回哪一個 */ (!(result = this[0].getAttribute(name)) && name in this[0]) ? this[0][name] : result ) : // 情況2：有第二個參數，設置值（針對每個元素設置值） this.each(function(idx){ if (this.nodeType !== 1) return // 傳入的參數可能是一個對象集合 // 此時，是不是應該放在『情況1』當中？？？此時，value根本沒有用啊？？？ if (isObject(name)) for (key in name) setAttribute(this, key, name[key]) // 傳入的不是對象，即設置一個單一的屬性。 // 但是，這里的 value 參數可以是一個函數 // funcArg 即處理了 value 是函數和非函數的兩種情況 else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name))) }) }, removeAttr: function(name){ return this.each( function(){ this.nodeType === 1 && name.split(' ').forEach( function(attribute){ setAttribute(this, attribute) // 將屬性設置為空，setAttribute會移除屬性 }, this // 改參數將成為 forEach 中函數的this ) } ) }, // 讀取、設置屬性（js對象的屬性） prop: function(name, value){ // propMap 中存儲的：key是html中的屬性名稱，value是js對象中的屬性名稱 // 例如，html中的 "class" 在DOM對象中，就需要使用 "className" 這個名字讀取，同理于：for maxlength cellspacing 等等 name = propMap[name] || name /* 上文定義： propMap = { 'tabindex': 'tabIndex', 'readonly': 'readOnly', 'for': 'htmlFor', 'class': 'className', 'maxlength': 'maxLength', 'cellspacing': 'cellSpacing', 'cellpadding': 'cellPadding', 'rowspan': 'rowSpan', 'colspan': 'colSpan', 'usemap': 'useMap', 'frameborder': 'frameBorder', 'contenteditable': 'contentEditable' } */ return // 有第二個參數，設置屬性 (1 in arguments) ? this.each(function(idx){ // 設置屬性值，funcArg處理函數或者非函數 this[name] = funcArg(this, value, idx, this[name]) }) : // 無第二個參數，讀取屬性（讀取第一個元素的） (this[0] && this[0][name]) }, // 前面加上 'data-' 通過 attr 設置或者讀取 data: function(name, value){ /* 上文定義： capitalRE = /([A-Z])/g, //大寫字母 */ // 前面加上 'data-' 將 'A' 替換為 '-a' var attrName = 'data-' + name.replace(capitalRE, '-$1').toLowerCase() var data = (1 in arguments) ? this.attr(attrName, value) : this.attr(attrName) return data !== null ? deserializeValue(data) : undefined /* 上文定義的，deserializeValue 函數的作用是： // 將字符串變成響應的對象或者值，例如源代碼的注釋： // "true" => true // "false" => false // "null" => null // "42" => 42 // "42.5" => 42.5 // "08" => "08" // JSON => parse if valid // String => self */ }, val: function(value){ return // 有參數，設置值 0 in arguments ? this.each(function(idx){ // 遍歷每個元素，直接對 value 屬性賦值 this.value = funcArg(this, value, idx, this.value) }) : // 無參數，讀取值 (this[0] && ( // 如果元素是 <select multiple> 多選列表 this[0].multiple ? // 返回所有選中的option的值的數組 $(this[0]).find('option').filter(function(){ return this.selected }).pluck('value') : /* 上文定義： pluck: function(property){ return $.map(this, function(el){ return el[property] }) }, */ // 如果不是，直接獲取 value this[0].value ) ) }, // 獲取、設置元素的 offset offset: function(coordinates){ // 如果有 coordinates 參數，設置坐標值，并返回當前對象 if (coordinates) return this.each(function(index){ var $this = $(this), // 支持函數（傳入 $this.offset() 做參數）和非函數 coords = funcArg(this, coordinates, index, $this.offset()), // 找到最近的 “relative”, “absolute” or “fixed” 的祖先元素，并獲取它的 offset() parentOffset = $this.offsetParent().offset(), // left 和 top 需要去掉定位的祖先元素的 left、top 值 props = { top: coords.top - parentOffset.top, left: coords.left - parentOffset.left } // static時，設置 top、left是無效的 if ($this.css('position') == 'static') props['position'] = 'relative' // 通過 css 賦值 $this.css(props) }) // 當前對象是空，則返回 null if (!this.length) return null // 如果沒有 coordinates 參數，則返回第一個元素的坐標值 var obj = this[0].getBoundingClientRect() /* elem.getBoundingClientRect() 返回一個對象， 包含元素的 top bottom left right width height 的值 但是這個 top、bottom、left、right 是相對于瀏覽器窗口的距離，而不是頁面的邊界 （注意，elem.getBoundingClientRect()在IE低版本瀏覽器有2px的兼容問題） window.pageXOffset 和 window.pageYOffset 可獲取網頁滾動的距離， IE低版本需要用 document.body.scrollLeft 和 document.body.scrollTop 兼容 */ return { left: obj.left + window.pageXOffset, top: obj.top + window.pageYOffset, width: Math.round(obj.width), height: Math.round(obj.height) } }, // 設置、獲取 css css: function(property, value){ // 只有一個參數，獲取第一個元素的樣式 if (arguments.length < 2) { var computedStyle, element = this[0] if(!element) return // 如果第一個元素無值，直接返回。否則繼續 // 獲取元素的計算后的樣式 computedStyle = getComputedStyle(element, '') if (typeof property == 'string') // 情況1，參數為字符串形式 // 先從elem內聯樣式獲取（element.style），此時需要 camelize(property) 轉換，如將 background-color 變為 backgroundColor // 如果未找到，則從css樣式獲取 computedStyle.getPropertyValue(property) // （重要）注釋：elem.style 只能獲取元素設置的內聯樣式、不能獲取css樣式；而 getComputedStyle 可獲取內聯、css樣式。 return element.style[camelize(property)] || computedStyle.getPropertyValue(property) else if (isArray(property)) { // 情況2，參數為數組形式（注意，此時 isObject 情況尚未判斷） var props = {} $.each(property, function(_, prop){ props[prop] = (element.style[camelize(prop)] || computedStyle.getPropertyValue(prop)) }) return props // 返回一個對象 } } // 其他情況：有兩個參數、property是對象 var css = '' if (type(property) == 'string') { // 情況1，property 是字符串，設置單個樣式 if (!value && value !== 0) // 如果value參數是 '' null undefined 則移除這個css樣式 // 注：此計算只適用于內聯樣式的刪除，對 css 樣式無效，因為它只通過 this.style.removeProperty 計算，而 this.style 獲取不到css樣式 this.each(function(){ this.style.removeProperty(dasherize(property)) }) else // value有正常值，將 css 生成一個字符串（如 'font-size:20px'）等待賦值給內聯樣式 // maybeAddPx(property, value) 需要增加 px 的增加上 css = dasherize(property) + ":" + maybeAddPx(property, value) } else { // 情況2，property 是對象（此時就不管第二個參數是什么了，不用第二個參數），一次性設置多個樣式 for (key in property) if (!property[key] && property[key] !== 0) // 如果對象屬性值是 '' null undefined 則移除這個css樣式，同理，只針對內聯樣式 this.each(function(){ this.style.removeProperty(dasherize(key)) }) else // 否則，給 css 賦值一個字符串，多樣式屬性用 ; 隔開 css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';' } // 針對每個元素，設置內聯樣式（this.style.cssText可獲取、設置內聯樣式） // 最后返回自身 return this.each(function(){ this.style.cssText += ';' + css }) /* 上文定義： // 將 lineHeight 轉換為 line-height 格式 function dasherize(str) { return str.replace(/::/g, '/') .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') .replace(/([a-z\d])([A-Z])/g, '$1_$2') .replace(/_/g, '-') .toLowerCase() } */ }, // 獲取一個元素的索引值（從0開始計數）。當elemen參數沒有給出時，返回當前元素在兄弟節點中的位置 index: function(element){ /* 上文定義： $.fn.indexOf: emptyArray.indexOf */ // 其實 this 本身就是一個數組，數組本身就有 indexOf ，為何還要上文的這個賦值呢？ // 因為上文中，this.__proto__ 修改了，不是 Array.prototype 了，也就沒有 indexOf 方法了 // 因此要手動賦值，需要將數組常用的方法在重新賦值給 $.fn.indexOf return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0]) }, hasClass: function(name){ if (!name) return false return emptyArray.some.call(this, function(el){ // this 就是 classRE(name) 的返回值（返回一個正則） // function className(node, value){...} 獲取或者設置elem的className return this.test(className(el)) }, classRE(name)) // array.some(callback,[ thisObject]); 只要數組中一項符合callback要求，即返回true /* // 上文定義 classCache = {} function classRE(name) { return name in classCache ? classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)')) // classCache 存儲的數據是這樣的： // { // abc: /(^|\s)abc(\s|$)/, // 能匹配 'abc' 或 ' abc ' 或 ' abc' 或 'abc ' // xyz: /(^|\s)abc(\s|$)/, // ... // } } */ }, addClass: function(name){ if (!name) return this // 針對所有元素都添加className，最終返回本身 return this.each(function(idx){ // 說明當前元素不是 DOM node if (!('className' in this)) return // classList 是一開始就定義的空變量 classList = [] // 獲取元素的 clasname // 支持傳入函數 var cls = className(this), newName = funcArg(this, name, idx, cls) // 把要賦值的值，按照空白分組，遍歷 newName.split(/\s+/g).forEach(function(klass){ // 把當前元素不存在的class，push到classlist中 if (!$(this).hasClass(klass)) classList.push(klass) }, this) // 如果classlist有數據，則為當前元素賦值最新的class值（現有的classname和新的classname拼接） classList.length && className(this, cls + (cls ? " " : "") + classList.join(" ")) }) }, removeClass: function(name){ // 針對所有元素都移除className，最終返回本身 return this.each(function(idx){ // 說明當前元素不是 DOM node if (!('className' in this)) return // 如果參數空，則移除元素的所有class if (name === undefined) return className(this, '') // 獲取現有的classname classList = className(this) // （可以傳入函數）遍歷新的classname字符串 funcArg(this, name, idx, classList).split(/\s+/g).forEach(function(klass){ // classRE(klass) 返回一個正則，匹配 'classname' 或 ' classname ' 或 ' classname' 或 'classname ' // 針對傳入的classname字符串，對每個符合條件的classname，都替換為 ' '（即刪除了） classList = classList.replace(classRE(klass), " ") }) // 對整理好的classname，重新賦值給當前元素 className(this, classList.trim()) }) }, toggleClass: function(name, when){ // when 參數相當于一個條件： // 如果 when === true 則單純執行 addClass // 如果 when === false 則單純執行 removeClass if (!name) return this return this.each(function(idx){ // name 可接收函數，可以是空白分割開來的多個classname var $this = $(this), names = funcArg(this, name, idx, className(this)) // 用空白分割開多個class names.split(/\s+/g).forEach(function(klass){ // 如果有 when 參數，則只通過when參數判斷，true則只執行addClass，false則只執行removeClass // 如果沒有 when 參數，則判斷元素有沒有該class，有則移除，沒有則添加 (when === undefined ? !$this.hasClass(klass) : when) ? $this.addClass(klass) : $this.removeClass(klass) }) }) }, scrollTop: function(value){ if (!this.length) return // 普通elem有 scrollTop 屬性，可以獲取或者設置top值 // window對象沒有 scrollTop 屬性，通過 pageYOffset 獲取，通過 scrollTo() 賦值 var hasScrollTop = 'scrollTop' in this[0] // value 無值，獲取 top if (value === undefined) return hasScrollTop ? this[0].scrollTop : this[0].pageYOffset // value 有值，設置 top return this.each(hasScrollTop ? function(){ this.scrollTop = value } : function(){ this.scrollTo(this.scrollX, value) }) // window.scrollX 獲取橫向滾動值 }, scrollLeft: function(value){ if (!this.length) return var hasScrollLeft = 'scrollLeft' in this[0] if (value === undefined) return hasScrollLeft ? this[0].scrollLeft : this[0].pageXOffset return this.each(hasScrollLeft ? function(){ this.scrollLeft = value } : function(){ this.scrollTo(value, this.scrollY) }) // window.scrollX 獲取縱向滾動值 }, position: function() { if (!this.length) return var elem = this[0], // Get *real* offsetParent offsetParent = this.offsetParent(), // 找到第一個定位過的祖先元素 “relative”, “absolute” or “fixed” // Get correct offsets offset = this.offset(), // 獲取自身的offset parentOffset = rootNodeRE.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset() // 獲取定位祖先元素的offset（ body、html直接設置 top:0;left:0 ） // 上文定義： rootNodeRE = /^(?:body|html)$/i, // 去掉當前元素的 margin 寬度 // Subtract element margins // note: when an element has margin: auto the offsetLeft and marginLeft // are the same in Safari causing offset.left to incorrectly be 0 offset.top -= parseFloat( $(elem).css('margin-top') ) || 0 offset.left -= parseFloat( $(elem).css('margin-left') ) || 0 // 增加父元素的 border 寬度 // Add offsetParent borders parentOffset.top += parseFloat( $(offsetParent[0]).css('border-top-width') ) || 0 parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0 // Subtract the two offsets return { top: offset.top - parentOffset.top, left: offset.left - parentOffset.left } }, offsetParent: function() { // 通過 this.map 遍歷當前對象所有元素，進行計算，然后拼接新的數組，并返回。保證鏈式操作 return this.map(function(){ var parent = this.offsetParent || document.body // elem.offsetParent 可返回最近的改元素最近的已經定位的父元素 while (parent && !rootNodeRE.test(parent.nodeName) && $(parent).css("position") == "static") // 如果獲取的parent不是null、不是body或html、而且position==static // 則繼續向上查找 offsetParent、大不了找到 body 為止 parent = parent.offsetParent // 最后返回改元素 return parent }) } } // for now $.fn.detach = $.fn.remove // Generate the `width` and `height` functions ;['width', 'height'].forEach(function(dimension){ // 將 width height 變為 Width Height var dimensionProperty = dimension.replace(/./, function(m){ return m[0].toUpperCase() }) $.fn[dimension] = function(value){ var offset, el = this[0] // 情況1，無參數，獲取第一個元素的值 if (value === undefined) return isWindow(el) ? el['inner' + dimensionProperty] : // window.innerHeight isDocument(el) ? el.documentElement['scroll' + dimensionProperty] : // document.documentElement.scrollHeight (offset = this.offset()) && offset[dimension] // this.offset().width // 情況2，有參數，設置所有元素的值 else return this.each(function(idx){ el = $(this) // 通過 css() 方法設置，支持傳入函數 el.css(dimension, funcArg(this, value, idx, el[dimension]())) }) } }) // 針對當前元素、遍歷子元素，都執行 fun 函數 function traverseNode(node, fun) { fun(node) for (var i = 0, len = node.childNodes.length; i < len; i++) traverseNode(node.childNodes[i], fun) } // 上文定義 adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ], // Generate the `after`, `prepend`, `before`, `append`, // `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods. adjacencyOperators.forEach(function(operator, operatorIndex) { var inside = operatorIndex % 2 //=> prepend, append $.fn[operator] = function(){ // arguments can be nodes, arrays of nodes, Zepto objects and HTML strings var argType, nodes = $.map(arguments, function(arg) { argType = type(arg) return argType == "object" || argType == "array" || arg == null ? arg : zepto.fragment(arg) }), parent, copyByClone = this.length > 1 if (nodes.length < 1) return this return this.each(function(_, target){ parent = inside ? target : target.parentNode // convert all methods to a "before" operation target = operatorIndex == 0 ? target.nextSibling : operatorIndex == 1 ? target.firstChild : operatorIndex == 2 ? target : null var parentInDocument = $.contains(document.documentElement, parent) nodes.forEach(function(node){ if (copyByClone) node = node.cloneNode(true) else if (!parent) return $(node).remove() parent.insertBefore(node, target) if (parentInDocument) traverseNode(node, function(el){ if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' && (!el.type || el.type === 'text/javascript') && !el.src) window['eval'].call(window, el.innerHTML) }) }) }) } // after => insertAfter // prepend => prependTo // before => insertBefore // append => appendTo $.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){ $(html)[operator](this) return this } }) zepto.Z.prototype = $.fn // Export internal API functions in the `$.zepto` namespace zepto.uniq = uniq zepto.deserializeValue = deserializeValue $.zepto = zepto return $ })() window.Zepto = Zepto window.$ === undefined && (window.$ = Zepto) ~~~