search

Home  >  Article  >  Web Front-end  >  About jQuery Reference Example 1.0 The Philosophy of jQuery_jquery

About jQuery Reference Example 1.0 The Philosophy of jQuery_jquery

WBOY
WBOYOriginal
2016-05-16 17:38:17963browse

This article is translated from jQuery Cookbook (O'Reilly 2009) 1.0 The jQuery Philosophy

The philosophy of jQuery is "Write less code, do more things". This philosophy can be divided into three concepts:

  • Find elements with CSS selectors and manipulate them with jQuery methods
  • Chaining multiple jQuery methods on a set of elements
  • jQuery encapsulation and implicit traversal

Fully understanding these three concepts is crucial to writing jQuery code. Let’s take a closer look at these three concepts.

Find elements and operate on them

To be more precise, it is to locate a batch of elements in the DOM tree and then operate on the set of elements. For example, the following example: first hide a dc6dce4a544fdca2df29d5ac0ea9906b element from the user, then insert some new text into the hidden dc6dce4a544fdca2df29d5ac0ea9906b element, then change its attributes, and finally redisplay the dc6dce4a544fdca2df29d5ac0ea9906b element. The corresponding jQuery code is as follows: 

<SPAN class=dec><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><html></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><head></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><script</SPAN><SPAN class=pln> </SPAN><SPAN class=atn>type</SPAN><SPAN class=pun>=</SPAN><SPAN class=atv>"text/JavaScript"</SPAN><SPAN class=pln>
  </SPAN><SPAN class=atn>src</SPAN><SPAN class=pun>=</SPAN><SPAN class=atv>"http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"</SPAN><SPAN class=tag>></script></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag></head></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><body></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><div></SPAN><SPAN class=pln>old content</SPAN><SPAN class=tag></div></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><script></SPAN><SPAN class=pln>
  </SPAN><SPAN class=com>//隐藏页面上所有的div元素</SPAN><SPAN class=pln>
  jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>hide</SPAN><SPAN class=pun>();</SPAN><SPAN class=pln>
  </SPAN><SPAN class=com>//更新所有div元素内的文本</SPAN><SPAN class=pln>
  jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>text</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'new content'</SPAN><SPAN class=pun>);</SPAN><SPAN class=pln>
  </SPAN><SPAN class=com>//在所有的div元素上添加值为updatedContent的class属性</SPAN><SPAN class=pln>
  jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>addClass</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>"updatedContent"</SPAN><SPAN class=pun>);</SPAN><SPAN class=pln>
  </SPAN><SPAN class=com>//显示页面上所有的div元素</SPAN><SPAN class=pln>
  jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>show</SPAN><SPAN class=pun>();</SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag></script></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag></body></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag></html></SPAN>

Let’s take a look at these four jQuery statements one by one:

  • Hide all div elements on the page, making them invisible
  • Replace the original text in the hidden div element with new text ('new content')
  • Add a new class attribute value (updatedContent) to the div element
  • Redisplay the div element on the page

The above example uses the jQuery function to find all dc6dce4a544fdca2df29d5ac0ea9906b elements in the HTML page, and then uses jQuery methods to operate on them (hide(), text(), addClass(), show()).

Chain call

When calling jQuery methods, according to the design of jQuery, these methods can be called in a chain. For example, only perform an element search once, and then perform a series of operations on the found elements. The previous code example can be rewritten as a JavaScript statement using chained calls.

Using chain calls, you can use the following code: 

<SPAN class=com>//隐藏页面上所有的div元素</SPAN><SPAN class=pln>
jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>hide</SPAN><SPAN class=pun>();</SPAN><SPAN class=pln>
</SPAN><SPAN class=com>//更新所有div元素内的文本</SPAN><SPAN class=pln>
jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>text</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'new content'</SPAN><SPAN class=pun>);</SPAN><SPAN class=pln>
</SPAN><SPAN class=com>//在所有的div元素上添加值为updatedContent的class属性</SPAN><SPAN class=pln>
jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>addClass</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>"updatedContent"</SPAN><SPAN class=pun>);</SPAN><SPAN class=pln>
</SPAN><SPAN class=com>//显示页面上所有的div元素</SPAN><SPAN class=pln>
jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>show</SPAN><SPAN class=pun>();</SPAN>

is rewritten as: 

<SPAN class=pln>jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>hide</SPAN><SPAN class=pun>().</SPAN><SPAN class=pln>text</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'new content'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>addClass</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>"updatedContent"</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>show</SPAN><SPAN class=pun>();</SPAN>

If you add code indentation it will be: 

