Ajax请求

append

append(content)   ⇒ self

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

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

parent

parent([selector])   ⇒ collection

得到Zepto对象集合中每个元素的第一手父元素。即使css选用器参数给出。过滤出符合条件的因素。

Ajax 回调函数

您可以指定以下的回调函数,给出的实施顺序:

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

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

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

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

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

indexOf

indexOf(element, [fromIndex])   ⇒ number

在当下Zepto中获取一个因素的职位。如若fromindex参数给出,从该地点未来查找,再次回到基于0的岗位,即便没找到,则赶回-1。index 方法是基于那些办法已毕的。

那是一个Zepto的章程,不是jquer的api。

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>

 

next

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

赢得Zepto对象集合中每一个要素的下一个小兄弟节点(可以选取性的带上过滤接纳器)。

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

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>  

submit

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

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

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

 


index

index([element])   ⇒ number

赢得一个因素的地点。当elemen参数没有付诸时,重返当前因素在兄弟节点中的地点。当element参数给出时,再次来到它在如今Zepto对象集合中的地点。假设没有该因素,则赶回-1。

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

after

after(content)   ⇒ self

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

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

die

Deprecated, use off instead.

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

除去通过 live 添加的风浪。

着力措施

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

serialize

serialize()   ⇒ string

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

$.camelCase v1.0+

$.camelCase(string)   ⇒ string

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

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

empty

empty()   ⇒ self

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

toggleClass

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

在非凡的要素集合中的每个元素上丰硕或删除一个或八个样式类。倘诺class的称号存在则删除它,即使不存在,就添加它。假如 setting的值为真,这么些职能看似于 addClass,如若为假,这么些效应看似与 removeClass

delegate

Deprecated, use on instead.

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

据悉一组特定的根元素为拥有拔取器匹配的因素附加一个处管事人件,匹配的因素可能现在或将来才创设。

live

Deprecated, use on instead.

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

类似delegate,添加一个个事变处理器到符合当下接纳器的所有因素匹配,匹配的因素可能现在或未来才创制。

addClass

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

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

width

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

收获Zepto对象集合中第四个因素的宽;或者安装Zepto对象集合所有因素的宽。

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

text

text()   ⇒ string
text(content)   ⇒ self

收获或者设置富有Zepto对象的文本内容。当content参数未提交。再次来到当前Zepto对象集合中第二个元素的文件内容(包蕴子节点中的文本内容)。当content参数给出,使用它替换Zepto对象集合中拥有因素的公文内容。它有待点似 html,与它分化的是它不可能用来博取或安装
HTML。

效果

scrollTop v1.0+

scrollTop()   ⇒ number

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

serializeArray

serializeArray()   ⇒ array

将作为提交的表单元素的值编译成富有name和value对象组成的数组。无法使用的表单元素,buttons,未当选的radio
buttons/checkboxs 将会被跳过。结果不含有file inputs的数码。

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

eq

eq(index)   ⇒ collection

从脚下Zepto对象集合中收获给定索引号的因素。

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

$.isArray

$.isArray(object)   ⇒ boolean

如果object是array,则返回ture。

$.isWindow v1.0+

$.isWindow(object)   ⇒ boolean

确定参数是或不是为一个窗口(window对象),若是是则赶回true。

那在处理iframe时万分有用,因为各种iframe都有它们自己的window对象,使用正规方法obj==window校验那几个objects的时候会败北。

removeAttr

removeAttr(name)   ⇒ self

运动当前Zepto对象集合中负有因素的指定属性。

举手投足端浏览器

  • 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希望在富有的当代浏览器中作为一种基础条件来利用。

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>

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

unbind

Deprecated, use off instead.

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

移除通过 bind 注册的轩然大波。

检测方法

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

$.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]"

bind

Deprecated, use on instead.

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

为一个要素绑定一个处负责人件。

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>

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

hide

hide()   ⇒ self

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

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

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>

$.fn

Zepto.fn是一个目标,它兼具Zepto对象上存有可用的格局。如 addClass(), attr(),和别的方法。在那一个目标添加一个艺术,所有的Zepto对象上都能用到该办法。

此地有一个落到实处 empty() 方法的例证:

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

contents v1.0+

contents()   ⇒ collection

获取每个匹配元素集合元素的子元素,包蕴文字和注释节点。.contents()和.children()办法类似,只可是前者包涵文件节点以及jQuery对象中发出的HTML元素。

