Zepto粤语API

animate

animate(properties, [duration, [easing, [function(){ ... }]]])   ⇒ self
animate(properties, { duration: msec, easing: type, complete: fn })   ⇒ self
animate(animationName, { ... })   ⇒ self

对现阶段Zepto集合对象中元素举办css transition属性平滑过渡。

  • properties:
    一个目标,该目的涵盖了css动画的值,或者css帧动画的称呼。
  • duration (默认 400):以纳秒为单位的大运,或者一个字符串。
    • fast (200 ms)
    • slow (600 ms)
    • 任何$.fx.speeds自定义属性
  • easing (默认 linear):指定动画的缓动类型,使用以下一个:
  • complete:动画完成时的回调函数

Zepto 还帮忙以下 CSS
transform
 属性:

  • translate(X|Y|Z|3d)
  • rotate(X|Y|Z|3d)
  • scale(X|Y|Z)
  • matrix(3d)
  • perspective
  • skew(X|Y)

如果duration参数为 0 或 $.fx.off 为 true(在不补助css
transitions的浏览器中默认为true),动画将不被实践;替代动画效果的靶子地点会登时见效。类似的,如若指定的卡通不是透过动画完成,而且动画的靶子地方即可见效。这种状态下并未动画, complete办法也不会被调用。

设若第一个参数是字符串而不是一个目的,它将被当作一个css关键帧动画 CSS
keyframe
animation
的名称。

$("#some_element").animate({
    opacity: 0.25,
    left: '50px',
    color: '#abcdef',
    rotateZ: '45deg',
    translate3d: '0,10px,0'
}, 500, 'ease-out');

Zepto只行使css过渡效果的卡通。jquery的easings不会支撑。jquery的相对变化(“=+10px”)
syntax 也不扶助。请查看 list of animatable
properties
。浏览器的支撑可能两样,所以自然要测试你所想要补助的浏览器。


开创插件

可以由此抬高格局作为$.fn的性质来写插件:

;(function($) {
    $.extend($.fn, {
        foo: function() {
            // `this` refers to the current Zepto collection.
            // When possible, return the Zepto collection to allow chaining.
            return this.html('bar')
        }
    })
})(Zepto)

为了更好起始支付插件,先看下source of Zepto’s core
module
,并认可读过coding
style
guidelines


remove

remove()   ⇒ self

移出当前Zepto对象中的元素。有效的从dom中移除。

$.isPlainObject v1.0+

$.isPlainObject(object)   ⇒ boolean

测试目标是否是纯粹的对象(通过 “{}” 或者 “new Object”
创造的),淌要是,则赶回true。

$.isPlainObject({});// => true
$.isPlainObject(new Object); // => true
$.isPlainObject(new Date); // => false
$.isPlainObject(window);// => false

slice

slice(start, [end])   ⇒ array

array中提取的点子。从start开始,如果end 指出。提取不包含end地方的元素。

$.inArray v1.0+

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

