1.1 创建一个Rails应用程序
$ rails app_name
可选项:
-d, database=xxx 指定安装一个数据库(mysql oracle postgresql sqlite2 sqlite3 ), 默认情况下是数据库
-r, ruby-path= 指定Ruby的安装路径,如果没有指定，scripts使用env去找Ruby
-f, freeze (冻结)freezes Rails在vendor/rails目录

1.2 API Documentation
$ gem_server
启动一个WEBrick服务器。这时候你可以通过Http://localhost:8808/ 打开浏览器去查看rails API文档

1.3 Rake
rake db:fixtures:load
   # 载入fixtures到当前环境的数据库
   # 载入指定的fixtures使用FIXTURES=x,y
rake db:migrate
# 迁移数据库通过在db/migrate目录下的脚本.可以指定版本号通过VERSION=x
rake db:schema:dump
# 创建一个db/schema.rb文件，通过AR能过够支持任何数据库去使用
rake db:schema:load
# 再入一个schema.rb文件进数据库
rake db:sessions:clear
# 清空sessions表
rake db:sessions:create
# 用CGI::Session::ActiveRecordStore创建一个sessions表为用户
rake db:structure:dump
# 导出数据库结构为一个SQL文件
rake db:test:clone
# 重新创建一个测试数据库从当前环境数据库中
rake db:test:clone_structure
# 重新创建测试数据库从开发模式数据库
rake db:test:prepare
# 准备测试数据库并在入schema
rake db:test:purge
# 清空测试数据库
rake doc:app
# 创建HTML文件的API Documentation
rake doc:clobber_app
# 删除Documentation
rake doc:clobber_plugins
# 删除 plugin Documentation
rake doc:clobber_rails
# 删除Documentation
rake doc:plugins
# 产生Documation为所有安装的plugins
rake doc:rails
# 创建HTML文件的API Documentation
rake doc:reapp
# 强制重新创建HTML文件的API Documentation
rake doc:rerails
# 强制重新创建HTML文件的API Documentation
rake log:clear
# 清空目录log/下的所有日志文件
rake rails:freeze:edge
# Lock this application to latest Edge Rails. Lock a specific revision with REVISION=X
rake rails:freeze:gems
# Lock this application to the current gems (by unpacking them into vendor/rails)
rake rails:unfreeze
# Unlock this application from freeze of gems or edge and return to a fluid use of system gems
rake rails:update
# Update both scripts and public/javascripts from Rails
rake rails:update:javascripts
# Update your javascripts from your current rails install
rake rails:update:scripts
# Add new scripts to the application script/ directory
rake stats
# Report code statistics (KLOCs, etc) from the application
rake test
# Test all units and functionals
rake test:functionals
   # Run tests for functionalsdb:test:prepare
rake test:integration
# Run tests for integrationdb:test:prepare
rake test:plugins
# Run tests for pluginsenvironment
rake test:recent
# Run tests for recentdb:test:prepare
rake test:uncommitted
# Run tests for uncommitteddb:test:prepare
rake test:units
# Run tests for unitsdb:test:prepare
rake tmp:cache:clear
# 清空tmp/cache目录下的所有文件
rake tmp:clear
# 清空session, cache, 和socket文件从tmp/目录
rake tmp:create
# 为sessions, cache, and sockets创建tmp/目录
rake tmp:sessions:clear
# 清空所有在tmp/sessions目录下的文件
rake tmp:sockets:clear
# 清空所有在tmp/sessions 目录下的ruby_sess.* 文件

1.4 Scripts
script/about
# 输出当前环境信息
script/breakpointer
# 启动断点server
script/console
# 启动交换式的Rails控制台
script/destroy
# 删除通过generators创建的文件
script/generate
# -> generators
script/plugin
# -> Plugins
script/runner
# 执行一个任务在rails上下文中
script/server
# 启动开发模式服务器http://localhost:3000
//以下几个不知道怎么去使用
script/performance/profiler
script/performance/benchmarker
script/process/reaper
script/process/spawner

