MooTools1.2.4 API

http://mootools.net/docs

注：参数列表中括号里的参数是可选参数，不是数组。

Core

$chk(item):
item - mixed

item为null、undefined、false和空字符串时返回false，否则（包括为0时）返回true。

$clear(timer):
timer - number

用于清除timeout或者interval，参数timer为timeout或者interval的id。

$defined(obj):
obj - mixed

当obj为null或者undefined时返回false，否则返回true。

$arguments(index)
index - number

返回一个function，这个function的返回值是传递给它的参数列表中第index+1个参数。
例：

var secondArgument = $arguments(1);
alert(secondArgument('a','b','c')); //Alerts "b".

源码：

function $arguments(i){
	return function(){
		return arguments[i];
	};
};

$empty:

返回一个空function，仅仅作占位符用。
源码：

function $empty(){};

$lambda(value):
value - mixed

返回一个function，如果参数value是一个function，则直接返回该function；否则返回一个新function，这个function的返回值是传递给$lambda的参数value。
例：

myLink.addEvent('click', $lambda(false)); //Prevents a link Element from being clickable.

源码：

function $lambda(value){
	return ($type(value) == 'function') ? value : function(){
		return value;
	};
};

$extend(original, extension):
original - object
extension - object

用extension扩展original，从extension中复制所有属性到original中。
例：

var firstObj = {
    'name': 'John',
    'lastName': 'Doe'
};
var secondObj = {
    'age': '20',
    'sex': 'male',
    'lastName': 'Dorian'
};
$extend(firstObj, secondObj);
//firstObj is now: {'name': 'John', 'lastName': 'Dorian', 'age': '20', 'sex': 'male'};

$merge(obj1, obj2...):
obj - object

递归的合并n个对象。和ruby中hash的merge差不多，不同的是mootools的merge是递归的：

 {:a=>1,:b=>{:c=>3,:d=>4}}.merge({:b=>{:c=>2}}) #=> {:a=>1, :b=>{:c=>2}}

$merge({a: 1}, {b: {c: 3, d: 4}}, {a: 1, b: {c: 2}})//{a: 1, b: {c: 2, d: 4}}

$each(iterable, fn, [bind]):
iterable - object OR array
fn - function(item, index, object)
  item - mixed
  index - number
  object - object 被遍历的对象或数组本身
bind - object

用fn遍历iterable，同时可用第3个参数object指定fn上下文。
例：

$each([1,2,3], function(item,index,array){alert('['+array+']的第'+(index+1)+'个元素是:'+item+'.'+this+'.');}, 'context');

$pick([var1, [var2, ...]]):
varn - mixed

返回第一个非null非undefined的值。
例：

function say(infoMessage, errorMessage){
    alert($pick(errorMessage, infoMessage, 'There was no message supplied.'));
}
say(); //Alerts "There was no message supplied."
say("This is an info message."); //Alerts "This is an info message."
say("This message will be ignored.", "This is the error message."); //Alerts "This is the error message."

$random(min, max):
min - number
max - number

返回min和max之间的一个随机值。

$splat(obj):
obj - mixed

假如参数obj为数组，则直接返回该数组；否则将obj包装成数组再返回。

$time():

以时间戳的形式返回当前时间。（实现很有意思，就一句return +new Date，这里有个隐式的类型转换，相当于 0 + Number(new Date)）

$try(fn[, fn[, fn...]]):
fn - function

尝试调用传递进来的所有function，如果没有任何一个function执行成功，返回null；如果有function能够成功执行，则执行之，并返回该function的返回值。
例：

$try(function(){alert(a);},function(){alert(0);}, function(){alert(9);})

$type(obj):
obj - mixed

返回obj的类型名。详见下面的列表：

引用

    * 'element' - (string) If object is a DOM element node.
    * 'textnode' - (string) If object is a DOM text node.
    * 'whitespace' - (string) If object is a DOM whitespace node.
    * 'arguments' - (string) If object is an arguments object.
    * 'array' - (string) If object is an array.
    * 'object' - (string) If object is an object.
    * 'string' - (string) If object is a string.
    * 'number' - (string) If object is a number.
    * 'date' - (string) If object is a date.
    * 'boolean' - (string) If object is a boolean.
    * 'function' - (string) If object is a function.
    * 'regexp' - (string) If object is a regular expression.
    * 'class' - (string) If object is a Class (created with new Class, or the extend of another class).
    * 'collection' - (string) If object is a native htmlelements collection, such as childNodes, getElementsByTagName, etc.
    * 'window' - (string) If object is the window object.
    * 'document' - (string) If object is the document object.
    * 'event' - (string) If object is an event.
    * false - (boolean) If object is undefined, null, NaN or none of the above.