检索数组中指定值并赶回它的目录(假设没有找到则赶回-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

offsetParent v1.0+

offsetParent()   ⇒ collection

找到第一个定点过的祖辈元素,在ccs中象征它的position 值为“relative”,
“absolute” or “fixed”

first

first()   ⇒ collection

取得当前Zepto对象集合中的第一个要素。

$('form').first();

prop v1.0+

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

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

<input class="taiyang" id="check1" type="checkbox" checked="checked">
<input class="yaotaiyang" id="check2" type="checkbox">

<script type="text/javascript">
    $("#check1").attr("checked"); //=> "checked"
    $("#check1").prop("checked"); //=> "true"
    $("#check2").attr("checked"); //=> "false"
    $("#check2").prop("checked"); //=> "false"
    $("input[type='checkbox']").prop("type",function(index,oldvalue){
        console.log(index+"|"+oldvalue);
    });
    //=> 0|checkbox
    //=> 1|checkbox
    $("input[type='checkbox']").prop("className",function(index,oldvalue){
        console.log(index+"|"+oldvalue);
    });
    //=> 0|taiyang
    //=> 1|yaotaiyang
</script>

serializeArray

serializeArray()   ⇒ array

将用作提交的表单元素的值编译成拥有name和value对象组成的数组。无法利用的表单元素,buttons,未入选的radio
buttons/checkboxs 将会被跳过。结果不分包file inputs的多少。

$('form').serializeArray()
//=> [{ name: 'size', value: 'micro' },
//    { name: 'name', value: 'Zepto' }]

load

load(url, function(data, status, xhr){ ... })   ⇒ self

透过GET Ajax载入远程 HTML 文件代码并插入至 DOM
中。此外,一个css选拔器可以在url中指定,像这样,可以应用匹配selector采纳器的HTML内容来更新集合。

Set the html contents of the current collection to the result of a GET
Ajax call to the given URL. Optionally, a CSS selector can be specified
in the URL, like so, to use only the HTML content matching the selector
for updating the collection:

$('#some_element').load('/foo.html #bar')

当这种措施执行,
它将寻找 foo.html 页面的始末,Zepto会获取ID为bar元素的内容,并且插入到ID为 some_element 元素,而此外的被寻找到的要素将被放弃。

万一css选用器不设有。将应用完全的回来文本。

请小心,在未曾采取器的状态下,任何javascript块都会进行。假设带上采取器,匹配选拔器内的script将会被去除。


$.camelCase v1.0+

$.camelCase(string)   ⇒ string

将一组字符串变成“骆驼”命名法的新字符串,如若该字符已经是“骆驼”命名法,则不扭转。

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

trigger

trigger(event, [data]) 

在Zepto对象集合的元素上接触指定的事件。事件能够是一个字符串,也足以是一个 $.Event 对象。即便data参数存在,它会作为参数传递给事件函数。

// add a handler for a custom event
$(document).on('mylib:change', function(e, from, to) {
    console.log('change on %o with data %s, %s', e.target, from, to)
});
// trigger the custom event
$(document.body).trigger('mylib:change', ['one', 'two']);

Zepto仅仅襄助在dom元素上接触事件。

siblings

siblings([selector])   ⇒ collection

得到Zepto集合对象具备兄弟节点。假如css采取器参数给出。过滤出适合采用器的元素。

$.trim v1.0+

$.trim(string)   ⇒ string

去除字符串开头和最后的空白符。类似String.prototype.trim()。

concat

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

添先令素到一个Zepto对象集合形成一个新数组。要是参数是一个数组,那么那么些数组中的元素将会师并到Zepto对象集合中。

这是一个Zepto提供的措施,不是jquey的API 。

$.param

$.param(object, [shallow])   ⇒ string
$.param(array)   ⇒ string

始建一个连串化的数组或对象,适用于一个URL
地址询问字符串或Ajax请求。即使shallow设置为true。嵌套对象不会被系列化,嵌套数组的值不会动用放括号在他们的key上。

此外,还接受 serializeArray格式的数组,其中每个项都有
“name” 和 “value”属性。

Also accepts an array
in serializeArray format,
where each item has “name” and “value” properties.

$.param({
    foo: {
        one: 1,
        two: 2
    }
});
//=> "foo[one]=1&foo[two]=2)"

$.param({
    ids: [1, 2, 3]
});
//=> "ids[]=1&ids[]=2&ids[]=3"

$.param({
    ids: [1, 2, 3]
}, true);
//=> "ids=1&ids=2&ids=3"

$.param({
    foo: 'bar',
    nested: {
        will: 'not be ignored'
    }
});
//=> "foo=bar&nested[will]=not+be+ignored"

$.param({
    foo: 'bar',
    nested: {
        will: 'be ignored'
    }
}, true);
//=> "foo=bar&nested=[object+Object]"

has v1.0+

has(selector)   ⇒ collection
has(node)   ⇒ collection

判断当前Zepto对象集合的子元素是否有契合选取器的因素,或者是否带有指定的dom节点,假设有,则赶回新的Zepto集合对象,该对象过滤掉不含有采用器匹配元素或者不分包指定dom节点的对象。

$('ol > li').has('a[href]')
//=> get only LI elements that contain links

reduce

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

与 Array.reduce有相同的用法,遍历当前Zepto对象集合。memo是函数上次的重返值。迭代举办遍历。

这是一个zepto的法门,不是jquery的api

clone v1.0+

clone()   ⇒ collection

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

此模式不会有数据和事件处理程序复制到新的因素。这一点和jquery中利用一个参数来确定是否复制数据和事件处理不等同。

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('<div class="highlight"><pre /></div>');

// wrap all form inputs in a span with classname
// corresponding to input type:
$('input').wrap(function(index) {
    return '';
});
//=> <input type=text />,
//   <input type=search />

// WARNING: will not work as expected!
$('<em>broken</em>').wrap('<li>').appendTo(document.body);
// do this instead:
$('<em>better</em>').appendTo(document.body).wrap('<li>');

$.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)
    });

filter

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

过滤Zepto集合对象,重临的Zepto集合对象里面的项满足参数中的css采用器。若是参数为一个函数,函数再次回到有实在值得时候,元素才会被再次来到。在函数中, this 关键字指向当前的元素。

与此相反的效用,查看not.

wrapAll

wrapAll(structure)   ⇒ self

在拥有匹配元素外面包一层HTML结构。

// wrap all buttons in a single div:
$('a.button').wrap('<div id=buttons />');

触控

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.touchpad
$.os.kindle

// specific browser
$.browser.chrome
$.browser.firefox
$.browser.silk
$.browser.playbook

// Additionally, version information is available as well.
// Here's what's returned for an iPhone running iOS 6.1.
!!$.os.phone
// => true
!!$.os.iphone
// => true
!!$.os.ios
// => true
!!$.os.version
// => "6.1"
!!$.browser.version
// => "536.26"

$.proxy v1.0+

$.proxy(fn, context)   ⇒ function
$.proxy(context, property)   ⇒ function

接受一个函数,然后回来一个新函数,并且这么些新函数始终维持了特定的上下文语境,新函数中this本着context参数。此外一种样式,原始的function是context对像的措施。

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

var obj = {
    name: "yaotaiyang",
    test: function() {
        alert(this.name);
        $("#test").unbind("click", obj.test);
    }
};
$("#test").click(jQuery.proxy(obj, "test"));

Touch events

“touch”模块添加以下事件,可以 on 和 off

  • tap —元素tap的时候接触。
  • singleTap and doubleTap —
    这一对事件可以用来检测元素上的单击和双击。(即便你不需要检测单击、双击,使用 tap 代替)。
  • longTap — 当一个因素被按住超越750ms触发。
  • swipeswipeLeftswipeRightswipeUpswipeDown —
    当元素被划过时触发。(可挑选给定的取向)

这个事件也是怀有Zepto对象集合上的顿时方法。

<style>
.delete {
    display: none;
}
</style>

<ul id=items>
    <li>List item 1
        DELETE
    </li>
    <li>List item 2
        DELETE
    </li>
