jQuery基础(2)

(续jQuery基础(1))

第5章 DOM节点的复制与替换

(1)DOM拷贝clone()

克隆节点是DOM的常见操作,jQuery提供一个clone方法,专门用于处理dom的克隆:
.clone()方法:复制所有匹配的元素集合,包括所有匹配元素、匹配元素的下级元素、文字节点。需要注意,如果节点有事件或者数据之类的其他处理,我们需要通过clone(ture)传递一个布尔值ture用来指定,这样不仅仅只是克隆单纯的节点结构,还要把附带的事件与数据给一并克隆了。

HTML部分 <div></div>  JavaScript部分 $("div").on('click', function() {//执行操作})  //clone处理一 $("div").clone()   //只克隆了结构,事件丢失  //clone处理二 $("div").clone(true) //结构、事件与数据都克隆 

细节:

  • clone()方法时,在将它插入到文档之前,我们可以修改克隆后的元素或者元素内容,如$(this).clone().css('color','red') 增加了一个颜色。
  • 通过传递true,将所有绑定在原始元素上的事件处理函数复制到克隆元素上。
  • clone()方法是jQuery扩展的,只能处理通过jQuery绑定的事件与数据。
  • 元素数据(data)内对象和数组不会被复制,将继续被克隆元素和原始元素共享。深复制的所有数据,需要手动复制每一个。

(2)DOM替换replaceWith()和replaceAll()

1).replaceWith( newContent )

用提供的内容替换集合中所有匹配的元素并且返回被删除元素的集合

简单来说:用$()选择节点A,调用replaceWith方法,传入一个新的内容B(HTML字符串,DOM元素,或者jQuery对象)用来替换选中的节点A

看个简单的例子:一段HTML代码

<div>     <p>第一段</p>     <p>第二段</p>     <p>第三段</p> </div> 

替换第二段的节点与内容
$("p:eq(1)").replaceWith('<a style="color:red">替换第二段的内容</a>')
通过jQuery筛选出第二个p元素,调用replaceWith进行替换,结果如下

<div>     <p>第一段</p>     <a style="color:red">替换第二段的内容</a>'     <p>第三段</p> </div> 
2).replaceAll( target )

用集合的匹配元素替换每个目标元素

.replaceAll()和.replaceWith()功能类似,但是目标和源相反,用上述的HTML结构,我们用replaceAll处理
$('<a style="color:red">替换第二段的内容</a>').replaceAll('p:eq(1)')

总结:

  • .replaceAll()和.replaceWith()功能类似,主要是目标和源的位置区别
  • .replaceWith()与.replaceAll() 方法会删除与节点相关联的所有数据和事件处理程序
  • .replaceWith()方法,和大部分其他jQuery方法一样,返回jQuery对象,所以可以和其他方法链接使用
  • .replaceWith()方法返回的jQuery对象引用的是替换前的节点,而不是通过replaceWith/replaceAll方法替换后的节点

(3)DOM包裹wrap()方法

如果要将元素用其他元素包裹起来,也就是给它增加一个父元素,针对这样的处理,JQuery提供了一个wrap方法

1).wrap( wrappingElement )

在集合中匹配的每个元素周围包裹一个HTML结构

简单的看一段代码:
<p>p元素</p>

给p元素增加一个div包裹
$('p').wrap('<div></div>')

最后的结构,p元素增加了一个父div的结构

<div>     <p>p元素</p> </div> 
2).wrap( function )

一个回调函数,返回用于包裹匹配元素的 HTML 内容或 jQuery 对象

使用后的效果与直接传递参数是一样,只不过可以把代码写在函数体内部,写法不同而已

以第一个案例为例:

$('p').wrap(function() {     return '<div></div>';   //与第一种类似,只是写法不一样 }) 

注意:
.wrap()函数可以接受任何字符串或对象,可以传递给$()工厂函数来指定一个DOM结构。这种结构可以嵌套了好几层深,但应该只包含一个核心的元素。每个匹配的元素都会被这种结构包裹。该方法返回原始的元素集,以便之后使用链式方法。

(4)DOM包裹unwrap()方法

我们可以通过wrap方法给选中元素增加一个包裹的父元素。相反,如果删除选中元素的父元素要如何处理 ?

jQuery提供了一个unwarp()方法 ,作用与wrap方法是相反的。将匹配元素集合的父级元素删除,保留自身(和兄弟元素,如果存在)在原来的位置。

看一段简单案例:

<div>     <p>p元素</p> </div> 

我要删除这段代码中的div,一般常规的方法会直接通过remove或者empty方法
$('div').remove();
但是如果我还要保留内部元素p,这样就意味着需要多做很多处理,步骤相对要麻烦很多,为了更便捷,jQuery提供了unwarp方法很方便的处理了这个问题
$('p').unwarp();
找到p元素,然后调用unwarp方法,这样只会删除父辈div元素了
结果:<p>p元素</p>
以下功能相同:
$('p').unwrap('<div></div>')
$('p').unwrap(function() { return '<div></div>'; })

(5)DOM包裹wrapAll()方法

wrap是针对单个dom元素处理,如果要将集合中的元素用其他元素包裹起来,也就是给他们增加一个父元素,针对这样的处理,JQuery提供了一个wrapAll方法

1).wrapAll( wrappingElement )

给集合中匹配的元素增加一个外面包裹HTML结构

简单的看一段代码:

<p>p元素</p> <p>p元素</p> 

给所有p元素增加一个div包裹
$('p').wrapAll('<div></div>')
最后的结构,2个P元素都增加了一个父div的结构

<div>     <p>p元素</p>     <p>p元素</p> </div> 
2).wrapAll( function )

