NodeJs基本语法和类型
投稿：hebedich
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了NodeJs基本语法和类型的相关资料,需要的朋友可以参考下
今天想要查下Node的类型什么的知识，想要总结下，在Googol上看到一个文章，但是原始的链接不在了，在快照中把这篇文章拉出来，如果原作者有问题，请联系我！
该文章都是一些JS的基础，高手自动跳过！我之前没怎么写过js，这方面比较弱，所以在写node的时候也遇到了麻烦，这里给自己补充下知识！
Node.js 的基础是 JavaScript 这门 脚本语言。而大多数的脚本语言一个共同的特点就是“弱类型”。
不同于 PHP 的是，PHP 就是是有了新变量也无需申明，而 JavaScript 则还是需要 var 来申明一下的。而这个 var 涵盖了 C++ 中的int、string、char等一切类型的含义，甚至是 function。
本篇以及后篇的所有内容都是在 Linux 或者 Cygwin 下用 vim 进行编辑（若不是则请自行转变成你自己的方法），然后在命令行下进行查看结果的。
在 C/C++ 中，我们这么声明变量的：
void foo() {}
int a = 0;
char b = 'a';
float c = 1.0f;
void (*d)() = ///& 忘了是不是这么写的了，总之是函数指针
而在 Node.js 中则是这样的：
```javascript
function foo() {}
var a = 0;
var b = 'a';
var c = 1.0;
所以，无论是什么类型的变量，在 Node.js 中都是以一个 var 来解决的。
这个循环语句基本上跟 C/C++ 一样，都是
for(int i = 0; i & i++)
而鉴于 Node.js 是弱类型，所以只需要：
```javascript
for(var i = 0; i & i++) {
这是一种后有型的循环语句，类似于 PHP 的 foreach。
比如我们有一个 JSON对象 如下：
javascript
var foo = {
&&& "hello"&&&& : "world",
&&& "node"&&&&& : "js",
&&& "blahblah"& : "bar"
这个时候我们就可以用 for...in 来循环遍历了：
javascript
for(var key in foo) {
&&& console.log(key + ": " + foo[key]);
我们如果在命令行中打入下面的命令：
$ node foo.js
屏幕上就会显示下面的内容了：
blahblah: bar
提示：由上可知，for...in 语句是用来遍历 JSON对象、数组、对象的键名的，而不提供键值的遍历。如果要获取键值，只能通过foo[&当前键名&]的形式来获取。这个跟 PHP 的 foreach 还是有一定区别的。
while…do, do…whill
这个就不多做解释了，跟其它语言没什么大的区别，无非就是如果有变量声明的话，需要用 var 就够了。
+, -, *, /
这几个运算符也就这样，要注意的是 +。它既可以作用于字符串，也可以作用于数值运算。弱类型语言虽然说类型是弱的，数字有时候可以以字符串的形态出现，字符串有时候可以用数值的形态出现，但是在必要的时候也还是要说一下它是什么类型的，我们可以用下面的代码去看看结果：
var a = "1";
var b = 2;
console.log(a + b);
console.log(parseInt(a) + b);
这里的 parseInt 是 Node.js 的一个内置函数，作用是将一个字符串解析成 int 类型的变量。
上面的代码执行结果是:
注：第一个 console.log 结果是 12，由于 a 是字符串，所以 b 也被系统以字符串的姿态进行加操作，结果就是将两个字符串黏连在一起就变成了 12。而第二个 console.log 结果是 3，是因为我们将第一个 a 转变为了 int 类型，两个 int 型的变量相加即数值相加，结果当然就是 3 了。
==, ===, !=, !==
这里有一点要解释，当这个逻辑运算符长度为 2 的时候（==, !=），只是判断外在的值是不是一样的，而不会判断类型。如
var a = 1, b = "1";
console.log(a == b);
它输出的结果就是 true 。但是如果我们在中间判断的时候再加上一个等号，那么就是严格判断了，需要类型和值都一样的时候才会是 true，否则就是 false。也就是说
var a = 1, b = "1";
console.log(a === b);
的时候，返回的结果就是 false 了，因为 a 是 int 型的，而 b 则是字符串。
顺带着就把条件语句讲了吧，其实这里的 if 跟别的语言没什么两样，就是几个逻辑运算符两个等号三个等号的问题。所以就不多做累述了。
这里我姑且把它当成是一个运算符而不是函数了。
这个运算符的作用是判断一个变量的类型，会返回一个字符串，即类型名，具体的执行下面的代码就知道了：
function foo() {}
var a = 0;
var b = '嘘~蛋花汤在睡觉。';
var c = 1.0;
var e = { "a" : a };
var f = [ 1, 2, 3 ];
console.log(typeof a);
console.log(typeof b);
console.log(typeof c);
console.log(typeof d);
console.log(typeof e);
console.log(typeof f);
console.log(typeof g);
console.log(typeof h);
这里的执行结果就将会是：
null, undefined, NaN
在 JavaScript 中，有三个特殊的值，如标题所示。其中第一个大家可能都比较熟悉吧，C/C++ 里面也有，不过是大写的，其本质就是一个
define NULL 0
而在 JavaScript 中，这三个值所代表的意义都不同。
### null ###
null 是一种特殊的 object，大致的意思就是空。比如说：
大家都能看懂，就不多做解释了。但是跟 C/C++ 不同的是，这个 null 跟 0 不相等。
### undefined ###
这个东西的意思就是说这个变量未声明。为了能够更好地区分 null，我们的样例代码如下写：
```javascript
&&& "foo" : null
console.log(a["foo"]);
console.log(a["bar"]);
上面的代码中，我们让 a["foo"] 的值为空，即 null。而压根没有声明 a["bar"] 这个东西，它连空都不是。输出的结果大家都差不多应该猜到了：
这是一个空的数值，是一个特殊的 number。它的全称是 Not a Number。有点奇怪，大家可以理解为 不是数字形态，或者数值出错的 number 类型变量。
多在浮点型数值运算错误（如被0除）的情况下出现，甚至可以是用户自己让一个变量等于 NaN 以便返回一个错误值让大家知道这个函数运算出错了云云。
其它剩余的语句也跟已存在的其它语言差不多，比如说 break 啊、switch 啊、continue 啊等等等等。
这一节主要讲的是 JavaScript 对象，其它类型差不多一带而过吧。
Node.js 包含的基础类型差不多有如下几个：
其中前三种类型可以直接赋值， 而 array 的赋值只是一个引用赋值而已，在新变量中改变某个值的话旧变量的值也会改变 ，直接可以试试下面的代码：
javascript
var foo = [ 1, 2, 3 ];
bar[0] = 3;
console.log(foo);
它得出的结果是：
javascript
[ 3, 2, 3 ]
也就是说 array 要是复制出一个新的数组的话，不能用直接赋值的方法，而必须“深拷贝”。
这里有必要讲一下 array 的三种创建方法。
javascript
var dog = new Array();
dog[0] = "嘘~";
dog[1] = "蛋花汤";
dog[2] = "在睡觉";
javascript
var dog = new Array( "嘘~", "蛋花汤", "在睡觉" );
javascript
var dog = [
&&& "嘘~",
&&& "蛋花汤",
&&& "在睡觉"
我个人比较喜欢第三种写法，比较简洁。
这里我把 JSON对象 单独拎出来而不是把它归类为 JavaScript对象，如果觉得我有点误人子弟就可以直接跳过这一节了。
本人对于 JSON对象 和 JavaScript 对象的区分放在 是否只用来存储数据，而并非是一个类的实例化。其实 JSON 的本质便是 JavaScript Object Notation。
更多有关 JSON 的信息请自行百科。
在 Node.js 中声明一个 JSON对象 非常简单：
javascript
var dog = {
& "pre" : "嘘~",
& "sub" : {
&&& "name" : "蛋花汤",
&&& "act"& : "在睡觉",
&&& "time" : 12
& "suf" : [ "我说了", "它在睡觉", "就是在睡觉" ]
有两种方式能得到 JSON对象 中的某个键名的键值，第一种是用点连接，第二种是用中括号：
javascript
dog["pre"];
注意：上面在用点的时候，后面直接跟的是JSON中的key，如果把key当成是变量去当问，只能用dog[key]试试看：现在你自己动手试试看，用 for...in 的形式遍历一遍上面的 JSON对象。别忘了用上 typeof 喵~
类（对象）的基础
严格意义上来讲，Node.js 的类不能算是类，其实它只是一个函数的集合体，加一些成员变量。它的本质其实是一个函数。
不过为了通俗地讲，我们接下去以及以后都将其称为“类”，实例化的叫“对象”。
因为类有着很多 函数 的特性，或者说它的本质就是一个 函数，所以这里面我们可能一不留神就顺带着把函数基础给讲了。
类的声明和实例化
声明一个类非常简单，大家不要笑：
javascript
function foo() {
好了，我们已经写好了一个 foo 类了。
真的假的？！真的。
不信？不信你可以接下去打一段代码看看：
javascript
var bar = new foo();
别看它是一个函数，如果以这样的形式（new）写出来，它就是这个类的实例化。
而这个所谓的 foo() 其实就是这个 foo() 类的构造函数。
成员变量有好两种方法。
第一种就是在类的构造函数或者任何构造函数中使用 this.&变量名& 。你可以在任何时候声明一个成员变量，在外部不影响使用，反正就算在还未声明的时候使用它，也会有一个 undefined 来撑着。所以说这就是第一种方法：
javascript
function foo() {
&&& this.hello = "world";
注意：只有在加了 this 的时候才是调用类的成员变量，否则只是函数内的一个局部变量而已。要分清楚有没有 this 的时候变量的作用范围。
第二种方法就是在构造函数或者任何成员函数外部声明，其格式是 &类名&.prototype.&变量名&：
javascript
function foo() {
foo.prototype.hello = "world";
无论上面哪种方法都是对成员变量的声明，我们可以看看效果：
javascript
var bar = new foo();
console.log(bar.hello);
甚至你可以这么修改这个类：
javascript
function foo() {
&&& this.hello = "world";
foo.prototype.hello = "蛋花汤";
然后再用上面的代码输出。
想想看为什么输出的还是 world 而不是 蛋花汤。
我们之前说过了这个 foo() 实际上是一个 构造函数。那么显然我们可以给构造函数传参数，所以就有了下面的代码：
javascript
// 代码2.1
function foo(hello) {
&&& if(hello === undefined) {
&&&&&&& this.hello = "world";
&&& } else {
&&&&&&& this.hello =
我们看到上面有一个奇葩的判断 if(hello === undefined)，这个判断有什么用呢？第一种可能，就是开发者很蛋疼地特意传进去一个 undefined 进去，这个时候它是 undefined 无可厚非。
还有一种情况。我们一开始就说了 JavaScript 是一门弱类型语言，其实不仅仅是弱类型，它的传参数也非常不严谨。你可以多传或者少传（只要保证你多传或者少传的时候可以保证程序不出错，或者逻辑不出错），原则上都是可以的。多传的参数会被自动忽略，而少传的参数会以 undefined 补足。
看看下面的代码就明白了：
javascript
// 上接代码2.1
var bar1 = new foo();
var bar2 = new foo("蛋花汤");
请自行输出一下两个 bar 的 hello 变量，会发现一个是 world 一个是 蛋花汤。显而易见，我们的第一个 bar1 在声明的时候，被 Node.js 自动看成了：
javascript
var bar1 = new foo(undefined);
所以就有了它是 world 一说。
还有就是在这个构造函数中，我们看到了传进去的参数是 hello 而这个类中本来就有个成员变量就是 this.hello。不过我们之前说过了有 this 和没 this 的时候作用域不同，那个参数只是作用于构造函数中，而加了 this 的那个则是成员变量。用一个 this 就马上区分开来他们了，所以即使同名也没关系。
成员函数声明
成员函数的声明跟成员变量的第二种声明方法差不多，即 &类名&.prototype.&函数名& = &函数&;
javascript
// 上接代码2.1
function setHello(hello) {
& this.hello =
foo.prototype.setHello = setH
bar1.setHello("鸡蛋饼");
上面这段代码显而易见，我们实现了 foo 类的 setHello 函数，能通过它修改 foo.hello 的值。
但是这么写是不是有点麻烦？接下去我要讲一个 JavaScript 函数重要的特性了。
★ 匿名函数 ★
很多时候我们的某些函数只在一个地方被引用或者调用，那么我们为这个函数起一个名字就太不值了，没必要，所以我们可以临时写好这个函数，直接让引用它的人引用它，调用它的人调用它。所以函数可以省略函数名，如：
javascript
function(hello) {
&&& this.hello =
至于怎么引用或者调用呢？如果是上面的那个类需要引用的话，就是写成这样的：
javascript
foo.prototype.setHello = function(hello) {
&&& this.hello =
这样的写法跟 成员函数 声明 是一个效果的，而且省了很多的代码量。而且实际上，基本上的类成员函数的声明都是采用这种匿名函数的方式来声明的。
至于说怎么样让匿名函数被调用呢？这通常用于传入一个只被某个函数调用的函数时这样写。
比如我们有一个函数的原型是：
javascript
&* 我们将传入a，b两个变量，
&* 在算出a+b的值后，交由func(num)
&* 去进行输出
function sumab(a, b, func) {
&&& var c = a +
&&& func(a, b, c);
比如我们有两个版本的输出函数，一个是中文输出，一个是英文输出，那么如果不用匿名函数时候是这么写的：
javascript
function zh(a, b, sum) {
& console.log(a + " + " + b + " 的值是：" + sum);
function en(a, b, sum) {
& console.log(a + " plus " + b + " is " + sum);
sumab(1, 2, zh);
sumab(3, 4, en);
执行一遍这段代码，输出的结果将会是：
1 + 2 的值是：3
3 plus 4 is 7
这样的代码如果采用匿名函数的形式则将会是：
javascript
sumab(1, 2, function(a, b, sum) {
&&& console.log(a + " + " + b + " 的值是：" + sum);
sumab(3, 4, function(a, b, sum) {
&&& console.log(a + " plus " + b + " is " + sum);
这种形式通常使用于回调函数。回调机制算是 Node.js 或者说 JavaScript 的精髓。在以后的篇章会做介绍。
成员函数声明的匿名函数声明方式
虽然上一节讲过了，不过还是再讲一遍吧。
通常我们声明类的成员函数时候都是用匿名函数来声明的，因为反正那个函数也就是这个类的一个成员函数而已，不会在其它地方被单独引用或者调用，所以就有了下面的代码：
javascript
// 上接代码2.1
foo.prototype.setHello = function(hello) {
&&& this.hello =
这样我们就使得 foo 类有了 setHello 这个函数了。
2.3.4. 类的随意性
这个又是我胡扯的。所谓类的随意性即 JavaScript 中你可以在任何地方修改你的类，这跟 Ruby 有着一定的相似之处。
比如说 string ，它其实也是一个类，有着诸如 length 这样的成员变量，也有 indexOf、substr 等成员函数。但是万一我们觉得这个 string 有些地方不完善，想加自己的方法，那么可以在你想要的地方给它增加一个函数，比如：
javascript
String.prototype.sb = function() {
& var newstr = "";
& for(var i = 0; i & this. i++) {
&&& if(i % 2 === 0) newstr += "s";
&&& else newstr += "b";
这个函数的意思就是填充一个字符串，使其变成 sb 的化身。
我们来测试一下：
var str = "嘘~蛋花汤在睡觉。";
console.log(str.sb());
你将会得到这样的结果：
你跟你的电脑说“嘘~蛋花汤在睡觉。”，你的电脑会骂你四次半傻逼。（赶快砸了它）
3.1. 深拷贝
所谓深拷贝就是自己新建一个数组或者对象，把源数组或者对象中的基础类型变量值一个个手动拷过去，而不是只把源数组或者对象的引用拿过来。所以这就涉及到了一个递归的调用什么的。
下面是我实现的一个深拷贝函数，大家可以写一个自己的然后加入到自己的 Node.js 知识库中。
javascript
function cloneObject(src) {
& var dest = {};
& for(var key in src) {
&&& if(typeof src === "object") dest[key] = cloneObject(src[key]);
&&& else dest[key] = src[key];
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具博客分类：
首先建立一个用来格式化日期的js文件dateFormat.js，内容如下：
* Created by huopanpan on .
functionMyDate(){
Date.prototype.format =function(format)
"M+":this.getMonth()+1,//month
"d+":this.getDate(),//day
"h+":this.getHours(),//hour
"m+":this.getMinutes(),//minute
"s+":this.getSeconds(),//second
"q+":Math.floor((this.getMonth()+3)/3),//quarter
"S":this.getMilliseconds()//millisecond
if(/(y+)/.test(format)) format=format.replace(RegExp.$1,
(this.getFullYear()+"").substr(4-RegExp.$1.length));
for(var k in o)if(newRegExp("("+ k +")").test(format))
format = format.replace(RegExp.$1,
RegExp.$1.length==1? o[k]:
("00"+ o[k]).substr((""+ o[k]).length));
return format;
module.exports =MyDate;/导出该方法
在上面代码中有一个MyDate函数，在函数中给Date的原型prototype中添加format函数，然后导出MyDate函数，或者可以将MyDate作为一个对象，只要能将其导出就行。
然后在代码中引入
var myDate = require('../models/utils/dateFormat');
此时myDate是一个函数，函数当然要执行了以后起内部的代码才起作用。所以我们可以再倒入以后让其自执行，就是在
var myDate = require('../models/utils/dateFormat')();
后面直接加括号，当然可以用myDate()这种方式来执行。执行以后Date对象中就有了format函数。我们在程序中如果需要对日期进行格式的时候就可以用这种方式来实现：
new Date().format("yyyy-MM-dd"),返回结果就是
浏览: 27618 次
来自: 西安
resave改为ture就行啊
解决该警告提示的方法竟然没写。。。。。
dbOptions={ ...
yaCHAO822 写道getConnect 怎么用啊？可以在 ...
getConnect 怎么用啊？
能否共享一下，你Struts2的针对微信开放平台第一步开发者身 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'JS中的phototype是JS中比较难理解的一个部分
本文基于下面几个知识点:
1 原型法设计模式
在.Net中可以使用clone()来实现原型法
原型法的主要思想是，现在有1个类A,我想要创建一个类B,这个类是以A为原型的,并且能进行扩展。我们称B的原型为A。
2 javascript的方法可以分为三类：
b 对象方法
c 原型方法
function People(name)
this.name=
//对象方法
this.Introduce=function(){
alert("My name is "+this.name);
People.Run=function(){
alert("I can run");
//原型方法
People.prototype.IntroduceChinese=function(){
alert("我的名字是"+this.name);
var p1=new People("Windking");
p1.Introduce();
People.Run();
p1.IntroduceChinese();
3 obj1.func.call(obj)方法
意思是将obj看成obj1,调用func方法
好了，下面一个一个问题解决：
prototype是什么含义？
javascript中的每个对象都有prototype属性，Javascript中对象的prototype属性的解释是：返回对象类型原型的引用。
A.prototype = new B();
理解prototype不应把它和继承混淆。A的prototype为B的一个实例，可以理解A将B中的方法和属性全部克隆了一遍。A能使用B的方法和属性。这里强调的是克隆而不是继承。可以出现这种情况：A的prototype是B的实例，同时B的prototype也是A的实例。
先看一个实验的例子：
function baseClass()
this.showMsg = function()
alert("baseClass::showMsg");
function extendClass()
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg(); // 显示baseClass::showMsg
我们首先定义了baseClass类，然后我们要定义extentClass，但是我们打算以baseClass的一个实例为原型，来克隆的extendClass也同时包含showMsg这个对象方法。
extendClass.prototype = new baseClass()就可以阅读为：extendClass是以baseClass的一个实例为原型克隆创建的。
那么就会有一个问题，如果extendClass中本身包含有一个与baseClass的方法同名的方法会怎么样？
下面是扩展实验2：
function baseClass()
this.showMsg = function()
alert("baseClass::showMsg");
function extendClass()
this.showMsg =function ()
alert("extendClass::showMsg");
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg();//显示extendClass::showMsg
实验证明：函数运行时会先去本体的函数中去找，如果找到则运行，找不到则去prototype中寻找函数。或者可以理解为prototype不会克隆同名函数。
那么又会有一个新的问题：
如果我想使用extendClass的一个实例instance调用baseClass的对象方法showMsg怎么办？
答案是可以使用call:
extendClass.prototype = new baseClass();
var instance = new extendClass();
var baseinstance = new baseClass();
baseinstance.showMsg.call(instance);//显示baseClass::showMsg
这里的baseinstance.showMsg.call(instance);阅读为&将instance当做baseinstance来调用，调用它的对象方法showMsg&
好了，这里可能有人会问，为什么不用baseClass.showMsg.call(instance);
这就是对象方法和类方法的区别，我们想调用的是baseClass的对象方法
------------------------------------------------------------------------------------------------------------------------------------------------------------------
对象方法和类方法的区别：
1、对象方法理解就很简单了，主要是如果类生成一个实例，那么该实例就能使用该方法2、类方法，不需要通过生成实例就可以使用的方法3、原型方法主要是用来对JS已有的系统对象进行扩展而生的，例如Array数组没有什么方法，你可以为其增加原型方法，那么创建的数组就拥有了该方法。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
1、对象方法包括构造函数中的方法以及构造函数原型上面的方法；2、类方法，其实这里的类就是一个函数，在js中由于函数也是一个对象，所以可以为函数添加属性以及方法，这种方法在node中用的比较多；3、原型方法一般用于对象实例共享，比如Person.prototype.sayName=function(){console.log(this.name);};在原型上面添加该方法，就能实现共享。这样就不用每一次初始化一个实例的时候，为其分配相应的内存了。
&------------------------------------------------------------------------------------------------------------------------------------------------------------------
最后，下面这个代码如果理解清晰，那么这篇文章说的就已经理解了：
&script type="text/javascript"&
function baseClass()
this.showMsg = function()
alert("baseClass::showMsg");
this.baseShowMsg = function()
alert("baseClass::baseShowMsg");
baseClass.showMsg = function()
alert("baseClass::showMsg static");
function extendClass()
this.showMsg =function ()
alert("extendClass::showMsg");
extendClass.showMsg = function()
alert("extendClass::showMsg static")
extendClass.prototype = new baseClass();
var instance = new extendClass();
instance.showMsg(); //显示extendClass::showMsg
instance.baseShowMsg(); //显示baseClass::baseShowMsg
instance.showMsg(); //显示extendClass::showMsg
baseClass.showMsg.call(instance);//显示baseClass::showMsg static
var baseinstance = new baseClass();
baseinstance.showMsg.call(instance);//显示baseClass::showMsg
阅读(...) 评论()出处:/thinhunan/archive//developernotesforprototype.html开发者手册
对应版本1.4.0
original article by sp('Sergio Pereira')
last update: March 30th 2006
最后更新：
看到一个很好的东西在国内没有被很多人使用起来，实在是不爽，所以花了很大功夫把这个手册翻译成中文，由于这篇文章很长，所以，翻译的工作量很大而且有些地方英文版也没有说清楚，虽得查看源代码，好在不是坚持做完了，大家鼓励下啊！^o^prototype.js是一个非常优雅的javascript基础类库，对javascript做了大量的扩展，而且很好的支持Ajax，国外有多个基于此类库实现的效果库，也做得很棒。prototype.js不仅是一个有很大实用价值的js库，而且有很高的学习价值，所以我强烈建议B/S开发人员和对JS开发感兴趣的朋友去浏览一些它的源代码，其中有很多的珠玑，你绝对会觉得读它的源代码是一种享受，当然要读得懂，呵呵。网上也有人写过1.3版的源码解读，大家可以找来看看。不过1.4版做了很大的扩充，所以希望有朋友写出1.4版的源码解读。几点说明：
prototype.js是什么?
万一你没有使用过大名鼎鼎的prototype.js，那么让我来告诉你，是由写的一个javascript类库。这个构思奇妙，而且兼容标准的类库，能帮助你轻松建立有高度互动的web2.0特性的富客户端页面。
如果你最近尝试使用它，你大概了解到文档并不是作者的一个强项。和在我以前使用这个类库的不少开发者一样，一开始，我不得不一头扎进阅读prototype.js的源代码和实验它的功能中。我想，在我学习完它之后，把我学到的东西分享给大家是件不错的事。
同时，在本文中，我也将提供一个关于这个类库提供的objects,classes,functions,extensions这对东东的
在阅读这个文档时，熟悉Ruby的开发者将会注意到Ruby的一些内建类和本类库扩展实现之间非常相似。
Advanced .
一些实用的函数
这个类库带有很多预定义的对象和实用函数，这些东东的目的显然是把你从一些重复的打字中解放出来 。
使用$()方法
$() 方法是在DOM中使用过于频繁的 document.getElementById() 方法的一个便利的简写，就像这个DOM方法一样，这个方法返回参数传入的id的那个元素。
比起DOM中的方法，这个更胜一筹。你可以传入多个id作为参数然后 $() 返回一个带有所有要求的元素的一个 Array 对象。
&TITLE& Test Page &/TITLE&
&script src=&prototype-1.3.1.js&&&/script&
function test1()
var d = $('myDiv');
alert(d.innerHTML);
function test2()
var divs = $('myDiv','myOtherDiv');
for(i=0; i&divs. i++)
alert(divs[i].innerHTML);
&div id=&myDiv&&
&p&This is a paragraph&/p&
&div id=&myOtherDiv&&
&p&This is another paragraph&/p&
&input type=&button& value=Test1 onclick=&test1();&&&br&
&input type=&button& value=Test2 onclick=&test2();&&&br&
另外一个好处是，这个函数能传入用string表示的对象ID，也可以传入对象本身，这样，在建立其它能传两种类型的参数的函数时非常有用。
使用$F()函数
$F()函数是另一个大收欢迎的&快捷键&，它能用于返回任何表单输入控件的值，比如text box,drop-down list。这个方法也能用元素id或元素本身做为参数。
function test3()
$F('userName')
&input type=&text& id=&userName& value=&Joe Doe&&&br&
&input type=&button& value=Test3 onclick=&test3();&&&br&
使用$A()函数
$A()函数能把它接收到的单个的参数转换成一个Array对象。
这个方法，结合被本类库扩展了的Array类，能方便的把任何的可枚举列表转换成或拷贝到一个Array对象。一个推荐的用法就是把DOM Node Lists转换成一个普通的Array对象，从而更有效率的进行遍历，请看下面的例子。
function showOptions(){
var someNodeList = $('lstEmployees').getElementsByTagName('option');
var nodes = $A(someNodeList);
nodes.each(function(node){
alert(node.nodeName + ': ' + node.innerHTML);
&select id=&lstEmployees& size=&10& &
&option value=&5&&Buchanan, Steven&/option&
&option value=&8&&Callahan, Laura&/option&
&option value=&1&&Davolio, Nancy&/option&
&input type=&button& value=&Show the options& onclick=&showOptions();& &
使用&$H() 函数
$H()函数把一些对象转换成一个可枚举的和联合数组类似的Hash对象。
function testHash()
//let's create the object
first: 10,
second: 20,
//now transform it into a hash
var h = $H(a);
alert(h.toQueryString()); //displays: first=10&second=20&third=30
使用$R()函数
$R()是new ObjectRange(lowBound,upperBound,excludeBounds)的缩写。
跳到 类文档可以看到一个关于此类的完整描述. 此时，我们还是先来看一个例子以展示这个缩写能代替哪些方法吧。其它相关的一些知识可以在 对象文档中找到。
function demoDollar_R(){
var range = $R(10, 20, false);
range.each(function(value, index){
alert(value);
&input type=&button& value=&Sample Count& onclick=&demoDollar_R();& &
使用Try.these()函数
Try.these() 方法使得实现当你想调用不同的方法直到其中的一个成功正常的这种需求变得非常容易， 他把一系列的方法作为参数并且按顺序的一个一个的执行这些方法直到其中的一个成功执行，返回成功执行的那个方法的返回值。
在下面的例子中， xmlNode.text在一些浏览器中好用，但是xmlNode.textContent在另一些浏览器中正常工作。 使用Try.these()方法我们可以得到正常工作的那个方法的返回值。
&script&function getXmlNodeValue(xmlNode){&&& return Try.these(&&&&&&& function() {return xmlNode.},&&&&&&& function() {return xmlNode.textC)&&&&&&& );}&/script&&&
上面提到的共通方法非常好，但是面对它吧，它们不是最高级的那类东西。它们是吗？你很可能自己编写了这些甚至在你的脚本里面有类似功能的方法。但是这些方法只是冰山一角。
我很肯定你对prototype.js感兴趣的原因很可能是由于它的AJAX能力。所以让我们解释当你需要完成AJAX逻辑的时候，这个包如何让它更容易。
Ajax 对象是一个预定义对象，由这个包创建，为了封装和简化编写 功能涉及的狡猾的代码。 这个对象包含一系列的封装AJAX逻辑的类。我们来看看其中几个类。
使用Ajax.Request类
如果你不使用任何的帮助程序包，你很可能编写了整个大量的代码来创建XMLHttpRequest对象并且异步的跟踪它的进程， 然后解析出响应 然后处理它。当你不需要支持多于一种类型的浏览器时你会感到非常的幸运。
为了支持 AJAX 功能。这个包定义了 Ajax.Request 类。
假如你有一个应用程序可以通过url http://yoursever/app/get_sales?empID=1234&year=1998与服务器通信。它返回下面这样的XML 响应。
&?xml version=&1.0& encoding=&utf-8& ?&
&ajax-response&
&response type=&object& id=&productDetails&&
&monthly-sales&
&employee-sales&
&employee-id&1234&/employee-id&
&year-month&1998-01&/year-month&
&sales&$8,115.36&/sales&
&/employee-sales&
&employee-sales&
&employee-id&1234&/employee-id&
&year-month&1998-02&/year-month&
&sales&$11,147.51&/sales&
&/employee-sales&
&/monthly-sales&
&/response&
&/ajax-response&
用 Ajax.Request对象和服务器通信并且得到这段XML是非常简单的。下面的例子演示了它是如何完成的。
function searchSales()
var empID = $F('lstEmployees');
var y = $F('lstYears');
var url = 'http://yoursever/app/get_sales';
var pars = 'empID=' + empID + '&year=' +
var myAjax = new Ajax.Request(
method: 'get',
parameters: pars,
onComplete: showResponse
function showResponse(originalRequest)
//put returned XML in the textarea
$('result').value = originalRequest.responseT
&select id=&lstEmployees& size=&10& onchange=&searchSales()&&
&option value=&5&&Buchanan, Steven&/option&
&option value=&8&&Callahan, Laura&/option&
&option value=&1&&Davolio, Nancy&/option&
&select id=&lstYears& size=&3& onchange=&searchSales()&&
&option selected=&selected& value=&&/option&
&option value=&&/option&
&option value=&&/option&
&br&&textarea id=result cols=60 rows=10 &&/textarea&
你注意到传入 Ajax.Request构造方法的第二个对象了吗？ 参数{method: 'get', parameters: pars, onComplete: showResponse} 表示一个匿名对象的真实写法。他表示你传入的这个对象有一个名为 method 值为 'get'的属性，另一个属性名为 parameters 包含HTTP请求的查询字符串，和一个onComplete 属性/方法包含函数showResponse。
还有一些其它的属性可以在这个对象里面定义和设置，如 asynchronous，可以为true 或 false 来决定AJAX对服务器的调用是否是异步的（默认值是 true）。
这个参数定义AJAX调用的选项。在我们的例子中，在第一个参数通过HTTP GET命令请求那个url，传入了变量 pars包含的查询字符串， Ajax.Request 对象在它完成接收响应的时候将调用showResponse 方法。
也许你知道， XMLHttpRequest在HTTP请求期间将报告进度情况。这个进度被描述为四个不同阶段：Loading, Loaded, Interactive, 或 Complete。你可以使 Ajax.Request 对象在任何阶段调用自定义方法 ，Complete 是最常用的一个。想调用自定义的方法只需要简单的在请求的选项参数中的名为 onXXXXX 属性/方法中提供自定义的方法对象。 就像我们例子中的 onComplete 。你传入的方法将会被用一个参数调用，这个参数是 XMLHttpRequest 对象自己。你将会用这个对象去得到返回的数据并且或许检查包含有在这次调用中的HTTP结果代码的 status 属性。
还有另外两个有用的选项用来处理结果。我们可以在onSuccess 选项处传入一个方法，当AJAX无误的执行完后调用， 相反的，也可以在onFailure选项处传入一个方法，当服务器端出现错误时调用。正如onXXXXX 选项传入的方法一样，这两个在被调用的时候也传入一个带有AJAX请求的XMLHttpRequest对象。
我们的例子没有用任何有趣的方式处理这个 XML响应， 我们只是把这段XML放进了一个文本域里面。对这个响应的一个典型的应用很可能就是找到其中的想要的信息，然后更新页面中的某些元素， 或者甚至可能做某些XSLT转换而在页面中产生一些HTML。
&在1.4.0版本中，一种新的事件回传外理被引入。如果你有一段代码总是要为一个特殊的事件执行，而不管是哪个AJAX调用引发它，那么你可以使用新的对象。
假设你想要在一个AJAX调用正在运行时，显示一些提示效果，像一个不断转动的图标之类的，你可以使用两个全局事件Handler来做到，其中一个在第一个调用开始时显示图标，另一个在最后一个调用完成时隐藏图标。看下面的例子。
var myGlobalHandlers = {
onCreate: function(){
Element.show('systemWorking');
onComplete: function() {
if(Ajax.activeRequestCount == 0){
Element.hide('systemWorking');
Ajax.Responders.register(myGlobalHandlers);
&div id='systemWorking'&&img src='spinner.gif'&Loading...&/div&
更完全的解释，请参照
使用Ajax.Updater类
如果你的服务器的另一端返回的信息已经是HTML了，那么使用这个程序包中 Ajax.Updater 类将使你的生活变得更加得容易。用它你只需提供哪一个元素需要被AJAX请求返回的HTML填充就可以了，例子比我写说明的更清楚。&
function getHTML()
var url = 'http://yourserver/app/getSomeHTML';
var pars = 'someParameter=ABC';
var myAjax = new Ajax.Updater(
'placeholder',
method: 'get',
parameters: pars
&input type=button value=GetHtml onclick=&getHTML()&&
&div id=&placeholder&&&/div&
你可以看到，这段代码比前面的例子更加简洁，不包括 onComplete 方法，但是在构造方法中传入了一个元素id。 我们来稍稍修改一下代码来描述如何在客户端处理服务器段错误成为可能。
我们将加入更多的选项， 指定处理错误的一个方法。这个是用 onFailure 选项来完成的。我们也指定了一个 placeholder 只有在成功请求之后才会被填充。为了完成这个目的我们修改了第一个参数从一个简单的元素id到一个带有两个属性的对象， success (一切OK的时候被用到) 和 failure (有地方出问题的时候被用到) 在下面的例子中没有用到failure属性，而仅仅在 onFailure 处使用了 reportError 方法。
&script&function getHTML(){var url = 'http://yourserver/app/getSomeHTML';var pars = 'someParameter=ABC';
var myAjax = new Ajax.Updater(
{success: 'placeholder'},
method: 'get',
parameters: pars,
onFailure: reportError
function reportError(request)
alert('Sorry. There was an error.');
&input type=button value=GetHtml onclick=&getHTML()&&
&div id=&placeholder&&&/div&
如果你的服务器逻辑是连同HTML 标记返回JavaScript 代码， Ajax.Updater对象可以执行那段JavaScript代码。为了使这个对象对待响应为JavaScript，你只需在最后参数的对象构造方法中简单加入evalScripts: true属性。但是值得提醒的是，像这个选项名evalScripts暗示的，这些脚本会被执行，但是它们不会被加入到Page的脚本中。&有什么区别？&，可能你会这样问。我们假定请求地址返回的东东像这样：
&script language=&javascript& type=&text/javascript&&
function sayHi(){
alert('Hi');
&input type=button value=&Click Me& onclick=&sayHi()&&
如果你以前这样尝试过，你知道这些脚本不会如你所期望的那样工作，原因是这段脚本会被执行，但像上面这样的脚本执行并不会创建一个名叫sayHi的函数，它什么也不做。如果要创建一个函数，我们应当把代码改成下面这个样子：
&script language=&javascript& type=&text/javascript&&
sayHi = function(){
alert('Hi');
&input type=button value=&Click Me& onclick=&sayHi()&&
为什么我们在上面的代码中不使用var关键字来声明这个变量呢（指sayHi&），因为那样做创建出来的函数将只是当前脚本块的一个局部变量（至少在IE中是这样）。不写var关键字，创建出来的对象的作用域就是我们所期望的window。
更多相关知识，请参看&
枚举... 噢!噢!
你知道，我们都是这样来做循环的，建一个Array，用elements组织它们，再建一个循环结构（例如for,foreach,while)通过index数字来访问每一个element，再用这个element做一些动作。
当你想到这时，你会发现几乎每次写循环代码你都会迟早用到一个Array。那么，如果Array对象能够提供更多的功能给它们的迭代器使用不是很爽吗？确实是这样，事实上很多的编程语言都在它们的Array或其它类似的结构中（如Collections,Lists）提供一些这样的功能。
现在好了，prototype.js了给我们一个 对象，它实现了很多和可迭代数据进行交互的窍门。和原有的JS对象相比prototype.js更上一层楼，它对扩展了所有枚举要用的函数。
循环, Ruby样式的
在标准的javascript中，如果你想把一个array中的所有elements显示出来，你可以像下面代码这样写得很好：
function showList(){
var simpsons = ['Homer', 'Marge', 'Lisa', 'Bart', 'Meg'];
for(i=0;i&simpsons.i++){
alert(simpsons[i]);
&input type=&button& value=&Show List& onclick=&showList();& &
使用我们新的最好的朋友，prototype.js，我们可以把它生写成这样
function showList(){
var simpsons = ['Homer', 'Marge', 'Lisa', 'Bart', 'Meg'];
simpsons.each( function(familyMember){
alert(familyMember);
你可能会想&非常奇怪的方式...相对旧的，这种语法太怪异了&。哦，在上面的例子，确实什么也没有，在这个简单得要死例子中，也没有改变太多啊，尽管如此，请继续读下去。
在继续下面内容之前，你注意到那个被做为一个参数传递给each函数的函数？我们把它理解成迭代器函数。
Your arrays on steroids
就如我们上面提到的，把你的Array中的elements当成相同的类型使用相同的属性和函数是很通用(Common,不知该翻译成通用还是庸俗)的。让我们看看怎么样利用我们新的马力强劲的Arrays的迭代功能吧。
依照标准找到一个element。
function findEmployeeById(emp_id){
var listBox = $('lstEmployees')
var options = listBox.getElementsByTagName('option');
options = $A(options);
var opt = options.find( function(employee){
return (employee.value == emp_id);
alert(opt.innerHTML); //displays the employee name
&select id=&lstEmployees& size=&10& &
&option value=&5&&Buchanan, Steven&/option&
&option value=&8&&Callahan, Laura&/option&
&option value=&1&&Davolio, Nancy&/option&
&input type=&button& value=&Find Laura& onclick=&findEmployeeById(8);& &
现在我们再下一城，看看如何过滤一个Array中的元素，从每个元素中得到我们想要的成员。
function showLocalLinks(paragraph){
paragraph = $(paragraph);
var links = $A(paragraph.getElementsByTagName('a'));
//find links that do not start with 'http'
var localLinks = links.findAll( function(link){
var start = link.href.substring(0,4);
return start !='http';
//now the link texts
var texts = localLinks.pluck('innerHTML');
//get them in a single string
var result = texts.inspect();
alert(result);
&p id=&someText&&
This &a href=&/page.html&&text&/a& has
a &a href=&#localAnchor&&lot&/a& of
&a href=&#otherAnchor&&links&/a&. Some are
&a href=&/page.html&&external&/a&
and some are &a href=&#someAnchor&&local&/a&
&input type=button value=&Find Local Links& onclick=&showLocalLinks('someText')&&
上面的代码仅仅是一点小小的实践让人爱上这种语法。请参看 和的所有函数
prototype.js参考
JavaScript类扩展
prototype.js 类库实现强大功能的一种途径是扩展已有的JavaScript 类。
对 Object的扩展
Description
extend(destination, source)
destination: any object, source: any object
提供一种通过拷贝所有源以象属性和函数到目标函数实现继承的方法
inspect(targetObj)
targetObj: any object
返回可读性好关于目标对象的文字描述，如果对象实例没有定义一个inspect函数，默认返回toString函数的值。
对Number的扩展
Description
toColorPart()
返回数字的十六进制表示形式。在把一个RGB数字转换成HTML表现形式时很有用。
&返回下一个数字，这个方法可用于迭代调用场景中。
times(iterator)
iterator: a function object conforming to Function(index)
Calls the iterator function repeatedly passing the current index in the index argument. 反复调用iterator函数并传递当前index到iterator的index参数。
下面的例子用提示框显示0-9。
function demoTimes(){
var n = 10;
n.times(function(index){
alert(index);
/***************************
* you could have also used:
(10).times( .... );
***************************/
&input type=button value=&Test Number.times()& onclick=&demoTimes()&&
对 Function扩展
Description
bind(object)
object: the object that owns the method
返回function的实例，这个实例和源function的结构一样，但是它已被绑定给了参数中提供的object，就是说，function中的this指针指向参数object。
bindAsEventListener(object)
object: the object that owns the method
用法和上面的bind一样，区别在于用来绑定事件。
让我们看看如何运用这些扩展。
&input type=checkbox id=myChk value=1& Test?
//declaring the class
var CheckboxWatcher = Class.create();
//defining the rest of the class implementation
CheckboxWatcher.prototype = {
initialize: function(chkBox, message) {
this.chkBox = $(chkBox);
this.message =
//assigning our method to the event
this.chkBox.onclick =
this.showMessage.bindAsEventListener(this);
showMessage: function(evt) {
alert(this.message + ' (' + evt.type + ')');
var watcher = new CheckboxWatcher('myChk', 'Changed');
对String的扩展
Description
stripTags()
返回一个把所有的HTML或XML标记都移除的字符串。
stripScripts()
返回一个把所有的script都移除的字符串。
escapeHTML()
返回一个把所有的HTML标记合适的转义掉的字符串。
unescapeHTML()
escapeHTML()的反转。
extractScripts()
返回一个包含在string中找到的所有&script&的数组。
evalScripts()
执行在string中找到的所有&script&。
toQueryParams()
把querystring分割才一个用parameter name做index的联合Array，更像一个hash。
parseQuery()
和toQueryParams()一样.
把字符串转换成字符数组.
camelize()
转换一个以连字符连接的字符串成一个骆驼法样式的字符串。比如，这个函数在写代码时，把它做为一个样式工具使用是很有用的。
对& Array的扩展
因为array扩展于enumerable，所以所有enumberable对象的函数，array都是可以使用的，除此之外，下面的这些也是已经实现了的。
Description
返回一个不包括源array中null或undefined元素的array,此方法不改变源array。
返回array的第一个对象。
通过递归组合array每个元素的子元素（如果该元素也是array)来返回一个&扁平的&一维的array。
indexOf(value)
value: what you are looking for.
返回给出数字位置（从０算起）的元素，如果在该位置没有找到对象，返回-1。
重载inspect(),返回更好格式的反映Array每个元素的字符描述。
返回最后一个元素。
reverse([applyToSelf])
applyToSelf: indicates if the array itself should also be reversed.
&反转Array中元素的顺序，如果没有给出参数，或参数为true，则源Array中元素的顺序也反转，否则源Array保持不变。
返回Array的第一个元素并从Array中移除它，Array的Length-1。
without(value1 [, value2 [, .. valueN]])
value1 ... valueN: values to be excluded if present in the array.
&返回一个把参数列表中包含的元素从源Array中排除的Array。
document DOM扩展
Description
getElementsByClassName(className [, parentElement])
className: name of a CSS class associated with the elements, parentElement: object or id of the element that contains the elements being retrieved.
返回所有CSS className属性等于className参数的元素，如果没有给出parentElement,那么将搜索document body。(此处使用document.body我觉得不如使用document,因为有时有的页面没有body)&
Description
KEY_BACKSPACE
NumberNumber
8: Constant. Code for the Backspace key.
9: Constant. Code for the Tab key.
KEY_RETURN
13: Constant. Code for the Return key.
27: Constant. Code for the Esc key.
37: Constant. Code for the Left arrow key.
38: Constant. Code for the Up arrow key.
39: Constant. Code for the Right arrow key.
40: Constant. Code for the Down arrow key.
KEY_DELETE
46: Constant. Code for the Delete key.
observers:
List of cached observers. Part of the internal implementation details of the object.
Description
element(event)
event: an Event object
返回事件源对象。
isLeftClick(event)
event: an Event object
如果点击了鼠标左键，返回true.
pointerX(event)
event: an Event object
返回鼠标的X座标。
pointerY(event)
event: an Event object
返回鼠标的Y座标。
stop(event)
event: an Event object
使用此函数来中断事件的默认行为并阻止传递（冒泡)。
findElement(event, tagName)
event: an Event object, tagName: name of the desired tag.
从事件源对象开始向上搜索DOM树，直到找到第一个符合tagName的元素
observe(element, name, observer, useCapture)
element: object or id, name: event name (like 'click', 'load', etc), observer: function to handle the event, useCapture: if true, handles the event in the capture phase and if false in the bubbling phase.
为对象的某个事件增加一个处理函数。
stopObserving(element, name, observer, useCapture)
element: object or id, name: event name (like 'click'), observer: function that is handling the event, useCapture: if true handles the event in the capture phase and if false in the bubbling phase.
和上面的函数相反。
_observeAndCache(element, name, observer, useCapture)
私有函数，别管它。
unloadCache()
私有函数，别管它。从内存中清除所有的observers缓存。
下面代码演示如何给window添加一个load事件处理函数。
Event.observe(window, 'load', showMessage, false);
function showMessage() {
alert('Page loaded.');
在prototype.js中定义新的对象和类
另一个这个程序包帮助你的地方就是提供许多既支持面向对象设计理念又有共通功能的许多对象。
The PeriodicalExecuter object
这个对象提供一定间隔时间上重复调用一个方法的逻辑。
Description
[ctor](callback, interval)
constructor
callback: a parameterless function, interval: number of seconds
创建这个对象的实例将会重复调用给定的方法。
Description
Function()
被调用的方法，该方法不能传入参数。
以秒为单位的间隔。
currentlyExecuting
表示这个方法是否正在执行。
The Prototype object
Prototype 没有太重要的作用，只是声明了该程序包的版本 。
Description
emptyFunction
Function()
Function(obj)
一个仅仅回传参数的函数。
ScriptFragment
识别script的正则式。
The Enumerable object
Enumberable对象能够已更优雅的方式实现对列表样式的结构进行枚举。
很多其它的对象通过扩展自Enumberable对象来得到这些有用的接口。
Description
each(iterator)
iterator: a function object conforming to Function(value, index)
把每个element做为第一个参数，element的index作为第一个参数调用iterator函数。
all([iterator])
iterator: a function object conforming to Function(value, index)
这个函数会用给出的iterator测试整个集合，如果集合中任一元素在iterator函数测试中返回false或null，那么这个函数返回false,否则返回true。如果没有给出iterator，那么就会测试所有的元素是不是不等于false和null。你可以简单的把它看成是&检测每个元素都为非空非负&。
any(iterator)
iterator: a function object conforming to Function(value, index), optional.
这个函数会用给出的iterator测试整个集合，如果集合中任一元素在iterator函数测试中返回true，那么这个函数返回true,否则返回false。如果没有给出iterator，那么就会测试所有的元素是不是有一个不等于false和null。你可以简单的把它看成是&检测元素中是不是有非空非负的&。
collect(iterator)
iterator: a function object conforming to Function(value, index)
&调用iterator函数根据集合中每个元素返回一个结果，然后按照原来集合中的顺序，返回一个Array。
detect(iterator)
iterator: a function object conforming to Function(value, index)
集合中每个元素调用一次Iterator，返回第一个使Iterator返回True的元素，如果最终都没有为true的调用，那么返回null。
等于toArray().
find(iterator)
iterator: a function object conforming to Function(value, index)
等于 detect().
findAll(iterator)
iterator: a function object conforming to Function(value, index)
集合中每个元素调用Iterator，返回一个由所有调用Iterator返回结果等于true的元素组成的数组。和reject()相反。
grep(pattern [, iterator])
pattern: a RegExp object used to match the elements, iterator: a function object conforming to Function(value, index)
&用pattern参数正则表达式测试集合中的每个元素，返回一个包含所有匹配正则式的元素的Array，如果给出了Iterator，那个每个结果还要经过一下Iterator处理。
include(obj)
obj: any object
&判断集合中包不包含指定对象。
inject(initialValue, iterator)
initialValue: any object to be used as the initial value, iterator: a function object conforming to Function(accumulator, value, index)
&用Iterator联接所有集合中的元素。Iterator在被调用时把上一次迭代的结果做为第一个参数传给accumulator。第一次迭代时，accurmelator等于initialValue,最后返回accumulator的值。
invoke(methodName [, arg1 [, arg2 [...]]])
methodName: name of the method that will be called in each element, arg1..argN: arguments that will be passed in the method invocation.
集合中的每个元素调用指定的函数（查看源代码可以发现指定函数被调用时，this指针被传成当前元素），并传入给出的参数，返回调用结果组成的Array。
map(iterator)
iterator: a function object conforming to Function(value, index)
同collect().
max([iterator])
iterator: a function object conforming to Function(value, index)
返回集合中元素的最大值，或调用Iterator后返回值的最大值(如果给出了Iterator的话)。
member(obj)
obj: any object
同 include().
min([iterator])
iterator: a function object conforming to Function(value, index)
返回最小值，参见max()。
partition([iterator])
iterator: a function object conforming to Function(value, index)
返回一个包含两个Array的Array，第一个Array包含所有调用Iterator返回True的元素，第二个Array包含剩下的元素。如果Iterator没有给出，那么就根据元素本身判断。
pluck(propertyName)
propertyName name of the property that will be read from each element. This can also contain the index of the element
返回每个元素的指定属性名的属性的值组成的Array。
reject(iterator)
iterator: a function object conforming to Function(value, index)
和& findAll()相反（返回所有等于false的元素）.
select(iterator)
iterator: a function object conforming to Function(value, index)
同 findAll().
sortBy(iterator)
iterator: a function object conforming to Function(value, index)
根据每个元素调用Iterator返回的值进行排序返回一个Array。
返回由集合所有元素组成的一个Array。
zip(collection1[, collection2 [, ... collectionN [,transform]]])
collection1 .. collectionN: enumerations that will be merged, transform: a function object conforming to Function(value, index)
合并每个给出的集合到当前集合。合并操作返回一个新的array，这个array的元素个数和原集合的元素个数一样，这个array的每个元素又是一个子array,它合并了所有集合中相同index的元素。如果transform函数被指定，那么array的每个元素还会调用transform函数先做处理。举个例子: [1,2,3].zip([4,5,6], [7,8,9]).inspect()&返回 &[ [1,4,7],[2,5,8],[3,6,9] ]&
The Hash object
&Hash对象实现一种Hash结构，也就是一个Key:Value对的集合。
Hash中的每个Item是一个有两个元素的array，前一个是Key，后一个是Value，每个Item也有两个不需加以说明的属性,key和value。
Description
返回所有Item的key的集合的一个array。
返回所有Item的value的集合的一个array。
merge(otherHash)
otherHash: Hash object
合并给出的Hash，返回一个新Hash。
toQueryString()
以QueryString那样的样式返回hash中所有的item，例如： 'key1=value1&key2=value2&key3=value3'
用一种合适的方法显示hash中的key:value对。
The ObjectRange class
用上、下边界描述一个对象区域。
Description
range的下边界
range的上边界
决定边界自身是不是range的一部分。
Description
[ctor](start, end, exclusive)
constructor
start: the lower bound, end: the upper bound, exclusive: include the bounds in the range?
创建一个range对象，从start生成到end,这里要注意的是，start和end必段类型一致，而且该类型要有succ()方法。
include(searchedValue)
searchedValue: value that we are looking for
检查一个value是不是在range中。
The Class object
在这个程序包中 Class 对象在声明其他的类时候被用到 。用这个对象声明类使得新类支持 initialize() 方法，他起构造方法的作用。
看下面的例子
//declaring the classvar MySampleClass = Class.create();//defining the rest of the class implmentationMySampleClass.prototype = {&& initialize: function(message) {this.message =&& },&& showMessage: function(ajaxResponse) {&&&&& alert(this.message);&& }}; //now, let's instantiate and use one objectvar myTalker = new MySampleClass('hi there.');myTalker.showMessage(); //displays alert
Description
定义新类的构造方法。
The Ajax object
这个对象被用作其他提供AJAX功能的类的根对象。&
Description
activeRequestCount
正在处理中的Ajax请求的个数。
Description
getTransport()
返回新的XMLHttpRequest 对象。
The Ajax.Responders object
这个对象维持一个在Ajax相关事件发生时将被调用的对象的列表。比如，你要设置一个全局钩子来处理Ajax操作异常，那么你就可以使用这个对象。
Description
responders
被注册到Ajax事件通知的对象列表。
Description
register(responderToAdd)
responderToAdd: object with methods that will be called.
被传入参数的对象应包含名如Ajax事件的系列方法（如onCreate,onComplete,onException）。通讯事件引发所有被注册的对象的合适名称的函数被调用。
unregister(responderToRemove)
responderToRemove: object to be removed from the list.
&从列表中移除。
dispatch(callback, request, transport, json)
callback: name of the AJAX event being reported, request: the Ajax.Request object responsible for the event, transport: the XMLHttpRequest object that carried (or is carrying) the AJAX call, json: the X-JSON header of the response (if present)
遍历被注册的对象列表，找出有由callback参数决定的那个函数的对象。然后向这些函数传递其它的三个参数，如果Ajax响应中包含一个含有JSON内容的X-JSON HTTP头，那么它会被热行并传入json参数。如果事件是onException,那么transport参数会被异常代替，json不会传递。
The Ajax.Base class
这个类是其他在Ajax对象中定义的类的基类。
Description
setOptions(options)
设定AJAX操作想要的选项。
responseIsSuccess()
返回 true 如果AJAX操作成功,否则为 false 。
responseIsFailure()
与 responseIsSuccess() 相反。
The Ajax.Request class
封装 AJAX 操作
Description
在AJAX操作中所有可能报告的事件/状态的列表。这个列表包括: 'Uninitialized', 'Loading', 'Loaded', 'Interactive', 和 'Complete'。
XMLHttpRequest
承载AJAX操作的 XMLHttpRequest 对象。
请求的URL。
Description
[ctor](url, options)
constructor
url: the url to be fetched, options: AJAX options
创建这个对象的一个实例，它将在给定的选项下请求url。onCreate事件在调用constructor事被激发。 重要： 如果选择的url受到浏览器的安全设置，他会一点作用也不起。 很多情况下，浏览器不会请求与当前页面不同主机(域名)的url。 你最好只使用本地url来避免限制用户配置他们的浏览器(谢谢Clay)
evalJSON()
这个方法显然不会被外部调用。它在Ajax响应中含有X-JSON&HTTP头时用于内部调用执行这些内容。
evalReponse()
这也方法显然不会被外部调用，如果Ajax响应含有一个值为text/javascript的Cotent-Type头，那么这个方法就用被调用执行响应体。
header(name)
name: HTTP header name
引用Ajax响应的头的内容，在Ajax访问结束后再调用这个方法。
onStateChange()
这个方法通常不会被外部调用。 当AJAX请求状态改变的时候被这个对象自己调用。
request(url)
url: url for the AJAX call
这个方法通常不会被外部调用。已经在构造方法中调用了。
respondToReadyState(readyState)
readyState: state number (1 to 4)
这个方法通常不会被外部调用。 当AJAX请求状态改变的时候被这个对象自己调用。
setRequestHeaders()
这个方法通常不会被外部调用。 被这个对象自己调用来配置在HTTP请求要发送的HTTP报头。
The options argument object
An important part of the AJAX operations is the options argument. There's no options class per se. Any object can be passed, as long as it has the expected properties. It is common to create anonymous objects just for the AJAX calls.
Description
HTTP 请求方式。
parameters
在HTTP请求中传入的url格式的值列表。
asynchronous
指定是否做异步 AJAX 请求。
在HTTP POST的情况下，传入请求体中的内容。
requestHeaders
和请求一起被传入的HTTP头部列表， 这个列表必须含有偶数个项目， 任何奇数项目是自定义的头部的名称， 接下来的偶数项目使这个头部项目的字符串值。 例子:['my-header1', 'this is the value', 'my-other-header', 'another value']
onXXXXXXXX
Function(XMLHttpRequest, Object)
在AJAX请求中，当相应的事件/状态形成的时候调用的自定义方法。 例如 var myOpts = {onComplete: showResponse, onLoaded: registerLoaded};. 这个方法将被传入一个参数， 这个参数是承载AJAX操作的 XMLHttpRequest 对象，另一个是包含被执行X-JSON响应HTTP头。
Function(XMLHttpRequest, Object)
当AJAX请求成功完成的时候调用的自定义方法。 这个方法将被传入一个参数， 这个参数是承载AJAX操作的 XMLHttpRequest 对象，另一个是包含被执行X-JSON响应HTTP头。
Function(XMLHttpRequest, Object)
当AJAX请求完成但出现错误的时候调用的自定义方法。这个方法将被传入一个参数， 这个参数是承载AJAX操作的 XMLHttpRequest 对象，另一个是包含被执行X-JSON响应HTTP头。
onException
Function(Ajax.Request, exception)
当一个在客户端执行的Ajax发生像无效响应或无效参数这样的异常情况时被调用的自定义函数。它收到两个参数，包含异常Ajax操作的Ajax.Request对象和异常对象。
an Insertion class
一个能决定怎么样插入新内容的类，能 , , ,&或 . 只能应用于 对象.
evalScripts
undefined, false
决定当响应到达的时候是否执行其中的脚本块，只在
对象中应用。
undefined, 1
决定当最后一次响应和前一次响应相同时在
对象中的减漫访问的次数， 例如，如果设为2，后来的刷新和之前的结果一样， 这个对象将等待2个设定的时间间隔进行下一次刷新， 如果又一次一样， 那么将等待4次，等等。 不设定这个只，或者设置为1，将避免访问频率变慢。
undefined, 2
用秒表示的刷新间的间隔，只能应用于
The Ajax.Updater class
当请求的url返回一段HTML而你想把它直接放置到页面中一个特定的元素的时候被用到。 如果url的返回&script& 的块并且想在接收到时就执行它的时候也可以使用该对象。含有脚本的时候使用 evalScripts 选项。
Description
containers
这个对象包含两个属性:AJAX请求成功执行的时候用到 containers.success , 否则的话用到 containers.failure 。
Description
[ctor](container, url, options)
constructor
container:this can be the id of an element, the element object itself, or an object with two properties - object.success element (or id) that will be used when the AJAX call succeeds, and object.failure element (or id) that will be used otherwise. url: the url to be fetched, options:
创建一个用给定的选项请求给定的url的一个实例。
updateContent()
这个方法通常不会被外部调用。 当响应到达的时候，被这个对象自己调用。 它会用HTML更新适当的元素或者调用在 insertion 选项中传入的方法-这个方法将被传入两个参数， 被更新的元素和响应文本。
The Ajax.PeriodicalUpdater class
这个类重复生成并使用 Ajax.Updater 对象来刷新页面中的一个元素。或者执行 Ajax.Updater 可以执行的其它任务。更多信息参照
Description
这个值将直接传入Ajax.Updater的构造方法。
这个值将直接传入Ajax.Updater的构造方法。
两次刷新之间的间隔 (不是频率) ，以秒为单位。 默认2秒。 This 当调用 Ajax.Updater 对象的时候，这个数将和当前的 decay 相乘。
重负执行任务的时候保持的衰败水平。
最后一次使用的 Ajax.Updater 对象
通知对象该下一次更新时用到的JavaScript 计时器。
Description
[ctor](container, url, options)
constructor
container:this can be the id of an element, the element object itself, or an object with two properties - object.success element (or id) that will be used when the AJAX call succeeds, and object.failure element (or id) that will be used otherwise. url: the url to be fetched, options:
创建一个用给定的选项请求给定的url的一个实例。
这个方法通常不会被外部调用。 对象为了开始周期性执行任务的时候调用的方法。
使对象停止执行周期任务。停止后，如果有onComplete选项，那么引发callback。
updateComplete()
这个方法通常不会被外部调用。 被当前的 Ajax.Updater 使用，当一次请求结束的时候，它被用作计划下一次请求。
onTimerEvent()
这个方法通常不会被外部调用。当到下一次更新时被内部调用。
The Element object
这个对象提供在操作DOM中元素时使用的功能性方法。
Description
addClassName(element, className)
element: element object or id, className: name of a CSS class
将给出的className添加到对象的className属性中。
classNames(element)
element: element object or id
返回一个Element.ClassName的对象表示CSS 给出对象有的class names。
cleanWhitespace(element)
element: element object or id
清除对象子元素中所有空白的text node。
empty(element)
element: element object or id
返回一个布尔值指示对象为空或只有空白字符。
getDimensions(element)
element: element object or id
返回对象的尺寸，返回值有两个属性，height和width。
getHeight(element)
element: element object or id
返回元素的 offsetHeight 。
getStyle(element, cssProperty)
element: element object or id, cssProperty name of a CSS property (either format 'prop-name' or 'propName' works).
返回给定对象的CSS属性值或没有指定cssProperty时返回null。
hasClassName(element, className)
element: element object or id, className: name of a CSS class
返回 true 如果元素的类名中含有给定的类名
hide(elem1 [, elem2 [, elem3 [...]]])
elemN: element object or id
通过设定style.display 为 'none'来隐藏每个传入的元素。
makeClipping(element)
element: element object or id
能过设定overflow的值设定内容溢出剪辑。
makePositioned(element)
element: element object or id
更改对象的style.position为'relative'。
remove(element)
element: element object or id
从document对象中删除指定的元素。
removeClassName(element, className)
element: element object or id, className: name of a CSS class
从元素的类名中删除给定的类名。
scrollTo(element)
element: element object or id
滚动window到对象的位置。
setStyle(element, cssPropertyHash)
element: element object or id, cssPropertyHash Hash object with the styles to be applied.
依照cssPropertyHash参数给对象设置CSS属性值。
show(elem1 [, elem2 [, elem3 [...]]])
elemN: element object or id
用设定它的 style.display 为 ''来显示每个传入的元素。
toggle(elem1 [, elem2 [, elem3 [...]]])
elemN: element object or id
切换每一个传入元素的可视性。
undoClipping(element)
element: element object or id
style.overflow的值返回上一个设定值。
undoPositioned(element)
element: element object or id
清除对象的 style.position 为 ''
update(element, html)
element: element object or id, html: html content
用给出的HTML参数替换对象的innerHTML,如果HTML参数中包含&script&，那么它们不会被包含进去，但是会执行。
visible(element)
element: element object or id
返回一个布尔值指示对象可不可见。
The Element.ClassNames class
在一个对象中表示CSS class names的集合。
Description
[ctor](element)
constructor
element: any DOM element object or id
创建一个对象，给出对象的CSS class names被表现在这个ClassNames对象中。
add(className)
className: a CSS class name
把CSS class name包含进对象的class names 列表。
remove(className)
className: a CSS class name
从对象的class names列表中移除className
set(className)
className: a CSS class name
设定对象CSS class name为className,移除其它class names。
The Abstract object
这个对象是这个程序包中其他类的根。它没有任何属性和方法。在这个对象中定义的类可以被视为传统的抽象类。
The Abstract.Insertion class
这个类被用作其他提供动态内容插入功能的类的基类，它像一个抽象类一样被使用。
Description
[ctor](element, content)
constructor
element: element object or id, content: HTML to be inserted
创建一个可以帮助插入动态内容的对象。
contentFromAnonymousTable()
对content通过匿名表格变成一个Node数组。
Description
static, parameter
这个参数指定相对于给定元素，内容将被放置的位置。 可能的值是: 'beforeBegin', 'afterBegin', 'beforeEnd', 和 'afterEnd'.
与插入物做参照元素对象。
被插入的 HTML 。
The Insertion object
这个对象是其他类似功能的根。它没有任何属性和方法。在这个对象中定义的类仍然可以被视为传统的抽象类。
The Insertion.Before class
在给定元素开始标记的前面插入HTML。
Description
[ctor](element, content)
constructor
element: element object or id, content: HTML to be inserted
继承自&& . 创建一个可以帮助插入动态内容的对象。
下面的代码
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going?&/span&
&script& new Insertion.Before('person', 'Chief '); &/script&
将把 HTML 变为
&br&Hello, Chief &span id=&person& style=&color:&&Wiggum. How's it going?&/span&
The Insertion.Top class
在给定元素第一个子节点位置插入 HTML。内容将位于元素的开始标记的紧后面。
Description
[ctor](element, content)
constructor
element: element object or id, content: HTML to be inserted
继承自&&. 创建一个可以帮助插入动态内容的对象。
下面的代码
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going?&/span&
&script& new Insertion.Top('person', 'Mr. '); &/script&
将把 HTML 变为
&br&Hello, &span id=&person& style=&color:&&Mr. Wiggum. How's it going?&/span&
The Insertion.Bottom class
Inherits from
在给定元素最后一个子节点位置插入 HTML。内容将位于元素的结束标记的紧前面。
Description
[ctor](element, content)
constructor
element: element object or id, content: HTML to be inserted
Inherited from . Creates an object that will help with dynamic content insertion.
The following code
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going?&/span&
&script& new Insertion.Bottom('person', & What's up?&); &/script&
Will change the HTML to
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going? What's up?&/span&
The Insertion.After class
Inherits from
在给定元素结束标记的后面插入HTML。
Description
[ctor](element, content)
constructor
element: element object or id, content: HTML to be inserted
Inherited from . Creates an object that will help with dynamic content insertion.
The following code
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going?&/span&
&script& new Insertion.After('person', ' Are you there?'); &/script&
Will change the HTML to
&br&Hello, &span id=&person& style=&color:&&Wiggum. How's it going?&/span& Are you there?
The Field object
这个对象提供操作表单中的输入项目的功能性方法。
Description
clear(field1 [, field2 [, field3 [...]]])
fieldN: field element object or id
清除传入表单中项目元素的值。
present(field1 [, field2 [, field3 [...]]])
fieldN: field element object or id
只有在所有的表单项目都不为空时返回 true 。
focus(field)
field: field element object or id
移动焦点到给定的表单项目。
select(field)
field: field element object or id
选择支持项目值选择的表单项目的值。
activate(field)
field: field element object or id
移动焦点并且选择支持项目值选择的表单项目的值。
The Form object
这个对象提供操作表单和他们的输入元素的功能性方法。
Description
serialize(form)
form: form element object or id
返回url参数格式的项目名和值的列表， 如'field1=value1&field2=value2&field3=value3'。
findFirstElement(form)
form: form element object or id
返回Form中第一个Enable的对象。
getElements(form)
form: form element object or id
返回包含所有在表单中输入项目的 Array 对象。
getInputs(form [, typeName [, name]])
form: form element object or id, typeName: the type of the input element, name: the name of the input element.
返回一个 Array 包含所有在表单中的 &input& 元素。 另外， 这个列表可以对元素的类型或名字属性进行过滤。
disable(form)
form: form element object or id
使表单中的所有输入项目无效。
enable(form)
form: form element object or id
使表单中的所有输入项目有效。
focusFirstElement(form)
form: form element object or id
激活第一个表单中可视的，有效的输入项目。
reset(form)
form: form element object or id
重置表单。和调用表单对象的 reset() 方法一样。
The Form.Element object
这个对象提供表单对象中的可视和非可视元素的功能性方法。
Description
serialize(element)
element: element object or id
返回元素的 名称=值 对, 如 'elementName=elementValue'。
getValue(element)
element: element object or id
返回元素的值。
The Form.Element.Serializers object
这个对象提供了内部使用的用来协助解析出表单元素的当前值的一些有用的方法。
Description
inputSelector(element)
element: object or id of a form element that has the checked property, like a radio button or checkbox.
返回带有元素名称和值的 Array , 如 ['elementName', 'elementValue']
textarea(element)
element: object or id of a form element that has the value property, like a textbox, button or password field.
返回带有元素名称和值的 Array , 如 ['elementName', 'elementValue']
select(element)
element: object of a &select& element
返回带有元素名称和所有被选择的选项的值或文本的 Array , 如 ['elementName', 'selOpt1 selOpt4 selOpt9']
The Abstract.TimedObserver class
这个类是用于其它监听一个元素的值(或者任何类中涉及的属性)变化的类的基类，这个类像一个抽象类一样被使用。
子类可以被创建来监听如输入项目值，或style属性，或表格的行数，或者其他任何对跟踪变化相关的东西。
子类必须实现这个方法来决定什么才是被监听的元素的当前值。
Description
[ctor](element, frequency, callback)
constructor
element: element object or id, frequency: interval in seconds, callback: function to be called when the element changes
创建一个监听元素的对象。
getValue()
instance, abstract
子类必须实现这个方法以瘊定什么这个元素被监视的当前值。
registerCallback()
这个方法通常不会被外部调用。 被这个对象自己调用来开始监听那个元素。
onTimerEvent()
这个方法通常不会被外部调用。 被这个对象自己调用来周期性的检查那个元素。
Description
被监听的元素对象。
每次检查中的以秒为单位的时间间隔。
Function(Object, String)
只要元素改变这个方法就会被调用。 会接收到元素对象和新值作为参数。
元素被核实的最后一个值。
The Form.Element.Observer class
Abstract.TimedObserver 的一个实现类用来监听表单输入项目的值的变化。当你想监听一个没有带报告值变化事件的元素的时候使用这个类。否则的话使用
Description
[ctor](element, frequency, callback)
constructor
element: element object or id, frequency: interval in seconds, callback: function to be called when the element changes
继承自 Abstract.TimedObserver. 创建一个监听元素值属性的对象。
getValue()
返回元素的值。
The Form.Observer class
Abstract.TimedObserver 的一个实现类用来监听表单中任何数据项的值的变化。当你想监听一个没有带报告值变化事件的元素的时候使用这个类。 否则的话使用类 代替。
Description
[ctor](form, frequency, callback)
constructor
form: form object or id, frequency: interval in seconds, callback function to be called when any data entry element in the form changes
继承自 Abstract.TimedObserver. 创建一个监听表单变化的对象。
getValue()
返回所有表单数据的一系列值。
The Abstract.EventObserver class
这个类被用作其他一些类的基类，这些类具有在一个元素的值改变事件发生的时候执行一个回调方法这样的功能。
类 Abstract.EventObserver 的多个对象可以绑定到一个元素上，不是一个帮其他的擦出了，而是按照他们付给元素的顺序执行这些回调方法。
单选按钮和复选框的触发事件是 onclick ，而文本框和下拉列表框/下拉列表框的是 onchange 。&
Description
[ctor](element, callback)
constructor
element: element object or id, callback: function to be called when the event happens
创建监听元素的对象。
getValue()
instance,abstract
子类必须实现这个方法以瘊定什么这个元素被监视的当前值。
registerCallback()
这个方法通常不会被外部调用。 被对象调用来把自己绑定到元素的事件上。
registerFormCallbacks()
这个方法通常不会被外部调用。 被对象调用来把自己绑定到表单中的每一个数据项元素的事件上。
onElementEvent()
这个方法通常不会被外部调用。 将被绑定到元素的事件上。
Description
被监听的元素对象。
Function(Object, String)
只要元素改变就调用的方法。会接收到元素对象和新值作为参数。
元素被核实的最后一个值。
The Form.Element.EventObserver class
Abstract.EventObserver 的一个实现类，它在监测到表单中数据项元素的值改变的相应事件时候执行一个回调方法。 如果元素没有任何报告变化的事件，那么你可以使用
Description
[ctor](element, callback)
constructor
element: element object or id, callback: function to be called when the event happens
继承自 Abstract.EventObserver。 创建一个监听元素值属性的对象。
getValue()
返回元素的值。
The Form.EventObserver class
Abstract.EventObserver 的一个实现类，监听表单对象中包含的任何对象的任何变化，用元素的事件检测值的变化。如果元素没有任何报告变化的事件， 那么你可以使用 类代替。
Description
[ctor](form, callback)
constructor
form: form object or id, callback: function to be called when any data entry element in the form changes
继承自 Abstract.EventObserver。 创建一个监听元素值属性的对象。
getValue()
返回所有表单数据的一系列值。
Position 对象 (预备文档)
这个对象提供许多和元素位置相关的方法。
Description
调整 deltaX 和 deltaY 属性来协调在滚动位置中的变化。 记得在页面滚动之后的任何调用的withinIncludingScrolloffset 之前调用这个方法。
realOffset(element)
element: object
返回这个元素的正确滚动偏差的 Array 对象， 包括所有影响元素的滚动偏差。结果数组类似 [total_scroll_left, total_scroll_top]
cumulativeOffset(element)
element: object
回这个元素的正确滚动偏差的 Array 对象， 包含任何被放置的父元素强加偏差。结果数组类似 [total_offset_left, total_offset_top]
within(element, x, y)
element: object, x and y: coordinates of a point
测试给定的点的坐标是否在给定的元素的外部矩形范围之内。
withinIncludingScrolloffsets(element, x, y)
element: object, x and y: coordinates of a point
&测试给定的点的坐标是否在给定的元素的外部矩形范围之内（包含scroll offsets）。
overlap(mode, element)
mode: 'vertical' or 'horizontal', element: object
在调用这个方法之前需要调用within() 。这个方法返回0.0到1.0之间的数字，来表示坐标在元素重叠的分数。 举个例子，如果元素是一个边长是100px的正方形的DIV，并且位于(300, 300), 然后 within(divSquare, 330, 330)；overlap('vertical', divSquare); 会返回 0.10，意思是那个点位于DIV顶部边框以下 10% (30px) 的位置上。
clone(source, target)
source: element object or id, target: element object or id
改变目标元素的大小尺寸