</ul>

<script>
// show delete buttons on swipe
$('#items li').swipe(function() {
    $('.delete').hide()
    $('.delete',
        this).show()
})

// delete row on tapping delete button
$('.delete').tap(function() {
    $(this).parent('li').remove()
})
</script>

 

children

children([selector])   ⇒ collection

取得每个匹配元素集合元素的间接子元素,假如selector存在,只回去符合css选取器的要素。

$('ol').children('*:nth-child(2n)')
//=> every other list item from every ordered list

主导措施

Ajax 回调函数

您可以指定以下的回调函数,给出的施行各种:

  1. beforeSend(xhr, settings):请求发出前调用,它接收xhr对象和settings作为参数对象。假如它回到false ,请求将被撤废。

  2. success(data, status, xhr):请求成功未来调用。传入再次回到后的数据,以及富含成功代码的字符串。

  3. error(xhr, errorType, error):请求出错时调用。
    (超时,解析错误,或者状态码不在HTTP 2xx)。

  4. complete(xhr, status):请求完成时调用,无论请求败北或成功。

data

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

读取或写入dom的 data-* 属性。行为有点像 attr ,不过属性名称前边加上 data-

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

  • “true”, “false”, and “null” 被更换为相应的品类;
  • 数字值转换为实在的数字类型;
  • JSON值将会被分析,倘诺它是实惠的JSON;
  • 另外的整套作为字符串再次回到。

    Zepto
    基本落实`data()`只得存储字符串。假若您要存储任意对象,请引入可选的“data”模块到您构建的Zepto中。

Ajax 事件

global: true时。在Ajax请求生命周期内,以下这多少个事件将被触发。

  1. ajaxStart (global):假若没有此外Ajax请求当前活跃将会被触发。

  2. ajaxBeforeSend (data: xhr, options):再发送请求前,可以被注销。

  3. ajaxSend (data: xhr, options):像 ajaxBeforeSend,但不可能撤废。

  4. ajaxSuccess (data: xhr, options, data):当再次回到成功时。

  5. ajaxError (data: xhr, options, error):当有错误时。

  6. ajaxComplete (data: xhr,
    options):请求已经成功后,无论请求是水到渠成依旧退步。

  7. ajaxStop (global):如若这是终极一个活蹦乱跳着的Ajax请求,将会被触发。

默认状况下,Ajax事件在document对象上接触。可是,即使请求的 context 是一个dom节点,该事件会在此节点上触发然后再dom中冒泡。唯一的不比是 ajaxStart & ajaxStop那六个全局事件。

$(document).on('ajaxBeforeSend', function(e, xhr, options) {
    // This gets fired for every Ajax request performed on the page.
    // The xhr object and $.ajax() options are available for editing.
    // Return false to cancel this request.
});

$.ajax({
    type: 'GET',
    url: '/projects',
    // data to be added to query string:
    data: {
        name: 'Zepto.js'
    },
    // type of data we are expecting in return:
    dataType: 'json',
    timeout: 300,
    context: $('body'),
    success: function(data) {
        // Supposing this JSON payload was received:
        //   {"project": {"id": 42, "html": "<div>..." }}
        // append the HTML to context object.
        this.append(data.project.html);
    },
    error: function(xhr, type) {
        alert('Ajax error!');
    }
});

// post a JSON payload:
$.ajax({
    type: 'POST',
    url: '/projects',
    // post payload:
    data: JSON.stringify({
        name: 'Zepto.js'
    }),
    contentType: 'application/json'
});

indexOf

indexOf(element, [fromIndex])   ⇒ number

在当下Zepto中取得一个要素的职位。假设fromindex参数给出,从该地方将来查找,重临基于0的岗位,如若没找到,则赶回-1。index 方法是遵照这么些法子实现的。

这是一个Zepto的点子,不是jquer的api。

$.grep v1.0+

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

$.grep([1,2,3], function(){
        return item > 1
}); //=>[2,3]

取得一个新数组,新数组只含有回调函数中回到 ture 的数组项。

push

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

添美金素到当前Zepto对象的尾声。

这是一个zepto的办法,不是jquery的api

replaceWith

replaceWith(content)   ⇒ self

用提供的内容替换所有匹配的要素。(包含元素本身)。content参数可以为 before中讲述的序列。

toggle

toggle([setting])   ⇒ self

体现或隐藏匹配元素。假诺 setting为true,相当于show 法。如果setting为false。相当于 hide方法。

var input = $('input[type=text]');
$('#too_long').toggle(input.val().length > 140);

live

Deprecated, use on instead.

live(type, function(e){ ... })   ⇒ self
live({ type: handler, type2: handler2, ... })   ⇒ self

类似delegate,添加一个个风波处理器到适合当下采取器的兼具因素匹配,匹配的因素可能现在或将来才创立。

is

is(selector)   ⇒ boolean

看清当前Zepto元素集合中的第一个要素是否符css选拔器。对于基础支撑jquery的非标准采用器类似::visible富含在可选的“selector”模块中。

jQuery CSS
extensions
 不被扶助。
选用“selector”模块仅仅能支撑少数多少个最常用的点子。

原文地址:http://zeptojs.com/

事件处理

css

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

读取或安装dom元素的css属性。当value参数不设有的时候,重回Zepto对象集合中率先个要素的css属性。当value参数存在时,设置Zepto对象集合中每一个因素的呼应css属性。多条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
});

offset

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

获取当前元素绝对于document的职位。重临一个对象涵盖: topleftwidthheight

