jquery基础知识整理

写在前面的话：由于公司做的政府网站，需要考虑到兼容ie。所以我们使用jquery解决方案。在一些展示类的、不是一个多网页的整体应用中。我们仍然可以使用jQuery进行开发。
以下是我看慕课网整理的jQuery知识。慕课网课程链接jQuery课程。
以下是我整理的知识：

新点jQuery学习

jQuery对象

jQuery对象和DOM对象

jQuery对象和DOM对象是不一样的，示例如下：

var p = document.getElementById('imooc1');
// 将元素p在html中内容改变
p.innerHTML = 'P1：您好！通过慕课网学习jQuery才是最佳的途径';
// 将元素p的内容颜色改为红色
p.style.color = 'red';	

DOM对象需要先获取到他的相应的元素才能改变他的style、class属性

var $p = $('#imooc2');
$p.html('P2：您好！通过慕课网学习jQuery才是最佳的途径').css('color','red');

jQuery对象是一个类数组操作

jQuery对象转化成dom对象

利用数组下标的方式读取到jQuery中的DOM对象

var $div = $('div') //jQuery对象
var div = $div[0] //转化成DOM对象
div.style.color = 'red' //操作dom对象的属性

通过jQuery自带的get()方法

var $div = $('div') //jQuery对象
var div = $div.get(0) //通过get方法，转化成DOM对象
div.style.color = 'red' //操作dom对象的属性

DOM对象转化成jQuery对象

var div = document.getElementsByTagName('div'); //获取到dom对象数组
var $div = $(div); //jQuery对象
var $first = $div.first(); //拿到第一个div元素
$first.css('color', 'red'); //给第一个元素设置颜色

jQuery选择器

id选择器

d选择器：一个用来查找的ID，即元素的id属性

$( "#id" )

注意：id是唯一的，每个id值在一个页面中只能使用一次。如果多个元素分配了相同的id，将只匹配该id选择集合的第一个DOM元素。

类选择器

$( ".class" )

和原生js的区别：jQuery的类选择器得到的也是一个数组。但是可以直接修改他们的css样式。$(“.class”).css()方法内部肯定是带了一个隐式的循环处理

<script type="text/javascript">
    //通过原生方法处理
    //样式是可以多选的，所以得到的是一个合集
    //需要通过循环给合集中每一个元素修改样式
    var divs = document.getElementsByClassName('aaron');
    for (var i = 0; i < divs.length; i++) {
        divs[i].style.border = "3px solid blue";
    }
</script>

<script type="text/javascript">
    var $divs = $( ".class" )
    $divs.css("border", "3px solid red");
</script>

元素选择器

$( "element" )

和类选择器类似，可以通过css方法直接赋予样式。

通配选择器

$( "*" )

在原生js中，如果要获取文档中所有的元素，通过document.getElementsByTagName()中传递"*"同样可以获取到。会获得从外到内的DOM元素数组。

层级选择器

和原生js类似

一般兄弟选择器能选中符合siblings规则的所有兄弟选择器，但是不能选中他们兄弟的子级选择器。示例如下：

<div class="prev"></div>
<div>
</div>
<div>
    能选中我么
</div>
<div>
    父级元素
    <div>我是他兄弟的儿子，选不中我吧</div>
</div>

基本筛选选择器

很多时候我们不能直接通过基本选择器与层级选择器找到我们想要的元素，为此jQuery提供了一系列的筛选选择器用来更快捷的找到所需的DOM元素。如下：

内容筛选选择器

注意：has能选中指定选择器的元素和包含着它的父级元素。但是不能选中包含着指定选择器元素的祖先及元素

示例：

$(".div:has(span)").css("color", "blue");

它这个的意思就是找类名为div的元素并且里面含有span元素的元素

可见性筛选选择器

我们有几种方式可以隐藏一个元素：

1. CSS display的值是none。
2. type="hidden"的表单元素。
3. 宽度和高度都显式设置为0。
4. 一个祖先元素是隐藏的，该元素是不会在页面上显示
5. CSS visibility的值是hidden
6. CSS opacity的指是0

那么什么元素会被:hidden选择器选到呢？

• display:none的元素会被hidden选择器选中

不能选中的？

• width和height都是0

• visibility:hidden的元素

• opacity:0的元素

  以上元素虽然不可见，但是会在文档流中占据一定的宽高，所以jQuery能选中他们。absolute元素虽然不占据文档流，但是也不会被选中。所以我猜测只要是在文档中显示一定宽高的元素，都不会被hidden选择器选中。

属性选择器

注意传入的value要以引号包起来。

能根据dom元素所具有的属性样式来选择到该dom元素，具体如下表：

子元素选择器

注意事项：

1. :first只匹配一个单独的元素，但是:first-child选择器可以匹配多个：即为每个父级元素匹配第一个子元素。这相当于:nth-child(1)
2. :last 只匹配一个单独的元素， :last-child 选择器可以匹配多个元素：即，为每个父级元素匹配最后一个子元素
3. 如果子元素只有一个的话，:first-child与:last-child是同一个
4. :only-child匹配某个元素是父元素中唯一的子元素，就是说当前子元素是父元素中唯一的元素，则匹配
5. jQuery实现:nth-child(n)是严格来自CSS规范，所以n值是“索引”，也就是说，从1开始计数，:nth-child(index)从1开始的，而eq(index)是从0开始的
6. nth-child(n) 与 :nth-last-child(n) 的区别前者是从前往后计算，后者从后往前计算

表单元素选择器

注意事项：

除了input筛选选择器，几乎每个表单类别筛选器都对应一个input元素的type值。大部分表单类别筛选器可以使用属性筛选器替换。比如 $(‘:password’) == $(‘[type=password]’)

表单对象属性筛选选择器

注意事项：

1. 选择器适用于复选框和单选框，对于下拉框元素, 使用 :selected 选择器
2. 在某些浏览器中，选择器:checked可能会错误选取到元素，所以保险起见换用选择器input:checked，确保只会选取元素

特殊选择器this

在DOM中this就是指向了这个html元素对象，因为this就是DOM元素本身的一个引用

假如给页面一个P元素绑定一个事件:

p.addEventListener('click',function(){
    //this === p
    //以下两者的修改都是等价的
    this.style.color = "red";
    p.style.color = "red";
},false);

通过addEventListener绑定的事件回调中，this指向的是当前的dom对象，所以再次修改这样对象的样式，只需要通过this获取到引用即可

 this.style.color = "red"

但是这样的操作其实还是很不方便的，这里面就要涉及一大堆的样式兼容，如果通过jQuery处理就会简单多了，我们只需要把this加工成jQuery对象

换成jQuery的做法：

