1. [代码][JavaScript]代码     
/*!
 * jLim Core
 *
 * jLim is a small JavaScript base code. It can be used to built your own
 * JavaScript library or framework.
 *
 * @version   0.1.1
 * @author    Victor Villaverde Laan
 * @link      http://www.freelancephp.net/jlim-small-javascript-framework/
 * @license   MIT license
 */
(function ( window ) {


/**
 * jLim function
 * @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
 * @param {string|DOM node|array of DOM nodes} context
 * @return {jLim} New instance
 */
var jLim = window.jLim = function ( selector, context ) {
return new jLim.core.init( selector, context );
};


// set $ global ( when not already exists )
if ( ! window.$ )
window.$ = jLim;


/**
 * jLim Core
 */
jLim.core = jLim.prototype = {


els: [],
selector: [],
context: [],


/**
* Init function, set selected elements
* @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
* @param {string|DOM node|array of DOM nodes} context  Optional, default is document
*/
init: function ( selector, context ) {
// set selector and context property
this.selector = selector || document;
this.context = context || document;


// get elements by selector
if ( typeof selector == ‘string‘ ) {
// trim spaces at the begin and end
selector = jLim.trim( selector );


if ( selector == ‘body‘ ) {
// set body
this.els = document.body;
} else if ( selector.substr( 0, 1 ) == ‘<‘ ) {
// create element
this.els = jLim.create( selector );
} else {
// find elements
this.els = jLim.selector( selector, context );
}
} else if ( jLim.isFunction( selector ) ) {
// set DOM ready function
jLim.ready( selector );
} else if ( selector instanceof jLim ) {
this.els = selector.get();
} else {
this.els = selector;
}


// make sure elements property is an array
if ( ! jLim.isArray( this.els ) )
this.els = this.els ? [ this.els ] : [];


// support for using jLim object as an array
// set indices
for ( var i in this.els )
this[ i ] = this.els[ i ];


// set length property
this.length = this.els.length;
},


/**
* Get element (return all current elements when no index given)
* @param {integer} index
* @return {DOM node|array of DOM nodes}
*/
get: function ( index ) {
if ( typeof index == ‘undefined‘ )
return this.els;


var el = ( index === -1 )
? this.els.slice( index )
: this.els.slice( index, +index + 1 );


return el.length ? el[0] : null;
},


/**
* Get count of current elements
* @return {integer}
*/
size: function () {
return this.els.length;
},


/**
* Call function for each element
* @param {function} fn
* @param {array} args
* @return {this} For chaining
*/
each: function ( fn, args ) {
jLim.each( this.els, fn, args );
return this;
},


/**
* Find elements within the current elements (context)
* @param {string} selector
* @return {jLim} Instance of new selection
*/http://www.huiyi8.com/css3/?
find: function ( selector ) {css3教程
return this.chain( selector, this.els );
},


/**
* Add to the current elements in a new created jLim object
* @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
* @param {string|DOM node|array of DOM nodes} context  Optional, when none is given it will use the context of current jLim object
* @return {jLim} Instance of new selection
*/
add: function ( selector, context ) {
var $new = this.chain( selector, context || this.context ),
els = this.els.concat( $new.get() );


$new.els = els;
return $new;
},


/**
* Set one of current elements as new jLim object
* @param {integer} index  Negative integer also possible, -1 means last item
* @return {jLim} Instance of new selection
*/
eq: function ( index ) {
return this.chain( this.get( index ) );
},


/**
* Set slice of current elements as new jLim object
* @param {integer} start  Like the first param of the standard Array.slice() function
* @param {integer} end  Like the second param of the standard Array.slice() function
* @return {jLim} Instance of new selection
*/
slice: function ( start, end ) {
var els = this.els.slice( start, end || this.els.length );
return this.chain( els );
},


/**
* Chain content as new jLim object
* @param {string|DOM node|array of DOM nodes} selector  When selector is not a string the context will be ignored
* @param {string|DOM node|array of DOM nodes} context  Optional
* @return {jLim} Instance of new selection
*/
chain: function ( selector, context ) {
var $new = jLim( selector, context );
$new.prevjLim = this;
return $new;
},


/**
* Set pointer to previous jLim object
* @return {jLim} Previous jLim object in the chain
*/
end: function () {
return this.prevjLim || jLim( null );
}


};


// init function gets core prototype
jLim.core.init.prototype = jLim.core;


/**
 * Extend method
 * @return {jLim|jLim.core|object|array|boolean}
 */
jLim.extend = jLim.core.extend = function () {
// target is current object if only one argument
var i = 0,
target = this,
deep = false,
obj, empty, item, x;


// check extending recursive (deep)
if ( typeof arguments[ 0 ] === ‘boolean‘ ) {
deep = true;
i = 1;


if ( arguments.length > 2 ) {
i = 2;
target = arguments[ 1 ];
}
} else if ( arguments.length > 1 ) {
i = 1;
target = arguments[ 0 ];
}


// loop through all source objects
for ( x = i; x < arguments.length; x++ ) {
obj = arguments[ x ];


// copy object items (properties and methods)
for ( item in obj ) {
if ( obj[ item ] === target )
continue;


if ( deep && typeof obj[ item ] == ‘object‘ && obj[ item ] !== null ) {
// item is also object, make copy
empty = jLim.isArray( obj[ item ] ) ? [] : {};
target[ item ] = jLim.extend( deep, target[ item ] || empty, obj[ item ] );
} else {
// copy property or method
target[ item ] = obj[ item ];
}
}
}


// return modified target
return target;
};


/**
 * Extent basic functions
 */
jLim.extend({


/**
* Selector method
* @param {string} selector
* @param {string|DOM node|array of DOM nodes} context  Default document
* @return {DOM node|array of DOM nodes|empty array}
*/
selector: function ( selector, context ) {
return jLim.$$( selector, context );
},


/**
* Add DOMReady callbacks
* @param {function|string} fn  When string will be run like code with eval()
* @return {this}
*/
ready: function ( fn ) {
// default use the DOMReady add() method
jLim.DOMReady.add( fn );


// return this for chaining
return this;
},


/**
* Create DOM element
* @param {string} html
* @return {DOM element|array of DOM elements}
*/
create: function ( html ) {
var ph = document.createElement( ‘div‘ ),
els = [];


ph.innerHTML = html;


// get created elements
els = ph.childNodes;


// return element or array of elements
return els.length == 1 ? els[0] : els;
},


/**
* Each function for arrays and objects
* @param {object|array} obj
* @param {function} fn
* @return {this}
*/
each: function ( obj, fn ) {
var item, retVal;


// call given function for each item
for ( item in obj ) {
retVal = fn.call( obj[ item ], item, obj[ item ] );


// do not continue further when return value is false
if ( retVal === false )
break;
}


// return this for chaining
return this;
},


/**
* Trim spaces
* @param {string} str
* @return {string}
*/
trim: function ( str ) {
return str.replace( /^\s+/, ‘‘ ).replace( /\s+$/, ‘‘ );
},


/**
* Check if argument is array
* @param {mixed} obj
* @return {boolean}
*/
isArray: function ( obj ) {
return ( Object.prototype.toString.call( obj ) === "[object Array]" );
},


/**
* Check if argument is function
* @param {mixed} obj
* @return {boolean}
*/
isFunction: function ( obj ) {
return ( Object.prototype.toString.call( obj ) === "[object Function]" );
}


});


/**
 * External components
 */


/**
 * DOMReady
 * 
 * @version   1.0
 * @link      http://www.freelancephp.net/domready-javascript-object-cross-browser/
 * @license   MIT license
 */
jLim.DOMReady=(function(){var fns=[],isReady=false,errorHandler=null,getFunc=function(fn){if(typeof fn==‘string‘)return function(){eval(fn);};return fn;},ready=function(){isReady=true;for(var x=0;x<fns.length;x++){try{fns[x]();}catch(err){if(errorHandler)errorHandler(err);}}};this.setOnError=function(fn){errorHandler=getFunc(fn);return this;};this.add=function(fn){fn=getFunc(fn);if(isReady){fn();}else{fns[fns.length]=fn;}return this;};if(window.addEventListener){document.addEventListener(‘DOMContentLoaded‘,function(){ready();},false);}else{(function(){if(!document.uniqueID&&document.expando)return;var tempNode=document.createElement(‘document:ready‘);try{tempNode.doScroll(‘left‘);ready();}catch(err){setTimeout(arguments.callee,0);}})();}return this;})();


/**
 * SS
 *
 * @version   0.1
 * @link      http://www.freelancephp.net/simple-css-selector-function/
 * @license   MIT license
 */
var $$=function(selector,context){var isObjType=function(o,type){return Object.prototype.toString.call(o)===‘[object ‘+type+‘]‘;},isDesc=function(d,a){return d.parentNode==a||d.tagName.toUpperCase()!=‘HTML‘&&isDesc(d.parentNode,a);},s=selector,c=context,els=[];s=s.split(‘,‘);c=isObjType(c,‘String‘)?$$(c):c&&c.length?c:document;if(!isObjType(c,‘Array‘))c=[c];for(var i in c){for(var j in s){var strim=s[j].replace(/\s+/g,‘‘),sp=s[j].split(‘ ‘),op=strim.substr(0,1),name=strim.substr(1),tels=[],nextContext;if(sp.length>1){nextContext=$$(sp[0],c[i]);tels=$$(sp.slice(1).join(‘ ‘),nextContext);els=els.concat(tels);}else if(op==‘#‘){tels[0]=c[i].getElementById?c[i].getElementById(name):document.getElementById(name);if(tels[0]&&isDesc(tels[0],c[i]))els.push(tels[0]);}else if(op==‘.‘){var expr=new RegExp(‘\\b‘+name+‘\\b‘),all=c[i].getElementsByTagName(‘*‘);for(var v=0,w=all.length;v<w;v++){if(expr.test(all[v].className))els.push(all[v]);}}else{tels=c[i].getElementsByTagName(strim);for(var y=0,z=tels.length;y<z;y++)els.push(tels[y]);}}}return els.length==1?els[0]:els;};
jLim.$$=$$;


})( window );