当给定一个目的属性lefttop应用这一个值来绝对于document对每一个因素进行固定。

triggerHandler

triggerHandler(event, [data])   ⇒ self

像 trigger,它只接触事件,但不冒泡。

比如说你再一个input上一经选取该格局。

$("input").triggerHandler('focus');
// 此时input上的focus事件触发,但是input不会聚焦
$("input").trigger('focus');
// 此时input上的focus事件触发,input聚焦

桌面浏览器

  • Safari 5+ (Mac, Win)
  • Chrome 5+ (Win, Mac, Linux, Chrome OS)
  • Mozilla Firefox 4+ (Win, Mac, Linux)
  • Opera 10+ (Win, Mac, Linux)

unwrap

unwrap()   ⇒ self

将匹配元素的父级元素删除,保留自己(和兄弟元素,假使存在)在本来的职位。

$(document.body).append('<div id=wrapper><p>Content</p></div>')
$('#wrapper p').unwrap().parents()
//=> [<body>, <html>]

get

get()   ⇒ array
get(index)   ⇒ DOM node

从眼前Zepto对象集合中得到具有因素或单个元素。当index参数不设有的时候,以一般数组的法门赶回所有的要素。当指定index时,只回去该置的元素。这一点与与eq今非昔比,该措施再次回到的不是Zepto集合对象。

var elements = $('h2');
elements.get()
//=> get all headings as an array
elements.get(0)
//=> get first heading node

举手投足端浏览器

  • iOS 4+ Safari
  • Chrome for Android
  • Chrome for iOS
  • Android 2.2+ Browser
  • webOS 1.4.5+ Browser
  • BlackBerry Tablet OS 1.0.7+ Browser
  • Amazon Silk 1.0+
  • Firefox for Android
  • Firefox OS Browser
  • Practically any WebKit-based browsers/runtimes

急需小心的是Zepto的局部可选功用是专门针对移动端浏览器的;因为它的前期目标在移动端提供一个简练的近乎jquery的js库。

在浏览器上(Safari和Chrome)上支出页面使用或者采纳PhoneGap构建基于html的web-view本地应用,使用Zepto是一个正确的精选。

 

简单来讲,除了ie浏览器外,Zepto希望在富有的当代浏览器中作为一种基础环境来利用。

height

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

收获Zepto对象集合中首个元素的低度;或者安装Zepto对象集合中有所因素的莫大。

$('#foo').height()
// => 123
$(window).height()
// => 838 (viewport height)
$(document).height()
// => 22302

val

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

赢得或设置匹配元素的值。当value参数不存在。重回第一个元素的值。假如是<select multiple>标签,则赶回一个数组。

undelegate

Deprecated, use off instead.

undelegate(selector, type, function(e){ ... })   ⇒ self
undelegate(selector, { type: handler, type2: handler2, ... })   ⇒ self

移除通过delegate 注册的事件。


on

on(type, [selector], function(e){ ... })   ⇒ self
on({ type: handler, type2: handler2, ... }, [selector])   ⇒ self

充分事件到Zepto对象集合上。两个事件可以经过空格的字符串模式丰硕。或者以事件类型、函数对象的
格局。假诺css采纳器给出,事件的对象满足选取器条件时。事件才会被触发。

事件处理程序在触及事件要素或者css采纳器匹配的元素的内外文中执行(this指向触发事件的因素)。

当事件处理程序再次回到false,
或调用preventDefault(),浏览器的默认事件将会被拦住。

var elem = $('#content');
// observe all clicks inside #content:
elem.on('click', function(e) {
        ...
});
// observe clicks inside navigation links in #content
elem.on('click', 'nav a', function(e) {
        ...
});
// all clicks inside links in the document
$(document).on('click', 'a', function(e) {
        ...
});

on(type, [selector], function(e){ ... }) ⇒ self

如果selector存在,则相当于delegate。
$("ul").on("click","li",function(){alert("yaotaiyang")});
以上代码相当于将li的事件代理到ul上。后续添加的li也能拥有以上方法。该事件可以通过undelegate来移除。
$("ul").undelegate();
也可用:$("ul").off();

如果selector参数不存在。则相当于bind。
$("li").on("click",function(){alert("yaotaiyang")});
该事件可以通过unbind来移除。
$("li").unbind("click");
也可以用off()来移除:$("li").off();

on方法继集成bind和delegate方法。

$.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' }

$.isWindow v1.0+

$.isWindow(object)   ⇒ boolean

规定参数是否为一个窗口(window对象),假假诺则赶回true。

那在拍卖iframe时特别有用,因为每个iframe都有它们自己的window对象,使用正规方法obj==window校验这多少个objects的时候会破产。

$.isFunction

$.isFunction(object)   ⇒ boolean

如果object是function,则返回ture。

Ajax请求

after

after(content)   ⇒ self

在各种匹配的因素后插入内容。内容可以为html字符串,dom节点,或者节点组成的数组。

$('form label').after('<p>A note below the label</p>')

hide

hide()   ⇒ self

透过安装css的习性display 为 none来将Zepto对象集合中的元素隐藏。

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

last

last()   ⇒ collection

拿到Zepto集合对象中最终一个因素。

$('li').last();

find

find(selector)   ⇒ collection
find(collection)   ⇒ collection v1.0+
find(element)   ⇒ collection v1.0+

获取当前Zepto集合对象内搜寻符合css选用器的各种元素的遗族。

虽然参数为Zepto集合对象或者元素,过滤它们,唯有当它们在现阶段Zepto集合对象中时,才回被重临。