一个回调函数,返回用于包裹匹配元素的 HTML 内容或 jQuery 对象,通过回调的方式可以单独处理每一个元素

以上面案例为例,

$('p').wrapAll(function() {     return '<div><div/>';  }) 

以上的写法的结果如下,等同于warp的处理了

<div>     <p>p元素</p> </div> <div>     <p>p元素</p> </div> 

注意:
.wrapAll()函数可以接受任何字符串或对象,可以传递给$()工厂函数来指定一个DOM结构。这种结构可以嵌套多层,但是最内层只能有一个元素。所有匹配元素将会被当作是一个整体,在这个整体的外部用指定的 HTML 结构进行包裹。

(6)DOM包裹wrapInner()方法

如果要将合集中的元素内部所有的子元素用其他元素包裹起来,并当作指定元素的子元素,针对这样的处理,JQuery提供了一个wrapInner方法

1).wrapInner( wrappingElement )

给集合中匹配的元素的内部,增加包裹的HTML结构

用个简单的例子描述下,简单的看一段代码:

<div>p元素</div> <div>p元素</div> 

给所有元素增加一个p包裹
$('div').wrapInner('<p></p>')
最后的结构,匹配的di元素的内部元素被p给包裹了

<div>     <p>p元素</p> </div> <div>     <p>p元素</p> </div> 
2).wrapInner( function )

允许我们用一个callback函数做参数,每次遇到匹配元素时,该函数被执行,返回一个DOM元素,jQuery对象,或者HTML片段,用来包住匹配元素的内容

以上面案例为例,

$('div').wrapInner(function() {     return '<p></p>';  }) 

以上的写法的结果如下,等同于第一种处理了
注意: 当通过一个选择器字符串传递给.wrapInner() 函数,其参数应该是格式正确的 HTML,并且 HTML 标签应该是被正确关闭的。

第6章 jQuery遍历

(1)children()方法

jQuery是一个合集对象,如果想快速查找合集里面的第一级子元素,此时可以用children()方法。这里需要注意:.children(selector) 方法是返回匹配元素集合中每个元素的所有子元素(仅儿子辈,这里可以理解为就是父亲-儿子的关系)
理解节点查找关系:

<div class="div">     <ul class="son">         <li class="grandson">1</li>     </ul> </div> 

代码如果是$(“div”).children(),那么意味着只能找到ul,因为div与ul是父子关系,li与div是祖辈关系,因此无法找到。

children()无参数
允许我们通过在DOM树中对这些元素的直接子元素进行搜索,并且构造一个新的匹配元素的jQuery对象
注意:jQuery是一个合集对象,所以通过children是匹配合集中每一给元素的第一级子元素

.children(selector)
选择性地接受同一类型选择器表达式
$("div").children(".selected")
同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

(2)find()方法

jQuery是一个合集对象,如果想快速查找DOM树中的这些元素的后代元素,此时可以用find()方法,这也是开发使用频率很高的方法。这里要注意 children与find方法的区别,children是父子关系查找,find是后代关系(包含父子关系)

理解节点查找关系:

<div class="div">     <ul class="son">         <li class="grandson">1</li>     </ul> </div> 

代码如果是$(“div”).find(“li”),此时,li与div是祖辈关系,通过find方法就可以快速的查找到了。

.find()方法要注意的知识点:
  • find是遍历当前元素集合中每个元素的后代。只要符合,不管是儿子辈,孙子辈都可以。
  • 与其他的树遍历方法不同,选择器表达式对于.find()是必需的参数。如果我们需要实现对所有后代元素的取回,可以传递通配选择器'*'
  • find只在后代中遍历,不包括自己。
  • 选择器 context 是由 .find() 方法实现的;因此,$('.item-ii').find('li') 等价于 $('li', '.item-ii')(找到类名为item-ii的标签下的li标签)。
注意重点:

.find()和.children()方法是相似的

  1. children只查找第一级的子节点
  2. find查找范围包括子节点的所有后代节点

(3)parent()方法

jQuery是一个合集对象,如果想快速查找合集里面的每一个元素的父元素(这里可以理解为就是父亲-儿子的关系),此时可以用parent()方法
因为是父元素,这个方法只会向上查找一级

理解节点查找关系:

<div class="div">     <ul class="son">         <li class="grandson">1</li>     </ul> </div> 

查找ul的父元素div, $(ul).parent(),就是这样简单的表达

1)parent()无参数

parent()方法允许我们能够在DOM树中搜索到这些元素的父级元素,从有序的向上匹配元素,并根据匹配的元素创建一个新的 jQuery 对象
注意:jQuery是一个合集对象,所以通过parent是匹配合集中每一个元素的父元素

2)parent()方法选择性地接受同一型选择器表达式

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

(4)parents()方法

jQuery是一个合集对象,如果想快速查找合集里面的每一个元素的所有祖辈元素,此时可以用parents()方法

其实也类似find与children的区别,parent只会查找一级,parents则会往上一直查到查找到祖先节点

理解节点查找关系:

<div class="div">     <ul class="son">         <li class="grandson">1</li>     </ul> </div> 

在li节点上找到祖 辈元素div, 这里可以用$(“li”).parents()方法

1)parents()无参数

parents()方法允许我们能够在DOM树中搜索到这些元素的祖先元素,从有序的向上匹配元素,并根据匹配的元素创建一个新的 jQuery 对象;