Browser

Browser.Features.xpath - (boolean) 如果浏览器支持XPath的方式查询DOM则该值为true。
Browser.Features.xhr - (boolean) 如果浏览器支持XMLHTTP对象则该值为true。
Browser.Engine.trident - (boolean) True if the current browser uses the trident engine (e.g. Internet Explorer).
Browser.Engine.gecko - (boolean) True if the current browser uses the gecko engine (e.g. Firefox, or any Mozilla Browser).
Browser.Engine.webkit - (boolean) True if the current browser uses the webkit engine (e.g. Safari, Google Chrome, Konqueror).
Browser.Engine.presto - (boolean) True if the current browser uses the presto engine (e.g. Opera 9).
Browser.Engine.name - (string) The name of the engine.
Browser.Engine.version - (number) The version of the engine. (e.g. 950)
Browser.Plugins.Flash.version - (number) The major version of the flash plugin installed.
Browser.Plugins.Flash.build - (number) The build version of the flash plugin installed.
Browser.Platform.mac - (boolean) True if the platform is Mac.
Browser.Platform.win - (boolean) True if the platform is Windows.
Browser.Platform.linux - (boolean) True if the platform is Linux.
Browser.Platform.ipod - (boolean) True if the platform is an iPod touch / iPhone.
Browser.Platform.other - (boolean) True if the platform is neither Mac, Windows, Linux nor iPod.
Browser.Platform.name - (string) The name of the platform.

Array

each(fn[, bind]):
fn - function(item, index, array)
  item - mixed
  index - number
  array - array 被遍历的数组本身
bind - object 同$each()的bind

用fn遍历该数组。

every(fn[, bind]):
参数同each

用fn遍历数组，如果每次fn的返回值都为true，则every()的返回值为true；否则every返回false。

例：

[1,2,3].every(function(item){return item<5;}); //返回true

filter(fn[, bind]):
参数同each

用fn遍历数组，返回一个新数组，过滤掉使fn返回false的元素。
例：

[1,2,3].filter(function(item){return item>2;}); //返回[3]

clean():

返回一个新数组，清除掉原数组中所有null和undefined值。
例：

var myArray = [null, 1, 0, true, false, "foo", undefined, ""];
myArray.clean() // returns [1, 0, true, false, "foo", ""]

indexOf(item[, from]):
item - object
from - number

返回item的索引值。如果未找到item，返回-1。from为查找item的起始位置，默认为0。
例：

[1,2,3,4,1].indexOf(1,1); // 返回4

map(fn[, bind]):
参数同each

用fn遍历数组，对数组中的每个元素进行修改，返回修改后的新数组。
例：

[1,2,3].map(function(item){return item+1;});//返回[2,3,4]

some(fn[, each]):
参数同each

用fn遍历数组，只要数组中有一个元素使fn返回true，则some()返回true，否则返回false。
例：

[1,2,3].some(function(item){return item==3});//返回true

associate(array):
array - array

把两个数组合并为一个键值对。
例：

[1,2,3].associate(['a','b','c']);//返回{a:1,b:2,c:3}

link(object):
object - object

参数是一个键值对，其中值为function。link方法用这些function测试数组，并根据其返回值返回一个新的键值对。
例：

[1,2,3].link({a:function(i){return i<2;}, b: function(i){return i==2;}, c: function(i){return i>2;}});//返回{a:1, b:2, c:3}

contains(item[, from]):
item - object
from - number

测试数组中是否存在指定元素。可以用参数from指定起始位置。

extend(array):
array - array
连接两个数组。（不太明白为什么还要这个方法，js数组本身有一个concat方法似乎够用了）
例：

[1].extend([1,2]);//[1,1,2]

getLast():

返回数组的最后一个元素。

getRandom():

随机返回数组中的一个元素。