$('p').click(function(){
    //把p元素转化成jQuery的对象
    var $this= $(this) 
    $this.css('color','red')
})

通过把$()方法传入当前的元素对象的引用this，把这个this加工成jQuery对象，我们就可以用jQuery提供的快捷方法直接处理样式了

jQuery的属性和样式

attribute方法

attribute和property的区别：

dom中有个概念的区分：Attribute和Property翻译出来都是“属性”，《js高级程序设计》书中翻译为“特性”和“属性”。简单理解，Attribute就是dom节点自带的属性

包括：html中常用的id、class、title、align等：

<div id="immooc" title="慕课网"></div>

而Property是这个DOM元素作为对象，其附加的内容，例如,tagName, nodeName, nodeType, defaultChecked, 和 defaultSelected 使用.prop()方法进行取值或赋值等

操作attribute

操作特性（attribute）的DOM方法主要有3个，getAttribute方法、setAttribute方法和removeAttribute方法，就算如此在实际操作中还是会存在很多问题，这里先不说。而在jQuery中用一个attr()与removeAttr()就可以全部搞定了，包括兼容问题

jQuery中用attr()方法来获取和设置元素属性,attr是attribute（属性）的缩写，在jQuery DOM操作中会经常用到attr()

attr()有4个表达式

1. attr(传入属性名)：获取属性的值
2. attr(属性名, 属性值)：设置属性的值
3. attr(属性名,函数值)：设置属性的函数值
4. attr(attributes)：给指定元素设置多个属性值，即：{属性名一: “属性值一” , 属性名二: “属性值二” , … … }

removeAttr()删除方法

.removeAttr( attributeName ) : 为匹配的元素集合中的每个元素中移除一个属性（attribute）

.html()及.text()方法

用法：括号内传入一个字符串参数。这两个方法会将参数按照html格式和txt文本格式渲染。相当于dom.innerHTML和innerText

如果不传入参数,

.html()方法 会返回该DOM下所有的子节点和文本，示例如下

<div class="div">
    <a>:first-child</a>
    <a>第二个元素</a>
    <a>:last-child</a>
</div>  
<div class="div">
    <a>:first-child</a>
    <a>第二个元素</a>
    <a>:last-child</a>
</div>

.text()方法会返回该DOM节点下的所有文本

:first-child
第二个元素
:last-child


:first-child
第二个元素
:last-child

.val()方法

.val()方法主要是用于处理表单元素的值，比如 input, select 和 textarea。

.val()方法中如果传入一个字符串参数，如果是input元素，他会被渲染成这个input的value值。

.val()方法中不传入参数，

• 如果是select，他会返回被选中状态的selected="selected"的文本字符串
• 如果是多个复合选项multiple="multiple",他会以数组的形式返回选中的文本字符串
• 如果是input，会返回他的value值也就是文本

总结：val、html、text方法都是用来读取、和写入dom节点的内容值的

增加样式方法.addClass()

• .addClass( className ) : 为每个匹配元素所要增加的一个或多个样式名

• .addClass( function(index, currentClass) ) : 这个函数返回一个或更多用空格隔开的要增加的样式名。

删除样式.removeClass()

• .removeClass( [className ] )：每个匹配元素移除的一个或多个用空格隔开的样式名

• .removeClass( function(index, class) ) ： 一个函数，返回一个或多个将要被移除的样式名。

切换样式.toggleClass()

• .toggleClass( className )：在匹配的元素集合中的每个元素上用来切换的一个或多个（用空格隔开）样式类名
• .toggleClass( className, switch )：一个布尔值，用于判断样式是否应该被添加或移除
• .toggleClass( [switch ] )：一个用来判断样式类添加还是移除的 布尔值
• .toggleClass( function(index, class, switch) [, switch ] )：用来返回在匹配的元素集合中的每个元素上用来切换的样式类名的一个函数。接收元素的索引位置和元素旧的样式类作为参数

**总结回调函数：**这个回调函数第一个参数是匹配到的元素索引，也就是匹配到的class数组中的第几个。第二个参数是这个索引元素的类名字符串，以空格隔开。

样式操作.css()

作用： .css() 方法：获取元素样式属性的计算值或者设置元素的CSS属性

获取：

1. .css( propertyName ) ：获取匹配元素集合中的第一个元素的样式属性的计算值
2. .css( propertyNames )：传递一组数组，返回一个对象结果

设置：

1. .css(propertyName, value )：设置CSS
2. .css( propertyName, function )：可以传入一个回调函数，返回取到对应的值进行处理
3. .css( properties )：可以传一个对象，同时设置多个样式

设置css样式的方法.css和.addClass的区别

可维护性：

.addClass()的本质是通过定义个class类的样式规则，给元素添加一个或多个类。css方法是通过JavaScript大量代码进行改变元素的样式

通过.addClass()我们可以批量的给相同的元素设置统一规则，变动起来比较方便，可以统一修改删除。如果通过.css()方法就需要指定每一个元素是一一的修改，日后维护也要一一的修改，比较麻烦

灵活性：

通过.css()方式可以很容易动态的去改变一个样式的属性，不需要在去繁琐的定义个class类的规则。一般来说在不确定开始布局规则，通过动态生成的HTML代码结构中，都是通过.css()方法处理的

样式值：

.addClass()本质只是针对class的类的增加删除，不能获取到指定样式的属性的值，.css()可以获取到指定的样式值。

样式的优先级：

css的样式是有优先级的，当外部样式、内部样式和内联样式同一样式规则同时应用于同一个元素的时候，优先级如下

外部样式 < 内部样式 < 内联样式

1. .addClass()方法是通过增加class名的方式，那么这个样式是在外部文件或者内部样式中先定义好的，等到需要的时候在附加到元素上
2. 通过.css()方法处理的是内联样式，直接通过元素的style属性附加到元素上的

元素存储数据

html5 dataset是新的HTML5标准，允许你在普通的元素标签里嵌入类似data-*的属性，来实现一些简单数据的存取。它的数量不受限制，并且也能由JavaScript动态修改，也支持CSS选择器进行样式设置。这使得data属性特别灵活，也非常强大。有了这样的属性我们能够更加有序直观的进行数据预设或存储。就是dom元素可以直接绑定数据。

在原生系统中如何实现呢？

写入

• 直接在dom中写入

<div class="child" data-name="小红" data-age="18"></div>

• dom对象的setAttribute()方法

dom.setAttribute('data-name', '小明')

这个 -后面带的就是data字典里的属性名

JS获取

js中有两种获取方法：

• dataset：放在data-*中的属性都在dataset中，以map（字典，键值对的方式存储）可以通过dataset.属性名来获取

  var dataset = dom.dataset.name;
  

  示意图如下：

  