返回的元素秩序是从离他们最近的父级元素开始的

注意:jQuery是一个合集对象,所以通过parent是匹配合集中所有元素的祖辈元素

2)parents()方法选择性地接受同一型选择器表达式

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

注意事项:

  1. parents()和.parent()方法是相似的,但后者只是进行了一个单级的DOM树查找
  2. $( “html” ).parent()方法返回一个包含document的集合,而$( “html” ).parents()返回一个空集合。

(5)closest()方法

以选定的元素为中心,往内查找可以通过find、children方法。如果往上查找,也就是查找当前元素的父辈祖辈元素,jQuery提供了closest()方法,这个方法类似parents但是又有一些细微的区别,属于使用频率很高的方法

closest()方法接受一个匹配元素的选择器字符串

从元素本身开始,在DOM 树上逐级向上级元素匹配,并返回最先匹配的祖先元素

例如:在div元素中,往上查找所有的li元素,可以这样表达
$("div").closet("li')
注意:jQuery是一个合集对象,所以通过closest是匹配合集中每一个元素的祖先元素

closest()方法给定的jQuery集合或元素来过滤元素

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个jQuery的对象

注意事项:
.parents()和.closest()是有点相似的,都是往上遍历祖辈元素,但是两者还是有区别的,否则就没有存在的意义了:

  • 起始位置不同:.closest开始于当前元素 .parents开始于父元素
  • 遍历的目标不同:.closest要找到指定的目标,.parents遍历到文档根元素,closest向上查找,直到找到一个匹配的就停止查找,parents一直查找到根元素,并将匹配的元素加入集合
  • 结果不同:.closest返回的是包含零个或一个元素的jquery对象,parents返回的是包含零个或一个或多个元素的jquery对象

(6)next()方法

jQuery是一个合集对象,如果想快速查找指定元素集合中每一个元素紧邻的后面同辈元素的元素集合,此时可以用next()方法

1)next()无参数

允许我们找元素集合中紧跟着这些元素的直接兄弟元素,并根据匹配的元素创建一个新的 jQuery 对象。
注意:jQuery是一个合集对象,所以通过next匹配合集中每一个元素的下一个兄弟元素

2)next()方法选择性地接受同一类型选择器表达式

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

(7)prev()方法

jQuery是一个合集对象,如果想快速查找指定元素集合中每一个元素紧邻的前面同辈元素的元素集合,此时可以用prev()方法

1)prev()无参数

取得一个包含匹配的元素集合中每一个元素紧邻的前一个同辈元素的元素集合
注意:jQuery是一个合集对象,所以通过prev是匹配合集中每一个元素的上一个兄弟元素

2)prev()方法选择性地接受同一类型选择器表达式

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

(8)siblings()

jQuery是一个合集对象,如果想快速查找指定元素集合中每一个元素的同辈元素,此时可以用siblings()方法

1)siblings()无参数

取得一个包含匹配的元素集合中每一个元素的同辈元素的元素集合
注意:jQuery是一个合集对象,所以通过siblings是匹配合集中每一个元素的同辈元素

2)siblings()方法选择性地接受同一类型选择器表达式

同样的也是因为jQuery是合集对象,可能需要对这个合集对象进行一定的筛选,找出目标元素,所以允许传一个选择器的表达式

(9)add()方法

jQuery是一个合集对象,通过$()方法找到指定的元素合集后可以进行一系列的操作。$()之后就意味着这个合集对象已经是确定的,如果后期需要再往这个合集中添加一新的元素要如何处理?jQuery为此提供add方法,用来创建一个新的jQuery对象 ,元素添加到匹配的元素集合中

.add()的参数可以几乎接受任何的$(),包括一个jQuery选择器表达式,DOM元素,或HTML片段引用。
简单的看一个案例:

操作:选择所有的li元素,之后把p元素也加入到li的合集中

<ul>     <li>list item 1</li>     <li>list item 3</li> </ul> <p>新的p元素</p> 

处理一:传递选择器
$('li').add('p')
处理二:传递dom元素
$('li').add(document.getElementsByTagName('p')[0])
还有一种方式,就是动态创建P标签加入到合集,然后将整个集合插入到指定的位置,但是这样就改变元素的本身的排列
$('li').add('<p>新的p元素</p>').appendTo(目标位置)

(10)each()

jQuery是一个合集对象,通过$()方法找到指定的元素合集后可以进行一系列的操作。比如我们操作$(“li”).css(”) 给所有的li设置style值,因为jQuery是一个合集对象,所以css方法内部就必须封装一个遍历的方法,被称为隐式迭代的过程。要一个一个给合集中每一个li设置颜色,这里方法就是each

.each() 方法就是一个for循环的迭代器,它会迭代jQuery对象合集中的每一个DOM元素。每次回调函数执行时,会传递当前循环次数作为参数(从0开始计数)

所以大体上了解3个重点:

  • each是一个for循环的包装迭代器
  • each通过回调的方式处理,并且会有2个固定的实参,索引与元素
  • each回调方法中的this指向当前迭代的dom元素

看一个简单的案例

<ul>     <li>慕课网</li>     <li>Aaron</li> </ul> 

开始迭代li,循环2次

$("li").each(function(index, element) {      index 索引 0,1      element是对应的li节点 li,li      this 指向的是li }) 

这样可以在循环体会做一些逻辑操作了,如果需要提前退出,可以以通过返回 false以便在回调函数内中止循

三、事件篇

第1章 鼠标事件

(1)click与dbclick事件