<SPAN class=pln>jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>)</SPAN><SPAN class=pln>
 </SPAN><SPAN class=pun>.</SPAN><SPAN class=pln>hide</SPAN><SPAN class=pun>()</SPAN><SPAN class=pln>
 </SPAN><SPAN class=pun>.</SPAN><SPAN class=pln>text</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'new content'</SPAN><SPAN class=pun>)</SPAN><SPAN class=pln>
 </SPAN><SPAN class=pun>.</SPAN><SPAN class=pln>addClass</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>"updatedContent"</SPAN><SPAN class=pun>)</SPAN><SPAN class=pln>
 </SPAN><SPAN class=pun>.</SPAN><SPAN class=pln>show</SPAN><SPAN class=pun>();</SPAN>

Simply put, chained calls allow unlimited jQuery methods to be used together on the currently selected set of elements. In essence, elements processed with jQuery methods will always be returned after the method is processed, so the chain of calls can continue. The jQuery plug-in is also designed in this way (returning an encapsulated element set), so using the plug-in does not affect the chain call.

Another benefit of chained calls is that it saves overhead by selecting DOM elements only once. Avoiding traversing the DOM tree is crucial to improving web page performance, so it is necessary to reuse or cache the selected set of DOM elements as much as possible.

jQuery wrapper

In most cases, if you use jQuery, you will definitely deal with something called "jQuery encapsulation". In other words, elements selected from an HTML page using jQuery will be encapsulated with a layer of functionality provided by jQuery. I personally like to call this thing "encapsulated element set" because it is a set of elements that encapsulates jQuery functions. This set of encapsulated elements sometimes contains one DOM element, sometimes it contains multiple, and sometimes it contains nothing at all. When the set of encapsulating elements is empty, jQuery methods/properties called on it will not throw any errors - this avoids unnecessary if statements.

Using the above HTML code as an example, what happens when there are multiple dc6dce4a544fdca2df29d5ac0ea9906b elements in the web page? In the example below, the HTML page has three more dc6dce4a544fdca2df29d5ac0ea9906b elements: 

<SPAN class=dec><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><html></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><head></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><script</SPAN><SPAN class=pln> </SPAN><SPAN class=atn>type</SPAN><SPAN class=pun>=</SPAN><SPAN class=atv>"text/JavaScript"</SPAN><SPAN class=pln> </SPAN><SPAN class=atn>src</SPAN><SPAN class=pun>=</SPAN><SPAN class=atv>"http://ajax.googleapis.com/ajax/libs/
  jquery/1.3.0/jquery.min.js"</SPAN><SPAN class=tag>></script></SPAN><SPAN class=pln> </SPAN><SPAN class=tag></head></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag><body></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><div></SPAN><SPAN class=pln>old content</SPAN><SPAN class=tag></div></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><div></SPAN><SPAN class=pln>old content</SPAN><SPAN class=tag></div></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><div></SPAN><SPAN class=pln>old content</SPAN><SPAN class=tag></div></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><div></SPAN><SPAN class=pln>old content</SPAN><SPAN class=tag></div></SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag><script></SPAN><SPAN class=pln>
  jQuery</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'div'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>hide</SPAN><SPAN class=pun>().</SPAN><SPAN class=pln>text</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>'new content'</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>addClass</SPAN><SPAN class=pun>(</SPAN><SPAN class=str>"updatedContent"</SPAN><SPAN class=pun>).</SPAN><SPAN class=pln>show</SPAN><SPAN class=pun>();</SPAN><SPAN class=pln>
 </SPAN><SPAN class=tag></script></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag></body></SPAN><SPAN class=pln>
</SPAN><SPAN class=tag></html></SPAN>

In the above example there is no programming code representing a loop. But the wonderful thing is that jQuery will scan the entire page, then put all dc6dce4a544fdca2df29d5ac0ea9906b elements into the encapsulated element set, and then execute a series of jQuery methods defined by the code for each element in the encapsulated set (implicit traversal). For example, every element in the encapsulated set calls .hide(). In the above code, in fact, every method we use (hide(), text(), addClass(), show()) has an effect on all div elements in the page, just like a human-written loop The same way to iterate over DOM elements. The execution result of the above code is: every dc6dce4a544fdca2df29d5ac0ea9906b element in the page is hidden, the contained text is changed, the class attribute is added, and finally reappears.

Being familiar with encapsulated element sets and implicit traversal is very important for writing complex looping logic - it is important to note that before writing any additional looping code, a simple looping operation already exists (for example: jQuery(' div').each(function(){}). In other words, the call to the jQuery method affects every element in the encapsulated element set.

It should be noted that some jQuery methods have special behavior and will only affect the first element in the set of encapsulated elements (for example: attr()).

Statement：
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Previous article：5 things you should do before JS completes your code_javascript tipsNext article：5 things you should do before JS completes your code_javascript tips

Related articles

See more