1.5 Generators
ruby script/generate model ModelName
ruby script/generate controller ListController show edit
ruby script/generate scaffold ModelName ControllerName
ruby script/generate migration AddNewTable
ruby script/generate plugin PluginName
ruby script/generate mailer Notification lost_password signup
ruby script/generate web_service ServiceName api_one api_two
ruby script/generate integration_test TestName
ruby script/generate session_migration
可选项:
-p, --pretend Run but do not make any changes.
-f, --force Overwrite files that already exist.
-s, --skip Skip files that already exist.
-q, --quiet Suppress normal output.
-t, --backtrace Debugging: show backtrace on errors.
-h, --help Show this help message.
-c, --svn Modify files with subversion. (Note: svn must be in path)

1.6 Plugins
script/plugin discover
# discover plugin repositories
script/plugin list
# list all available plugins
script/plugin install where
# install the a

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

问："如果你死后，你的墓志铭打算写点啥？"以下是一些牛人的暴笑回复： 

1、感谢政府为我解决了住房问题！
2、一居室，求合租，面议。
3、小事招魂，大事挖坟。
4、发布违规信息，永久封杀！ by GCD
5、我觉得我还可以抢救一下！
6、老子是被活埋的！曰！
7、广告位招租
8、提供鞭尸服务，一次100！
9、初从文，三年不中；后习武，校场发一矢，中鼓吏，逐之出；遂学医，有所成。自撰一良方，服之，卒。
10、基因重组中，请稍候……二十年
11、我生在中国，我葬在中国，祸不单行啊！
12、单挑冥王哈迪斯中，征求组队!(网游篇）
13、牧师，帮我复活一下下，谢谢，坐标××.××（网游篇）
14、当你看清这行字的时候：朋友，你踩到我了。
15、老子终于不用怕鬼了！
16、给爷笑一个，要不……爷给你笑一个？
17、神农氏的墓志铭：我靠！这草有毒！！！！！
18、这是我挖的最后一个坑（警告挖坑者）
19、摸骨算命
20、陪聊，提供夜间上门服务

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

/*
 * 定义一个全局对象, 属性 Version 在发布的时候会替换为当前版本号
 */
var Prototype = {
    Version: '1.5.0_rc0',
    ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

    emptyFunction: function()
    {
    },
    K: function(x)
    {
        return x
    }
}

/*
 * 创建一种类型，注意其属性 create 是一个方法，返回一个构造函数。
 * 一般使用如下 
 *     var X = Class.create();  返回一个类型，类似于 java 的一个Class实例。
 * 要使用 X 类型，需继续用 new X()来获取一个实例，如同 java 的 Class.newInstance()方法。
 *
 * 返回的构造函数会执行名为 initialize 的方法， initialize 是 Ruby 对象的构造器方法名字。
 * 此时initialize方法还没有定义，其后的代码中创建新类型时会建立相应的同名方法。
 *
 * 如果一定要从java上去理解。你可以理解为用Class.create()创建一个继承java.lang.Class类的类。当然java不允许这样做，因为Class类是final的
 *
 */
var Class = {
    create: function()
    {
        return function()
        {
            this.initialize.apply(this, arguments);
        }
    }
}

/*
 * 创建一个对象，从变量名来思考，本意也许是定义一个抽象类，以后创建新对象都 extend 它。
 * 但从其后代码的应用来看， Abstract 更多是为了保持命名空间清晰的考虑。
 * 也就是说，我们可以给 Abstract 这个对象实例添加新的对象定义。
 *
 * 从java去理解，就是动态给一个对象创建内部类。
 */
var Abstract = new Object();

/*
 * 获取参数对象的所有属性和方法，有点象多重继承。但是这种继承是动态获得的。
 * 如：
 *     var a = new ObjectA(), b = new ObjectB();
 *     var c = a.extend(b);
 * 此时 c 对象同时拥有 a 和 b 对象的属性和方法。但是与多重继承不同的是，c instanceof ObjectB 将返回false。
 */
Object.extend = function(destination, source)
{
    for (var property in source)
    {
        destination[property] = source[property];
    }
    return destination;
}

Object.inspect = function(object)
{
    try
    {
        if (object == undefined) return 'undefined';
        if (object == null) return 'null';
        return object.inspect ? object.inspect() : object.toString();
    }
    catch (e)
    {
        if (e instanceof RangeError) return '...';
        throw e;
    }
}

/*
 * 这个方法很有趣，它封装一个javascript函数对象，返回一个新函数对象，新函数对象的主体和原对象相同，但是bind()方法参数将被用作当前对象的对象。
 * 也就是说新函数中的 this 引用被改变为参数提供的对象。
 * 比如：
 *     <input type="text" id="aaa" value="aaa">
 *     <input type="text" id="bbb" value="bbb">
 *     .................
 *     <script>
 *         var aaa = document.getElementById("aaa");
 *         var bbb = document.getElementById("bbb");
 *         aaa.showValue = function() {alert(this.value);}
 *         aaa.showValue2 = aaa.showValue.bind(bbb);
 *     /script>
 *  那么，调用aaa.showValue 将返回"aaa", 但调用aaa.showValue2 将返回"bbb"。
 *
 * apply 是ie5.5后才出现的新方法(Netscape好像很早就支持了)。
 * 该方法更多的资料参考MSDN http://msdn.microsoft.com/library/en-us/script56/html/js56jsmthApply.asp
 * 还有一个 call 方法，应用起来和 apply 类似。可以一起研究下。
 */
Function.prototype.bind = function()
{
    var __method = this, args = $A(arguments), object = args.shift();
    return function()
    {
        return __method.apply(object, args.concat($A(arguments)));
    }
}

/*
 * 和bind一样，不过这个方法一般用做html控件对象的事件处理。所以要传递event对象
 * 注意这时候，用到了 Function.call。它与 Function.apply 的不同好像仅仅是对参数形式的定义。
 * 如同 java 两个过载的方法。
 */
Function.prototype.bindAsEventListener = function(object)
{
    var __method = this;
    return function(event)
    {
        return __method.call(object, event || window.event);
    }
}

/*
 * 将整数形式RGB颜色值转换为HEX形式
 */
Object.extend(Number.prototype, {
    toColorPart: function()
    {
        var digits = this.toString(16);
        if (this < 16) return '0' + digits;
        return digits;
    },

    succ: function()
    {
        return this + 1;
    },

    times: function(iterator)
    {
        $R(0, this, true).each(iterator);
        return this;
    }
});

/*
 * 典型 Ruby 风格的函数，将参数中的方法逐个调用，返回第一个成功执行的方法的返回值
 */
var Try = {
    these: function()
    {
        var returnValue;

        for (var i = 0; i < arguments.length; i++)
        {
            var lambda = arguments[i];
            try
            {
                returnValue = lambda();
                break;
            }
            catch (e)
            {
            }
        }

        return returnValue;
    }
}

/*--------------------------------------------------------------------------*/

/*
 * 一个设计精巧的定时执行器
 * 首先由 Class.create() 创建一个 PeriodicalExecuter 类型，
 * 然后用对象直接量的语法形式设置原型。
 *
 * 需要特别说明的是 rgisterCallback 方法，它调用上面定义的函数原型方法bind, 并传递自己为参数。
 * 之所以这样做，是因为 setTimeout 默认总以 window 对象为当前对象，也就是说，如果 registerCallback 方法定义如下的话：
 *     registerCallback: function() {
 *         setTimeout(this.onTimerEvent, this.frequency * 1000);
 *     }
 * 那么，this.onTimeoutEvent 方法执行失败，因为它无法访问 this.currentlyExecuting 属性。
 * 而使用了bind以后，该方法才能正确的找到this，也就是PeriodicalExecuter的当前实例。
 */
var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
    initialize: function(callback, frequency)
    {
        this.callback = callback;
        this.frequency = frequency;
        this.currentlyExecuting = false;

        this.registerCallback();
    },

    registerCallback: function()
    {
        setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
    },

    onTimerEvent: function()
    {
        if (!this.currentlyExecuting)
        {
            try
            {
                this.currentlyExecuting = true;
                this.callback();
            }
            finally
            {
                this.currentlyExecuting = false;
            }
        }
    }
}
Object.extend(String.prototype, {
    gsub: function(pattern, replacement)
    {
        var result = '', source = this, match;
        replacement = arguments.callee.prepareReplacement(replacement);

        while (source.length > 0)
        {
            if (match = source.match(pattern))
            {
                result += source.slice(0, match.index);
                result += (replacement(match) || '').toString();
                source = source.slice(match.index + match[0].length);
            }
            else
            {
                result += source,source = '';
            }
        }
        return result;
    },

    sub: function(pattern, replacement, count)
    {
        replacement = this.gsub.prepareReplacement(replacement);
        count = count === undefined ? 1 : count;

        return this.gsub(pattern, function(match)
        {
            if (--count < 0) return match[0];
            return replacement(match);
        });
    },

    scan: function(pattern, iterator)
    {
        this.gsub(pattern, iterator);
        return this;
    },

    truncate: function(length, truncation)
    {
        length = length || 30;
        truncation = truncation === undefined ? '...' : truncation;
        return this.length > length ?
               this.slice(0, length - truncation.length) + truncation : this;
    },

    strip: function()
    {
        return this.replace(/^\s+/, '').replace(/\s+$/, '');
    },

    stripTags: function()
    {
        return this.replace(/<\/?[^>]+>/gi, '');
    },

    stripScripts: function()
    {
        return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
    },

    extractScripts: function()
    {
        var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
        var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
        return (this.match(matchAll) || []).map(function(scriptTag)
        {
            return (scriptTag.match(matchOne) || ['', ''])[1];
        });
    },

    evalScripts: function()
    {
        return this.extractScripts().map(function(script)
        {
            return eval(script)
        });
    },

    escapeHTML: function()
    {
        var div = document.createElement('div');
        var text = document.createTextNode(this);
        div.appendChild(text);
        return div.innerHTML;
    },

    unescapeHTML: function()
    {
        var div = document.createElement('div');
        div.innerHTML = this.stripTags();
        return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
    },

    toQueryParams: function()
    {
        var pairs = this.match(/^\??(.*)$/)[1].split('&');
        return pairs.inject({}, function(params, pairString)
        {
            var pair = pairString.split('=');
            params[pair[0]] = pair[1];
            return params;
        });
    },

    toArray: function()
    {
        return this.split('');
    },

    camelize: function()
    {
        var oStringList = this.split('-');
        if (oStringList.length == 1) return oStringList[0];

        var camelizedString = this.indexOf('-') == 0
                ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
                : oStringList[0];

        for (var i = 1, len = oStringList.length; i < len; i++)
        {
            var s = oStringList[i];
            camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
        }

        return camelizedString;
    },

    inspect: function()
    {
        return "'" + this.replace(/\\/g, '\\\\').replace(/'/g, '\\\'') + "'";
    }
});