include(item):
item - object

往数组中添加item，如果数组中已经存在item，则不对原数组做任何操作。

combine(array):
array - array

连接两个数组，不允许元素重复。
例：

[1,2,3].combine([1,4,5]);//[1,2,3,4,5]

erase(item):
item - object

删除数组中所有指定的元素。

['Cow', 'Pig', 'Dog', 'Cat', 'Dog'].erase('Dog') //returns ['Cow', 'Pig', 'Cat']

empty():

清空数组。

flatten():

把n维数组转换成1维数组。

[1,2,3,[4,5, [6,7]], [[[8]]]].flatten();//[1,2,3,4,5,6,7,8]

hexToRgb([array]):
array - boolean

把数组形式的16进制颜色值转换成RGB值。如果给一个参数true，RGB值将以数组形式返回。
例：

['11','22','33'].hexToRgb(); //returns "rgb(17,34,51)"
['11','22','33'].hexToRgb(true); //returns [17, 34, 51]

rgbToHex([array]):
array - boolean

与hexToRgb相反。

$A(iterable):
iterable - array

复制一份数组。

Function

create([options]):
options - object

用function创建一个闭包。Function的其它方法的实现（除了run方法）都基于该方法。options为一个键值对集合，可选项有：
bind - 略
event - mixed 默认为false。如果设置为true，闭包会变成一个事件监听器，并且接受一个事件对象作为第1个参数。如果设置为一个Class，闭包则接受一个该类的实例作为第1个参数，该实例以事件对象做为构造函数的参数构造。
arguments - mixed 传递给闭包的参数，如果要传递多个参数，必须以数组的形式传入。如果同时设置了event选项，事件对象将作为第1个参数传递给闭包，通过arguments设置的参数紧跟其后。
delay - number 指定调用该闭包时延迟执行的时间。返回值是一个timer的id。
periodical - number 指定闭包执行的周期。返回值是一个timer的id。
attempt - boolean 默认为false，如果设置为true，闭包会在创建成功后立即执行。如果执行成功，返回该闭包的返回值。如果执行失败则返回null。

pass([args[, bind]]):
args - mixed
bind - object

用function创建一个闭包，并给这个闭包传递一些参数，绑定上下文。

attempt([args[, bind]]):
args - mixed
bind - object

同pass，立即执行。如果执行成功，返回该闭包的返回值。如果执行失败则返回null。

bind([bind[, args]]):
bind - object
args - mixed

用function创建一个闭包，并给这个闭包绑定一个上下文，再传递一些参数。

bindWithEvent([bind[, args]]):
bind - object
args - mixed

用function创建一个闭包，并给这个闭包绑定一个上下文，再传递一些参数。同时将该闭包作为事件监听器（第1个参数为事件对象，args紧跟其后，bind为this引用的上下文）。

delay(delay[, bind[, args]]):
用function创建一个闭包，延迟指定的毫秒数执行。返回值是一个timer的id。bind、args不再赘述。

periodical(period[, bind[, args]]):
用function创建一个闭包，并指定闭包执行的周期。返回值是一个timer的id。

run(args[, bind]):
同apply，但是颠倒了参数的位置。同时可以接受单个参数。跟attempt很像，但attempt用了$try，run则是直接用apply实现的。（create内部也用了apply，attempt和run的主要区别只是attempt通过$try调用，run则没有。）

Number

limit(min, max):
min - number
max - number

限制该数值的上下限，如果该数值在上下限之间，返回该数值，否则返回上限值或下限值。（注意参数顺序，第1个是下限，第2个是上限，否则会得到预期之外的结果。）
例：

(1).limit(0, 2)// 返回1
(1).limit(2, 3)// 返回2
(1).limit(-1, 0)// 返回0

round([precision]):
precision - number

四舍五入，可以用指定精度，默认为0。精度可以是负数。
例：

(12.45).round()   //Returns: 12
(12.45).round(1)  //Returns: 12.5
(12.45).round(-1) //Returns: 10

times(fn[, bind]):
fn - function
bind - object

调用传入的function N次。
例：

(4).times(alert); //Alerts "0", then "1", then "2", then "3".

toFloat()

把数值转换成浮点型。

toInt([base]):
base - number

把数值转换成整型，同时可指定基数。