push

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

添新币素到近年来Zepto对象的末梢。

那是一个zepto的措施,不是jquery的api

insertBefore

insertBefore(target)   ⇒ self

插入Zepto对象集合中的元素到指定的各种元素前面的dom中。那一个有点像 before,不过使用方法相反。

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

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

siblings

siblings([selector])   ⇒ collection

收获Zepto集合对象拥有兄弟节点。要是css选拔器参数给出。过滤出适合采取器的要素。

not

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

过滤当前Zepto对象集合,获取一个新的Zepto对象集合,它其中的要素无法匹配css拔取器。如若另一个参数为Zepto集合对象,那么再次来到的新Zepto对象中的元素都不带有在该参数对象中。如若参数是一个函数。仅仅蕴含函数执行为false值得时候的元素,函数的 this 关键字指向当前循环元素。

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

forEach

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

遍历当前Zepto集合对象的买个因素,有点类似 each,不过遍历函数的参数差别,当函数重回 false 的时候,遍历不会告一段落。

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

wrapAll

wrapAll(structure)   ⇒ self

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

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

appendTo

appendTo(target)   ⇒ self

将匹配的因素插入到对象元素的尾声(里面的末端)。那个有点像 append,可是插入的对象与其相反。

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

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方法。

remove

remove()   ⇒ self

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

height

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

得到Zepto对象集合中首先个因素的可观;或者安装Zepto对象集合中享有因素的冲天。

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

before

before(content)   ⇒ self

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

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

prependTo

prependTo(target)   ⇒ self

将所有因素插入到对象前面(元素内)。那有点像prepend,可是是相反的主意。

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

last

last()   ⇒ collection

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

$('li').last();

replaceWith

replaceWith(content)   ⇒ self

用提供的情节替换所有匹配的要素。(包括元素本身)。content参数可以为 before中讲述的花色。

$()

$(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”模块有限提供支撑,如局地常用的伪拔取器,可以与存活的代码或插件包容执行。

parents

parents([selector])   ⇒ collection

获得Zepto对象集合每个元素所有的先世元素。假使css接纳器参数给出,过滤出符合条件的要素。

设若想博得第一手父级元素,使用 parent。假设只想取得到第四个适合css拔取器的要素,使用closest

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

reduce

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

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

那是一个zepto的方法,不是jquery的api

开创插件

能够透过添加艺术作为$.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


offset

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

收获当前元素相对于document的职位。重回一个对象涵盖: topleftwidthheight

当给定一个对象属性lefttop使用那几个值来相对于document对每一个元素进行定位。

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

触控

下载 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>

undelegate

Deprecated, use off instead.

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

移除通过delegate 注册的风浪。


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方法。

$.ajaxJSONP

Deprecated,
use $.ajax instead.

$.ajaxJSONP(options)   ⇒ mock XMLHttpRequest

履行JSONP跨域获取数据。

此方式相对 $.ajax 没有优势,提出不用使用。

prepend

prepend(content)   ⇒ self

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

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

$.trim v1.0+

$.trim(string)   ⇒ string

删去字符串起头和末段的空白符。类似String.prototype.trim()。

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

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"

data

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

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

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

  • “true”, “false”, and “null” 被转换为对应的花色;
  • 数字值转换为实际的数字类型;
  • JSON值将会被分析,若是它是卓有作用的JSON;
  • 别的的一体作为字符串重返。

    Zepto
    基本完成`data()`只可以存储字符串。要是您要存储任意对象,请引入可选的“data”模块到你创设的Zepto中。

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

ready

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

增进一个事件侦听器,当页面dom加载完成 “DOMContentLoaded”
事件触发时触发。提出利用 $())来取代那种用法。

filter

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

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

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

手动建立Zepto

zepto.jszepto.min.js提供以上使用方法。
可是,为了更好的次第效果和自由性,可以在使用Zepto源码营造Zepto.js和zepto.min.js的时候接纳模块并作测试,
使用UglifyJS据悉你的要求来变化(当服务端开启gzipped后,最精简的代码)代码。

关于怎么着树立Zepto的the
README
,包蕴运行测试和补丁。.

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

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元素上接触事件。

unwrap

unwrap()   ⇒ self