String.prototype.gsub.prepareReplacement = function(replacement)
{
    if (typeof replacement == 'function') return replacement;
    var template = new Template(replacement);
    return function(match)
    {
        return template.evaluate(match)
    };
}

String.prototype.parseQuery = String.prototype.toQueryParams;

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
    initialize: function(template, pattern)
    {
        this.template = template.toString();
        this.pattern = pattern || Template.Pattern;
    },

    evaluate: function(object)
    {
        return this.template.gsub(this.pattern, function(match)
        {
            var before = match[1];

            if (before == '\\') return match[2];
            return before + (object[match[3]] || '').toString();
        });
    }
}

var $break = new Object();
var $continue = new Object();

var Enumerable = {
    each: function(iterator)
    {
        var index = 0;
        try
        {
            this._each(function(value)
            {
                try
                {
                    iterator(value, index++);
                }
                catch (e)
                {
                    if (e != $continue) throw e;
                }
            });
        }
        catch (e)
        {
            if (e != $break) throw e;
        }
    },

    all: function(iterator)
    {
        var result = true;
        this.each(function(value, index)
        {
            result = result && !!(iterator || Prototype.K)(value, index);
            if (!result) throw $break;
        });
        return result;
    },

    any: function(iterator)
    {
        var result = true;
        this.each(function(value, index)
        {
            if (result = !!(iterator || Prototype.K)(value, index))
                throw $break;
        });
        return result;
    },

    collect: function(iterator)
    {
        var results = [];
        this.each(function(value, index)
        {
            results.push(iterator(value, index));
        });
        return results;
    },

    detect: function (iterator)
    {
        var result;
        this.each(function(value, index)
        {
            if (iterator(value, index))
            {
                result = value;
                throw $break;
            }
        });
        return result;
    },

    findAll: function(iterator)
    {
        var results = [];
        this.each(function(value, index)
        {
            if (iterator(value, index))
                results.push(value);
        });
        return results;
    },

    grep: function(pattern, iterator)
    {
        var results = [];
        this.each(function(value, index)
        {
            var stringValue = value.toString();
            if (stringValue.match(pattern))
                results.push((iterator || Prototype.K)(value, index));
        })
        return results;
    },

    include: function(object)
    {
        var found = false;
        this.each(function(value)
        {
            if (value == object)
            {
                found = true;
                throw $break;
            }
        });
        return found;
    },

    inject: function(memo, iterator)
    {
        this.each(function(value, index)
        {
            memo = iterator(memo, value, index);
        });
        return memo;
    },

    invoke: function(method)
    {
        var args = $A(arguments).slice(1);
        return this.collect(function(value)
        {
            return value[method].apply(value, args);
        });
    },

    max: function(iterator)
    {
        var result;
        this.each(function(value, index)
        {
            value = (iterator || Prototype.K)(value, index);
            if (result == undefined || value >= result)
                result = value;
        });
        return result;
    },

    min: function(iterator)
    {
        var result;
        this.each(function(value, index)
        {
            value = (iterator || Prototype.K)(value, index);
            if (result == undefined || value < result)
                result = value;
        });
        return result;
    },

    partition: function(iterator)
    {
        var trues = [], falses = [];
        this.each(function(value, index)
        {
            ((iterator || Prototype.K)(value, index) ?
             trues : falses).push(value);
        });
        return [trues, falses];
    },

    pluck: function(property)
    {
        var results = [];
        this.each(function(value, index)
        {
            results.push(value[property]);
        });
        return results;
    },

    reject: function(iterator)
    {
        var results = [];
        this.each(function(value, index)
        {
            if (!iterator(value, index))
                results.push(value);
        });
        return results;
    },

    sortBy: function(iterator)
    {
        return this.collect(function(value, index)
        {
            return {value: value, criteria: iterator(value, index)};
        }).sort(function(left, right)
        {
            var a = left.criteria, b = right.criteria;
            return a < b ? -1 : a > b ? 1 : 0;
        }).pluck('value');
    },

    toArray: function()
    {
        return this.collect(Prototype.K);
    },
    zip: function()
    {
        var iterator = Prototype.K, args = $A(arguments);
        if (typeof args.last() == 'function')
            iterator = args.pop();

        var collections = [this].concat(args).map($A);
        return this.map(function(value, index)
        {
            return iterator(collections.pluck(index));
        });
    },

    inspect: function()
    {
        return '#<Enumerable:' + this.toArray().inspect() + '>';
    }
}