用交互操作中,最简单直接的操作就是点击操作。jQuery提供了两个方法一个是click方法用于监听用户单击操作,另一个方法是dbclick方法用于监听用户双击操作。这两个方法的用法是类似的,下面以click()事件为例

方法一:$ele.click()

绑定$ele元素,不带任何参数一般是用来指定触发一个事件,用的比较少

<div id="test">点击触发<div> $("ele").click(function(){     alert('触发指定事件') }) $("#test").click(function(){      $("ele").click()  //手动指定触发事件  }); 
方法二:$ele.click( handler(eventObject) )

绑定$ele元素,每次$ele元素触发点击操作会执行回调 handler函数,这样可以针对事件的反馈做很多操作了,方法中的this是指向了绑定事件的元素

<div id="test">点击触发<div> $("#test").click(function() {     //this指向 div元素 }); 
方法三:$ele.click( [eventData ], handler(eventObject) )

使用与方法二一致,不过可以接受一个数据参数,这样的处理是为了解决不同作用域下数据传递的问题

<div id="test">点击触发<div> $("#test").click(11111,function(e) {     //this指向 div元素     //e.data  => 11111 传递数据 }); 

dblclick()的用法和click()的用法是类似的,可以参考以上click()的用法。

dbclick与click事件不同的是:

  1. click事件触发需要以下几点:
    click事件其实是由mousedown与mouseup 2个动作构成,所以点击的动作只有在松手后才触发
  2. dblclick事件触发需要以下几点:
    dblclick又是由2个click叠加而来的,所以dblclick事件只有在满足以下条件的情况下才能被触发
    (1)鼠标指针在元素里面时点击。
    (2)鼠标指针在元素里面时释放。
    (2)鼠标指针在元素里面时再次点击,点击间隔时间,是系统而定。
    (4)鼠标指针在元素里面时再次释放。

注意:在同一元素上同时绑定 click 和 dblclick 事件是不可取的。各个浏览器事件触发的顺序是不同的,一些浏览器在dblclick之前接受两个 click 事件 ,而一些浏览器只接受一个 click 事件。用户往往可通过不同的操作系统和浏览器配置双击灵敏度

(2)mousedown与mouseup事件

用户交互操作中,最简单直接的操作就是点击操作,因此jQuery提供了一个mousedown的快捷方法可以监听用户鼠标按下的操作,与其对应的还有一个方法mouseup快捷方法可以监听用户鼠标弹起的操作。两种方法用法类似,下面以mousedown()为例

方法一:$ele.mousedown()
方法二:$ele.mousedown( handler(eventObject) )
方法三:$ele.mousedown( [eventData ], handler(eventObject) )

mousedown事件触发需要以下几点:

  • mousedown强调是按下触发
  • 如果在一个元素按住了鼠标不放,并且拖动鼠标离开这个元素,并释放鼠标键,这仍然是算作mousedown事件
  • 任何鼠标按钮被按下时都能触发mousedown事件
  • 用event 对象的which区别按键,敲击鼠标左键which的值是1,敲击鼠标中键which的值是2,敲击鼠标右键which的值是3

mouseup事件触发需要以下几点:

  • mouseup强调是松手触发,与mousedown是相反的
  • mouseup与mousedown组合起来就是click事件
  • 任何鼠标按钮松手时都能触发mouseup事件
  • 用event 对象的which区别按键,敲击鼠标左键which的值是1,敲击鼠标中键which的值是2,敲击鼠标右键which的值是3

click与mousedown的区别:
click事件其实是由mousedown于mouseup 2个动作构成,所以点击的动作只有在松手后才触发

(3)mousemove事件

用交互操作中,经常需要知道用户是否有移动的操作。基于移动的机制可以做出拖动、拖拽一系列的效果出来。针对移动事件,jQuery提供了一个mousemove的快捷方法可以监听用户移动的的操作

方法一:$ele.mousemove()
方法二:$ele.mousemove( handler(eventObject) )
方法三:$ele.mousemove( [eventData ], handler(eventObject) )

    <h4>测试</h4>     <div class="left">         <div class="aaron1">             <p>鼠标在绿色区域移动触发mousemove</p>             <p>移动的X位置:</p>         </div>     </div>     <script type="text/javascript">     //绑定一个mousemove事件     //触发后修改内容     $(".aaron1").mousemove(function(e) {         $(this).find('p:last').html('移动的X位置:' + e.pageX)     })     </script> 
jQuery基础(2)

mousemove事件触发需要以下几点:

  • mousemove事件是当鼠标指针移动时触发的,即使是一个像素
  • 如果处理器做任何重大的处理,或者如果该事件存在多个处理函数,这可能造成浏览器的严重的性能问题

(4)mouseover与mouseout事件

在学JS的时候,大家还记得有两个方法叫移入移出事件吗?onmouseover()与onmouseout()事件~

jQuery当中同样提供了这样的事件来监听用户的移入移出操作,mouseover()与mouseout()事件,两者用法类似,下面一mouseover为例:
方法一:$ele.mouseover()
方法二:$ele.mouseover( handler(eventObject) )
方法三:$ele.mouseover( [eventData ], handler(eventObject) )

 <h4>测试</h4>     <div class="right">         <div class="aaron2">             <p>鼠标移动:不同函数传递数据</p>             <a>进入元素内部,mouseover事件触发次数:</a>         </div>     </div>     <br/>     <script type="text/javascript">         var n = 0;         //不同函数传递数据         function data(e) {             $(".right a").html('mouseover事件触发次数:' + (++n) + '<br/> 传入数据为 :'+ e.data)         }          function a() {             $(".right p:first").mouseover('data = 慕课网', data)         }         a();     </script> 

(5)mouseenter与mouseleave事件

用交互操作中,经常需要知道用户操作鼠标是否有移到元素内部或是元素外部,因此jQuery提供了一个mouseenter和mouseleave的快捷方法可以监听用户移动到内部的操作

使用上非常简单,三种参数传递方式与mouseover和mouseout是一模一样的,所以这里不再重复,主要讲讲区别,下面以mouseenter为例:

mouseenter JavaScript事件是Internet Explorer专有的。由于该事件在平时很有用,jQuery的模拟这一事件,以便它可用于所有浏览器。该事件在鼠标移入到元素上时被触发。任何HTML元素都可以接受此事件。

mouseenter事件和mouseover的区别:
关键点就是:冒泡的方式处理问题

mouseover为例:

<div>     <p>鼠标离开此区域触发mouseover事件</p> </div> 

如果在p元素与div元素都绑定mouseover事件,鼠标在离开p元素,但是没有离开div元素的时候,触发的结果:

  1. p元素响应事件
  2. div元素响应事件

这里的问题是div为什么会被触发? 原因就是事件冒泡的问题,p元素触发了mouseover,他会一直往上找父元素上的mouseover事件,如果父元素有mouseover事件就会被触发

所以在这种情况下面,jQuery推荐我们使用 mouseenter事件
mouseenter事件只会在绑定它的元素上被调用,而不会在后代节点上被触发

(6)hover事件

学了mouseover、mouseout、mouseenter、mouseleave事件,也理解了四个事件的相同点与不同点,现在可以用来给元素做一个简单的切换效果

在元素上移进移出切换其颜色,一般通过2个事件配合就可以达到,这里用mouseenter与mouseleave,这样可以避免冒泡问题

$(ele).mouseenter(function(){      $(this).css("background", 'red');  }) $(ele).mouseleave(function(){     $(this).css("background", '#bbffaa'); }) 

这样目的是达到了,代码稍微有点多,对于这样的简单逻辑jQuery直接提供了一个hover方法,可以便捷处理

只需要在hover方法中传递2个回调函数就可以了,不需要显示的绑定2个事件

$(selector).hover(handlerIn, handlerOut)

  • handlerIn(eventObject):当鼠标指针进入元素时触发执行的事件函数
  • handlerOut(eventObject):当鼠标指针离开元素时触发执行的事件函数
$("p").hover(         function() {             $(this).css("background", 'red');         },         function() {             $(this).css("background", '#bbffaa');         }     ); 

第2章 表单事件

(1)focusin事件

当一个元素,或者其内部任何一个元素获得焦点的时候,例如:input元素,用户在点击聚焦的时候,如果开发者需要捕获这个动作的时候,jQuery提供了一个focusin事件
方法一:$ele.focusin()
方法二:$ele.focusin( handler )
方法三:$ele.focusin( [eventData ], handler )

//input聚焦 //给input元素增加一个边框  $("input:first").focusin(function() {       $(this).css('border','10px solid red') }) 
//不同函数传递数据 function fn(e) {      $(this).val(e.data) }  function a() {      $("input:last").focusin('慕课网', fn) } a(); 
jQuery基础(2)

(2)focusout事件

当一个元素,或者其内部任何一个元素失去焦点的时候,比如input元素,用户在点击失去焦的时候,如果开发者需要捕获这个动作,jQuery提供了一个focusout事件
方法一:$ele.focusout()
方法二:$ele.focusout( handler )
方法三:$ele.focusout( [eventData ], handler )

(3)focus与blur事件

除了表单处理事件focusin事件与focusout事件,同样用于处理表单焦点的事件还有focus与blur事件

它们之间的本质区别:是否支持冒泡处理

举个简单的例子

<div>   <input type="text" /> </div> 

其中input元素可以触发focus()事件

div是input的父元素,当它包含的元素input触发了focus事件时,它就产生了focusin()事件。

focus()在元素本身产生,focusin()在元素包含的元素中产生

    <h4>.focusin与blur</h4>     <div class="left">         <div class="aaron">             点击触发焦点(无反应):             <input type="text" />         </div>         <div class="aaron1">             点击触发焦点并冒泡:             <input type="text" />         </div>     </div>     <script type="text/javascript">     $(".aaron").focus(function() {         $(this).css('border', '2px solid red')     })     $(".aaron1").focusin(function() {         $(this).find('input').val('冒泡捕获了focusin事件')     })     </script> 

blur与focusout也亦是如此

(4)change事件

<input>元素,<textarea>和<select>元素的值都是可以发生改变的,开发者可以通过change事件去监听这些改变的动作

  1. input元素
    监听value值的变化,当有改变时,失去焦点后触发change事件。对于单选按钮和复选框,当用户用鼠标做出选择时,该事件立即触发。
  2. select元素
    对于下拉选择框,当用户用鼠标作出选择时,该事件立即触发
  3. textarea元素
    多行文本输入框,当有改变时,失去焦点后触发change事件

(5)select事件

当 textarea 或文本类型的 input 元素中的文本被选择时,会发生 select 事件。
这个函数会调用执行绑定到select事件的所有函数,包括浏览器的默认行为。可以通过在某个绑定的函数中返回false来防止触发浏览器的默认行为。

select事件只能用于<input>元素与<textarea>元素

使用上非常简单:
方法一:$ele.select()
方法二:$ele.select( handler(eventObject) )
方法三:$ele.select( [eventData ], handler(eventObject) )

    //监听input元素中value的选中     //触发元素的select事件     $("input").select(function(e){         alert(e.target.value)     })     $("#bt1").click(function(){         $("input").select();     }) 

(6)submit事件

提交表单是一个最常见的业务需求,比如用户注册,一些信息的输入都是需要表单的提交。同样的有时候开发者需要在表单提交的时候过滤一些的数据、做一些必要的操作(例如:验证表单输入的正确性,如果错误就阻止提交,从新输入)此时可以通过submit事件,监听下提交表单的这个动作
方法一:$ele.submit()
方法二:$ele.submit( handler(eventObject) )
方法三:$ele.submit( [eventData ], handler(eventObject) )

通过在<form>元素上绑定submit事件,开发者可以监听到用户的提交表单的的行为

具体能触发submit事件的行为:

  • <input type=”submit”>
  • <input type=”image”>
  • <button type=”submit”>
  • 当某些表单元素获取焦点时,敲击Enter(回车键)

上述这些操作下,都可以截获submit事件。

这里需要特别注意:

form元素是有默认提交表单的行为,如果通过submit处理的话,需要禁止浏览器的这个默认行为
传统的方式是调用事件对象 e.preventDefault() 来处理, jQuery中可以直接在函数中最后结尾return false即可

jQuery处理如下:

$("#target").submit(function(data) {     return false; //阻止默认行为,提交表单 }); 
<body>     <h2>submit</h2>     <div class="left">         <div class="aaron">             <form id="target1" action="test.html">                 回车键或者点击提交表单:                  <input type="text" value="输入新的值" />                 <input type="submit" value="Go" />             </form>         </div>         <div class="aaron">             <form id="target2" action="destination.html">                 回车键或者点击提交表单,禁止浏览器默认跳转:                  <input type="text" value="输入新的值" />                 <input type="submit" value="Go" />             </form>         </div>     </div>     <script type="text/javascript">     //回车键或者点击提交表单     $('#target1').submit(function(e) {         alert('捕获提交表达动作,不阻止页面跳转')     });     //回车键或者点击提交表单,禁止浏览器默认跳转:     $('#target2').submit(function() {         alert('捕获提交表达动作,阻止页面跳转')         return false;     });     </script> </body> 

第3章 键盘事件

(1)keydown()与keyup()事件

鼠标有mousedown,mouseup之类的事件,这是根据人的手势动作分解的2个触发行为。相对应的键盘也有这类事件,将用户行为分解成2个动作,键盘按下与松手,针对这样的2种动作,jQuery分别提供了对应keydown与keyup方法来监听

keydown事件:

当用户在一个元素上第一次按下键盘上字母键的时候,就会触发它。使用上非常简单,与基本事件参数处理保持一致,这里使用不在重复了,列出使用的方法

//直接绑定事件 $elem.keydown( handler(eventObject) ) //传递参数 $elem.keydown( [eventData ], handler(eventObject) ) //手动触发已绑定的事件 $elem.keydown() 
keyup事件:

当用户在一个元素上第一次松手键盘上的键的时候,就会触发它。使用方法与keydown是一致的只是触发的条件是方法的

注意:
  • keydown是在键盘按下就会触发
  • keyup是在键盘松手就会触发
  • 理论上它可以绑定到任何元素,但keydown/keyup事件只是发送到具有焦点的元素上,不同的浏览器中,可获得焦点的元素略有不同,但是表单元素总是能获取焦点,所以对于此事件类型表单元素是最合适的。

(2)keypress()事件

在input元素上绑定keydown事件会发现一个问题:
每次获取的内容都是之前输入的,当前输入的获取不到

keydown事件触发在文字还没敲进文本框,这时如果在keydown事件中输出文本框中的文本,得到的是触发键盘事件前的文本,而keyup事件触发时整个键盘事件的操作已经完成,获得的是触发键盘事件后的文本

当浏览器捕获键盘输入时,还提供了一个keypress的响应,这个跟keydown是非常相似。

keypress事件与keydown和keyup的主要区别

  • 只能捕获单个字符,不能捕获组合键
  • 无法响应系统功能键(如delete,backspace)
  • 不区分小键盘和主键盘的数字字符

总而言之,KeyPress主要用来接收字母、数字等ANSI字符,而 KeyDown 和 KeyUP 事件过程可以处理任何不被 KeyPress 识别的击键。诸如:功能键(F1-F12)、编辑键、定位键以及任何这些键和键盘换档键的组合等。

第4章 事件的绑定和解绑

(1)on()的多事件绑定

之前学的鼠标事件,表单事件与键盘事件都有个特点,就是直接给元素绑定一个处理函数,所有这类事件都是属于快捷处理。翻开源码其实可以看到,所有的快捷事件在底层的处理都是通过一个”on”方法来实现的。jQuery on()方法是官方推荐的绑定事件的一个方法。

基本用法:.on( events ,[ selector ] ,[ data ] )

最常见的给元素绑定一个点击事件,对比一下快捷方式与on方式的不同

$("#elem").click(function(){})  //快捷方式 $("#elem").on('click',function(){}) //on方式 

最大的不同点就是on是可以自定义事件名,当然不仅仅只是如何,继续往下看

1)多个事件绑定同一个函数

$("#elem").on("mouseover mouseout",function(){ });
通过空格分离,传递不同的事件名,可以同时绑定多个事件

2)多个事件绑定不同函数
$("#elem").on({    mouseover:function(){},      mouseout:function(){} }); 

通过空格分离,传递不同的事件名,可以同时绑定多个事件,每一个事件执行自己的回调方法

3)将数据传递到处理程序
function greet( event ) {   alert( "Hello " + event.data.name ); //Hello 慕课网 } $( "button" ).on( "click", {   name: "慕课网" }, greet ); 

可以通过第二参数(对象),当一个事件被触发时,会传递给事件处理函数

<body>     <h2>on绑定多事件</h2>      <h4>测试一</h4>     <div class="left">         点击触发:on('click',fn)         <div id="test1"></div>     </div>     <script type="text/javascript">     //事件绑定一     $("#test1").on('click', function(e) {         $(this).text('触发事件:' + e.type)     })     </script>       <h4>测试二</h4>     <div class="left">         点击触发:on('mousedown mouseup')         <div id="test2"></div>     </div>     <script type="text/javascript">     //多事件绑定一     $("#test2").on('mousedown mouseup', function(e) {         $(this).text('触发事件:' + e.type)     })     </script>       <h4>测试三</h4>     <div class="right">         点击触发:on(mousedown:fn1,mouseup:fn2)         <div id="test3"></div>     </div>     <script type="text/javascript">     //多事件绑定二     $("#test3").on({         mousedown: function(e) {             $(this).text('触发事件:' + e.type)         },         mouseup: function(e) {             $(this).text('触发事件:' + e.type)         }     })     </script> </body> 

(2)on()的高级用法

针对自己处理机制中,不仅有on方法,还有根据on演变出来的live方法(1.7后去掉了),delegate方法等等。这些方法的底层实现部分还是on方法,这是利用了on的另一个事件机制委托的机制衍变而来的

委托机制

.on( events ,[ selector ] ,[ data ], handler(eventObject) )
在on的第二参数中提供了一个selector选择器,简单的来描述下

<div class="left">     <p class="aaron">         <a>目标节点</a> //点击在这个元素上     </p> </div> 

给出如下代码:
$("div").on("click","p",fn)

事件绑定在最上层div元素上,当用户触发在a元素上,事件将往上冒泡,一直会冒泡在div元素上。如果提供了第二参数,那么事件在往上冒泡的过程中遇到了选择器匹配的元素,才会触发事件回调函数

(3)卸载事件off()方法

通过.on()绑定的事件处理程序
通过.off() 方法移除该绑定
根据on绑定事件的一些特性,off方法也可以通过相应的传递组合的事件名,名字空间,选择器或处理函数来移除绑定在元素上指定的事件处理函数。当有多个过滤参数时,只有与这些参数完全匹配的事件处理函数才会被移除

绑定2个事件
$("elem").on("mousedown mouseup",fn)

删除一个事件
$("elem").off("mousedown")

删除所有事件
$("elem").off("mousedown mouseup")

快捷方式删除所有事件,这里不需要传递事件名了,节点上绑定的所有事件将全部销毁
$("elem").off()

第5章 事件对象的使用

(1)jQuery事件对象的作用

事件中的Event对象容易被初学者忽略掉,可能大多时候初学者不知道怎么去用它,但有些时候它还是非常有用的。

一个标准的”click”点击事件

$(elem).on("click",function(event){    event //事件对象 }) 

在不同浏览器之间事件对象的获取, 以及事件对象的属性都有差异。jQuery根据 W3C 标准规范了事件对象,所以在jQuery事件回调方法中获取到的事件对象是经过兼容后处理过的一个标准的跨浏览器对象

这里不在千篇一律的说方法的使用,通过实际的一个小案例,从而来了解事件对象的作用

<ul>     <li class="even1"></li>     <li class="even2"></li>     <li class="even2"></li>     ......... </ul> 

ul有N个子元素li(这里只写了3个),如果要响应每一个li的事件,那么常规的方法就是需要给所有的li都单独绑定一个事件监听,这样写法很符合逻辑,但是同时有显得繁琐

因为li都有一个共同的父元素,而且所有的事件都是一致的,这里我们可以采用要一个技巧来处理,也是常说的“事件委托”

事件没直接和li元素发生关系,而且绑定父元素了。由于浏览器有事件冒泡的这个特性,我们可以在触发li的时候把这个事件往上冒泡到ul上,因为ul上绑定事件响应所以就能够触发这个动作了。唯一的问题怎么才知道触发的li元素是哪个一个?

这里就引出了事件对象了

事件对象是用来记录一些事件发生时的相关信息的对象。事件对象只有事件发生时才会产生,并且只能是事件处理函数内部访问,在所有事件处理函数运行结束后,事件对象就被销毁

回到上面的问题,既然事件对象是跟当前触发元素息息相关的,所以我们就能从里面相关的信息,从事件对象中找到 event.target

event.target

target 属性可以是注册事件时的元素,或者它的子元素。通常用于比较 event.target 和 this 来确定事件是不是由于冒泡而触发的。经常用于事件冒泡时处理事件委托

简单来说:event.target代表当前触发事件的元素,可以通过当前元素对象的一系列属性来判断是不是我们想要的元素

(2)jQuery事件对象的属性和方法

事件对象的属于与方法有很多,但是我们经常用的只有那么几个,这里我主要说下作用与区别

1)event.type:获取事件的类型,触发元素的事件类型
$("a").click(function(event) {   alert(event.type); // "click"事件 }); 
2)event.pageX 和 event.pageY:获取鼠标当前相对于页面的坐标

通过这2个属性,可以确定元素在当前页面的坐标值,鼠标相对于文档的左边缘的位置(左边)与 (顶边)的距离,简单来说是从页面左上角开始,以页面为参考点,不随滑动条移动而变化

3)event.preventDefault() 方法:阻止默认行为

这个用的特别多,在执行这个方法后,如果点击一个链接(a标签),浏览器不会跳转到新的 URL 去了。我们可以用 event.isDefaultPrevented() 来确定这个方法是否(在那个事件对象上)被调用过了

4)event.stopPropagation() 方法:阻止事件冒泡

事件是可以冒泡的,为防止事件冒泡到DOM树上,也就是不触发的任何前辈元素上的事件处理函数

5)event.which:获取在鼠标单击时,单击的是鼠标的哪个键

event.which 将 event.keyCode 和 event.charCode 标准化了。event.which也将正常化的按钮按下(mousedown 和 mouseup),左键报告1,中间键报告2,右键报告3

6)event.currentTarget : 在事件冒泡过程中的当前DOM元素

冒泡前的当前触发事件的DOM对象, 等同于this.

this和event.target的区别:

js中事件是会冒泡的,所以this是可以变化的,但event.target不会变化,它永远是直接接受事件的目标DOM元素;

.this和event.target都是dom对象

如果要使用jquey中的方法可以将他们转换为jquery对象。比如this和$(this)的使用、event.target和$(event.target)的使用;

第6章 自定义事件

(1)trigger事件

众所周知类似于mousedown、click、keydown等等这类型的事件都是浏览器提供的,通俗叫原生事件,这类型的事件是需要有交互行为才能被触发。

在jQuery通过on方法绑定一个原生事件

$('#elem').on('click', function() {     alert("触发系统事件")  }); 

alert需要执行的条件:必须有用户点击才可以。如果不同用户交互是否能在某一时刻自动触发该事件呢? 正常来说是不可以的,但是jQuery解决了这个问题,提供了一个trigger方法来触发浏览器事件

所以我们可以这样:

$('#elem').trigger('click');
在绑定on的事件元素上,通过trigger方法就可以调用到alert了,挺简单!

.trigger是什么?
简单来讲就是:根据绑定到匹配元素的给定的事件类型执行所有的处理程序和行为

trigger除了能够触发浏览器事件,同时还支持自定义事件,并且自定义时间还支持传递参数

$('#elem').on('Aaron', function(event,arg1,arg2) {     alert("自触自定义时间")  }); $('#elem').trigger('Aaron',['参数1','参数2']) 

trigger触发浏览器事件与自定义事件区别?

  • 自定义事件对象,是jQuery模拟原生实现的
  • 自定义事件可以传递参数
<body>     <h2>自定义事件trigger</h2>     <div class="left">         <div><span></span><span>0</span>点击次数</div>         <button>直接点击</button>         <button>通过自定义点击</button>     </div>     <script type="text/javascript">      //点击更新次数     $("button:first").click(function(event,bottonName) {         bottonName = bottonName || 'first';         update($("span:first"),$("span:last"),bottonName);     });      //通过自定义事件调用,更新次数     $("button:last").click(function() {         $("button:first").trigger('click','last');     });      function update(first,last,bottonName) {         first.text(bottonName);         var n = parseInt(last.text(), 10);         last.text(n + 1);     }     </script> </body> 

(2)triggerHandler事件

trigger事件还有一个特性:会在DOM树上冒泡,所以如果要阻止冒泡就需要在事件处理程序中返回false或调用事件对象中的.stopPropagation() 方法可以使事件停止冒泡

trigger事件是具有触发原生与自定义能力的,但是存在一个不可避免的问题: 事件对象event无法完美的实现,毕竟一个是浏览器给的,一个是自己模拟的。尽管 .trigger() 模拟事件对象,但是它并没有完美的复制自然发生的事件,若要触发通过 jQuery 绑定的事件处理函数,而不触发原生的事件,使用.triggerHandler() 来代替

triggerHandler与trigger的用法是一样的,重点看不同之处:

  • triggerHandler不会触发浏览器的默认行为,.triggerHandler( “submit” )将不会调用表单上的.submit()
  • .trigger() 会影响所有与 jQuery 对象相匹配的元素,而 .triggerHandler()** 仅影响第一个匹配到的元素**
  • 使用 .triggerHandler() 触发的事件,并不会在 DOM 树中向上冒泡。 如果它们不是由目标元素直接触发的,那么它就不会进行任何处理
  • 与普通的方法返回 jQuery 对象(这样就能够使用链式用法)相反,.triggerHandler() 返回最后一个处理的事件的返回值。如果没有触发任何事件,会返回 undefined
<body> <h2>自定义事件triggerHandler</h2> <div class="left">     <div id="accident">         <a>triggerHandler事件</a>         <input type="text">     </div>     <button>事件冒泡,触发浏览器默认聚焦行为</button><br><br>     <button>不会冒泡,不触发浏览器默认聚焦行为</button> </div> <script type="text/javascript">      //给input绑定一个聚焦事件     $("input").on("focus",function(event,title) {         $(this).val(title)     });      $("#accident").on("click",function() {         alert("trigger触发的事件会在 DOM 树中向上冒泡");     });     //trigger触发focus     $("button:first").click(function() {         $("a").trigger("click");         $("input").trigger("focus");     });      //triggerHandler触发focus     $("button:last").click(function() {         $("a").triggerHandler("click");         $("input").triggerHandler("focus","没有触发默认聚焦事件");     }); </script> </body> </html> 

来源1:慕课网_jQuery基础(二)—DOM篇
来源2:慕课网_jQuery基础(三)—事件篇

点赞