String

test(regex[, params])
regex - mixed
params - string

测试字符串是否匹配某个正则表达式。第一个参数regex可以是一个正则对象，也可以是一个字符串。第2个参数params可选，但只在第一个参数regex为字符串时有用，用于构造正则对象。
例：

"I like cookies".test("cookie"); //returns true
"I like cookies".test("COOKIE", "i"); //returns true (ignore case)
"I like cookies".test("cake"); //returns false

contains(string[, separator]):
string - string
separator - string

测试字符串中是否包含某个字符串。（看不出这个separator有什么用）

'a bc'.contains('bc'); //returns true
'a b c'.contains('c', ' '); //returns true
'a bc'.contains('b', ' '); //returns false

trim():

去掉字符串两头的空格和换行符。

clean():

去掉多余的空格和所有换行符，并且去掉字符串两头的空格。
例：

" i      like     cookies      \n\n".clean(); //returns "i like cookies"

camelCase():

把连字符(-)连接的字符串转换成驼峰形式。
例：

"I-like-cookies".camelCase(); //returns "ILikeCookies"

hyphenate():

与camelCate相反。

capitalize():

把字符串中每个单词的首字母转换成大写形式。
例：

"i like cookies".capitalize(); //returns "I Like Cookies"

escapeRegExp():

将字符串中的正则字符转义。
例：

'animals.sheep[1]'.escapeRegExp(); //returns 'animals\.sheep\[1\]'

toInt([base]):

将字符串转换成整型，并可指定基数。用parseInt实现，转换规则同parseInt。

toFloat():

将字符串转换成浮点型。

hexToRgb([array]):
array - boolean

将hex形式的颜色字符串转换成RGB形式的字符串，如果参数为true，则转换结果为数组。
例：

"#123".hexToRgb(); //returns "rgb(17,34,51)"
"112233".hexToRgb(); //returns "rgb(17,34,51)"
"#112233".hexToRgb(true); //returns [17, 34, 51]

rgbToHex([array]):
array - boolean

将RGB形式的字符串转换成hex形式。如果参数为true，则转换结果为数组。
例：

"rgb(17,34,51)".rgbToHex(); //returns "#112233"
"rgb(17,34,51)".rgbToHex(true); //returns ['11','22','33']
"rgba(17,34,51,0)".rgbToHex(); //returns "transparent"

stripScripts(option):
option - mixed

将字符串中的<script>标签以及其中的内容删除掉。如果参数option为true，在方法返回之前会先执行script标签中的脚本。如果参数option为function，在方法返回之前会调用该function，该function接受两个参数，第1个参数是<script>标签之间的javascript脚本，第2个参数是去掉<script>标签之后的字符串。
例：

var myString = "<script>alert('Hello')</script>Hello, World.";
myString.stripScripts(); //Returns "Hello, World."
myString.stripScripts(true); //Alerts "Hello", then returns "Hello, World."
myString.stripScripts(function(script,text){$exec(script);alert(text);});//Alerts "Hello", then alerts "Hello, World."

substitute(object[, regexp]):
object - mixed
regexp - regexp

用一个键值对(参数object)对字符串中的内容进行替换，用一个正则表达式(参数regexp)指定匹配规则。正则默认值为/\?{([^}]+)}/g
例：

var myString = "{subject} is {property_1} and {property_2}.";
var myObject = {subject: 'Jack Bauer', property_1: 'our lord', property_2: 'savior'};
myString.substitute(myObject); //Jack Bauer is our lord and savior

Hash

A custom Object ({}) implementation which does not account for prototypes when setting, getting, or iterating. Useful because in JavaScript, we cannot use Object.prototype. Instead, we can use Hash.prototype!

constructor([object]):
object - mixed

构造一个hash。

each(fn[, bind]):
fn - function(value, key, hash)
  value - mixed
  key - string
  hash - hash
bind - object

遍历hash。

has(key):
key - string

测试hash中是否存在指定的键。

keyOf(item):
item - mixed

返回指定值的key。如果指定的item在hash中不存在，则返回false。

hasValue(value):
value - mixed

测试hash中是否存在指定的值。

extend(properties):
properties - object

用properties扩展hash，properties中如果有与原hash重复的键，将会覆盖原hash中的键值对。
例：