Object.extend(Enumerable, {
    map:     Enumerable.collect,
    find:    Enumerable.detect,
    select:  Enumerable.findAll,
    member:  Enumerable.include,
    entries: Enumerable.toArray
});
var $A = Array.from = function(iterable)
{
    if (!iterable) return [];
    if (iterable.toArray)
    {
        return iterable.toArray();
    }
    else
    {
        var results = [];
        for (var i = 0; i < iterable.length; i++)
            results.push(iterable[i]);
        return results;
    }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
    Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
    _each: function(iterator)
    {
        for (var i = 0; i < this.length; i++)
            iterator(this[i]);
    },

    clear: function()
    {
        this.length = 0;
        return this;
    },

    first: function()
    {
        return this[0];
    },

    last: function()
    {
        return this[this.length - 1];
    },

    compact: function()
    {
        return this.select(function(value)
        {
            return value != undefined || value != null;
        });
    },

    flatten: function()
    {
        return this.inject([], function(array, value)
        {
            return array.concat(value && value.constructor == Array ?
                                value.flatten() : [value]);
        });
    },

    without: function()
    {
        var values = $A(arguments);
        return this.select(function(value)
        {
            return !values.include(value);
        });
    },

    indexOf: function(object)
    {
        for (var i = 0; i < this.length; i++)
            if (this[i] == object) return i;
        return -1;
    },

    reverse: function(inline)
    {
        return (inline !== false ? this : this.toArray())._reverse();
    },

    inspect: function()
    {
        return '[' + this.map(Object.inspect).join(', ') + ']';
    }
});
var Hash = {
    _each: function(iterator)
    {
        for (var key in this)
        {
            var value = this[key];

            if (typeof value == 'function') continue;

            var pair = [key, value];
            pair.key = key;
            pair.value = value;
            iterator(pair);
        }
    },

    keys: function()
    {
        return this.pluck('key');
    },

    values: function()
    {
        return this.pluck('value');
    },

    merge: function(hash)
    {
        return $H(hash).inject($H(this), function(mergedHash, pair)
        {
            mergedHash[pair.key] = pair.value;
            return mergedHash;
        });
    },

    toQueryString: function()
    {
        return this.map(function(pair)
        {
            return pair.map(encodeURIComponent).join('=');
        }).join('&');
    },

    inspect: function()
    {
        return '#<Hash:{' + this.map(function(pair)
        {
            return pair.map(Object.inspect).join(': ');
        }).join(', ') + '}>';
    }
}

