jQuery 的各種功能彼此高度耦合,很難只抽出一塊來單獨理解。這篇文章分享讀 jQuery 源碼的心得,以及一套實際可行的閱讀方法。啃程式碼這件事沒有捷徑,但有章法之後效率會差很多。
請務必用支援語法折疊的編輯器開啟源碼。從折疊層次一眼就能看出,整份 jQuery 其實都包在一個函式裡:
(function( window, undefined ) {
// jQuery 代碼
})(window);
這樣做有兩個好處:避免內部物件污染全域;把 window 與 undefined 當參數傳入,則是為了加快這兩個物件的搜尋速度——同時也順便解決了「舊環境下 undefined 可能被改寫」的隱患。
展開第一層後,可以發現 jQuery 是按這個順序組織的:
這個順序不是隨意的:下面的模組可以用上面的,上面的模組不需要下面的。理解這條依賴鏈,就掌握了閱讀的先後次序。
整段的骨架大致如下:
var jQuery = (function() {
// 創建 jQuery 對象
var jQuery = function( selector, context ) {
// 略
};
// 創建 jQuery.fn 對象
jQuery.fn = jQuery.prototype = {
// 略
};
// 聲明 jQuery.extend
jQuery.extend = jQuery.fn.extend = function() {
// 略
};
// 使用 jQuery.extend 擴展自己
jQuery.extend({
// 略
});
// 浏覽器方面的一些瑣碎
// 略
// 定義全局對象
return (window.jQuery = window.$ = jQuery);
})();
第一個結論就出來了:我們平常用的 $,其實只是 jQuery 函式的別名。
var jQuery = function( selector, context ) {
// 實際上 jQuery 對象是 jQuery.fn.init 返回的。
return new jQuery.fn.init( selector, context, rootjQuery );
}
也就是說,想知道 jQuery 到底是什麼,就必須去看 jQuery.fn.init。這同時解釋了為什麼寫程式時不需要 new jQuery。
再看 29 - 97 行,都是變數宣告,供後續函式使用。提前提取變數有兩個好處:正則表達式不必重複編譯,壓縮後的結果也更小。
fn 就是 jQuery.prototype,這正是「jQuery.fn 是擴充 jQuery 物件的唯一途徑」的原因。
你可能會疑惑:jQuery 回傳的是 new jQuery.fn.init,那原型應該是 jQuery.fn.init.prototype 才對,怎麼會是 jQuery.prototype?答案很乾脆——第 322 行明確寫著 jQuery.fn.init.prototype === jQuery.prototype。
把關係整理清楚:
jQuery.fn.init 的實例。jQuery.fn === jQuery.prototype === jQuery.fn.init.prototype。jQuery.fn 下的主要成員:
init — 初始化(後述)constructor — 手動指定建構函式,預設是 jQuery.fn.initlength — 讓這個物件更接近原生陣列size — 回傳 lengthtoArray — 透過 Array.prototype.slice 轉成真陣列get — 即 this[num],另外處理了索引參數的邊界pushStack — 推入一個元素堆疊ready — 瀏覽器就緒後執行(後述)end — 透過 prevObject 退回上一層each — 例遍,可參考 https://www.cnblogs.com/Fooo/archive/2011/01/11/1932900.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/21/1607632.html這就是俗稱的 $ 函式。平常寫的 $("#id"),等同於 new jQuery.fn.init("#id")。
函式很長,但分支覆蓋率其實不高:
init: function( selector, context, rootjQuery ) {
// 參數: selector 選擇器
// context 上下文
// rootjQuery 父節點
// 處理 $("")、 $(null) 和 $(undefined)
if ( !selector ) {
return this;
}
// 處理 $(DOMElement)
if ( selector.nodeType ) {
// 直接扔數組中, 就搞定了。
this.context = this[0] = selector;
this.length = 1;
return this;
}
// 處理 $("body") body 元素只存在一次,單獨找它
if ( selector === "body" && !context && document.body ) {
// 同樣扔數組中, 順便把 selector 更新更新。
this.context = document;
this[0] = document.body;
thisis.selector = "body";
this.length = 1;
return this;
}
// 處理 $(HTML 代碼 或者是 css 選擇器)
if ( typeof selector === "string" ) {
// 略
// 處理 $(函數)
} else if ( jQuery.isFunction( selector ) ) {
// 如果是函數,則執行 $(document).ready , 這樣 $(document).ready(func) 簡為 $(func)
return rootjQuery.ready( selector );
}
// 略。
// 如果傳入的是一個 Dom列表 ( getElementsByTagName 結果 ) 則轉為 jQuery 數組。
return jQuery.makeArray( selector, this );
}
接著是「略」掉的那段字串處理:
// 這部分代碼是 上段中 略 的 也就是說是 jQuery(字符串) 處理。
// 檢查是否字符串是常用選擇器 (/^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/)
match = quickExpr.exec( selector );
// 檢查是否正確匹配
if ( match && (match[1] || !context) ) {
// 處理: $(html) -> $(array)
if ( match[1] ) {
// 獲取正文,默認 document
context = context instanceof jQuery ? context[0] : context;
doc = (context ? context.ownerDocument || context : document);
// 如果傳入簡單的 "<標簽>", ( /^<(\w+)\s*\/?>(?:<\/\1>)?$/)
ret = rsingleTag.exec( selector );
// 返回 createElement("tag")
return jQuery.merge( this, selector );
// 處理: $("#id")
} else {
elem = document.getElementById( match[2] );
// 因為有的浏覽器 getElementById 不只返回 id匹配的,所以做檢查。
return this;
}
// 處理 $("標簽")
} else if ( !context && !rnonword.test( selector ) ) {
this.selector = selector;
this.context = document;
selector = document.getElementsByTagName( selector );
return jQuery.merge( this, selector );
//處理: $(選擇器, $(...))
} else if ( !context || context.jquery ) {
return (context || rootjQuery).find( selector );
// 處理: $(選擇器, 上下文)
// (相當於: $(上下文).find(選擇器)
} else {
return this.constructor( context ).find( selector );
}
用於擴充函式。內部有多重參數判斷,目的是讓呼叫方式更靈活,基本原理就是 for (in)。
noConflict: function( deep ) {
window.$ = _$;
if ( deep ) {
window.jQuery = _jQuery;
}
return jQuery;
},
讓 jQuery 把 $(以及可選的 jQuery)還給其他函式庫。
裡面有兩個函式:jQuery.ready 負責觸發 readyList 中的所有函式,jQuery.bindReady 則負責讓 ready 能成功執行。
bindReady: function() {
// 如果已經執行 bindReady 則返回。
if ( readyBound ) {
return;
}
readyBound = true;
// 如果頁面已經加載, 馬上執行 jQuery.ready
if ( document.readyState === "complete" ) {
return setTimeout( jQuery.ready, 1 );
}
// 標准浏覽器支持 DOMContentLoaded
if ( document.addEventListener ) {
// 你懂的
document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
// 為什麼還要 load ? , 因為有些時候 DOMContentLoaded 失敗(如 iframe) ,而 load 總是會成功, 所以,同時處理 DOMContentLoaded load, 在 jQuery.ready 中會刪除監聽函數,保證最後這個函數只執行一次
window.addEventListener( "load", jQuery.ready, false );
// IE浏覽器( IE 8 以下)
} else if ( document.attachEvent ) {
// 使用 onreadystatechange
document.attachEvent("onreadystatechange", DOMContentLoaded);
// 同理
window.attachEvent( "onload", jQuery.ready );
// 如果 IE 下且非 iframe, 這裡有個技巧。 見 doScrollCheck();
// 原理: 浏覽器在沒加載時 設置 scrollLeft 會錯誤,所喲每隔1秒廁所 是否 scrollLeft 成功,如果發現成功,則執行 jQuery.ready 。但這只對非 frame 會有用。
var toplevel = false;
try {
toplevel = window.frameElement == null;
} catch(e) {}
if ( document.documentElement.doScroll && toplevel ) {
doScrollCheck();
}
}
},
那個 IE 專用的 doScrollCheck 是經典 hack:利用「頁面未就緒時設定 scrollLeft 會失敗」這個特性,輪詢到成功為止。而 bindReady 是等到真正需要時才執行(1.4 之前是無條件執行),屬於效能上的小優化。
它解決了大量跨瀏覽器相容問題,做法是基于「特性檢測」而非判斷瀏覽器版本:建立一個元素,看它是否符合某些預期行為。例如測試是否支援 checkOn,就先設 check = 'on',再看讀出來是否等於 'on'。這種思路比 navigator.userAgent 可靠得多。
jQuery.data() 用於存放一個字典,資料最終存在 jQuery.cache(1283 行),而全域物件則放在 windowData(1279 行)。
問題是:拿到一個物件之後,怎麼找到它在 cache 裡的對應項?答案就是 expando 字串。以物件 elem 為例,滿足:
elem.expando = "jQuery12321";
那麼 jQuery.cache["jQuery12321"] 就是存放該 elem 資料的物件。嚴格來說,鍵值並不是 elem.expando,而是 elem[jQuery.expando]。
由於每個物件的資料本身又是一個字典,所以執行 jQuery.data(elem, 'events') 之後,實際存取的位置是 jQuery.cache[elem[jQuery.expando]]['events']。
隊列是 1.5 新增的機制,主要用在特效這類需要排隊等待執行的場合,核心操作就是進隊 queue 與出隊 dequeue。
隊列內部的資料狀態變化如下。尚未執行時:
[將執行的1, 將執行的2]
開始執行〈將執行的1〉,若 type 為空或 "fx",隊列變成:
["inprogress", 將執行的2]
執行完之後:
["將執行的2]
這些狀態都存在 jQuery.data(obj, (type || "fx") + "queue")(1520 - 1522 行)。而 jQuery.delay 則是延時執行,相當於把隊列更新成 setTimeout 之後的結果(1589 - 1598 行)。
從這裡開始要先理解 jQuery.access。對於 attr、css 這類函式,取值時只回傳第一個元素的結果,設值時則作用於所有元素——這個神奇效果全靠 jQuery.access(794 - 819 行)完成。
jQuery 大部分函式都依賴它:對使用者而言呼叫的是 jQuery.fn.XX,而這個函式需要對多個元素操作,透過 access 轉換之後,最後只需寫「對單一元素的操作」,通常就是 jQuery.XX。這也解釋了為什麼我們常同時看到 jQuery.XX 與 jQuery.fn.XX——前者是底層實作,後者是給使用者用的便利工具。
jQuery.fn.attr(1632 - 1634 行)只有一句話,真正的實作在 jQuery.attr(1880 - 1988 行),又是一個百行以上的大函式:
attr: function( elem, name, value, pass ) {
// 檢查是否為 nodeType 為 Element
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
return undefined;
}
// 如果這個屬性需要特殊對待。 height/width/left 等屬性需特殊計算
if ( pass && name in jQuery.attrFn ) {
return jQuery(elem)[name](value);
}
// 檢查是否為 XML 還 HTML
var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
// Whether we are setting (or getting)
set = value !== undefined;
// 修正名字, 比如 float 改 cssFloat
name = notxml && jQuery.props[ name ] || name;
// 只有在節點的時候執行。
if ( elem.nodeType === 1 ) {
// 在 IE7- 下, href src 屬性直接獲取會返回絕對位置,而不是真實的位置字符串,
// 要獲得它們的真實值,需要 elem.getAttribute("href", 2);
var special = rspecialurl.test( name );
// Safari 誤報默認選項。通過獲取父元素的已選擇索引來修復。
if ( name === "selected" && !jQuery.support.optSelected ) {
var parent = elem.parentNode;
if ( parent ) {
parent.selectedIndex;
// 對 optgroups ,同理
if ( parent.parentNode ) {
parent.parentNode.selectedIndex;
}
}
}
// 檢查屬性是否存在, 有些時候 name in elem 會失敗,所以多次測試。
if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
// 如果設置屬性
if ( set ) {
// 在IE, 不能設置屬性 type 。
if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
jQuery.error( "type property can't be changed" );
}
// 如果 value === null, 表示移除屬性
if ( value === null ) {
if ( elem.nodeType === 1 ) {
elem.removeAttribute( name );
}
} else {
// 一切屬性設置就是1句話。。。
elem[ name ] = value;
}
}
// 表單索引元素獲取需要 getAttributeNode( name ).nodeValue
if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
return elem.getAttributeNode( name ).nodeValue;
}
// elem.tabIndex 特殊處理
if ( name === "tabIndex" ) {
var attributeNode = elem.getAttributeNode( "tabIndex" );
return attributeNode && attributeNode.specified ?
attributeNode.value :
rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
0 :
undefined;
}
return elem[ name ];
}
// 處理 style 屬性
if ( !jQuery.support.style && notxml && name === "style" ) {
if ( set ) {
elem.style.cssText = "" + value;
}
return elem.style.cssText;
}
if ( set ) {
// 這裡除了 IE, 其它屬性使用標准 setAttribute
elem.setAttribute( name, "" + value );
}
// 如果屬性不存在,返回 undefined, 而不是 null 或 "" 之類的。
if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
return undefined;
}
// 見上
var attr = !jQuery.support.hrefNormalized && notxml && special ?
// Some attributes require a special call on IE
elem.getAttribute( name, 2 ) :
elem.getAttribute( name );
// 同上
return attr === null ? undefined : attr;
}
// 如果不是 DOM 元素,檢查處理。
if ( set ) {
elem[ name ] = value;
}
return elem[ name ];
}
平常呼叫的 click(func) 之類都只是工具函式,真正與事件掛鉤的是:
jQuery.fn.bind → 呼叫 jQuery.event.addjQuery.fn.unbind → 呼叫 jQuery.event.removejQuery.fn.trigger → 呼叫 jQuery.event.triggerjQuery.fn.one → 呼叫 jQuery.fn.bind 與 jQuery.fn.unbind想理解事件原理,必須讀 jQuery.event.add(2012 - 2155 行):
add: function( elem, types, handler, data ) {
// 只對節點操作。
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
return;
}
// IE 無法傳遞 window,而是復制這個對象 。
if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
elem = window;
}
// 如果 handler === false, 也就是說就是阻止某事件,
// 這樣只要 bind("evt", false); 就是阻止此事件。
if ( handler === false ) {
handler = returnFalse;
} else if ( !handler ) {
return;
}
// handleObjIn 是內部處理句柄, handleObj 是直接使用的處理句柄。
var handleObjIn, handleObj;
if ( handler.handler ) {
handleObjIn = handler;
handler = handleObjIn.handler;
}
// 為函數生成唯一的 guid 。具體下面介紹。
if ( !handler.guid ) {
handler.guid = jQuery.guid++;
}
// 獲取一個節點的數據。
var elemData = jQuery.data( elem );
// 如果沒有數據,則直接返回。
if ( !elemData ) {
return;
}
// 避免和原生的js對象混淆。
var eventKey = elem.nodeType ? "events" : "__events__",
// 這裡就是關鍵。
// elemData 是存儲數據的位置, 而 elemData[ eventKey ] 就是存儲當前事件的對象。 elemData.handle 就是當前綁定的所有函數數組。
// 也就是說,當我們綁定一個函數時,會往 elemData.handle 放這個函數,然後事件觸發時,會遍歷 elemData.handle 中函數然後去執行。
// 肯能有人會問,為什麼這麼做,因為原生的DOM內部也有一個 函數數組,事件觸發後會執行全部函數。答案還是 兼容。
// 標准浏覽器使用 addEventListener
// IE 使用 attachEvent
// 而這2者還是有差距的。因為 addEventListener 執行函數的順序即添加函數的順序,然而 attachEvent 執行函數的順序和添加的順序是相反的。
// jQuery 使用自定義的 handler 數組,好處有:
// 因為最後僅綁定一次原生事件,事件觸發後,手動執行 數組中的函數。這樣保證兼容。
// 同時也可以知道到底綁定了什麼函數,可以方便 trigger 函數的完成。
events = elemData[ eventKey ],
eventHandle = elemData.handle;
// 一些功能。。
if ( typeof events === "function" ) {
eventHandle = events.handle;
events = events.events;
} else if ( !events ) {
if ( !elem.nodeType ) {
elemData[ eventKey ] = elemData = function(){};
}
elemData.events = events = {};
}
// 如果是第一次執行,需創建 eventHandle
if ( !eventHandle ) {
// eventHandle 就是真正綁定到原生事件的那個函數,這個函數用來執行events.hadlers 用。
elemData.handle = eventHandle = function() {
// Handle the second event of a trigger and when
// an event is called after a page has unloaded
return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
jQuery.event.handle.apply( eventHandle.elem, arguments ) :
undefined;
};
}
// 綁定函數和原生,這樣可以保證函數可執行為目前作用域。
eventHandle.elem = elem;
// 處理 jQuery(...).bind("mouseover mouseout", fn);
types = types.split(" ");
var type, i = 0, namespaces;
while ( (type = types[ i++ ]) ) {
handleObj = handleObjIn ?
jQuery.extend({}, handleObjIn) :
{ handler: handler, data: data };
// 略
// 綁定 type guid
handleObj.type = type;
if ( !handleObj.guid ) {
handleObj.guid = handler.guid;
}
// 獲取當前的函數數組。
var handlers = events[ type ],
special = jQuery.event.special[ type ] || {};
// 如果第一次,則創建這個數組。
if ( !handlers ) {
handlers = events[ type ] = [];
// 特殊事件要執行 setup 而不是標准 addEventListener。
// 此行用來支持自定義的事件。
if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
// 標准事件。 這裡綁定的為 eventHandle
if ( elem.addEventListener ) {
elem.addEventListener( type, eventHandle, false );
} else if ( elem.attachEvent ) {
elem.attachEvent( "on" + type, eventHandle );
}
}
}
// 自定義事件,執行 add
if ( special.add ) {
special.add.call( elem, handleObj );
if ( !handleObj.handler.guid ) {
handleObj.handler.guid = handler.guid;
}
}
// 不管是不是首次,都放入目前綁定的函數。
handlers.push( handleObj );
// 為實現 trigger 。
jQuery.event.global[ type ] = true;
}
// 讓IE下可以正常回收 elem 內存。
elem = null;
},
這段最關鍵的設計是「只綁一次原生事件」。原生 DOM 本來也有函式陣列,但 addEventListener 依註冊順序執行,IE 的 attachEvent 卻是相反順序。jQuery 乾脆自己維護一個 handler 陣列,事件觸發後手動遍歷執行,既統一了順序,也讓 trigger 能知道究竟綁了哪些函式。
框架的責任之一也包括修正事件參數。jQuery 自訂了 jQuery.Event(2583 - 2610 行)來模擬原生事件物件:
jQuery.Event = function( src ) {
// 支持 沒有 new jQuery.Event
if ( !this.preventDefault ) {
return new jQuery.Event( src );
}
// 略
}
搭配 jQuery.event.fix(2470 - 2527 行)使用,把 IE 的 window.event 補齊成標準介面。
都定義在 jQuery.event.special(2537 - 2567 行),預設有 ready、live、beforeunload。特殊事件是 jQuery 內部特別處理的事件,可自訂綁定、新增、刪除與觸發的行為。
程式碼在 2292 - 2403 行,目的是模擬觸發某事件,並支援冒泡。可參考 https://www.cnblogs.com/rooney/archive/2008/12/03/1346449.html
專門解釋選擇器的文章已經很多,這裡不贅述。可參考 https://www.cnblogs.com/rooney/archive/2008/12/02/1346135.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/23/1607917.html
parent、next 這類查找節點的工具都屬於這塊。它們都依賴 jQuery.fn.nth(),透過關係找到下一個節點,若是 Element 就回傳,否則繼續找。
1.5 的 clone 與 Mootools 一樣採用 cloneFixAttributes(5196 - 5225 行)。其中 cloneCopyEvent 不是複製 data,而是依 data 重新執行 bind;cloneFixAttributes 則先 clearAttributes 再 mergeAttributes(IE 專用),以確保屬性正確拷貝。
按 HTML 字串產生節點,也就是 $("複雜 html") 背後做的事,這裡用到了不常見的 document.createDocumentFragment()。
遇到 <script> 就交給 jQuery.globalEval 全域執行。之所以不直接塞進 head,是因為單獨插入 script 標籤容易造成記憶體洩漏。
清除元素的內容子節點。可參考 https://www.cnblogs.com/70buluo/archive/2009/06/03/1495040.html 與 https://www.cnblogs.com/rooney/archive/2008/12/02/1346135.html
讀取元素的 CSS 屬性一直是件麻煩事。jQuery 先把少數屬性單獨處理,其餘則用 style[name] || (IE ? getComputedStyle(...).getProperty(name) : elem.currentStyle[name]) 的方式取值,並做一些相容處理。細節可參考 https://www.cnblogs.com/rubylouvre/archive/2009/09/05/1559883.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/21/1607255.html
1.5 重寫了整个 ajax 模組。值得注意的是,它並非直接依賴元素上的 onreadystatechange,而是自己維護一個輪詢機制,每隔十幾毫秒檢查一次 readyState 是否變化。可參考 https://www.cnblogs.com/qleelulu/archive/2008/04/21/1163021.html
可參考 https://www.cnblogs.com/rooney/archive/2008/12/03/1346475.html
這裡補充說明動畫的數學原理。大家都知道特效靠 setTimeout,但具體怎麼算?
假設運動是均勻的,從 x = x1 出發,在 dt 時間內移動到 x2。為了方便計算,引入一個 delta,滿足「當前位置 = x1 + (x2 - x1) × delta」。這樣一來,動畫開始時 delta = 0,結束時 delta = 1——無論 x1、x2 差距多大,計算都收斂到 delta 上。
delta 隨時間變化,即 delta = f(t)(0 < t < dt)。每畫一幀就把 t 加一,重新算出 delta 與 x。若要一秒顯示 fps 幀,就是每 1000/fps 毫秒更新一次:
var t = 0, f = 某個變換;
setInterval(function(){
var delta = f(t);
var x = x1 + (x2 - x1) * dalta;
// 更新顯示 x
t++;
}, 1000 / fps);
接著說明 f 是什麼。f 的輸入是時間、輸出是 delta,且 f(0) = 0、f(dt) = 1。任一時刻下 delta = (x - x1) / (x2 - x1),當 x 從 0 走到 x、t 從 0 走到 dt,根據微分的意義,f 其實就是 x 對 t 的導函數。
若是 x = k · t 的均勻運動(k = (x2 - x1) / dt),則 f 為常數;若是 x = k · t² 的拋物線,則 f = 2k · t。一般情況會用 sin 函式讓變化更柔和,所以 jQuery 預設採用 sin 變換:
x = sin( t - 3π/2) ( 最低點 ) f = x' = -(cos( πt ) - 1) / 2
(第 7477 行)
jQuery.offset 負責管理定位,其餘多為工具程式。jQuery.offset.initialize 測試瀏覽器的定位法則;jQuery.offset.bodyOffset 取得 body 的定位(因與其他元素不同而單獨測試);核心的 jQuery.fn.offset 回傳絕對位置,新瀏覽器直接用 getBoundingClientRect,否則自己遍歷父元素把相對位置累加。
jQuery.fn.position 回傳的值等同 style.left,算法是先算 offset 與父節點(offsetParent)的 offset,兩者相減即得偏移量。可參考 https://www.cnblogs.com/xuld/archive/2011/02/13/1953907.html
讀源碼時最好對照程式碼逐段理解。jQuery 雖然龐大,但程式碼可讀性相當不錯。解讀源碼的最終目的是为了更好地使用它——知道內部怎麼運作之後,自然就明白它為什麼能做這麼多事。
不過 jQuery 並不是唯一的選擇。在讚嘆它設計之餘,也該看看個性截然不同的框架,例如 Mootools,對照著讀往往能有更多收穫。