• getAttribute()方法获取

  dom.getAttribute('data-name');
  

CSS中使用

可以使用属性选择器，data里面的age属性等于18

.child[data-age='18'] {
    color: red;
}

Jquery中使用

那么在不支持HTML5标准的浏览器中，我们如何实现数据存取? jQuery就提供了一个.data()的方法来处理这个问题

使用jQuery初学者一般不是很关心data方式，这个方法是jquery内部预用的，可以用来做性能优化，比如sizzle选择中可以用来缓存部分结果集等等。当然这个也是非常重要的一个API了，常常用于我们存放临时的一些数据，因为它是直接跟DOM元素对象绑定在一起的

jQuery提供的存储接口

jQuery.data( element, key, value )   //静态接口,存数据
jQuery.data( element, key )  //静态接口,取数据   
.data( key, value ) //实例接口,存数据
.data( key ) //实例接口,存数据

2个方法在使用上存取都是通一个接口，传递元素，键值数据。在jQuery的官方文档中，建议用.data()方法来代替。

我们把DOM可以看作一个对象，那么我们往对象上是可以存在基本类型，引用类型的数据的，但是这里会引发一个问题，可能会存在循环引用的内存泄漏风险

通过jQuery提供的数据接口，就很好的处理了这个问题了，我们不需要关心它底层是如何实现，只需要按照对应的data方法使用就行了

同样的也提供2个对应的删除接口，使用上与data方法其实是一致的，只不过是一个是增加一个是删除罢了

jQuery.removeData( element [, name ] )
.removeData( [name ] )

jQuery的dom

dom节点的创建

js原生中创建节点的流程

• 创建元素：document.createElement
• 设置属性：setAttribute
• 把文本文本或子元素添加进去：创建的节点.innerHTML=,或者创建的节点.appendChild(其他dom节点)
• 加入文档：dom.appendChild(创建的元素)

jQuery创建

$("<div class='right'><div class='aaron'>动态创建DIV元素节点</div></div>")

可以创建多层次的dom节点，class等属性也可以以字符串的形式写进里面，然后传给jQuery对象

dom节点的插入

内部插入

内部插入的意思就是往所选中的元素内部插入元素，以下方法属于内部插入。

append和appendTo

append和appendTo方法会将创建的节点插入到选中节点的内部的最后一个子元素中

• append

  $(".content").append('<div class="append">通过append方法添加的元素</div>')
  

• appendTo

  $('<div class="appendTo">通过appendTo方法添加的元素</div>').appendTo($(".content"))
  

prepend()与prependTo()

prepend()与prependTo()方法会将创建的元素插入到所选中的元素内部第一个元素的位置上。如果有第一个了，则会把原来的第一个往后挤。

使用示例如下、

• prepend

  $('.aaron1').append('<p>prepend增加的p元素</p>')
  

• prependTo

  $('<p>prependTo增加的p元素</p>').prependTo($('.aaron2'))
  

外部插入

外部插入的意思就是在所选元素的标签外面插入元素，以下方法属于外部插入：

after和before方法

after和before方法会分别把元素插入到所选定的元素的前面和后面相邻的位置上。

可以插入多个，按照插入的顺序（以逗号隔开，每一个要插入的元素都是字符串的形式）分别往前和往后排列。

如果所选定的元素前面已经有元素了，那么会将前面的元素往前挤一个位置，然后插入。后面也是如此，如果选定的元素后面已经有元素了，那么将后面的元素往后挤一个位置，然后插入。

具体代码如下所示：

• after

  $(".test2").after('<p style="color:blue">after,在匹配元素之后增加</p>', '<p style="color:blue">多参数</p>')
  

• before

  $(".test1").before('<p style="color:red">before,在匹配元素之前增加</p>', '<p style="color:red">多参数</p>')
  

insertAfter()与insertBefore()

和前面的after、before相同，只是位置不同，将元素插入到所选节点之前/之后的意思

具体代码示例如下：

$('<p style="color:red">测试insertBefore方法增加</p>', '<p style="color:red">多参数</p>').insertBefore($(".test1"))

indsertAfter类似。

吐槽一下：明明是一样的作用，偏偏要弄两套写法，这开发jQuery的人脑子是有坑吧

dom节点的删除

empty()方法

清空方法，会移除所选节点内所有的子元素和后代元素、文本，但不会移除所选的节点。例如以下节点：

<div id="test">
    <p>p元素1</p>
    <p>p元素2</p>
    你好啊
</div>

会移除p1,p2 和你好啊。但是#test这个节点会被保留

remove()方法

移除方法，remove方法会将所选节点、包括子节点、后代元素、文本全部删除。

remove方法可以传入一个筛选表达式:contains('')，表示在所有选中的节点中，删除包含传入参数的节点。具体用法如下：

//找到所有p元素中，包含了3的元素
//这个也是一个过滤器的处理
$("p").remove(":contains('3')")

等效于

$("p").filter(":contains('3')").remove()

注意：remove移除的节点中如果有绑定的事件，remove方法会自动操作使事件销毁方法。如果事件没有被销毁，则会长久的占据内存，直到网页生命周期结束。

var $item = $(this).parent(),
        id = $item.data('id');
    // remove 方法会将dom自身移除 
    $item.remove();

detach()方法

我的理解是，该方法把dom节点从文档流中删除，然后返回该节点的内存模型数据（包括节点上绑定的事件和数据）。使用示例如下：

var p;
p = $("p").detach()
//把p元素在添加到页面中
//事件还是存在
$("body").append(p);

detach方法是JQuery特有的，所以它只能处理通过JQuery的方法绑定的事件或者数据。vue和原生绑定的事件

jQuery对象$("p")包括里面嵌套的文本数据，但是不会包括子节点，所以移除和显示都不会带上子节点。

dom节点的复制和替换

clone() 方法

.clone()方法深度 复制所有匹配的元素集合，包括所有匹配元素、匹配元素的下级元素、文字节点。

clone() 方法接收一个Boolean类型的数据，默认为false。为true表示将原始节点的绑定的事件处理函数复制到克隆元素上

注意：

• clone()方法是jQuery扩展的，只能处理通过jQuery绑定的事件与数据
• 元素数据（data）内对象和数组不会被复制，将继续被克隆元素和原始元素共享。深复制的所有数据，需要手动复制每一个

replaceWith()和replaceAll()

意思相同，就是源节点和替换节点的位置不同，具体用法如下所示：

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

• replaceWidth：

  $("p:eq(1)").replaceWith('<a style="color:red">替换第二段的内容</a>')
  

• replaceAll：

  $('<a style="color:red">替换第二段的内容</a>').replaceAll('p:eq(1)')
  

注意：