var form = $('#myform');
form.find('input, select');

not

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

过滤当前Zepto对象集合,获取一个新的Zepto对象集合,它其中的元素不可以匹配css采取器。假设另一个参数为Zepto集合对象,那么再次来到的新Zepto对象中的元素都不分包在该参数对象中。尽管参数是一个函数。仅仅包含函数执行为false值得时候的要素,函数的 this 关键字指向当前循环元素。

与它反而的效果,查看 filter.

parent

parent([selector])   ⇒ collection

得到Zepto对象集合中每个元素的直接父元素。如果css选用器参数给出。过滤出符合条件的因素。

$.ajaxSettings

一个含有Ajax请求的默认设置的靶子。大部分的安装在 $.ajax中已经描述。以下设置为全局卓殊实惠:

Object containing the default settings for Ajax requests. Most settings
are described in $.ajax.
The ones that are useful when set globally are:

  • timeout (默认: 0):对Ajax请求设置一个非零的值指定一个默认的逾期时间,以皮秒为单位。
  • global (默认: true):设置为false。以预防触发Ajax事件。
  • xhr (默认:XMLHttpRequest
    factory):设置为一个函数,它回到XMLHttpRequest实例(或一个匹配的对象)
  • accepts: 从服务器请求的MIME类型,指定dataType值:
    • script: “text/javascript, application/javascript”
    • json: “application/json”
    • xml: “application/xml, text/xml”
    • html: “text/html”
    • text: “text/plain”

检测方法

$.ajax

$.ajax(options)   ⇒ XMLHttpRequest 

执行Ajax请求。请求地址可以是本土的要么跨域的,在匡助的浏览器中通过 HTTP
access
control
要么通过JSONP来完成。

参数:

  • type (默认: “GET”):请求方法 (“GET”, “POST”, or other)
  • url (默认: 当前地点):发送请求的地址
  • data (默认:none):发送到服务器的数目;即使是get请求,它会自行被看做参数拼接到url上。非String对象将透过 $.param 得到体系化字符串。
  • processData (默认: true):
    对于非Get请求。是否自动将 data 转换为字符串。
  • contentType (默认: “application/x-www-form-urlencoded”):
    发送音讯至服务器时内容编码类型。
    (那也可以透过安装headers headers)。通过安装 false 跳过设置默认值。
  • dataType (默认: none):预期服务器重返的数据类型(“json”, “jsonp”,
    “xml”, “html”, or “text”)
  • timeout (默认: 0): 设置请求超时时间(飞秒),0意味着然则期。
  • headers (默认:{}): 一个相当的”{键:值}”对映射到请求一起发送
  • async (默认:
    true):默认设置下,所有请求均为异步。若是需发送同步请求,请将此设置为 false
  • global (默认: true):请求将触及全局AJAX事件处理程序,设置为 false
    将不会触发全局 AJAX 事件。
  • context (默认: window):
    这么些目标用于安装Ajax相关回调函数的上下文(this指向)。
  • traditional (默认:false):激活传统的方式经过$.param来赢得连串化的 data

如果URL中含有 =?或者dataType是“jsonp”,这讲求将会透过注入一个 <script>标签来代表使用
XMLHttpRequest
(查看 JSONP)。此时对 contentTypedataTypeheaders有限制,async 不被帮助。

text

text()   ⇒ string
text(content)   ⇒ self

获取或者安装富有Zepto对象的公文内容。当content参数未提交。再次回到当前Zepto对象集合中率先个要素的文书内容(包含子节点中的文本内容)。当content参数给出,使用它替换Zepto对象集合中颇具因素的文件内容。它有待点似 html,与它不同的是它无法用来得到或设置
HTML。

ready

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

加上一个事变侦听器,当页面dom加载完毕 “DOMContentLoaded”
事件触发时触发。指出拔取 $())来代替这种用法。

contents v1.0+

contents()   ⇒ collection

拿到每个匹配元素集合元素的子元素,包括文字和注释节点。.contents()和.children()形式类似,只可是前者包括文件节点以及jQuery对象中发出的HTML元素。

one

one(type, function(e){ ... })   ⇒ self
one({ type: handler, type2: handler2, ... })   ⇒ self

累加一个处理事件到元素。处理函数在每个元素上最多执行一回。

index

index([element])   ⇒ number

取得一个因素的地点。当elemen参数没有交给时,重回当前因素在兄弟节点中的地点。当element参数给出时,再次回到它在现阶段Zepto对象集合中的地点。若是没有该因素,则赶回-1。

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

toggleClass

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

在配合的元素集合中的每个元素上助长或删除一个或多个样式类。假若class的称呼存在则删除它,假使不设有,就添加它。如若 setting的值为真,那一个功能类似于 addClass,如若为假,这多少个效应相近与 removeClass

html

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

取得或安装Zepto对象集合中元素的HTML内容。当content参数没有给定时,再次来到IZepto对象集合中第一个元素的innerHtm。当content参数给定时。用其替换Zepto对象集合中各样元素的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@<a href="http://twitter.com/$2">$2</a>');
});

add

add(selector, [context])   ⇒ self

添比索素到非常的因素集合。假诺content参数存在,只在content中开展搜索,否则在document中找寻。

<ul>    
    <li>list item 1</li>    
    <li>list item 2</li>    
    <li>list item 3</li>  
</ul>  
<p>a paragraph</p>

<script type="text/javascript">
    $('li').add('p').css('background-color', 'red');