将匹配元素的父级元素删除,保留自己(和兄弟元素,若是存在)在原先的任务。

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

children

children([selector])   ⇒ collection

收获每个匹配元素集合元素的第一手子元素,即使selector存在,只回去符合css拔取器的要素。

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

show

show()   ⇒ self

光复Zepto对象集合中种种元素默许的“display”值。假如您用 hide将元素隐藏,用该属性可以将其出示。相当于干掉了display:none

slice

slice(start, [end])   ⇒ array

array中领到的法子。从start开始,如果end 提议。提取不分包end职位的元素。

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

布署的目标是提供jquery的切近的APIs,但并不是100%蒙面jquery为目标。zepto设计的目的是有一个5-10k的通用库、下载并执行快、有一个了然通用的API,所以你能把您根本的肥力放到应用开发上。

$.parseJSON v1.0+

$.parseJSON(string)   ⇒ object

类似本地JSON.parse 方法,接受一个业内格式的 JSON
字符串,并回到解析后的 JavaScript 对象。

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将会被删去。


size

size()   ⇒ number

得到Zepto对象集合中元素的数据。

first

first()   ⇒ collection

获取当前Zepto对象集合中的首个要素。

$('form').first();

insertAfter

insertAfter(target)   ⇒ self

插入Zepto对象集合中的元素到指定的每个元素前面的dom中。这么些有点像 after,不过利用办法相反。

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

$.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 不被援救。

$.isFunction

$.isFunction(object)   ⇒ boolean

如果object是function,则返回ture。

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

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

$.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]

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

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
。浏览器的协助可能两样,所以自然要测试你所想要支持的浏览器。


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

toggle

toggle([setting])   ⇒ self

来得或隐藏匹配元素。即使 setting为true,相当于show 法。如果setting为false。相当于 hide方法。

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

事件处理

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

is

is(selector)   ⇒ boolean

判定当前Zepto元素集合中的第三个因素是不是符css选取器。对于基础支撑jquery的非标准选取器类似::visible含有在可选的“selector”模块中。

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

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>

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

$.Event

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

始建并先河化一个指定的dom事件。若是properties参数给出,使用它来扩张出新的风云目的。默许意况下,事件被设置为冒泡形式;这么些可以由此设置bubblesfalse来关闭。

开端化的成效可以利用 trigger来触发。

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

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

one

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

增进一个处负责人件到元素。处理函数在各类元素上最多执行一次。

clone v1.0+

clone()   ⇒ collection

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

此措施不会有数量和事件处理程序复制到新的要素。那点和jquery中选拔一个参数来规定是或不是复制数据和事件处理不等同。

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

对象平台

$.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”

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

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

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

$.type v1.0+

$.type(object)   ⇒ string

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

对此任何对象,它只是简短报告为“object”,如若你想掌握一个目标是不是是一个javascript普通对象,使用isPlainObject

concat

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

添台币素到一个Zepto对象集合形成一个新数组。若是参数是一个数组,那么那些数组中的元素将会统一到Zepto对象集合中。

那是一个Zepto提供的法门,不是jquey的API 。

prev

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

取得Zepto对象集合中每一个要素的前一个弟兄节点,通过选用器来拓展过滤。

$.isPlainObject v1.0+

$.isPlainObject(object)   ⇒ boolean

测试目的是或不是是纯粹的靶子(通过 “{}” 或者 “new Object”
创立的),假诺是,则赶回true。

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

each

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

遍历一个Zepto集合对象,为每一个匹配元素执行一个函数。this根本字指向当前item(作为函数的首个参数传递)。假诺函数重返 false,遍历甘休。

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

triggerHandler

triggerHandler(event, [data])   ⇒ self

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

譬如你再一个input上一旦利用该办法。

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

表单方法

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

桌面浏览器

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

val

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

赢得或安装匹配元素的值。当value参数不设有。再次来到第二个因素的值。固然是<select multiple>标签,则赶回一个数组。

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

$.grep v1.0+

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

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

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

offsetParent v1.0+

offsetParent()   ⇒ collection

找到第三个定点过的上代元素,在ccs中意味着它的position 值为“relative”,
“absolute” or “fixed”

$.contains v1.0+

$.contains(parent, node)   ⇒ boolean

反省父节点是或不是带有给定的dom节点,假诺双方如出一辙,则赶回 false

相关文章

网站地图xml地图