function $H(object)
{
    var hash = Object.extend({}, object || {});
    Object.extend(hash, Enumerable);
    Object.extend(hash, Hash);
    return hash;
}
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
    initialize: function(start, end, exclusive)
    {
        this.start = start;
        this.end = end;
        this.exclusive = exclusive;
    },

    _each: function(iterator)
    {
        var value = this.start;
        do {
            iterator(value);
            value = value.succ();
        } while (this.include(value));
    },

    include: function(value)
    {
        if (value < this.start)
            return false;
        if (this.exclusive)
            return value < this.end;
        return value <= this.end;
    }
});

var $R = function(start, end, exclusive)
{
    return new ObjectRange(start, end, exclusive);
}

/*
 * 定义 Ajax 对象, 静态方法 getTransport 方法返回一个 XMLHttp 对象
 */
var Ajax = {
    getTransport: function()
    {
        return Try.these(
                function()
                {
                    return new XMLHttpRequest()
                },
                function()
                {
                    return new ActiveXObject('Msxml2.XMLHTTP')
                },
                function()
                {
                    return new ActiveXObject('Microsoft.XMLHTTP')
                }
                ) || false;
    },

    activeRequestCount: 0
}

Ajax.Responders = {
    responders: [],

    _each: function(iterator)
    {
        this.responders._each(iterator);
    },

    register: function(responderToAdd)
    {
        if (!this.include(responderToAdd))
            this.responders.push(responderToAdd);
    },

    unregister: function(responderToRemove)
    {
        this.responders = this.responders.without(responderToRemove);
    },

    dispatch: function(callback, request, transport, json)
    {
        this.each(function(responder)
        {
            if (responder[callback] && typeof responder[callback] == 'function')
            {
                try
                {
                    responder[callback].apply(responder, [request, transport, json]);
                }
                catch (e)
                {
                }
            }
        });
    }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
    onCreate: function()
    {
        Ajax.activeRequestCount++;
    },

    onComplete: function()
    {
        Ajax.activeRequestCount--;
    }
});