</script>

show

show()   ⇒ self

回复Zepto对象集合中每个元素默认的“display”值。假设你用 hide将元素隐藏,用该属性可以将其出示。相当于干掉了display:none

设计的目标是提供jquery的接近的APIs,但并不是100%覆盖jquery为目标。zepto设计的目标是有一个5-10k的通用库、下载并进行快、有一个熟谙通用的API,所以您能把你根本的精力放到应用开发上。

off

off(type, [selector], function(e){ ... })   ⇒ self
off({ type: handler, type2: handler2, ... }, [selector])   ⇒ self
off(type, [selector])   ⇒ self
off()   ⇒ self

移除通过 on 注册的风波(用bind或者用on注册的风波)。假使没有参数,将移出当前元素上具有的登记事件。

off(type, [selector], function(e){ ... }) ⇒ self

如果selector存在,则相当于delegate。
$("ul").on("click","li",function(){alert("yaotaiyang")});
以上代码相当于将li的事件代理到ul上。后续添加的li也能拥有以上方法。该事件可以通过undelegate来移除。
$("ul").undelegate();
也可用:$("ul").off();

如果selector参数不存在。则相当于bind。
$("li").on("click",function(){alert("yaotaiyang")});
该事件可以通过unbind来移除。
$("li").unbind("click");
也可以用off()来移除:$("li").off();

on方法继集成bind和delegate方法。

before

before(content)   ⇒ self

在万分每个元素的前面(外面)插入内容。内容可以为html字符串,dom节点,或者节点组成的数组。

$('table').before('<p>See the following table:</p>')

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');

removeClass

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

移动当前Zepto对象集合中持有因素的指定class。假诺name参数未提交。将移出所有的class。两个class参数名称可以采用空格分隔。下例移除了几个class。

<input class="taiyang yueliang" id="check1" type="checkbox" checked="checked">
<input class="yaotaiyang" id="check2" type="checkbox">

<script type="text/javascript">
    $("#check1").removeClass("taiyang yueliang")
    //=>[<input class id="check1" type="checkbox" checked="checked">]
</script>

unbind

Deprecated, use off instead.

unbind(type, function(e){ ... })   ⇒ self
unbind({ type: handler, type2: handler2, ... })   ⇒ self

移除通过 bind 注册的事件。

position v1.0+

position()   ⇒ object

拿到Zepto对象集合中第一个因素的地点。绝对于 offsetParent。当绝对定位的一个素靠近另一个因素的时候,这些方法是实惠的。

回去一个的靶子有这多少个属性:topleft

var pos = element.position();

// position a tooltip relative to the element
$('#tooltip').css({
    position: 'absolute',
    top: pos.top - 30,
    left: pos.left
});

$.parseJSON v1.0+

$.parseJSON(string)   ⇒ object

恍如本地JSON.parse 方法,接受一个规范格式的 JSON
字符串,并赶回解析后的 JavaScript 对象。

$.post

$.post(url, [data], function(data, status, xhr){ ... }, [dataType])   ⇒ XMLHttpRequest

实施Ajax
POST请求。这是一个 $.ajax 的简写形式。

$.post('/create', {
    sample: 'payload'
}, function(response) {
    // process response
});

data 参数可以是一个字符串:

$.post('/create',
    $('#some_form').serialize(),
    function(response) {
        // ...
    });

$.contains v1.0+

$.contains(parent, node)   ⇒ boolean

反省父节点是否带有给定的dom节点,固然两者如出一辙,则赶回 false

$.ajaxJSONP

Deprecated,
use $.ajax instead.

$.ajaxJSONP(options)   ⇒ mock XMLHttpRequest

实践JSONP跨域获取数据。

此办法相对 $.ajax 没有优势,提议并非采纳。

each

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

遍历一个Zepto集合对象,为每一个匹配元素执行一个函数。this重中之重字指向当前item(作为函数的第二个参数传递)。假如函数再次来到 false,遍历截止。

$('form input').each(function(index) {
    console.log('input %d is: %o', index, this);
});

addClass

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

为各类匹配的要素添加指定的class类名。四个class类名通过空格分隔。

Zepto是一个轻量级的本着现代高等浏览器的JavaScript库, 它与jquery具有近乎的api
假诺您会用jquery,那么您也会用zepto。

$.getJSON

$.getJSON(url, function(data, status, xhr){ ... })   ⇒ XMLHttpRequest
$.getJSON(url, [data], function(data, status, xhr){ ... })   ⇒ XMLHttpRequest v1.0+

经过 Ajax
GET请求获取JSON数据。这是一个 $.ajax 的简写形式。

$.getJSON('/awesome.json', function(data) {
    console.log(data);
});

// fetch data from another domain with JSONP
$.getJSON('//example.com/awesome.json?callback=?', function(remoteData) {
    console.log(remoteData);
});

insertBefore

insertBefore(target)   ⇒ self

安插Zepto对象集合中的元素到指定的各样元素后边的dom中。这一个有点像 before,可是使用方法相反。

$('<p>See the following table:</p>').insertBefore('table');

表单方法

手动建立Zepto

zepto.jszepto.min.js提供上述使用办法。
然则,为了更好的程序效果和自由性,可以在选择Zepto源码构建Zepto.js和zepto.min.js的时候采纳模块并作测试,
使用UglifyJS基于你的急需来扭转(当服务端开启gzipped后,最精简的代码)代码。

关于什么建立Zepto的the
README
,包含运行测试和补丁。.

bind

Deprecated, use on instead.