• .replaceWith()与.replaceAll() 方法不会删除与节点相关联的所有数据和事件处理程序。
• .replaceWith()方法，和大部分其他jQuery方法一样，返回jQuery对象，所以可以和其他方法链接使用
• .replaceWith()方法返回的jQuery对象引用的是替换前的节点，而不是通过replaceWith/replaceAll方法替换后的节点

wrap() 方法

接收一个字符串参数，用来给选中的节点包裹上父元素，具体用法如下所示：

<p>p元素</p>

给p元素增加一个div包裹

$('p').wrap('<div></div>')

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

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

unwrap()方法

删除所选中元素的父元素，但是保留自身和兄弟元素的位置。

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

$('p').unwrap();

结果：

<p>p元素</p>

wrapAll() 方法

给集所有选中的元素集合增加一个外面包裹HTML结构。按照集合中第一个元素的位置包裹。

<p>p元素</p>
<h6>如果有中间元素</h6>
<p>p元素</p>

$('p').wrapAll('<div></div>')

结果：

<div>
    <p>p元素</p>
    <p>p元素</p>
</div>
<h6>如果有中间元素</h6>

wrapInner() 方法

将合集中的元素内部所有的子元素用其他元素（括号内指定的元素）包裹起来

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

$('div').wrapInner('<p></p>')

结果：

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

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

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

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

其实是一样的，因为jQuery选择器(例如class选择器)选中出来的本身就是集合，使用的时候会有一个隐式遍历处理。给所有集合里面的元素都处理一边

dom节点的遍历

children() 方法

快速查找合集里面的第一级子元素，此时可以用children()方法。这里需要注意：.children(selector) 方法是返回匹配元素集合中每个元素的所有子元素（仅儿子辈，这里可以理解为就是父亲-儿子的关系）

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

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

.**children()**方法选择性地接受同一类型选择器表达式，包括class选择器、id选择器等等

$("div").children(".selected")

find() 方法

如果想快速查找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只在后代中遍历，不包括自己。
• 选择器 context 是由 .find() 方法实现的；因此，$(‘.item-ii’).find(‘li’) 等价于 $(‘li’, ‘.item-ii’)(找到类名为item-ii的标签下的li标签)。

parent() 方法

快速查找合集里面的每一个元素的父元素（这里可以理解为就是父亲-儿子的关系），此时可以用parent()方法

因为是父元素，这个方法只会向上查找一级

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

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

**parent()**无参数

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

注意：jQuery是一个合集对象，所以通过parent是匹配合集中每一个元素的父元素

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

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

parents() 方法

快速查找合集里面的每一个元素的所有祖辈元素，此时可以用parents()方法

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

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

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

**parents()**无参数

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

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

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

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

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

closest() 方法

找寻离自己最近的符合要求的祖先及元素（包括自己）

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

例如：在div元素中，往上查找所有的li元素，可以这样表达

$("div").closet("li')

注意：jQuery是一个合集对象，所以通过closest是匹配合集中每一个元素的祖先元素

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

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

**注意事项：**在使用的时候需要特别注意下

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

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

next() 方法

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

理解节点查找关系：

如下class="item-1"元素就是红色部分，那蓝色的class="item-2"就是它的兄弟元素

<ul class="level-3">
    <li class="item-1">1</li>
    <li class="item-2">2</li>
    <li class="item-3">3</li>
</ul>

next()无参数

允许我们找遍元素集合中紧跟着这些元素的直接兄弟元素，并根据匹配的元素创建一个新的 jQuery 对象。

注意：jQuery是一个合集对象，所以通过next匹配合集中每一个元素的下一个兄弟元素

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

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

prev() 方法

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

理解节点查找关系：

如下蓝色的class="item-2"的li元素，红色的节点就是它的prev兄弟节点

<ul class="level-3">
    <li class="item-1">1</li>
    <li class="item-2">2</li>
    <li class="item-3">3</li>
</ul>

**prev()**无参数

取得一个包含匹配的元素集合中每一个元素紧邻的前一个同辈元素的元素集合

注意：jQuery是一个合集对象，所以通过prev是匹配合集中每一个元素的上一个兄弟元素

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

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

同辈元素siblings() 方法

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

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])

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以便在回调函数内中止循

jQuery事件

表单事件

blur与focus事件

与focusin和focusout事件类似，focus就是获得焦点，blur就是失去焦点。不同的是focus和blur不会冒泡。

change事件

元素，和元素的值都是可以发生改变的，开发者可以通过change事件去监听这些改变的动作

input元素

监听value值的变化，当有改变时，失去焦点后触发change事件。对于单选按钮和复选框，当用户用鼠标做出选择时，该事件立即触发。

select元素

对于下拉选择框，当用户用鼠标作出选择时，该事件立即触发

textarea元素

多行文本输入框，

select事件

当 textarea 或文本类型的 input 元素中的文本被选择时，会发生 select 事件。

重点也就是和焦点事件不同的就是select事件只有上述两种类型的文本被选择时才会被触发。

这个函数会调用执行绑定到select事件的所有函数，包括浏览器的默认行为。可以通过在某个绑定的函数中返回false来防止触发浏览器的默认行为。

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

使用上非常简单：

方法一：.select()

触发元素的select事件:

$("input").select();

方法二：$ele.select( handler(eventObject) )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<input id="test" value="文字选中"></input>
$("#test").select(function() { //响应文字选中回调
    //this指向 input元素 
});

方法三：$ele.select( [eventData ], handler(eventObject) )

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

<input id="test" value="文字选中"></input>
$("#test").select(11111,function(e) {//响应文字选中回调
    //this指向 div元素 
   //e.data  => 11111 传递数据
});

submit事件

提交表单是一个最常见的业务需求，比如用户注册，一些信息的输入都是需要表单的提交。同样的有时候开发者需要在表单提交的时候过滤一些的数据、做一些必要的操作（例如：验证表单输入的正确性，如果错误就阻止提交，从新输入）此时可以通过submit事件，监听下提交表单的这个动作

使用上非常简单，与基本事件参数处理保持一致

方法一：$ele.submit()

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

<div id="test">点击触发<div>
$("ele").submit(function(){
    alert('触发指定事件')
})
$("#text").click(function(){
     $("ele").submit()  //指定触发事件 
});

方法二：$ele.submit( handler(eventObject) )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<form id="target" action="destination.html">
  <input type="submit" value="Go" />
</form>
$("#target").submit(function() { //绑定提交表单触发
    //this指向 from元素 
});

方法三：$ele.submit( [eventData ], handler(eventObject) )

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

<form id="target" action="destination.html">
  <input type="submit" value="Go" />