var hash = new Hash({
    'name': 'John',
    'lastName': 'Doe'
});
var properties = {
    'age': '20',
    'sex': 'male',
    'lastName': 'Dorian'
};
hash.extend(properties);
//hash now holds an object containing: { 'name': 'John', 'lastName': 'Dorian', 'age': '20', 'sex': 'male' };

combine([properties]):
properties - object

联合两个hash，与extend不同的是：properties中如果有与原hash重复的键，将忽略properties中的键值对。

erase(key):
key - string

删除指定键的键值对。

get(key):
key - string

获取指定键对应的值。如果指定的键不存在，返回null。

set(key, value):
key - string
value - mixed

为指定的键设置一个值，如果键已经存在，则覆盖。

empty():

清空hash。

include(key, value):
key - string
value - mixed

往hash中添加一个键值对，如果键已经存在则不做任何操作。

map(fn[, bind]):
fn - function(value, key, hash)
bind - object

用fn遍历hash，修改每一个键值对，返回修改后的hash。
例：

var timesTwo = new Hash({a: 1, b: 2, c: 3}).map(function(value, key){
    return value * 2;
}); //timesTwo now holds an object containing: {a: 2, b: 4, c: 6};

filter(fn[, bind]):
fn - function(value, key, hash)
bind - object

用fn遍历hash，过滤掉不满足条件的键值对，返回过滤后的hash。

every(fn[, bind]):
fn - function
bind - object

用fn遍历hash，如果hash中的每一对键值对都满足条件则返回true，否则返回false。

some(fn[, bind]):
fn - function(value, key, has)
bind - object

用fn遍历hash，如果hash中有任何一对键值对满足条件则返回true，否则返回false。

getClean():

返回一个干净的不带Hash.prototype的Object。
例：

var hash = new Hash({
    'name': 'John',
    'lastName': 'Doe'
});
hash = hash.getClean(); // hash doesnt contain Hash prototypes anymore
hash.each() //error!

getKeys():

返回hash中所有的键组成的数组。

getValues():

返回hash中所有的值组成的数组。

getLength():

返回hash中键值对的数量。

toQueryString():

把hash转换成url查询字符串的形式。
例：

var hash = new Hash({'name': 'John', 'lastName': 'Doe'});
hash.toQueryString();//返回"name=John&lastName=Doe"

$H(object):

new Hash的快捷方式。
源码：

function $H(object){
	return new Hash(object);
};

Event

new Event(event[, win])
event - event
win - window

构造event。可以通过第2个参数win给event设置上下文。

MooTools Event的属性：

引用

    * shift - (boolean) True if the user pressed the shift key.
    * control - (boolean) True if the user pressed the control key.
    * alt - (boolean) True if the user pressed the alt key.
    * meta - (boolean) True if the user pressed the meta key.
    * wheel - (number) The amount of third button scrolling.
    * code - (number) The keycode of the key pressed.
    * page.x - (number) The x position of the mouse, relative to the full window.
    * page.y - (number) The y position of the mouse, relative to the full window.
    * client.x - (number) The x position of the mouse, relative to the viewport.
    * client.y - (number) The y position of the mouse, relative to the viewport.
    * key - (string) The key pressed as a lowercase string. key can be 'enter', 'up', 'down', 'left', 'right', 'space', 'backspace', 'delete', and 'esc'.
    * target - (element) The event target, not extended with $ for performance reasons.
    * relatedTarget - (element) The event related target, NOT extended with $.

例：

$('myText').addEvent('keydown', function(event){
    //The passed event parameter is already an instance of the Event class.
    alert(event.key);   //Returns the lowercase letter pressed.
    alert(event.shift); //Returns true if the key pressed is shift.
    if (event.key == 's' && event.control) alert('Document saved.'); //Executes if the user hits Ctr+S.
});

stop():

stopPropagation + preventDefault。另外MooTools重写了……更正确的说法是为自己的Event类添加了跨平台的stopPropagation和preventDefault方法。

stopPropagation():
阻止事件传播（包括“捕获”和“冒泡”）。

preventDefault():
中止事件默认的行为。

Event.Keys
这是一个hash（是的，MooTools的hash），可以用来添加自定义的event key code。
例：

