Zepto.js 1.2.0 中文参考手册

形式。

当一个函数附加在 DOMContentLoaded 事件的处理流程中。如果页面已经加载完毕，这个方法将会立即被执行。

$('div') //=> 所有页面中得div元素

$('#foo') //=> ID 为 "foo" 的元素

// 创建元素:

$("

Hello

") //=> 新的p元素

// 创建带有属性的元素:

$("

", { text:"Hello", id:"greeting", css:{color:'darkblue'} })

//=>

Hello

// 当页面ready的时候，执行回调:

Zepto(function($){

alert('Ready to Zepto!')

})

不支持jQuery CSS 扩展，

然而，可选的“selector”模块有限提供了支持几个最常用的伪选择器，而且可以被丢弃，与现有的代码或插件的兼容执行。

如果$变量尚未定义，Zepto只设置了全局变量$指向它本身。允许您同时使用的Zepto和有用的遗留代码，例如，prototype.js。只要首先加载Prototype，Zepto将不会覆盖Prototype的 $ 函数。Zepto将始终设置全局变量Zepto指向它本身。

$.camelCase v1.0+

$.camelCase(string) ⇒ string

将一组字符串变成“骆驼”命名法的新字符串，如果该字符已经是“骆驼”命名法，则不变化。

$.camelCase('hello-there') //=> "helloThere"

$.camelCase('helloThere') //=> "helloThere"

$.contains v1.0+

$.contains(parent, node) ⇒ boolean

检查父节点是否包含给定的dom节点，如果两者是相同的节点，则返回 false。

$.each

$.each(collection, function(index, item){ ... }) ⇒ collection

遍历数组元素或以key-value值对方式遍历对象。回调函数返回 false 时停止遍历。

$.each(['a', 'b', 'c'], function(index, item){

console.log('item %d is: %s', index, item)

})

var hash = { name: 'zepto.js', size: 'micro' }

$.each(hash, function(key, value){

console.log('%s: %s', key, value)

})

$.extend

$.extend(target, [source, [source2, ...]]) ⇒ target

$.extend(true, target, [source, ...]) ⇒ target v1.0+

通过源对象扩展目标对象的属性，源对象属性将覆盖目标对象属性。

默认情况下为，复制为浅拷贝（浅复制）。如果第一个参数为true表示深度拷贝（深度复制）。

var target = { one: 'patridge' },

source = { two: 'turtle doves' }

$.extend(target, source)

//=> { one: 'patridge',

// two: 'turtle doves' }

$.fn

Zepto.fn是一个对象，它拥有Zepto对象上所有可用的方法，如 addClass()， attr()，和其它方法。在这个对象添加一个方法，所有的Zepto对象上都能用到该方法。

这里有一个实现 Zepto 的 empty() 方法的例子：

$.fn.empty = function(){

return this.each(function(){ this.innerHTML = '' })

}

$.grep v1.0+

$.grep(items, function(item){ ... }) ⇒ array

获取一个新数组，新数组只包含回调函数中返回 ture 的数组项。

$.grep([1,2,3],function(item){

return item > 1

});//=>[2,3]

$.inArray v1.0+

$.inArray(element, array, [fromIndex]) ⇒ number

返回数组中指定元素的索引值（注：以0为基数），如果没有找到该元素则返回-1。

注：[fromIndex] 参数可选，表示从哪个索引值开始向后查找。

$.inArray("abc",["bcd","abc","edf","aaa"]);//=>1

$.inArray("abc",["bcd","abc","edf","aaa"],1);//=>1

$.inArray("abc",["bcd","abc","edf","aaa"],2);//=>-1

$.isArray

$.isArray(object) ⇒ boolean

如果object是array，则返回ture。

$.isFunction

$.isFunction(object) ⇒ boolean

如果object是function，则返回ture。

$.isNumeric v1.2+

$.isNumeric(value) ⇒ boolean

如果该值为有限数值或一个字符串表示的数字，则返回ture。

$.isPlainObject v1.0+

$.isPlainObject(object) ⇒ boolean

测试对象是否是“纯粹”的对象，这个对象是通过 对象常量（"{}"） 或者 new Object 创建的，如果是，则返回true。

$.isPlainObject({}) // => true

$.isPlainObject(new Object) // => true

$.isPlainObject(new Date) // => false

$.isPlainObject(window) // => false

$.isWindow v1.0+

$.isWindow(object) ⇒ boolean

如果object参数为一个window对象，那么返回true。这在处理iframe时非常有用，因为每个iframe都有它们自己的window对象，使用常规方法obj === window校验这些objects的时候会失败。

$.map

$.map(collection, function(item, index){ ... }) ⇒ collection

通过遍历集合中的元素，返回通过迭代函数的全部结果，（注：一个新数组）null 和 undefined 将被过滤掉。

$.map([1,2,3,4,5],function(item,index){

if(item>1){return item*item;}

});

// =>[4, 9, 16, 25]

$.map({"yao":1,"tai":2,"yang":3},function(item,index){

if(item>1){return item*item;}

});

// =>[4, 9]

$.noop v1.2+

var callback = $.noop

引用一个空函数（什么都不处理）。

$.parseJSON v1.0+

$.parseJSON(string) ⇒ object

原生JSON.parse方法的别名。（注：接受一个标准格式的 JSON 字符串，并返回解析后的 JavaScript 对象。）

$.trim v1.0+

$.trim(string) ⇒ string

删除字符串首尾的空白符。类似String.prototype.trim()。

$.type v1.0+

$.type(object) ⇒ string

获取JavaScript 对象的类型。可能的类型有： null undefined boolean number string function array date regexp object error。

对于其它对象，它只是简单报告为“object”，如果你想知道一个对象是否是一个javascript普通对象，使用 isPlainObject。

add

add(selector, [context]) ⇒ self

添加元素到当前匹配的元素集合中。如果给定content参数，将只在content元素中进行查找，否则在整个document中查找。

• list item 1
• list item 2
• list item 3

a paragraph

addClass

addClass(name) ⇒ self

addClass(function(index, oldClassName){ ... }) ⇒ self

为每个匹配的元素添加指定的class类名。多个class类名使用空格分隔。

after

after(content) ⇒ self

在每个匹配的元素后插入内容（注：外部插入）。内容可以为html字符串，dom节点，或者节点组成的数组。

$('form label').after('

A note below the label

')

append

append(content) ⇒ self

在每个匹配的元素末尾插入内容（注：内部插入）。内容可以为html字符串，dom节点，或者节点组成的数组。

$('ul').append('

new list item

')

appendTo

appendTo(target) ⇒ self

将匹配的元素插入到目标元素的末尾（注：内部插入）。这个有点像 append，但是插入的目标与其相反。

$('

new list item

').appendTo('ul')

attr

attr(name) ⇒ string

attr(name, value) ⇒ self

attr(name, function(index, oldValue){ ... }) ⇒ self

attr({ name: value, name2: value2, ... }) ⇒ self

读取或设置dom的属性。如果没有给定value参数，则读取对象集合中第一个元素的属性值。当给定了value参数。则设置对象集合中所有元素的该属性的值。当value参数为null，那么这个属性将被移除(类似removeAttr)，多个属性可以通过对象键值对的方式进行设置。

要读取DOM的属性如 checked和selected, 使用 prop。

var form = $('form')

form.attr('action') //=> 读取值

form.attr('action', '/create') //=> 设置值

form.attr('action', null) //=> 移除属性

// 多个属性:

form.attr({

action: '/create',

method: 'post'

})

before

before(content) ⇒ self

在匹配每个元素的前面插入内容（注：外部插入）。内容可以为html字符串，dom节点，或者节点组成的数组。

$('table').before('

See the following table:

')

children

children([selector]) ⇒ collection

获得每个匹配元素集合元素的直接子元素，如果给定selector，那么返回的结果中只包含符合css选择器的元素。

$('ol').children('*:nth-child(2n)')

//=> every other list item from every ordered list

clone v1.0+

clone() ⇒ collection

通过深度克隆来复制集合中的所有元素。

此方法不会将数据和事件处理程序复制到新的元素。这点和jquery中利用一个参数来确定是否复制数据和事件处理不相同。

closest

closest(selector, [context]) ⇒ collection

closest(collection) ⇒ collection v1.0+

closest(element) ⇒ collection v1.0+

从元素本身开始，逐级向上级元素匹配，并返回最先匹配selector的元素。如果给定context节点参数，那么只匹配该节点的后代元素。这个方法与 parents(selector)有点相像，但它只返回最先匹配的祖先元素。

如果参数是一个Zepto对象集合或者一个元素，结果必须匹配给定的元素而不是选择器。

var input = $('input[type=text]')

input.closest('form')

concat

concat(nodes, [node2, ...]) ⇒ self

添加元素到一个Zepto对象集合形成一个新数组。如果参数是一个数组，那么这个数组中的元素将会合并到Zepto对象集合中。

这是一个Zepto提供的方法，不是jquey的API 。

contents v1.0+

contents() ⇒ collection

获得每个匹配元素集合元素的子元素，包括文字和注释节点。（注：.contents()和.children()方法类似，只不过前者包括文本节点以及jQuery对象中产生的HTML元素。）

css

css(property) ⇒ value

css([property1, property2, ...]) ⇒ object v1.1+

css(property, value) ⇒ self

css({ property: value, property2: value2, ... }) ⇒ self

读取或设置DOM元素的css属性。当value参数不存在的时候，返回对象集合中第一个元素的css属性。当value参数存在时，设置对象集合中每一个元素的对应css属性。

多个属性可以通过传递一个属性名组成的数组一次性获取。多个属性可以利用对象键值对的方式进行设置。

当value为空(空字符串，null 或 undefined)，那个css属性将会被移出。当value参数为一个无单位的数字，如果该css属性需要单位，“px”将会自动添加到该属性上。

var elem = $('h1')

elem.css('background-color') // read property

elem.css('background-color', '#369') // set property

elem.css('background-color', '') // remove property

// set multiple properties:

elem.css({ backgroundColor: '#8EE', fontSize: 28 })

// read multiple properties:

elem.css(['backgroundColor', 'fontSize'])['fontSize']

data

data(name) ⇒ value data(name, value) ⇒ self

读取或写入dom的 data-* 属性。行为有点像 attr ，但是属性名称前面加上 data-。

当读取属性值时，会有下列转换：v1.0+

“true”, “false”, and “null” 被转换为相应的类型；

数字值转换为实际的数字类型；

JSON值将会被解析，如果它是有效的JSON；

其它的一切作为字符串返回。

Zepto

基本实现`data()`只能存储字符串。如果你要存储任意对象，请引入可选的“data”模块到你构建的Zepto中。

each

each(function(index, item){ ... }) ⇒ self

遍历一个对象集合每个元素。在迭代函数中，this关键字指向当前项(作为函数的第二个参数传递)。如果迭代函数返回 false，遍历结束。

$('form input').each(function(index){

console.log('input %d is: %o', index, this)

})

empty

empty() ⇒ self

清空对象集合中每个元素的DOM内容。

eq

eq(index) ⇒ collection

从当前对象集合中获取给定索引值（注：以0为基数）的元素。

$('li').eq(0) //=> only the first list item

$('li').eq(-1) //=> only the last list item

filter

filter(selector) ⇒ collection

filter(function(index){ ... }) ⇒ collection v1.0+

过滤对象集合，返回对象集合中满足css选择器的项。如果参数为一个函数，函数返回有实际值得时候，元素才会被返回。在函数中， this 关键字指向当前的元素。

与此相反的功能，查看not.

find

find(selector) ⇒ collection

find(collection) ⇒ collection v1.0+

find(element) ⇒ collection v1.0+

在当对象前集合内查找符合CSS选择器的每个元素的后代元素。

如果给定Zepto对象集合或者元素，过滤它们，只有当它们在当前Zepto集合对象中时，才回被返回。

var form = $('#myform')

form.find('input, select')

first

first() ⇒ collection

获取当前对象集合中的第一个元素。

$('form').first()

forEach

forEach(function(item, index, array){ ... }, [context])

遍历对象集合中每个元素，有点类似 each，但是遍历函数的参数不一样，当函数返回 false 的时候，遍历不会停止。

这是一个Zepto提供的方法，不是jquery的API。

get

get() ⇒ array

get(index) ⇒ DOM node

从当前对象集合中获取所有元素或单个元素。当index参数不存在的时，以普通数组的方式返回所有的元素。当指定index时，只返回该置的元素。这点与eq不同，该方法返回的是DOM节点，不是Zepto对象集合。

var elements = $('h2')

elements.get() //=> get all headings as an array

elements.get(0) //=> get first heading node

has v1.0+

has(selector) ⇒ collection

has(node) ⇒ collection

判断当前对象集合的子元素是否有符合选择器的元素，或者是否包含指定的DOM节点，如果有，则返回新的对象集合，该对象过滤掉不含有选择器匹配元素或者不含有指定DOM节点的对象。

$('ol > li').has('a[href]')

//=> get only LI elements that contain links

hasClass

hasClass(name) ⇒ boolean

检查对象集合中是否有元素含有指定的class。

• list item 1
• list item 2
• list item 3

a paragraph

height

height() ⇒ number

height(value) ⇒ self

height(function(index, oldHeight){ ... }) ⇒ self

获取对象集合中第一个元素的高度；或者设置对象集合中所有元素的高度。

$('#foo').height() // => 123

$(window).height() // => 838 (viewport height)

$(document).height() // => 22302

hide

hide() ⇒ self

Hide elements in this collection by setting their display CSS property to none.

通过设置css的属性display 为 none来将对象集合中的元素隐藏。

html

html() ⇒ string

html(content) ⇒ self

html(function(index, oldHtml){ ... }) ⇒ self

获取或设置对象集合中元素的HTML内容。当没有给定content参数时，返回对象集合中第一个元素的innerHtml。当给定content参数时，用其替换对象集合中每个元素的内容。content可以是append中描述的所有类型。

// autolink everything that looks like a Twitter username

$('.comment p').html(function(idx, oldHtml){

return oldHtml.replace(/(^|\W)@(\w{1,15})/g,

'$1@$2')

})

index

index([element]) ⇒ number

获取一个元素的索引值（注：从0开始计数）。当elemen参数没有给出时，返回当前元素在兄弟节点中的位置。当element参数给出时，返回它在当前对象集合中的位置。如果没有找到该元素，则返回-1。

$('li:nth-child(2)').index() //=> 1

indexOf

indexOf(element, [fromIndex]) ⇒ number

Get the position of an element in the current collection. If fromIndex number is

given, search only from that position onwards. Returns the 0-based position when

found and -1 if not found. Use of index is recommended over this

method.

在当前对象集合中获取一个元素的索引值（注：从0开始计数）。如果给定formindex参数，从该位置开始往后查找，返回基于0的索引值，如果没找到，则返回-1。index 方法是基于这个方法实现的。

这是一个Zepto的方法，不是jquer的api。

insertAfter

insertAfter(target) ⇒ self

将集合中的元素插入到指定的目标元素后面（注：外部插入）。这个有点像 after，但是使用方式相反。

$('

Emphasis mine.

').insertAfter('blockquote')

insertBefore

insertBefore(target) ⇒ self

将集合中的元素插入到指定的目标元素前面（注：外部插入）。这个有点像 before，但是使用方式相反。

$('

See the following table:

').insertBefore('table')

is

is(selector) ⇒ boolean

判断当前元素集合中的第一个元素是否符css选择器。对于基础支持jquery的非标准选择器类似： :visible包含在可选的“selector”模块中。

jQuery

CSS extensions 不被支持。 选择“selector”模块仅仅能支持有限几个最常用的方式。

last

last() ⇒ collection

获取对象集合中最后一个元素。

$('li').last()

map

map(function(index, item){ ... }) ⇒ collection

遍历对象集合中的所有元素。通过遍历函数返回值形成一个新的集合对象。在遍历函数中this关键之指向当前循环的项（遍历函数中的第二个参数）。

遍历中返回 null和undefined，遍历将结束。

// get text contents of all elements in collection

elements.map(function(){ return $(this).text() }).get().join(', ')

next

next() ⇒ collection

next(selector) ⇒ collection v1.0+

Get the next sibling–optionally filtered by selector–of each element in the

collection.

获取对象集合中每一个元素的下一个兄弟节点(可以选择性的带上过滤选择器)。

$('dl dt').next() //=> the DD elements

not

not(selector) ⇒ collection

not(collection) ⇒ collection

not(function(index){ ... }) ⇒ collection

过滤当前对象集合，获取一个新的对象集合，它里面的元素不能匹配css选择器。如果另一个参数为Zepto对象集合，那么返回的新Zepto对象中的元素都不包含在该参数对象中。如果参数是一个函数。仅仅包含函数执行为false值得时候的元素，函数的 this 关键字指向当前循环元素。

与它相反的功能，查看 filter.

offset

offset() ⇒ object

offset(coordinates) ⇒ self v1.0+

offset(function(index, oldOffset){ ... }) ⇒ self v1.0+

获得当前元素相对于document的位置。返回一个对象含有： top, left, width和height

当给定一个含有left和top属性对象时，使用这些值来对集合中每一个元素进行相对于document的定位。

offsetParent v1.0+

offsetParent() ⇒ collection

找到第一个定位过的祖先元素，意味着它的css中的position 属性值为“relative”, “absolute” or “fixed”

parent

parent([selector]) ⇒ collection

获取对象集合中每个元素的直接父元素。如果css选择器参数给出。过滤出符合条件的元素。

parents

parents([selector]) ⇒ collection

获取对象集合每个元素所有的祖先元素。如果css选择器参数给出，过滤出符合条件的元素。

如果想获取直接父级元素，使用 parent。如果只想获取到第一个符合css选择器的元素，使用closest。

$('h1').parents() //=> [, , ]

pluck

pluck(property) ⇒ array

获取对象集合中每一个元素的属性值。返回值为 null或undefined值得过滤掉。

$('body > *').pluck('nodeName') // => ["DIV", "SCRIPT"]

// implementation of Zepto's `next` method

$.fn.next = function(){

return $(this.pluck('nextElementSibling'))

}

这是一个Zepto的方法，不是jquery的api

position v1.0+

position() ⇒ object

获取对象集合中第一个元素的位置。相对于 offsetParent。当绝对定位的一个元素靠近另一个元素的时候，这个方法是有用的。

Returns an object with properties: top, left.

var pos = element.position()

// position a tooltip relative to the element

$('#tooltip').css({

position: 'absolute',

top: pos.top - 30,

left: pos.left

})

prepend

prepend(content) ⇒ self

将参数内容插入到每个匹配元素的前面（注：元素内部插入）。插入d的元素可以试html字符串片段，一个dom节点，或者一个节点的数组。

$('ul').prepend('

first list item

')

prependTo

prependTo(target) ⇒ self

将所有元素插入到目标前面（注：元素内部插入）。这有点像prepend，但是是相反的方式。

$('

first list item

').prependTo('ul')

prev

prev() ⇒ collection

prev(selector) ⇒ collection v1.0+

获取对象集合中每一个元素的前一个兄弟节点，通过选择器来进行过滤。

prop v1.0+

prop(name) ⇒ value

prop(name, value) ⇒ self

prop(name, function(index, oldValue){ ... }) ⇒ self

读取或设置dom元素的属性值。它在读取属性值的情况下优先于 attr，因为这些属性值会因为用户的交互发生改变，如checked 和 selected。

简写或小写名称，比如for, class, readonly及类似的属性，将被映射到实际的属性上，比如htmlFor, className, readOnly, 等等。

push

push(element, [element2, ...]) ⇒ self

Add elements to the end of the current collection.

添加元素到当前对象集合的最后。

这是一个zepto的方法，不是jquery的api

ready

ready(function($){ ... }) ⇒ self

添加一个事件侦听器，当页面DOM加载完毕 “DOMContentLoaded” 事件触发时触发。建议使用 $()来代替这种用法。

reduce

reduce(function(memo, item, index, array){ ... }, [initial]) ⇒ value

与 Array.reduce有相同的用法，遍历当前对象集合。memo是函数上次的返回值。迭代进行遍历。

这是一个zepto的方法，不是jquery的api

remove

remove() ⇒ self

从其父节点中删除当前集合中的元素，有效的从dom中移除。

removeAttr

removeAttr(name) ⇒ self

移除当前对象集合中所有元素的指定属性。

removeClass

removeClass([name]) ⇒ self

removeClass(function(index, oldClassName){ ... }) ⇒ self

移除当前对象集合中所有元素的指定class。如果没有指定name参数，将移出所有的class。多个class参数名称可以利用空格分隔。下例移除了两个class。

removeProp v1.2+

removeProp(name) ⇒ self

从集合的每个DOM节点中删除一个属性。这是用JavaScript的delete操作符完成。值得注意的是如果尝试删除DOM的一些内置属性，如className或maxLength，将不会有任何效果，因为浏览器禁止删除这些属性。

replaceWith

replaceWith(content) ⇒ self

用给定的内容替换所有匹配的元素。(包含元素本身)。content参数可以为 before中描述的类型。

scrollLeft v1.1+

scrollLeft() ⇒ number

scrollLeft(value) ⇒ self

获取或设置页面上的滚动元素或者整个窗口向右滚动的像素值。

scrollTop v1.0+

scrollTop() ⇒ number

scrollTop(value) ⇒ self v1.1+

获取或设置页面上的滚动元素或者整个窗口向下滚动的像素值。

show

show() ⇒ self

恢复对象集合中每个元素默认的“display”值。如果你用 hide将元素隐藏，用该属性可以将其显示。相当于去掉了display：none。

siblings

siblings([selector]) ⇒ collection

获取对象集合中所有元素的兄弟节点。如果给定CSS选择器参数，过滤出符合选择器的元素。

size

size() ⇒ number

获取对象集合中元素的数量。

slice

slice(start, [end]) ⇒ array

提取这个数组array的子集，从start开始，如果给定end，提取从从start开始到end结束的元素，但是不包含end位置的元素。

text

text() ⇒ string

text(content) ⇒ self

text(function(index, oldText){ ... }) ⇒ self v1.1.4+

获取或者设置所有对象集合中元素的文本内容。当没有给定content参数时，返回当前对象集合中第一个元素的文本内容（包含子节点中的文本内容）。当给定content参数时，使用它替换对象集合中所有元素的文本内容。它有待点似 html，与它不同的是它不能用来获取或设置 HTML。

toggle

toggle([setting]) ⇒ self

显示或隐藏匹配元素。如果 setting为true，相当于show 法。如果setting为false。相当于 hide方法。

var input = $('input[type=text]')

$('#too_long').toggle(input.val().length > 140)

toggleClass

toggleClass(names, [setting]) ⇒ self

toggleClass(function(index, oldClassNames){ ... }, [setting]) ⇒ self

在匹配的元素集合中的每个元素上添加或删除一个或多个样式类。如果class的名称存在则删除它，如果不存在，就添加它。如果 setting的值为真，这个功能类似于 addClass，如果为假，这个功能类似与 removeClass。

unwrap

unwrap() ⇒ self

移除集合中每个元素的直接父节点，并把他们的子元素保留在原来的位置。

基本上，这种方法删除上一的祖先元素，同时保持DOM中的当前元素。

$(document.body).append('

')

$('#wrapper p').unwrap().parents() //=> [, ]

val

val() ⇒ string

val(value) ⇒ self

val(function(index, oldValue){ ... }) ⇒ self

获取或设置匹配元素的值。当没有给定value参数，返回第一个元素的值。如果是标签，则返回一个数组。当给定value参数，那么将设置所有元素的值。

width

width() ⇒ number

width(value) ⇒ self

width(function(index, oldWidth){ ... }) ⇒ self

获取对象集合中第一个元素的宽；或者设置对象集合中所有元素的宽。

$('#foo').width() // => 123

$(window).width() // => 768 (viewport width)

$(document).width() // => 768

wrap

wrap(structure) ⇒ self

wrap(function(index){ ... }) ⇒ self v1.0+

在每个匹配的元素外层包上一个html元素。structure参数可以是一个单独的元素或者一些嵌套的元素。也可以是一个html字符串片段或者dom节点。还可以是一个生成用来包元素的回调函数，这个函数返回前两种类型的包裹片段。

需要提醒的是：该方法对于dom中的节点有着很好的支持。如果将wrap() 用在一个新的元素上，然后再将结果插入到document中，此时该方法无效。

// wrap each button in a separate span:

$('.buttons a').wrap('')

// wrap each code block in a div and pre:

$('code').wrap('

')

// wrap all form inputs in a span with classname

// corresponding to input type:

$('input').wrap(function(index){

return ''

})

//=>

,

//

// WARNING: will not work as expected!

$('broken').wrap('

').appendTo(document.body)

// do this instead:

$('better').appendTo(document.body).wrap('

')

wrapAll

wrapAll(structure) ⇒ self

在所有匹配元素外面包一个单独的结构。结构可以是单个元素或

几个嵌套的元素，并且可以通过在作为HTML字符串或DOM节点。

// wrap all buttons in a single div:

$('a.button').wrapAll('

')

wrapInner

wrapInner(structure) ⇒ self

wrapInner(function(index){ ... }) ⇒ self v1.0+

将每个元素中的内容包裹在一个单独的结构中。结构可以是单个元件或多个嵌套元件，并且可以通过在作为HTML字符串或DOM节点，或者是一个生成用来包元素的回调函数，这个函数返回前两种类型的包裹片段。

// wrap the contents of each navigation link in a span:

$('nav a').wrapInner('')

// wrap the contents of each list item in a paragraph and emphasis:

$('ol li').wrapInner('

')

Detect methods

Detect module

该检测方法可以在不同的环境中微调你的站点或者应用程序，并帮助你识别手机和平板；以及不同的浏览器和操作系统。

// The following boolean flags are set to true if they apply,

// if not they're either set to `false` or `undefined`.

// We recommend accessing them with `!!` prefixed to coerce to a boolean.

// general device type

$.os.phone

$.os.tablet

// specific OS

$.os.ios

$.os.android

$.os.webos

$.os.blackberry

$.os.bb10

$.os.rimtabletos

// specific device type

$.os.iphone

$.os.ipad

$.os.ipod // [v1.1]

$.os.touchpad

$.os.kindle

// specific browser

$.browser.chrome

$.browser.firefox

$.browser.safari // [v1.1]

$.browser.webview // (iOS) [v1.1]

$.browser.silk

$.browser.playbook

$.browser.ie // [v1.1]

// 此外，版本信息是可用的。

// 下面是运行iOS 6.1的iPhone所返回的。

!!$.os.phone // => true

!!$.os.iphone // => true

!!$.os.ios // => true

$.os.version // => "6.1"

$.browser.version // => "536.26"

事件处理

$.Event

$.Event(type, [properties]) ⇒ event

创建并初始化一个指定的DOM事件。如果给定properties对象，使用它来扩展出新的事件对象。默认情况下，事件被设置为冒泡方式；这个可以通过设置bubbles为false来关闭。

一个事件初始化的函数可以使用 trigger来触发。

$.Event('mylib:change', { bubbles: false })

$.proxy v1.0+

$.proxy(fn, context) ⇒ function

$.proxy(fn, context, [additionalArguments...]) ⇒ function v1.1.4+

$.proxy(context, property) ⇒ function

$.proxy(context, property, [additionalArguments...]) ⇒ function v1.1.4+

接受一个函数，然后返回一个新函数，并且这个新函数始终保持了特定的上下文(context)语境，新函数中this指向context参数。另外一种形式，原始的function是从上下文(context)对象的特定属性读取。

如果传递超过2个的额外参数，它们被用于 传递给fn参数的函数 引用。

var obj = {name: 'Zepto'},

handler = function(){ console.log("hello from + ", this.name) }

// ensures that the handler will be executed in the context of `obj`:

$(document).on('click', $.proxy(handler, obj))