</form>
$("#target").submit(11111,function(data) { //绑定提交表单触发
    //data => 1111 //传递的data数据
});

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

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

• 当某些表单元素获取焦点时，敲击Enter（回车键）

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

这里需要特别注意：

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

jQuery处理如下：

$("#target").submit(function(data) { 
   return false; //阻止默认行为，提交表单
});

键盘事件

keydown() 和 keyup() 事件

keydown事件：

当用户在一个元素上第一次按下键盘上字母键的时候，就会触发它。然后他就会把按下的值发送给焦点所在的元素上。

使用上非常简单，与基本事件参数处理保持一致，这里使用不在重复了，列出使用的方法

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

eventObject.target.value 就是按键的值。

keyup事件：

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

注意：

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

表单元素有以下类型：

1. form: 定义供用户输入的表单。
2. fieldset: 定义域。即输入区加有文字的边框。
3. legend：定义域的标题，即边框上的文字。
4. label：定义一个控制的标签。如输入框前的文字，用以关联用户的选择。
5. input: 定义输入域，常用。可设置type属性，从而具有不同功能。
6. textarea: 定义文本域(一个多行的输入控件)，默认可通过鼠标拖动调整大小。
7. button: 定义一个按钮。
8. select: 定义一个选择列表，即下拉列表。
9. option: 定义下拉列表中的选项。

keypress() 事件

在input元素上绑定keydown事件会发现一个问题：

每次获取的内容都是之前输入的，当前输入的获取不到

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

当浏览器捕获键盘输入时，还提供了一个keypress的响应，这个跟keydown是非常相似，这里使用请参考keydown这一节，具体说说不同点

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

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

总而言之，

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

鼠标事件

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 传递数据
});

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

mousedown和mouseup事件

jQuery提供了一个mousedown的快捷方法可以监听用户鼠标按下的操作，与其对应的还有一个方法mouseup快捷方法可以监听用户鼠标弹起的操作。两种方法用法类似，下面以mousedown()为例

使用上非常简单：

方法一：$ele.mousedown()

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

<div id="test">点击触发<div>
$("ele").mousedown(function(){
    alert('触发指定事件')
})
$("#test").mousedown(function(){
     $("ele").mousedown()  //手动指定触发事件 
});

方法二：$ele.mousedown( handler(eventObject) )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<div id="test">点击触发<div>
$("#test").mousedown(function() {
    //this指向 div元素
});

方法三：$ele.mousedown( [eventData ], handler(eventObject) )

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

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

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

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

mouseup****事件触发需要以下几点：

• mouseup强调是松手触发，与mousedown是相反的
• mouseup与mousedown组合起来就是click事件
• 如果用户在一个元素上按下鼠标按键，并且拖动鼠标离开这个元素，然后释放鼠标键，这仍然是算作mouseup事件
• 任何鼠标按钮松手时都能触发mouseup事件
• 用event 对象的which区别按键，敲击鼠标左键which的值是1，敲击鼠标中键which的值是2，敲击鼠标右键which的值是3

另外需要注意的是：

click与mousedown****的区别：

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

mousemove事件

监听对象在范围内是否有移动，只要有移动，就会不停的触发事件。所以比较吃性能。

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

使用上非常简单：

方法一：$ele.mousemove()

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

<div id="test">点击触发<div>
$("ele").mousemove(function(){
    alert('触发指定事件')
})
$("#test").click(function(){
     $("ele").mousemove()  //指定触发事件 
});

方法二：$ele.mousemove( handler(eventObject) )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<div id="test">滑动触发<div>
$("#test").mousemove(function() {
    //this指向 div元素 
});

方法三：$ele.mousemove( [eventData ], handler(eventObject) )

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

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

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

• mousemove事件是当鼠标指针移动时触发的，即使是一个像素

mouseover和mouseout事件

mouseover事件监听鼠标指针的移入，mouseout事件监听鼠标的移出。具体用法如下：

方法一：$ele.mouseover()

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

<div id="test">点击触发<div>
$("ele").mouseover(function(){
    alert('触发指定事件')
})
$("#test").click(function(){
     $("ele").mouseover()  //指定触发事件 
});

方法二：$ele.mouseover( handler(eventObject) )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<div id="test">滑动触发<div>
$("#test").mouseover(function() {
    //this指向 div元素 
});

方法三：$ele.mouseover( [eventData ], handler(eventObject) )

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

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

mouseenter和mouseleave事件

mouseenter和mouseleave事件和上述mouseover、mouseout事件功能一模一样，区别的点就在于冒泡方式不同。mouseenter和mouseleave事件不冒泡，但是mouseover和mouseout会冒泡。

hover事件

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

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

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

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

$(selector).hover(handlerIn, handlerOut)

• handlerIn(eventObject)：当鼠标指针进入元素时触发执行的事件函数
• handlerOut(eventObject)：当鼠标指针离开元素时触发执行的事件函数

如果只传递一个回调函数，那么鼠标移入移出都会触发这个函数。

focusin事件

只有包含input的元素能用。会往上冒泡。例如：input元素，用户在点击聚焦的时候，如果开发者需要捕获这个动作的时候，jQuery提供了一个focusin事件

使用上非常简单：

方法一：$ele.focusin()

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

<div id="test">点击触发<div>
$("ele").focusin(function(){
    alert('触发指定事件')
})
$("#test").mouseup(function(){
     $("ele").focusin()  //指定触发事件 
});

方法二：$ele.focusin( handler )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<div id="test">点击触发<div>
$("#test").focusin(function() {
    //this指向 div元素
});

方法三：$ele.focusin( [eventData ], handler )

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

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

focesout事件

当一个元素，或者其内部任何一个元素失去焦点的时候，比如input元素，用户在点击失去焦的时候，如果开发者需要捕获这个动作，jQuery提供了一个focusout事件

使用上非常简单：

方法一：$ele.focusout()

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

<div id="test">点击触发<div>
$("ele").focusout(function(){
    alert('触发指定事件')
})
$("#test").mouseup(function(){
     $("ele").focusout()  //指定触发事件 
});

方法二：$ele.focusout( handler )

绑定$ele元素，每次$ele元素触发点击操作会执行回调 handler函数

这样可以针对事件的反馈做很多操作了

<div id="test">点击触发<div>
$("#test").focusout(function() {
    //this指向 div元素
});

方法三：$ele.focusout( [eventData ], handler )

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

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

事件绑定

on() 的多事件绑定

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

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

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

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

多个事件绑定同一个函数

 $("#elem").on("mouseover mouseout",function(){ });

通过空格分离，传递不同的事件名，可以同时绑定多个事件

多个事件绑定不同函数

$("#elem").on({
    mouseover:function(){},  
    mouseout:function(){}
});

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