Event.Keys.shift = 16;
$('myInput').addEvent('keydown', function(event){
    if (event.key == "shift") alert("You pressed shift.");
});

Class

constructor(properties):
properties - object/function

构造一个类。如果properties是一个function，它将被当作类的构造方法。如果是一个object，这个object将作为类的属性集。同时，这个object接受3个特别的属性：Extends、Implements和initialize。

initialize - function: 用作该类的构造方法。
Extends - class: 作为该类所继承的类，子类将拥有父类所有的属性，并且在子类中可以通过parent调用父类的同名方法。
Implements - mixed: 当该属性是一个对象或者类时，它的所有属性将被复制到新类中；如果是一个数组，则遍历数组中的对象或类，依次复制这些对象或类的属性到新类中。

implement(properties):
properties - object

用于给类动态的添加属性或者方法。
例：

var Animal = new Class({
    initialize: function(age){
        this.age = age;
    }
});
Animal.implement({
    setName: function(name){
        this.name = name;
    }
});
var myAnimal = new Animal(20);
myAnimal.setName('Micia');
alert(myAnimal.name); //alerts 'Micia'

Class Extras:Chain

constructor():

For new classes:

var MyClass = new Class({ Implements: Chain });

For existing classes:

MyClass.implement(Chain);

Stand alone

var myChain = new Chain;

例：

    var Todo = new Class({
        Implements: Chain,
        initialize: function(){
            this.chain.apply(this, arguments);
        }
    });
 
    var myTodoList = new Todo(
        function(){ alert('get groceries'); },
        function(){ alert('go workout'); },
        function(){ alert('code mootools documentation until eyes close involuntarily'); },
        function(){ alert('sleep'); }
    );

chain(fn[, fn2[, fn3....]]):
fn - function

把参数中的function存入Chain实例的调用队列中。
例：

var c = new Chain
c.chain(function(){alert(1);});
c.chain(function(){alert(2);});
c.chain(function(){alert(3);});

c.callChain();// Alerts 1
c.callChain();// Alerts 2
c.callChain();// Alerts 3

callChain([args]):
args - mixed

调用Chain实例中的function，并返回该function的返回值。可以通过参数args给Chain中的function传递参数。

clearChain():

清除Chain中所有的function。返回值为Chain实例本身。

Class Extras:Events

For new classes:

var MyClass = new Class({ Implements: Events });

For existing classes:

MyClass.implement(Events);

Events类可以被实现到其它的类中，以增加其它类的功能。
Events类被设计为可以跟Options类很好的合作。当option的属性名以'on'开头并且后面跟着一个大写字母开头的单词时，这个option将被当用事件添加进来。（例如'onComplete'将被当用'complete'事件添加进来）
例：

var Widget = new Class({
    Implements: Events,
    initialize: function(element){
        // ...
    },
    complete: function(){
        this.fireEvent('complete');
    }
});
 
var myWidget = new Widget();
myWidget.addEvent('complete', myFunction);

addEvent(type, fn[, internal]):
type - string
fn - function
internal - boolean

给某个对象添加事件。添加事件时，第3个参数internal如果为true，该事件将不能被removeEvent、removeEvents方法移除。

addEvents(events):
events - object

通过键值对的形式给某个对象添加一系列事件。
例：

var myFx = new Fx.Tween('element', 'opacity');
myFx.addEvents({
    'start': myStartFunction,
    'complete': function() {
        alert('Done.');
    }
});

fireEvent(type[, args[, delay]]):
type - string
args - mixed
delay - number

触发某个事件。可以给该事件传递参数，如果参数不止一个，则需要用数组的形式。参数delay可以指定延迟事件所绑定的function执行的时间，单位为毫秒。
例：

var Widget = new Class({
    Implements: Events,
    complete: function(arg1, arg2){
        this.fireEvent("complete", [arg1, arg2], 500);
    }
});
var w = new Widget;
w.addEvent('complete', function(a,b){alert(a+b)});
w.complete(1,2);

removeEvent(type, fn):
type - string
fn - function

移除对象中某个类型的事件中指定的监听器。

removeEvents([events]):
events - mixed

移除对象中的事件监听器。参数可选。当不传参数时，移除所有事件的所有监听器；当参数为string类型时，移除指定类型事件的所有监听器；当参数为以事件类型为键、function为值的object类型时，移除该键值对中指定的所有事件监听器。