/*
 * 我以为此时的Ajax对象起到命名空间的作用。
 * Ajax.Base 声明为一个基础对象类型
 * 注意 Ajax.Base 并没有使用 Class.create() 的方式来创建，我想是因为作者并不希望 Ajax.Base 被库使用者实例化。
 * 作者在其他对象类型的声明中，将会继承于它。
 * 就好像 java 中的私有抽象类
 */
Ajax.Base = function()
{
};
Ajax.Base.prototype = {
    setOptions: function(options)
    {
        this.options = {
            method:       'post',
            asynchronous: true,
            contentType:  'application/x-www-form-urlencoded',
            parameters:   ''
        }
        Object.extend(this.options, options || {});
    },

    responseIsSuccess: function()
    {
        return this.transport.status == undefined
                || this.transport.status == 0
                || (this.transport.status >= 200 && this.transport.status < 300);
    },

    responseIsFailure: function()
    {
        return !this.responseIsSuccess();
    }
}

/*
 * Ajax.Request 封装 XmlHttp
 */
Ajax.Request = Class.create();

/*
 * 定义四种事件(状态)， 参考http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/readystate_1.asp
 */
Ajax.Request.Events =
['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
    initialize: function(url, options)
    {
        this.transport = Ajax.getTransport();
        this.setOptions(options);
        this.request(url);
    },

    request: function(url)
    {
        var parameters = this.options.parameters || '';
        if (parameters.length > 0) parameters += '&_=';

        try
        {
            this.url = url;
            if (this.options.method == 'get' && parameters.length > 0)

                this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

            Ajax.Responders.dispatch('onCreate', this, this.transport);

            /*
             * 此处好像强制使用了异步方式，而不是依照 this.options.asynchronous 的值
             */
            this.transport.open(this.options.method, this.url,
                    this.options.asynchronous);

            /*
             * 这里提供了 XmlHttp 传输过程中每个步骤的回调函数
             */
            if (this.options.asynchronous)
            {
                this.transport.onreadystatechange = this.onStateChange.bind(this);
                setTimeout((function()
                {
                    this.respondToReadyState(1)
                }).bind(this), 10);
            }

            this.setRequestHeaders();

            var body = this.options.postBody ? this.options.postBody : parameters;
            this.transport.send(this.options.method == 'post' ? body : null);

        }
        catch (e)
        {
            this.dispatchException(e);
        }
    },

    setRequestHeaders: function()
    {
        var requestHeaders =
                ['X-Requested-With', 'XMLHttpRequest',
                        'X-Prototype-Version', Prototype.Version,
                        'Accept', 'text/javascript, text/html, application/xml, text/xml, */*'];

        if (this.options.method == 'post')
        {
            requestHeaders.push('Content-type', this.options.contentType);

            if (this.transport.overrideMimeType)
                requestHeaders.push('Connection', 'close');
        }

        if (this.options.requestHeaders)
            requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

        for (var i = 0; i < requestHeaders.length; i += 2)
            this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i + 1]);
    },

    onStateChange: function()
    {
        var readyState = this.transport.readyState;
        /*
         * 如果不是 Loading 状态，就调用回调函数
         */
        if (readyState != 1)
            this.respondToReadyState(this.transport.readyState);
    },

    header: function(name)
    {
        try
        {
            return this.transport.getResponseHeader(name);
        }
        catch (e)
        {
        }
    },

    evalJSON: function()
    {
        try
        {
            return eval('(' + this.header('X-JSON') + ')');
        }
        catch (e)
        {
        }
    },
    evalResponse: function()
    {
        try
        {
            return eval(this.transport.responseText);
        }
        catch (e)
        {
            this.dispatchException(e);
        }
    },