将数据传递到处理程序

function greet( event ) {
  alert( "Hello " + event.data.name ); //Hello 慕课网
}
$( "button" ).on( "click", {
  name: "慕课网"
}, greet );

可以通过第二参数（对象），当一个事件被触发时，要传递给事件处理函数的

on的事件委托机制

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

.on( events ,[ selector ] ,[ data ], handler(eventObject) )

通常使用情况下，将on绑定在html的最小dom元素中，然后委托给js插入的dom元素。一般监听给js代码插入的dom元素使用。

卸载事件off()方法

• 通过.on()绑定的事件处理程序
• 通过off() 方法移除该绑定

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

绑定2个事件

$("elem").on("mousedown mouseup",fn)

删除一个事件

$("elem").off("mousedown")

删除所有事件

$("elem").off("mousedown mouseup")

快捷方式删除所有事件，这里不需要传递事件名了，节点上绑定的所有事件讲全部销毁

$("elem").off()

销毁事件以后，事件将永远不会被触发。

事件对象event的使用

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

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

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

接收一个参数，包含了所有触发事件的相关信息。包括一些物理信息和方法。具体如下：

event.type：获取事件的类型

触发元素的事件类型

$("a").click(function(event) {
  alert(event.type); // "click"事件
});

event.pageX 和 event.pageY：获取鼠标当前相对于页面的坐标

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

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

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

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

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

event.which：获取在鼠标单击时，单击的是鼠标的哪个键

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

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

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

this和event.target的区别：

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

谁触发谁就是this和currentTarget，绑定在谁身上谁就是target。本质上都是dom结构，可以通过$(dom)转化为jQuery对象。

.this和event.target都是dom对象

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

jQuery自定义事件

trigger事件

1. 就是模拟用户的行为去触发原生事件。

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

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

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

所以我们可以这样：

$('#elem').trigger('click', '参数1');

可以传递自定义参数，定义事件时第一个接收的参数是默认event事件对象。后面可以按顺序接收自定义参数。

2.就是去触发绑定的事件

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

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

triggerHandler

若要触发通过 jQuery 绑定的事件处理函数，而不触发原生的事件，使用.triggerHandler() 来代替

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

• triggerHandler不会触发浏览器的默认行为，.triggerHandler( “submit” )将不会调用表单上的.submit()

  这个暂时不明白，如果你用原生定义一个事件的话，二者都会触发这个事件。我的理解就是triggerHandler不会触发浏览器初始就定义好的默认事件

• .trigger() 会影响所有与 jQuery 对象相匹配的元素，而 .triggerHandler() 仅影响第一个匹配到的元素

• 使用 .triggerHandler() 触发的事件，并不会在 DOM 树中向上冒泡。 如果它们不是由目标元素直接触发的，那么它就不会进行任何处理

• 与普通的方法返回 jQuery 对象(这样就能够使用链式用法)相反，.triggerHandler() 返回最后一个处理的事件的返回值。如果没有触发任何事件，会返回 undefined

jQuery动画

动画基础隐藏和显示

hide()方法

让页面上的元素不可见，一般可以通过设置css的display为none属性。但是通过css直接修改是静态的布局，如果在代码执行的时候，一般是通过js控制元素的style属性，这里jQuery提供了一个快捷的方法.hide()来达到这个效果

$elem.hide()

提供参数：

.hide( options )

当提供hide方法一个参数时，.hide()就会成为一个动画方法。.hide()方法将会匹配元素的宽度，高度，以及不透明度，同时进行动画操作

快捷参数：

.hide("fast / slow")

这是一个动画设置的快捷方式，‘fast’ 和 ‘slow’ 分别代表200和600毫秒的延时，就是元素会执行200/600毫秒的动画后再隐藏

注意：

jQuery在做hide操作的时候，是会保存本身的元素的原始属性值，再之后通过对应的方法还原的时候还是初始值。比如一个元素的display属性值为inline，那么隐藏再显示时，这个元素将再次显示inline。一旦透明度 达到0，display样式属性将被设置为none，这个元素将不再在页面中影响布局

show() 方法

css中有display:none属性，同时也有display:block，所以jQuery同样提供了与hide相反的show方法

方法的使用几乎与hide是一致的，hide是让元素显示到隐藏，show则是相反，让元素从隐藏到显示

看一段代码：使用上一致，结果相反

$('elem').hide(3000).show(3000)

让元素执行3秒的隐藏动画，然后执行3秒的显示动画。

show与hide方法是非常常用的，但是一般很少会基于这2个属性执行动画，大多情况下还是直接操作元素的显示与隐藏为主

注意事项：

• show与hide方法是修改的display属性，通过是visibility属性布局需要通过css方法单独设置
• 如果使用!important在你的样式中，比如display: none !important，如果你希望.show()方法正常工作，必须使用.css(‘display’, ‘block !important’)重写样式
• 如果让show与hide成为一个动画，那么默认执行动画会改变元素的高度，高度，透明度

切换toggle() 方法

jQuery提供了一个便捷方法toggle用于切换显示或隐藏匹配元素

基本的操作：toggle();

这是最基本的操作，处理元素显示或者隐藏，因为不带参数，所以没有动画。通过改变CSS的display属性，匹配的元素将被立即显示或隐藏，没有动画。

• 如果元素是最初显示，它会被隐藏
• 如果隐藏的，它会显示出来

display属性将被储存并且需要的时候可以恢复。如果一个元素的display值为inline，然后是隐藏和显示，这个元素将再次显示inline

提供参数：.toggle( [duration ] [, complete ] )

同样的提供了时间、还有动画结束的回调。在参数对应的时间内，元素会发生显示/隐藏的改变，在改变的过程中会把元素的高、宽、不透明度进行一系列动画效果。这个元素其实就是show与hide的方法

直接定位：.toggle(display)

直接提供一个参数，指定要改变的元素的最终效果

其实就是确定是使用show还是hide方法

if ( display === true ) {
  $( "elem" ).show();
} else if ( display === false ) {
  $( "elem" ).hide();
}

下拉动画slideDown

对于隐藏的元素，在将其显示出来的过程中，可以对其进行一些变化的动画效果。之前学过了show方法，show方法在显示的过程中也可以有动画，但是.show()方法将会匹配元素的宽度，高度，以及不透明度，同时进行动画操作。这里将要学习一个新的显示方法slideDown方法

.slideDown()：用滑动动画显示一个匹配元素

.slideDown()方法将给匹配元素的高度的动画，这会导致页面的下面部分滑下去，弥补了显示的方式

常见的操作，提供一个动画是时间，然后传递一个回调，用于知道动画是什么时候结束

.slideDown( [duration ] [, complete ] )