Class Extras: Options

For new classes:

var MyClass = new Class({Implements: Options});

For existing classes:

MyClass.implement(Options);

setOptions([options]):
options - object

给实现了Options的类的对象设置options。当option的属性名以'on'开头并且后面跟着一个大写字母开头的单词时，这个option将被当用事件添加进来。（例如'onComplete'将被当用'complete'事件添加进来）
例：

var Widget = new Class({
    Implements: Options,
    options: {
        color: '#fff',
        size: {
            width: 100,
            height: 100
        }
    },
    initialize: function(options){
        this.setOptions(options);
    }
});
 
var myWidget = new Widget({
    color: '#f00',
    size: {
        width: 200
    }
});
 
//myWidget.options is now: {color: #f00, size: {width: 200, height: 100}}

Element

window.$(el)
el - mixed

$的作用有两个：通过id获取页面上的元素；给IE浏览器的HTML元素添加所有Element的方法。如果参数el为element对象，并且该element对象还未被MooTools扩展，则该element对象将被扩展，否则直接返回该element；如果参数el为字符串，MooTools则会将其当作元素的id，并通过该id找到对应的元素，再扩展，返回扩展后的element，如果id不存在，则返回null；如果参数el为普通对象，并且该对象有一个toElement方法，则该对象的toElement方法将被调用，返回值为调用toElement后的element，如果对象没有toElement方法则返回null。

因为MooTools会自动检测一个element是否需要被扩展，所以$可以操作同一个element多次并且不会有任何问题。