/*
 * 回调函数定义在 this.options 属性中，比如:
 var option = {
 onLoaded : function(req) {...};
 ......
 }
 new Ajax.Request(url, option);
 */
    respondToReadyState: function(readyState)
    {
        var event = Ajax.Request.Events[readyState];
        var transport = this.transport, json = this.evalJSON();

        if (event == 'Complete')
        {
            try
            {
                (this.options['on' + this.transport.status]
                        || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
                        || Prototype.emptyFunction)(transport, json);
            }
            catch (e)
            {
                this.dispatchException(e);
            }

            if ((this.header('Content-type') || '').match(/^text\/javascript/i))
                this.evalResponse();
        }

        try
        {
            (this.options['on' + event] || Prototype.emptyFunction)(transport, json);
            Ajax.Responders.dispatch('on' + event, this, transport, json);
        }
        catch (e)
        {
            this.dispatchException(e);
        }

        if (event == 'Complete')

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

今年以来，在部分领导的耳濡目染下，公司一些部门及员工在日常工作 中 “非正式语言”使用频繁，造成部分员工自尊心受到伤害，工作萎靡不振、效率低下。鉴于公司的这种现状，为认真贯彻执行《公民道德建设实施纲要》，加强思公语言为重点和突破口，从即日起当遇到下列情况时，请务必用正式语言替代非正式语言。要求各部门负责人主动带头，严格贯彻执行。

情况一、没有时间

非正式：我他妈没空！ 正式：我真的很想帮你，可是我也好忙。

情况二、否定一项计划

非正式：大粪！全是大粪！ 正式：我不确定这样是否能顺利实施。

情况三、拒绝提供帮助

非正式：滚！ 正式：嗯，或许你可以问一下别人。

情况四、怀疑

非正式：扯JB蛋！ 正式：真的？

情况五、对他人观点持异议

非正式：你脑子里有屎啊！？ 正式：你可能不太了解这件事情。

情况六、同意他人观点

非正式：此屁有理！ 正式：我非常赞同你的观点。

情况七、被要求加班

非正式：你他妈要我干到几点？ 正式：也许我可以加班把它做完。

情况八、轻蔑

非正式：狗屁！ 正式：这倒很有意思。

情况九、接受任务

非正式：你他妈的怎么不早说？ 正式：我会试着把它加入到我的工作安排中。

情况十、拒绝任务

非正式：关我鸟事！ 正式：对不起，我一开始就没参与这个项目。

特此通知！

附：《公民道德建设实施纲要》

环球软件有限公司（公章）

报：董事长、总经理、副总经理、总监、各CXO

送：公司各部门

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

struts.action.extension
          The URL extension to use to determine if the request is meant for a Struts action
           用URL扩展名来确定是否这个请求是被用作Struts action，其实也就是设置 action的后缀，例如login.do的\'do\'字。

struts.configuration
          The org.apache.struts2.config.Configuration implementation class
            org.apache.struts2.config.Configuration接口名

struts.configuration.files
          A list of configuration files automatically loaded by Struts
           struts自动加载的一个配置文件列表

struts.configuration.xml.reload
          Whether to reload the XML configuration or not
           是否加载xml配置(true,false)

struts.continuations.package
           The package containing actions that use Rife continuations
           含有actions的完整连续的package名称

struts.custom.i18n.resources
          Location of additional localization properties files to load
           加载附加的国际化属性文件（不包含.properties后缀）

struts.custom.properties
          Location of additional configuration properties files to load
           加载附加的配置文件的位置

struts.devMode
          Whether Struts is in development mode or not
           是否为struts开发模式

struts.dispatcher.parametersWorkaround
          Whether to use a Servlet request parameter workaround necessary for some versions of WebLogic
            （某些版本的weblogic专用）是否使用一个servlet请求参数工作区（PARAMETERSWORKAROUND）

struts.enable.DynamicMethodInvocation
          Allows one to disable dynamic method invocation from the URL
            允许动态方法调用

struts.freemarker.manager.classname
          The org.apache.struts2.views.freemarker.FreemarkerManager implementation class
           org.apache.struts2.views.freemarker.FreemarkerManager接口名

struts.i18n.encoding
          The encoding to use for localization messages
           国际化信息内码

struts.i18n.reload
          Whether the localization messages should automatically be reloaded
           是否国际化信息自动加载

struts.locale
          The default locale for the Struts application
           默认的国际化地区信息

struts.mapper.class
          The org.apache.struts2.dispatcher.mapper.ActionMapper implementation class
            org.apache.struts2.dispatcher.mapper.ActionMapper接口

struts.multipart.maxSize
          The maximize size of a multipart request (file upload)
           multipart请求信息的最大尺寸（文件上传用）

struts.multipart.parser
          The org.apache.struts2.dispatcher.multipart.
          MultiPartRequest parser implementation for a multipart request (file upload)
          专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.MultiPartRequest解析器接口（文件上传用）

struts.multipart.saveDir
          The directory to use for storing uploaded files
           设置存储上传文件的目录夹

struts.objectFactory
          The com.opensymphony.xwork2.ObjectFactory implementation class
           com.opensymphony.xwork2.ObjectFactory接口（spring）

struts.objectFactory.spring.autoWire
          Whether Spring should autoWire or not
           是否自动绑定Spring

struts.objectFactory.spring.useClassCache
          Whether Spring should use its class cache or not
           是否spring应该使用自身的cache

struts.objectTypeDeterminer
          The com.opensymphony.xwork2.util.ObjectTypeDeterminer implementation class
            com.opensymphony.xwork2.util.ObjectTypeDeterminer接口

struts.serve.static.browserCache
  If static content served by the Struts filter should set browser caching header properties or not