持续时间（duration）是以毫秒为单位的，数值越大，动画越慢，不是越快。字符串 ‘fast’ 和 ‘slow’ 分别代表200和600毫秒的延时。如果提供任何其他字符串，或者这个duration参数被省略，那么默认使用400 毫秒的延时。

具体使用：

$("ele").slideDown(1000, function() {
    //等待动画执行1秒后,执行别的动作....
});

注意事项：

• 下拉动画是从无到有，所以一开始元素是需要先隐藏起来的，可以设置display:none
• 如 果提供回调函数参数，callback会在动画完成的时候调用。将不同的动画串联在一起按顺序排列执行是非常有用的。这个回调函数不设置任何参数，但是 this会设成将要执行动画的那个DOM元素，如果多个元素一起做动画效果，那么要非常注意，回调函数会在每一个元素执行完动画后都执行一次，而不是这组 动画整体才执行一次

上卷动画slideUp

对于显示的元素，在将其隐藏的过程中，可以对其进行一些变化的动画效果。之前学过了hide方法，hide方法在显示的过程中也可以有动画，但 是.hide()方法将为匹配元素的宽度，高度，以及不透明度，同时进行动画操作。这里将要学习一个新的显示方法slideUp方法

最简单的使用：不带参数

$("elem").slideUp();

这个使用的含义就是：找到元素的高度，然后采用一个下滑动画让元素一直滑到隐藏，当高度为0的时候，也就是不可见的时，修改元素display 样式属性被设置为none。这样就能确保这个元素不会影响页面布局了

带参数：

.slideUp( [duration ] [, easing ] [, complete ] )

同样可以提供一个时间，然后可以使用一种过渡使用哪种缓动函数，jQuery默认就2种，可以通过下载插件支持。最后一个动画结束的回调方法。

因为动画是异步的，所以要在动画之后执行某些操作就必须要写到回调函数里面，这里要特别注意

上卷下拉切换slideToggle

slideDown与slideUp是一对相反的方法。需要对元素进行上下拉卷效果的切换，jQuery提供了一个便捷方法slideToggle用滑动动画显示或隐藏一个匹配元素

基本的操作：slideToggle();

这是最基本的操作，获取元素的高度，使这个元素的高度发生改变，从而让元素里的内容往下或往上滑。

提供参数：.slideToggle( [duration ] ,[ complete ] )

同样的提供了时间、还有动画结束的回调。在参数对应的时间内，元素会完成动画，然后出发回调函数

同时也提供了时间的快速定义，字符串 ‘fast’ 和 ‘slow’ 分别代表200和600毫秒的延时

slideToggle("fast") 
slideToggle("slow") 

注意：

• display属性值保存在jQuery的数据缓存中，所以display可以方便以后可以恢复到其初始值
• 当一个隐藏动画后，高度值达到0的时候，display 样式属性被设置为none，以确保该元素不再影响页面布局

淡出淡入效果

淡出动画fadeOut

让元素在页面不可见，常用的办法就是通过设置样式的display:none。除此之外还可以一些类似的办法可以达到这个目的。这里要提一个透明度的方法，设置元素透明度为0，可以让元素不可见，透明度的参数是0~1之间的值，通过改变这个值可以让元素有一个透明度的效果。常见的淡入淡出动画正是这样的原理。

fadeOut()函数用于隐藏所有匹配的元素，并带有淡出的过渡动画效果

所谓"淡出"隐藏的，元素是隐藏状态不对作任何改变，元素是可见的，则将其隐藏。

.fadeOut( [duration ], [ complete ] )

通过不透明度的变化来实现所有匹配元素的淡出效果，并在动画完成后可选地触发一个回调函数。这个动画只调整元素的不透明度，也就是说所有匹配的元素的高度和宽度不会发生变化。

字符串 ‘fast’ 和 ‘slow’ 分别代表200和600毫秒的延时。如果提供任何其他字符串，或者这个duration参数被省略，那么默认使用400毫秒的延时

淡入动画fadeIn

fadeOut是淡出效果，相反的还有淡入效果fadeIn,方法使用上两者都是一致的，只是结果相反

.fadeIn( [duration ], [ complete ] )

• duration：指定过渡动画运行多长时间(毫秒数)，默认值为400。该参数也可以为字符串"fast"(=200)或"slow"(=600)。
• 元素显示完毕后需要执行的函数。函数内的this指向当前DOM元素。

fadeIn()函数用于显示所有匹配的元素，并带有淡入的过渡动画效果。

注意：

• 淡入的动画原理：操作元素的不透明度从0%逐渐增加到100%
• 如果元素本身是可见的，不对其作任何改变。如果元素是隐藏的（包括display:none,和透明度），则使其可见

淡入淡出切换fadeToggle

fadeToggle()函数用于切换所有匹配的元素，并带有淡入/淡出的过渡动画效果。之前也学过toggle、slideToggle 也是类似的处理方式

fadeToggle切换fadeOut与fadeIn效果，所谓"切换"，即如果元素当前是可见的，则将其隐藏(淡出)；如果元素当前是隐藏的，则使其显示(淡入)。

常用语法：.fadeToggle( [duration ] ,[ complete ] )

可选的 duration 参数规定效果的时长。它可以取以下值：“slow”、“fast” 或毫秒。 可选的 callback 参数是 fadeToggle完成后所执行的函数名称。

fadeToggle() 方法可以在 fadeIn() 与 fadeOut() 方法之间进行切换。如果元素已淡出，则 fadeToggle() 会向元素添加淡入效果。如果元素已淡入，则 fadeToggle() 会向元素添加淡出效果。

淡入淡出效果fadeTo

到达某个opcity,就是将opacity就显示或者隐藏去趋向一个中间值

淡入淡出fadeIn与fadeOut都是修改元素样式的opacity属性，但是他们都有个共同的特点，变化的区间要么是0，要么是1

fadeIn：淡入效果，内容显示，opacity是0到1
fadeOut：淡出效果，内容隐藏，opacity是1到0

如果要让元素保持动画效果，执行opacity = 0.5的效果时，要如何处理？

如果不考虑CSS3，我们用JS实现的话，基本就是通过定时器，在设定的时间内一点点的修改opacity的值，最终为0.5，原理虽说简单，但是总不如一键设置这么舒服，jQuery提供了fadeTo方法，可以让改变透明度一步到位

语法

.fadeTo( duration, opacity ,callback)

必需的 duration参数规定效果的时长。它可以取以下值：“slow”、“fast” 或毫秒。fadeTo() 方法中必需的 opacity 参数将淡入淡出效果设置为给定的不透明度（值介于 0 与 1 之间）。可选的 callback 参数是该函数完成后所执行的函数名称。

动画animate