bind(type, function(e){ ... })   ⇒ self
bind({ type: handler, type2: handler2, ... })   ⇒ self

为一个要素绑定一个处理事件。

$()

$(selector, [context])   ⇒ collection
$(<Zepto collection>)   ⇒ same collection
$(<DOM nodes>)   ⇒ collection
$(htmlString)   ⇒ collection
$(htmlString, attributes)   ⇒ collection v1.0+
Zepto(function($){ ... }) 

由此实施css选用器包装dom节点,创造元素或者从一个html片段来创立一个Zepto对象。

Zepto集合是一个类似数组的目标,它抱有链式方法来操作它指向的dom,除了$对象上的一向情势外(如$.extend),文档对象中的所有办法都是会聚方法。

即便采纳器中留存content参数(css采用器,dom,或者Zepto集合对象),那么只在所给的节点背景下进展css选取器;这几个职能有点像使用$(context).find(selector)

可以经过一个html字符串有的来成立一个dom节点。也可以由此给定一组属性映射来创制节点。最快的创办但元素,使用<div> 或 <div/>形式。

当一个函数附加在 DOMContentLoaded 事件的拍卖流程中。假如页面已经加载完毕,这么些措施将会应声被实施。

$('div')
//=> all DIV elements on the page
$('#foo')
//=> element with ID "foo"

// create element:
$("<p>Hello</p>")
//=> the new P element
// create element with attributes:
$("<p />", {
    text: "Hello",
    id: "greeting",
    css: {
        color: 'darkblue'
    }
})
//=> <p id=greeting style="color:darkblue">Hello</p>

// execute callback when the page is ready:
Zepto(function($) {
    alert('Ready to Zepto!')
})

不支持jQuery CSS
扩展
,不过能够选的“selector”模块有限提供支撑,如局部常用的伪选取器,可以与存活的代码或插件兼容执行。

效果

$.get

$.get(url, function(data, status, xhr){ ... })   ⇒ XMLHttpRequest
$.get(url, [data], [function(data, status, xhr){ ... }], [dataType])   ⇒ XMLHttpRequest v1.0+

实践一个Ajax
GET请求。这是一个 $.ajax的简写模式。

$.get('/whatevs.html', function(response){
        $(document.body).append(response)
});

Zepto 是一款开源软件,它可以被开发者和商贸发表。 MIT
license
.

next

next()   ⇒ collection
next(selector)   ⇒ collection v1.0+

收获Zepto对象集合中每一个因素的下一个兄弟节点(可以采用性的带上过滤拔取器)。

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

prepend

prepend(content)   ⇒ self

将参数内容插入到各个匹配元素的眼前(元素内部)。插入d的元素得以试html字符串片段,一个dom节点,或者一个节点的数组。

$('ul').prepend('<li>first list item</li>');

下载 Zepto

默认的构建包括以下模块:
Core, Ajax, Event, Form, Effects, Polyfill, and Detect.

再有更多的模块;
所以可用模块链接在此 README.

用一个script标签引入Zepto到你的页面的最底层:

    ...
    </body>
    <script src=zepto.min.js></script>
</html>

一旦你需要兼容ie浏览器,你能够用回jquery。
需要专注ie10自此不再辅助标准化注释(为了增强与HTML5
的可互操作性和兼容性,Internet Explorer 10 标准格局和Quirks
格局中剔除了对规格注释的支撑),由此,大家提议以下的document.write方法:

<script>
    document.write('<script src=' +  ('__proto__' in {} ? 'zepto' :  'jquery') + '.js><\/script>')
</script>

submit

submit()   ⇒ self
submit(function(e){ ... })   ⇒ self

为 “submit” 事件绑定一个处理函数,或者触发元素上的 “submit”
事件。当参数function没有付诸时,触发当前表单“submit”事件,并且实施默认的提交表单行为,除非调用了 preventDefault()

当function参数给出时,在现阶段元素上它概括得为其在“submit”事件绑定一个处理函数。

 


译文地址:http://www.html-5.cn/Manual/Zepto/

width

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

获取Zepto对象集合中率先个元素的宽;或者设置Zepto对象集合所有因素的宽。

$('#foo').width();
// => 123
$(window).width();
// => 768 (viewport width)
$(document).width();
// => 768 

$.type v1.0+

$.type(object)   ⇒ string

获得JavaScript
对象的项目。可能的品种有: null undefined boolean number string function array``date regexp object error

对此其余对象,它只是简短报告为“object”,假使你想理解一个目的是否是一个javascript普通对象,使用isPlainObject

$.fn

Zepto.fn是一个目标,它拥有Zepto对象上享有可用的章程。如 addClass(), attr(),和任何措施。在这多少个目的添加一个主意,所有的Zepto对象上都能用到该办法。

此地有一个落实 empty() 方法的事例:

$.fn.empty = function() {
    return this.each(function() {
        this.innerHTML = '';
    });
}

scrollTop v1.0+

scrollTop()   ⇒ number

得到页面上的滚动元素或者全体窗口已经滚动的像素值。

serialize

serialize()   ⇒ string

在Ajax post请求司令员用作提交的表单元素的值编译成 URL-encoded 字符串。

prependTo

prependTo(target)   ⇒ self

将兼具因素插入到对象前边(元素内)。这有点像prepend,但是是倒转的办法。

$('<li>first list item</li>').prependTo('ul');

对象平台

parents

parents([selector])   ⇒ collection

拿到Zepto对象集合每个元素所有的先世元素。如若css采取器参数给出,过滤出符合条件的要素。