window.$$(aTag[, anElement[, Elements[, ...]):
接受任意数量的以下类型参数：
HTMLCollection
elements数组
elements
作为选择器的字符串

返回值为一个各元素都被$扩展后的element数组。

constructor(element[, properties]):
element - mixed
properties - object

创建一个新的Element对象。参数element可以是一个Dom element，也可以是一个字符串（字符串用作元素标签名）。参数properties用于给Element对象添加属性。
例：

var myAnchor = new Element('a', {
    'href': 'http://mootools.net',
    'class': 'myClass',
    'html': 'Click me!',
    'styles': {
        'display': 'block',
        'border': '1px solid black'
    },
    'events': {
        'click': function(){
            alert('clicked');
        },
        'mouseover': function(){
            alert('mouseovered');
        }
    }
});

getElement(selector):
selector - string

获取element对象的第1个匹配selector的子元素。该方法同样适合于document对象。

getElements(selector):
selector - string
获取element对象所有匹配selector的子元素，以数组形式返回。

getElementById(id):
id - string
获取element对象中指定id的子元素。

set(arguments):
arguments - arguments

为element对象设置属性。当参数为两个时：
set(property, value):
property - string
value - mixed
例：

$('myElement').set('text', 'text goes here');
$('myElement').set('class', 'active');
//The 'styles' property passes the object to Element:setStyles.
var body = $(document.body).set('styles', {
    'font': '12px Arial',
    'color': 'blue'
});

当参数为一个对象时：
set(properties):
properties - object
例：

var myElement = $('myElement').set({
    //The 'styles' property passes the object to Element:setStyles.
    'styles': {
        'font': '12px Arial',
        'color': 'blue',
        'border': '1px solid #f00'
    },
    //The 'events' property passes the object to Element:addEvents.
    'events': {
        'click': function(){ alert('click'); },
        'mouseover': function(){ this.addClass('over') }
    },
    //Any other property uses Element:setProperty.
    'id': 'documentBody'
});

所有的property参数都将被传递给Element.Properties这个Hash中相应的方法。
如果在Element.Properties中没有找到相应的方法，则调用该element的setProperty方法。
使用Element.Properties来设置属性的时候，属性名请使用小写、简化的形式，例如：
使用'for'而不是 'htmlFor',
使用'class'而不是 'className'
使用'frameborder'而不是 'frameBorder'

get(property):
property - string
获取element对象的属性。

erase(property):
property - string
移除element对象的属性。

match(match)：
match - mixed
测试element对象是否与传进来的参数匹配。当参数match为字符串时，将被当作选择器来测试；当参数match为element对象时，如果与被测对象是同一对象（element == match），则返回true。

inject(el[, where]):
el - mixed
where - string

把element对象插入另一个element对象中。参数el可以是element对象，也可以是字符串。当参数el为字符串时表示要插入的element的id。 可以使用参数where指定插入的位置。可选项有：top、bottom、before、after。默认值为bottom。

grab(el[, where]):
el - mixed
where - string

往element对象中插入另一个element对象。

adopt(el[, others]):
el - mixed
others - mixed

和grab一样，但是可以同时往element对象中插入多个其它element对象（可以是数组形式，也可以是多个参数）。
例：

myParent.adopt(myFirstElement);
myParent2.adopt(myFirstElement, 'mySecondElement');
myParent3.adopt([myFirstElement, mySecondElement, myThirdElement]);

wraps(el[, where]):
el - mixed
where - string

和grab差不多，不同的是grab将被包围的element移动到包围它的element中；而wraps则是将包围element的对象移动到被包围的element的周围。

appentText(text[, where]):
text - string
where -string
也和grap差不多，所不同的是appentText接受的第一个参数不是一个element对象或者它的id，而是一段要往该element中插入的文本。

dispose():
从DOM中移除该element。返回值是element对象本身，以便重新将该element插入DOM中。

clone([contents, keepid]):
contents - boolean
keepid - boolean

复制element对象并返回。如果参数contents为true，复本将拥有被复制的element的子节点；否则仅复制element本身，不包括子节点。contents默认为true。参数keepid用于指定复本是否拥有原element的id属性（对所有子节点都有效），默认为false。

replaces(el):
el - mixed

替换指定的element对象。参数el可以是被替换的element，也可以是它的id。

hasClass(className):
className - string

判断element对象是否拥有指定的class。

addClass(className):
className - string

为elemenet对象添加一个class。

removeClass(className):
className - string

为elemenet对象移除一个class。

toggleClass(className):
className - string

如果element对象有指定的class，则移除它；否则添加指定的class。

getPrevious([match]):
match - string

获取element的上一个同级element。可用match设置条件，match是一个选择器。

getAllPrevious([match]):
match - string

和getPrevious()差不多，只是getAllPrevious返回一个匹配的所有element的数组，getPrevious只返回第一个匹配的element对象。

getNext([match]):
match - string

和getPrevious相反。

getAllNext([match]):
match - string

和getAllPrevious相反。

getFirst([match]):
match - string

返回第一个子节点。可用match设置过滤条件，match是一个选择器。

getLast([match]):
match - string

返回最后一个子节点。可用match设置过滤条件，match是一个选择器。

getParent([match]):
match - string

返回第一个父节点。可用match设置过滤条件，match是一个选择器。

getParents([match]):
match - string

返回所有父节点。可用match设置过滤条件，match是一个选择器。

getChildren([match]):
match - string

返回所有子节点。可用match设置过滤条件，match是一个选择器。

hasChild(el):
el - mixed

测试element对象是否有子对象el。el可以是一个element对象或者id。

empty():

清空element对象的所有子节点。

destroy():

删除element对象以及其子节点，并进行内存释放。返回null。

toQueryString():

根据element及其子节点的name和value转换成url的查询字符串。

getSelected():

获取select元素中被选中的option，以数组形式返回。

getProperty(property):
property - string

返回element的属性值。

getProperties(property1[, property2...]):
property - string

以键值对的形式返回element指定的属性集。

setProperty(name, value):

给element对象设置一个属性值。

setProperties(properties):
properties - object

给element对象设置一组属性值。

removeProperty(property):
property - string

移除element对象的某个属性。

removeProperties(property1[, property2...]):
property - string

移除element对象的一组属性。

store(key, value):
key - string
value - mixed

把key/value存在一个与该element相关联的一个hash里，相当于给element创建了一个自定义属性。store、retrieve以及eliminate是MooTools1.2新增的内容，详见：http://mootools.net/docs/core/Element/Element

retrieve(key):
key - string

把用store方法存进去的value用key取出来。

eliminate(key):
key - string

把用store方法存进去的整个键值对通过key删除。

Element.Properties

笔记先到此为止……进度太慢，明天起直接做东西。

评论

1 楼 贫嘴男孩 2010-05-31  

圆圆喜欢mootools啊