有些复杂的动画通过之前学到的几个动画函数是不能够实现，这时候就需要强大的animate方法了

操作一个元素执行3秒的淡入动画，对比一下2组动画设置的区别

$(elem).fadeOut(3000)  
$(elem).animate({   
    opacity:0
},3000)

显而易见，animate方法更加灵活了，可以精确的控制样式属性从而执行动画

语法：

.animate( properties ,[ duration ], [ easing ], [ complete ] )
.animate( properties, options )

.animate()方法允许我们在任意的数值的CSS属性上创建动画。2种语法使用，几乎差不多了，唯一必要的属性就是一组CSS属性键值对。这组属性和用于设置.css()方法的属性键值对类似，除了属性范围做了更多限制。第二个参数开始可以单独传递多个实参也可以合并成一个对象传递了

参数分解：

properties：一个或多个css属性的键值对所构成的Object对象。要特别注意所有用于动画的属性必须是数字的，除非另有说明；这些属性如果不是数字的将不能使用基本的jQuery功能。比如常见的，border、margin、padding、width、height、font、left、top、right、bottom、wordSpacing等等这些都是能产生动画效果的。background-color很明显不可以，因为参数是red或者GBG这样的值，非常用插件，否则正常情况下是不能只用动画效果的。注意，CSS 样式使用 DOM 名称（比如 “fontSize”）来设置，而非 CSS 名称（比如 “font-size”）。

特别注意单位，属性值的单位像素（px）,除非另有说明。单位em 和 %需要指定使用

.animate({
    left: 50, 
    width: '50px'   
    opacity: 'show',  
    fontSize: "10em",
}, 500);

除了定义数值，每个属性能使用’show’, ‘hide’, 和 ‘toggle’。这些快捷方式允许定制隐藏和显示动画用来控制元素的显示或隐藏

.animate({
    width: "toggle"
});

如果提供一个以+= 或 -=开始的值，那么目标值就是以这个属性的当前值加上或者减去给定的数字来计算的

.animate({ 
    left: '+=50px'
}, "slow");

duration时间

动画执行的时间，持续时间是以毫秒为单位的；值越大表示动画执行的越慢，不是越快。还可以提供’fast’ 和 'slow’字符串，分别表示持续时间为200 和 600毫秒。

easing动画运动的算法

jQuery库中默认调用 swing。如果需要其他的动画算法，请查找相关的插件

complete回调

动画完成时执行的函数，这个可以保证当前动画确定完成后发会触发

动画animate的参数

animate在执行动画中，如果需要观察动画的一些执行情况，或者在动画进行中的某一时刻进行一些其他处理，我们可以通过animate提供的第二种设置语法，传递一个对象参数，可以拿到动画执行状态一些通知

.animate( properties, options )

options参数

• duration - 设置动画执行的时间
• easing - 规定要使用的 easing 函数，过渡使用哪种缓动函数
• step：规定每个动画的每一步完成之后要执行的函数
• progress：每一次动画调用的时候会执行这个回调，就是一个进度的概念
• complete：动画完成回调

其中最关键的一点就是：

如果多个元素执行动画，回调将在每个匹配的元素上执行一次，不是作为整个动画执行一次

动画stop

动画在执行过程中是允许被暂停的，当一个元素调用.stop()方法，当前正在运行的动画（如果有的话）立即停止

语法：

.stop( [clearQueue ], [ jumpToEnd ] )
.stop( [queue ], [ clearQueue ] ,[ jumpToEnd ] )

stop还有几个可选的参数，简单来说可以这3种情况

• .stop(); 停止当前动画，点击在暂停处继续开始

• .stop(true); 如果同一元素调用多个动画方法，尚未被执行的动画被放置在元素的效果队列中。这些动画不会开始，直到第一个完成。当调用.stop()的时候，队列中的下一个动画立即开始。如果clearQueue参数提供true值,那么在队列中的动画其余被删除并永远不会运行

• .stop(true,true); 当前动画将停止，但该元素上的 CSS 属性会被立刻修改成动画的目标值

  注：后面两种方法经过实验发现好像没什么用啊

简单的说：参考下面代码

$("#aaron").animate({
    height: 300
}, 5000)
$("#aaron").animate({
    width: 300
}, 5000)
$("#aaron").animate({
    opacity: 0.6
}, 2000)

动画它是从前往后，一个个被执行的。

1. stop()：只会停止第一个动画，第二个第三个继续
2. stop(true)：停止第一个、第二个和第三个动画
3. stop(true ture)：停止动画，直接跳到第一个动画的最终状态

jQuery高级

each() 方法的应用

.each只是处理jQuery对象的方法，jQuery还提供了一个通用的jQuery.each方法，用来处理对象和数组的遍历

语法

jQuery.each(array, callback )
jQuery.each( object, callback )

第一个参数传递的就是一个对象或者数组，第二个是回调函数

$.each(["Aaron", "慕课网"], function(index, value) {
   //index是索引,也就是数组的索引
   //value就是数组中的值了
});

each就是for循环方法的一个包装，内部就是通过for遍历数组与对象，通过回调函数返回内部迭代的一些参数，第一个参数是当前迭代成员在对象或数组中的索引值(从0开始计数)，第二个参数是当前迭代成员(与this的引用相同，就是当前正在遍历的普通dom。

jQuery.each()函数还会根据每次调用函数callback的返回值来决定后续动作。如果返回值为false，则停止循环(相当于普通循环中的break)；如果返回其他任何值，均表示继续执行下一个循环。

$.each(["Aaron", "慕课网"], function(index, value) {
    return false; //停止迭代
});

数组查找方法inArray

在ECMAScript5已经有数据的indexOf方法支持了，但是jQuery保持了版本向下兼容，所以封装了一个inArray方法

jQuery.inArray()函数用于在数组中搜索指定的值，并返回其索引值。如果数组中不存在该值，则返回 -1。

语法：

jQuery.inArray( value, array ,[ fromIndex ] )

用法非常简单，传递一个检测的目标值，然后传递原始的数组，可以通过fromIndex规定查找的起始值，默认数组是0开始

例如：在数组中查找值是5的索引

$.inArray(5,[1,2,3,4,5,6,7]) //返回对应的索引：4

注意：

如果要判断数组中是否存在指定值，你需要通过该函数的返回值不等于(或大于)-1来进行判断

去空格神器trim方法

jQuery.trim()函数用于去除字符串两端的空白字符

这个函数很简单，没有多余的参数用法

需要注意：

• 移除字符串开始和结尾处的所有换行符，空格(包括连续的空格)和制表符（tab）
• 如果这些空白字符在字符串中间时，它们将被保留，不会被移除

$.trim('内部传入字符串')