假诺想博得第一手父级元素,使用 parent。如若只想获取到第一个适合css选取器的因素,使用closest

$('h1').parents()
//=> [<div#container>, <body>, <html>]

appendTo

appendTo(target)   ⇒ self

将分外的元素插入到目的元素的末尾(里面的末端)。这个有点像 append,然则插入的靶子与其相反。

$('<li>new list item</li>').appendTo('ul')

append

append(content)   ⇒ self

在各样匹配的元素末尾插入内容。内容可以为html字符串,dom节点,或者节点组成的数组。

$('ul').append('<li>new list item</li>')

$.isArray

$.isArray(object)   ⇒ boolean

如果object是array,则返回ture。

insertAfter

insertAfter(target)   ⇒ self

插入Zepto对象集合中的元素到指定的每个元素后边的dom中。那多少个有点像 after,然而接纳格局相反。

$('<p>Emphasis mine.</p>').insertAfter('blockquote');

prev

prev()   ⇒ collection
prev(selector)   ⇒ collection v1.0+

得到Zepto对象集合中每一个元素的前一个小兄弟节点,通过选拔器来展开过滤。

$.Event

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

成立并起头化一个点名的dom事件。假使properties参数给出,使用它来扩展出新的轩然大波目的。默认情形下,事件被安装为冒泡模式;那个能够透过安装bubblesfalse来关闭。

初阶化的功力能够使用 trigger来触发。

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

map

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

遍历Zepto对象集合中的所有因素。通过遍历函数重回值形成一个新的成团对象。在遍历函数中this紧要之指向当前循环的item(遍历函数中的第二个参数)。遍历中回到 nullundefined,遍历将被打断。

// get text contents of all elements in collection
elements.map(function() {
    return $(this).text();
}).get().join(', ');

delegate

Deprecated, use on instead.

delegate(selector, type, function(e){ ... })   ⇒ self
delegate(selector, { type: handler, type2: handler2, ... })   ⇒ self

基于一组特定的根元素为具有接纳器匹配的元素附加一个处理事件,匹配的因素可能现在或以后才创造。

removeAttr

removeAttr(name)   ⇒ self

活动当前Zepto对象集合中颇具因素的指定属性。

attr

attr(name)   ⇒ string
attr(name, value)   ⇒ self
attr(name, function(index, oldValue){ ... })   ⇒ self
attr({ name: value, name2: value2, ... })   ⇒ self

读取或安装dom的性质。假使没有给定value参数,则读取Zepto对象第集合一个元素的属性值。当给定了value参数。则设置Zepto对象集合中具有因素所有因素的属性值。当value参数为null,那么这么些特性将被移除(类似removeAttr),多个属性能以通过对象值对的方法举办设置。

要读取dom的性质如 checkedselected,
使用 prop

var form = $('form');
form.attr('action');//=> read value
form.attr('action', '/create'); //=> set value
form.attr('action', null); //=> remove attribute

// multiple attributes:
form.attr({
    action: '/create',
    method: 'post'
});

pluck

pluck(property)   ⇒ array

取得Zepto对象集合中每一个要素的属性值。再次回到值为 nullundefined值得过滤掉。

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

// implementation of Zepto's `next` method
$.fn.next = function() {
    return $(this.pluck('nextElementSibling'));
}

这是一个Zepto的模式,不是jquery的api

forEach

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

遍历当前Zepto集合对象的买个要素,有点类似 each,可是遍历函数的参数不一致,当函数再次来到 false 的时候,遍历不会终止。

这是一个Zepto提供的不二法门,不是jquery的API。

die

Deprecated, use off instead.

die(type, function(e){ ... })   ⇒ self
die({ type: handler, type2: handler2, ... })   ⇒ self

剔除通过 live 添加的轩然大波。

empty

empty()   ⇒ self

从Zepto对象集合中移除所有的dom子节点。

eq

eq(index)   ⇒ collection

从近来Zepto对象集合中拿到给定索引号的元素。

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

$.map

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

透过遍历集合中的元素,通过函数重回一个新的数组,null and 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]

wrapInner

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

在匹配元素里的内容外包一层结构。

// 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('<p><em /></p>');

以下为原始html:

<div class="yaotaiyang">
     <div class="taiyang">yao</div>
     <div class="taiyang">yao</div>
</div>

通过:

$('.taiyang).wrapInner('<div class="new" />');

得到:

<div class="yaotaiyang">
      <div class="taiyang"><div class="new">yao</div></div>
      <div class="taiyang"><div class="new">yao</div></div>
</div>  

size

size()   ⇒ number

收获Zepto对象集合中元素的多寡。

$.fx

大局动画设置:

  • $.fx.off (在支撑css transition
    的浏览器中默认为false):设置true来禁止所有animate() transitions。

  • $.fx.speeds:用来安装动画时间的目的。

    • _default (400 ms)
    • fast (200 ms)
    • slow (600 ms)

     

    变动现有值或者添加一个新属性去影响使用一个字符串来设置时间的动画。

    Change existing values or add new properties to affect animations
    that use a string for setting duration.

hasClass

hasClass(name)   ⇒ boolean

反省Zepto对象集合中是否有元素含有指定的class。

<ul>    
    <li>list item 1</li>    
    <li class="yaotaiyang">list item 2</li>    
    <li>list item 3</li>  
</ul>  
<p>a paragraph</p>

<script type="text/javascript">
    $("li").hasClass("yaotaiyang");
    //=> true
</script>

相关文章