删除 core 文件

# find ~ -name core -exec file {} \; -exec rm -i {} \;

查看使用文件的进程

# fuser -u /usr/my_application/foo

搜索字符串

#grep "hello world" `find ./ -name "*" -print -exec file {} \; |grep text | cut -d ':' -f 1`

目录

#alias dir='ls -Lla|grep ^d'

输出 IP 地址

#ifconfig | grep "inet addr" | grep -v "127.0.0.1" | awk '{print $2;}' | awk -F':' '{print $2;}'

按文件长度排序

#ls -l | grep ^- | sort -nr -k 5 | more

#ls -lR | grep ^- | sort -nr -k 5 | more

二进制文件中的可打印字符

# strings name of binary file

一个月的最后一个星期天执行任务：

18 * * * 0 [`date "+%d"` -gt 24] && /path/to/script

修改扩展名：

# for f in *.abc; do mv $f `basename $f .abc`.def ; done

查看硬盘情况：(Solaris)

# iostat -En

整个目录树拷贝：

# cd

# find . -depth -print | cpio -pudm

按长度排序目录下所有文件

# du -a | sort -n -r | more

检查文件内每行是否有相同列数

#awk '{print NF}' test.txt |sort -nu|more

去除空行

#sed -e '/^[ ]*$/d' InputFile >OutputFile

查看进程占用的对应文件 inode 号(Solaris)

#/usr/proc/bin/pfiles

删除指定用户的所有进程

# kill -9 `ps -fu username |awk '{ print $2 }'|grep -v PID`

Bash 操作快捷键：

ctrl-l -- clear screen

ctrl-r -- does a search in the previously given commands so that you don't

have to repeat long command.

ctrl-u -- clears the typing before the hotkey.

ctrl-a -- takes you to the begining of the command you are currently typing.

ctrl-e -- takes you to the end of the command you are currently typing in.

esc-b -- takes you back by one word while typing a command.

ctrl-c -- kills the current command or process.

ctrl-d -- kills the shell.

ctrl-h -- deletes one letter at a time from the command you are typing in.

ctrl-z -- puts the currently running process in background, the process

can be brought back to run state by using fg command.

esc-p -- like ctrl-r lets you search through the previously given commands.

esc-. -- gives the last command you typed.

文件名里的空格替换为下划线

# for i in $1 ; do mv "$i" `echo $i | sed 's/ /_/g'` ; done

查看远程主机时间

# telnet remotehostname 13|grep :

只显示 top 命令的states 行

#while true; do top -d 2 | col -b | grep states; sleep 10; done

加速显示　tar 文件内容

# tar tvfn

让 目录名也能　Spell Check

#shopt -s cdspell

当输错命令时，系统会自动进入类似的目录

查看　Sun 服务器型号

# /usr/platform/`uname -m`/sbin/prtdiag -v | grep `uname -m`

在vi 中一行文字前后添加字符

:/^\(.*\)/s//我要 \1 添加/

查找某包含字符串(Verita)软件包的详细信息 (Solaris)

pkginfo -l `pkginfo | grep -i VERITAS | awk '{print $2}'`

Sun 的一大堆脚本

http://www.sun.com/bigadmin/scripts/index.html 

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

module ActiveRecord
  # Active Record automatically timestamps create and update operations if the table has fields
  # named created_at/created_on or updated_at/updated_on.
  #
  # Timestamping can be turned off by setting
  #   <tt>ActiveRecord::Base.record_timestamps = false</tt>
  #
  # Timestamps are in the local timezone by default but can use UTC by setting
  #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
  module Timestamp
    def self.included(base) #:nodoc:
      base.alias_method_chain :create, :timestamps
      base.alias_method_chain :update, :timestamps
值得注意的是 :create , :update 这两个方法均为实例方法，它和类方法 :create ,:update 重名，但最终类方法也要去掉实例的:create 和 :update方法。

   这里并不是把实例方法用别名定义为类方法。   再说也不可能把实例方法定义为类方法
。
base.class_inheritable_accessor :record_timestamps, :instance_writer => false
      base.record_timestamps = true
    end

    private
      def create_with_timestamps #:nodoc:
        if record_timestamps
          t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
          write_attribute('created_at', t) if respond_to?(:created_at) && created_at.nil?
          write_attribute('created_on', t) if respond_to?(:created_on) && created_on.nil?

          write_attribute('updated_at', t) if respond_to?(:updated_at)
          write_attribute('updated_on', t) if respond_to?(:updated_on)
        end
        create_without_timestamps
      end

      def update_with_timestamps #:nodoc:
        if record_timestamps
          t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
          write_attribute('updated_at', t) if respond_to?(:updated_at)
          write_attribute('updated_on', t) if respond_to?(:updated_on)
        end
        update_without_timestamps
      end
  end
end

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

Math Object Methods

FF: Firefox, N: Netscape, IE: Internet Explorer
Method 	Description 	FF 	N 	IE
abs(x) 	Returns the absolute value of a number 	1 	2 	3
acos(x) 	Returns the arccosine of a number 	1 	2 	3
asin(x) 	Returns the arcsine of a number 	1 	2 	3
atan(x) 	Returns the arctangent of x as a numeric value between -PI/2 and PI/2 radians 	1 	2 	3
atan2(y,x) 	Returns the angle theta of an (x,y) point as a numeric value between -PI and PI radians 	1 	2 	3
ceil(x) 	Returns the value of a number rounded upwards to the nearest integer 	1 	2 	3
cos(x) 	Returns the cosine of a number 	1 	2 	3
exp(x) 	Returns the value of Ex 	1 	2 	3
floor(x) 	Returns the value of a number rounded downwards to the nearest integer 	1 	2 	3
log(x) 	Returns the natural logarithm (base E) of a number 	1 	2 	3
max(x,y) 	Returns the number with the highest value of x and y 	1 	2 	3
min(x,y) 	Returns the number with the lowest value of x and y 	1 	2 	3
pow(x,y) 	Returns the value of x to the power of y 	1 	2 	3
random() 	Returns a random number between 0 and 1 	1 	2 	3
round(x) 	Rounds a number to the nearest integer 	1 	2 	3
sin(x) 	Returns the sine of a number 	1 	2 	3
sqrt(x) 	Returns the square root of a number 	1 	2 	3
tan(x) 	Returns the tangent of an angle 	1 	2 	3
toSource() 	Represents the source code of an object 	1 	4 	-
valueOf() 	Returns the primitive value of a Math object 	1 	2 	4

Math Object Properties
Property 	Description 	FF 	N 	IE 
constructor 	A reference to the function that created the object 	1 	2 	4
E 	Returns Euler's constant (approx. 2.718) 	1 	2 	3
LN2 	Returns the natural logarithm of 2 (approx. 0.693) 	1 	2 	3
LN10 	Returns the natural logarithm of 10 (approx. 2.302) 	1 	2 	3
LOG2E 	Returns the base-2 logarithm of E (approx. 1.414) 	1 	2 	3
LOG10E 	Returns the base-10 logarithm of E (approx. 0.434) 	1 	2 	3
PI 	Returns PI (approx. 3.14159) 	1 	2 	3
prototype 	Allows you to add properties and methods to the object 	1 	2 	4
SQRT1_2 	Returns the square root of 1/2 (approx. 0.707) 	1 	2 	3
SQRT2 	Returns the square root of 2 (approx. 1.414) 	1 	2 	3

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

require 'redcloth'       #在application_helper 文件头引入redcloth

       用于页中生成相应textarea框的jstoolbar方法。
  def wikitoolbar_for(field_id)
    help_link = "文本格式化" + ': ' +
      link_to("帮助", compute_public_path('wiki_syntax', 'help', 'html'),
                              :onclick => "window.open(\"#{ compute_public_path('wiki_syntax', 'help', 'html') }\", \"\", \"resizable=yes, location=no, 
width=300, height=640, menubar=no, status=no, scrollbars=yes\"); return false;")

    javascript_include_tag('jstoolbar/jstoolbar') +
      javascript_include_tag("jstoolbar/lang/jstoolbar-zh") +
      javascript_tag("var toolbar = new jsToolBar($('#{field_id}')); toolbar.setHelpLink('#{help_link}'); toolbar.draw();")
  end
  
     在view中格式化要显示的文本.
  def textilizable(text)
    RedCloth.new(h(text)).to_html
  end

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

      # ==== Relying on named routes
      #
      # If you instead of a hash pass a record (like an Active Record or Active Resource) as the options parameter,
      # you'll trigger the named route for that record. The lookup will happen on the name of the class. So passing
      # a Workshop object will attempt to use the workshop_path route. If you have a nested route, such as 
      # admin_workshop_path you'll have to call that explicitly (it's impossible for url_for to guess that route). 
      #

有这样一个路由：
map.show_forums_topic '/forums/:forum_id/topics/:topic_id/', :controller=>'topic', :action=>'show'
我们就可以用来映射到些地址：
redirect_to show_forums_topic(@forums,@topic)
或者编辑：redirect_to edit_forums_topic(@forums,@topic)

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

difference = Time.now - time
    seconds    =  difference % 60
    difference = (difference - seconds) / 60
    minutes    =  difference % 60
    difference = (difference - minutes) / 60
    hours      =  difference % 24
    difference = (difference - hours)   / 24
    days       =  difference % 7
    difference = (difference - days)    /  7
    weeks      =  difference % 4
    difference = (difference - weeks)   / 4
    months     =  difference % 12
    years      = (difference - months)  / 12

puts "(#{years} years , #{months} months ,#{weeks} weeks, #{days} days, #{hours}:#{minutes}:#{seconds})"

def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
        from_time = from_time.to_time if from_time.respond_to?(:to_time)
        to_time = to_time.to_time if to_time.respond_to?(:to_time)
        distance_in_minutes = (((to_time - from_time).abs)/60).round
        distance_in_seconds = ((to_time - from_time).abs).round

        case distance_in_minutes
          when 0..1
            return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
            case distance_in_seconds
              when 0..4   then 'less than 5 seconds'
              when 5..9   then 'less than 10 seconds'
              when 10..19 then 'less than 20 seconds'
              when 20..39 then 'half a minute'
              when 40..59 then 'less than a minute'
              else             '1 minute'
            end

          when 2..44           then "#{distance_in_minutes} minutes"
          when 45..89          then 'about 1 hour'
          when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
          when 1440..2879      then '1 day'
          when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
          when 43200..86399    then 'about 1 month'
          when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
          when 525600..1051199 then 'about 1 year'
          else                      "over #{(distance_in_minutes / 525600).round} years"
        end
      end

  #相对现在来格式化时间
  def time_ago_in_words_zh(from_time, include_seconds = false)
    distance_of_time_in_words(from_time,Time.now,include_seconds)
  end
  
  def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
    from_time = from_time.to_time if from_time.respond_to?(:to_time)
    to_time = to_time.to_time if to_time.respond_to?(:to_time)
    distance_in_minutes = (((to_time - from_time).abs)/60).round
    distance_in_seconds = ((to_time - from_time).abs).round

    case distance_in_minutes
      when 0..1
        return ' 1 分钟' unless include_seconds
        case distance_in_seconds
          when 0..4   then ' 5 秒'
          when 5..9   then ' 10 秒'
          when 10..19 then ' 20 秒'
          when 20..39 then ' 半分钟'
          else             ' 1 分钟'
        end

      when 2..44           then " #{distance_in_minutes} 分钟"
      when 45..1439        then " #{(distance_in_minutes.to_f / 60.0).round} 小时"
      when 1440..2879      then ' 昨天'
      when 2880..4319      then ' 前天'
      when 4320..43199     then " #{(distance_in_minutes / 1440).round} 天"
      when 43200..525599   then " #{(distance_in_minutes / 43200).round} 个月"
      else                      " #{(distance_in_minutes / 525600).round} 年"
    end
  end

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

project issue  : 一对多
issue comment : 一对多
comment history : 一对多
Project ［1］ <---- [n] issue (1) <---- (n) comment [1] <---- [n] history

class Project
  has_many :issues
end

class Issue
  belongs_to :project
  has_many :cccc      # cccc  为了区别后面的名称不致混淆

#在issue中创建一条与之对应的comment,这里用实例变量为了方便在issue保存的时候也一同保存comment的信息。
  def init_comment(content = "")
    @current_comment ||= Comment.new(:resource => self, :creater => current_user, :content => content)
    @issue_before_change = self.clone
    @current_comment
  end
  
#issue保存的时候一同保存comment，以及histories的信息。
##这里需要注意的是，要保证histories表中的comment_id(histories表中与comment关联的外键) `comment_id` int(11) default '0', 必需设置一个默认值，否则将不能保存comment 和 history的信息。
  def before_save
    if @current_comment
      # attributes changes
      (Issue.column_names - %w(id content resource_id resource_type)).each {|c|
        @current_comment.histories << History.new(:property=>c,
                                                  :comment => @current_comment,
                                                  :old_value => @issue_before_change.send(c),
                                                  :value => send(c)) unless send(c)==@issue_before_change.send(c)
      }
      @current_comment.save
    end
    # Save the issue even if the comment is not saved (because empty)
    true
  end

end

class Comment
  belongs_to :issue
  has_many :histories
end

class History
  belongs_to :comment
end

Project.find(:first,:include =>[{ :issue => { :cccc => { :histories => :comment }}}]
注意，include中的关联的名称要对应好。

API 中的相关使用介绍
To include a deep hierarchy of associations, use a hash:

  for post in Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ])

That‘ll grab not only all the comments but all their authors and gravatar pictures. You can mix and match symbols, arrays and hashes in any combination to describe the associations you want to load.

All of this power shouldn‘t fool you into thinking that you can pull out huge amounts of data with no performance penalty just because you‘ve reduced the number of queries. The database still needs to send all the data to Active Record and it still needs to be processed. So it‘s no catch-all for performance problems, but it‘s a great way to cut down on the number of queries in a situation as the one described above.

Since the eager loading pulls from multiple tables, you‘ll have to disambiguate any column references in both conditions and orders. So :order => "posts.id DESC" will work while :order => "id DESC" will not. Because eager loading generates the SELECT statement too, the :select option is ignored.

You can use eager loading on multiple associations from the same table, but you cannot use those associations in orders and conditions as there is currently not any way to disambiguate them. Eager loading will not pull additional attributes on join tables, so "rich associations" with has_and_belongs_to_many are not a good fit for eager loading.

When eager loaded, conditions are interpolated in the context of the model class, not the model instance. Conditions are lazily interpolated before the actual model exists. 

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

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

class Sku < ActiveRecord::Base

  has_and_belongs_to_many :records,
      :delete_sql=>'DELETE FROM skus_records WHERE sku_id= \'#{id}\' AND record_id = #{record.id}',
      :before_remove=>:record_removed_info,
      :insert_sql =>'insert into skus_records (sku_id,record_id,createdOn) values (\'#{id}\',#{record.id},now())'

end

class Record < ActiveRecord::Base
  has_and_belongs_to_many :skus,
      :delete_sql=>'DELETE FROM skus_records WHERE sku_id= \'#{record.id}\' AND record_id = #{id}',
      :before_remove=>:record_removed_info,
      :insert_sql =>'insert into skus_records (sku_id,record_id,createdOn) values (\'#{record.id}\',#{id},now())' 

end

sku_models = []
[1,2,3,4,5,6,7].each do |id|
sku = Sku.find_by_skuid(id)
sku_models << sku unless sku.nil?
end
record_m = Record.find(224)
record_m.skus.concat(sku_models) unless record_m.nil?   # 向 record 224 的记录添加多个sku的信息。

record_m.skus.delete(sku_models)  # 从 record 224中删除指定的sku的对应关系。

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

1. 1. Business logics can be implemented as simple Web applications, or ruby code, whether it's called asynchronously or synchronously.
2. 2. Asynchronous messaging is reliable by RDBMS persistence (now MySQL only) or file persistence, under the favor of reliable-msg.
3. 3. Load balancing over multiple AP4R processes on single/multiple server(s) is supported.
4. 4. Asynchronous logics are called via various protocols, such as XML-RPC, SOAP, HTTP POST, and more.

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

<% form_tag "/purchase/save_order" do -%>
<p><label for="order_name">订单:</label><%= text_field :order, :name %></p>
<p>物 品:    <%= link_to_remote "增加物品",
                     :update => 'mat',
                     :url => {:action => :add_field },
                     :position => 'bottom' %></p>
<div id="mat">
    <%= render :partial => 'mat_input' %>
</div>
<p><%= submit_tag "提 交", :class => "submit" %></p>
controller:
def save_order
    begin
      @order = Order.new(params[:order])
      total = params[:invoice].length
      params[:invoice].each do |invoice|
        @invoice = Invoice.new(invoice)
        @order.invoices << @invoice
      end
      if request.post? and @order.save
        flash[:notice] = "#{total}条物品记录已保存"
      end
    rescue
      raise
    end
    redirect_to(:action => "index")
end

def add_field
    render :partial => 'mat_input'
end

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

在使用 rail 中的 自动完成功能 auto_complete_field时，假若返回的页面中有 javascript脚本，那它将不会被返回。 必需把它用 javascript_function 方法进行改写。
a.rhtml 中 render _b.rhtml 页面。 在_b.rhtml中如果包含了 javascript脚本，则不能被render到a.rhtml中。

我在_b.rhtml中用了auto_complete_field来对用户输入进去提示。因为auto_complete_result 返回的已经是javascript脚本了，就不能把javascript发送给客户端。

在application_helper.rb中覆盖此方法：不返回javascript脚本，把结果放到_b.rhtml中 用javascript_function方法把脚本输出到客户端。

  def auto_complete_field_no_javascript_tag(field_id, options = {})
    function =  "var #{field_id}_auto_completer = new Ajax.Autocompleter("
    function << "'#{field_id}', "
    function << "'" + (options[:update] || "#{field_id}_auto_complete") + "', "
    function << "'#{url_for(options[:url])}'"

    js_options = {}
    js_options[:tokens] = array_or_string_for_javascript(options[:tokens]) if options[:tokens]
    js_options[:callback]   = "function(element, value) { return #{options[:with]} }" if options[:with]
    js_options[:indicator]  = "'#{options[:indicator]}'" if options[:indicator]
    js_options[:select]     = "'#{options[:select]}'" if options[:select]
    js_options[:paramName]  = "'#{options[:param_name]}'" if options[:param_name]
    js_options[:frequency]  = "#{options[:frequency]}" if options[:frequency]

    { :after_update_element => :afterUpdateElement, 
      :on_show => :onShow, :on_hide => :onHide, :min_chars => :minChars }.each do |k,v|
      js_options[v] = options[k] if options[k]
  end

    function << (', ' + options_for_javascript(js_options) + ')')

    function
  end

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

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

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

MySql的字符串函数

ASCII(str)
    返回字符串str的最左面字符的ASCII代码值。如果str是空字符串，返回0。如果str是NULL，返回NULL。

    mysql> select ASCII('2');
              -> 50
    mysql> select ASCII(2);
              -> 50
    mysql> select ASCII('dx');
              -> 100

    也可参见ORD()函数。
ORD(str)
    如果字符串str最左面字符是一个多字节字符，通过以格式((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]返回字符的ASCII代码值来返回多字节字符代码。如果最左面的字符不是一个多字节字符。返回与ASCII()函数返回的相同值。

    mysql> select ORD('2');
              -> 50
     

CONV(N,from_base,to_base)
    在不同的数字基之间变换数字。返回数字N的字符串数字，从from_base基变换为to_base基，如果任何参数是NULL，返回NULL。参数N解释为一个整数，但是可以指定为一个整数或一个字符串。最小基是2且最大的基是36。如果to_base是一个负数，N被认为是一个有符号数，否则，N被当作无符号数。 CONV以64位点精度工作。

    mysql> select CONV("a",16,2);
              -> '1010'
    mysql> select CONV("6E",18,8);
              -> '172'
    mysql> select CONV(-17,10,-18);
              -> '-H'
    mysql> select CONV(10+"10"+'10'+0xa,10,10);
              -> '40'
     

BIN(N)
    返回二进制值N的一个字符串表示，在此N是一个长整数(BIGINT)数字，这等价于CONV(N,10,2)。如果N是NULL，返回NULL。

    mysql> select BIN(12);
              -> '1100'

OCT(N)
    返回八进制值N的一个字符串的表示，在此N是一个长整型数字，这等价于CONV(N,10,8)。如果N是NULL，返回NULL。

    mysql> select OCT(12);
              -> '14'
     

HEX(N)
    返回十六进制值N一个字符串的表示，在此N是一个长整型(BIGINT)数字，这等价于CONV(N,10,16)。如果N是NULL，返回NULL。

    mysql> select HEX(255);
              -> 'FF'
     

CHAR(N,...)
    CHAR()将参数解释为整数并且返回由这些整数的ASCII代码字符组成的一个字符串。NULL值被跳过。

    mysql> select CHAR(77,121,83,81,'76');
              -> 'MySQL'
    mysql> select CHAR(77,77.3,'77.3');
              -> 'MMM'
     

CONCAT(str1,str2,...)
    返回来自于参数连结的字符串。如果任何参数是NULL，返回NULL。可以有超过2个的参数。一个数字参数被变换为等价的字符串形式。

    mysql> select CONCAT('My', 'S', 'QL');
              -> 'MySQL'
    mysql> select CONCAT('My', NULL, 'QL');
              -> NULL
    mysql> select CONCAT(14.3);
              -> '14.3'

LENGTH(str)
    　 
OCTET_LENGTH(str)
    　 
CHAR_LENGTH(str)
    　 
CHARACTER_LENGTH(str)
    返回字符串str的长度。

    mysql> select LENGTH('text');
              -> 4
    mysql> select OCTET_LENGTH('text');
              -> 4

    注意，对于多字节字符，其CHAR_LENGTH()仅计算一次。
LOCATE(substr,str)
    　 
POSITION(substr IN str)
    返回子串substr在字符串str第一个出现的位置，如果substr不是在str里面，返回0.

    mysql> select LOCATE('bar', 'foobarbar');
              -> 4
    mysql> select LOCATE('xbar', 'foobar');
              -> 0

    该函数是多字节可靠的。  

LOCATE(substr,str,pos)
    返回子串substr在字符串str第一个出现的位置，从位置pos开始。如果substr不是在str里面，返回0。

    mysql> select LOCATE('bar', 'foobarbar',5);
              -> 7

    这函数是多字节可靠的。
INSTR(str,substr)
    返回子串substr在字符串str中的第一个出现的位置。这与有2个参数形式的LOCATE()相同，除了参数被颠倒。

    mysql> select INSTR('foobarbar', 'bar');
              -> 4
    mysql> select INSTR('xbar', 'foobar');
              -> 0

    这函数是多字节可靠的。
LPAD(str,len,padstr)
    返回字符串str，左面用字符串padstr填补直到str是len个字符长。

    mysql> select LPAD('hi',4,'??');
              -> '??hi'
     

RPAD(str,len,padstr)
    返回字符串str，右面用字符串padstr填补直到str是len个字符长。    

    mysql> select RPAD('hi',5,'?');
              -> 'hi???'

LEFT(str,len)
    返回字符串str的最左面len个字符。

    mysql> select LEFT('foobarbar', 5);
              -> 'fooba'

    该函数是多字节可靠的。
RIGHT(str,len)
    返回字符串str的最右面len个字符。

    mysql> select RIGHT('foobarbar', 4);
              -> 'rbar'

    该函数是多字节可靠的。
SUBSTRING(str,pos,len)
    　 
SUBSTRING(str FROM pos FOR len)
    　 
MID(str,pos,len)
    从字符串str返回一个len个字符的子串，从位置pos开始。使用FROM的变种形式是ANSI SQL92语法。

    mysql> select SUBSTRING('Quadratically',5,6);
              -> 'ratica'

    该函数是多字节可靠的。
SUBSTRING(str,pos)
    　 
SUBSTRING(str FROM pos)
    从字符串str的起始位置pos返回一个子串。

    mysql> select SUBSTRING('Quadratically',5);
              -> 'ratically'
    mysql> select SUBSTRING('foobarbar' FROM 4);
              -> 'barbar'

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

mysql>select sum(if(locate(',watch,',concat(",",seokeyword,","))>0,1,0)) as watch,sum(if(locate(',fashion watch,',concat(',',seokeyword,',')>0,1,0)) as `fashion watch` 
from uxcell_channels;

+-------+---------------+
| watch | fashion watch |
+-------+---------------+
|   928 |           501 | 
+-------+---------------+

ux.first.attributes
ux.first.attributes.keys

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

用   WHERE   和   HAVING   筛选行  
  SELECT   语句中的   WHERE   和   HAVING   子句控制用源表中的那些行来构造结果集。WHERE   和   HAVING   是筛选。这两个子句指定指定一系列搜索条件，只有那些满足搜索条件的行才用来构造结果集。我们称满足搜索条件的行符合参与行集的限定条件。例如，下列   SELECT   语句中的   WHERE   子句将限定只选择地区为华盛顿州   (WA)   的行：  
   
  SELECT   CustomerID,   CompanyName  
  FROM   Northwind.dbo.Customers  
  WHERE   Region   =   'WA'  
   
  HAVING   子句通常与   GROUP   BY   子句结合使用，尽管指定该子句时也可以不带   GROUP   BY。HAVING   子句指定在应用   WHERE   子句的筛选后要进一步应用的筛选。例如，下列   WHERE   子句仅限定以高于   $100   的单价销售产品的订单，而   HAVING   子句进一步将结果限制为只包括   100   件以上的订单：  
   
  SELECT   OrdD1.OrderID   AS   OrderID,  
                SUM(OrdD1.Quantity)   AS   "Units   Sold",  
                SUM(OrdD1.UnitPrice   *   OrdD1.Quantity)   AS   Revenue  
  FROM   [Order   Details]   AS   OrdD1  
  WHERE   OrdD1.OrderID   in   (SELECT   DISTINCT   OrdD2.OrderID  
                                                  FROM   [Order   Details]   AS   OrdD2  
                                                  WHERE   OrdD2.UnitPrice   >   $100)  
  GROUP   BY   OrdD1.OrderID  
  HAVING   SUM(OrdD1.Quantity)   >   100  
   
  WHERE   和   HAVING   子句中的搜索条件或限定条件可包括：    
   
  比较运算符（如   =、<   >、<   和   >）。例如，下列查询从   Products   表中检索产品分类为   2   的行：    
  SELECT   ProductID,   ProductName  
  FROM   Northwind.dbo.Products  
  WHERE   CategoryID   =   2  
  ORDER   BY   ProductID  
   
  范围（BETWEEN   和   NOT   BETWEEN）。例如，下列查询从   Products   表中检索产品分类从   2   到   4   的行：    
  SELECT   CategoryID,   ProductID,   ProductName  
  FROM   Northwind.dbo.Products  
  WHERE   CategoryID   BETWEEN   2   and   4  
  ORDER   BY   CategoryID,   ProductID  
   
  列表（IN、NOT   IN）。例如，下列查询从   Products   表中检索产品分类   ID   与列表中某一   ID   匹配的行：    
  SELECT   CategoryID,   ProductID,   ProductName  
  FROM   Northwind.dbo.Products  
  WHERE   CategoryID   IN   (1,4,5,7)  
  ORDER   BY   CategoryID,   ProductID  
   
  模式匹配（LIKE   和   NOT   LIKE）。例如，下列查询从   Products   表中检索产品名称以   Ch   开头的行：    
  SELECT   CategoryID,   ProductID,   ProductName  
  FROM   Northwind.dbo.Products  
  WHERE   ProductName   LIKE   'Ch%'  
  ORDER   BY   CategoryID,   ProductID  
   
   
   
  说明     可用于   text   列的   WHERE   条件只有返回其它数据类型的函数（如   PATINDEX()）或运算符（如   IS   NULL、IS   NOT   NULL、LIKE   和   NOT   LIKE）。  
   
  空值（IS   NULL   和   IS   NOT   NULL）。例如，下列查询从   Customers   表中检索客户地区不为   NULL   的行：    
  SELECT   CompanyName,   City,   Region,   Country  
  FROM   Northwind.dbo.Customers  
  WHERE   Region   IS   NOT   NULL  
  ORDER   BY   CompanyName  
   
   
   
  说明     比较空值时请谨慎从事。例如，指定   =   NULL   与指定   IS   NULL   是不同的。有关更多信息，请参见空值。  
   
  所有记录（=ALL、>ALL、<=   ALL、ANY）。例如，下列查询从   Order   Details   表中检索装运产品数量大于分类   1   中任意产品的装运数量的订单和产品   ID：    
  USE   Northwind  
  GO  
  SELECT   OrdD1.OrderID,   OrdD1.ProductID  
  FROM   "Order   Details"   OrdD1  
  WHERE   OrdD1.Quantity   >   ALL  
              (SELECT   OrdD2.Quantity  
                FROM   "Order   Details"   OrdD2   JOIN   Products   Prd  
                            ON   OrdD2.ProductID   =   Prd.ProductID  
                WHERE   Prd.CategoryID   =   1)  
  GO  
   
  上述条件的组合（AND、OR、NOT）。例如，下列查询检索库存水平低于再订购点，或来自供应商   15   并属于分类   4   的所有产品：    
  SELECT   ProductID,   ProductName  
  FROM   Northwind.dbo.Products  
  WHERE   UnitsInStock   <   ReorderLevel  
        OR   (SupplierID   =   15   AND   CategoryID   =   4)  
   
   
   
  说明     当在   WHERE   子句中搜索   Unicode   字符串时，请在搜索字符串之前加字符   N，例如：  
   
  SELECT   CompanyName,   ContactName,   Phone,   Fax  
  FROM   Northwind.dbo.Customers  
  WHERE   CompanyName   =   N'Berglunds   snabbköp'   

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

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

class Company < ActiveRecord::Base; end

class Firm < Company; end

class Client < Company; end

class PriorityClient < Client; end

# simplified

def new

case @params[:person_type]

when "Manager"

@person = Manager.new

when "Slave"

@person = Slave.new

end

end

在你的“视图”中，完成：

<%= hidden_field_tag "person_type", @person[:type] %>

然后是create方法：

#again, simplified

def create

case @params[:person_type]

when "Manager"

@person = Manager.new(@params[:person])

when "Slave"

@person = Slave.new(@params[:person])

end

if @person.save

redirect_to :action => :list

else

render_action :new

end

end

甚至你可以在你的Person类中创建一个factory类方法。

class Person < ActiveRecord::Base

def self.factory(type, params = nil)

case type

when "Manager"

return Manager.new(params)

when "Slave"

return Slave.new(params)

else

return nil

end

end

end

然后，你可以在new和create方法内完成

def new

@person = Person.factory(@params[:person_type])

end

def create

@person = Person.factory(@params[:person_type], @params[:person])

if @person.save

...

end

end

你也可以使用下面方式来创建一个子类(thanks to Sean Hussey/Ezra)

person_type = "Manager"

@person = eval(person_type + ".new")

或者使用 constantize:

person_type = "Manager"

@person = person_type.constantize.new

如果你的“type”列的文本没有精确地匹配你的类名字，你可能得这样做：

class ETH < ListData; end

Ethnicity = ETH

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

序列 说明 
\a ASCII 响铃字符（也可以键入 \007） 
\d "Wed Sep 06" 格式的日期 
\e ASCII 转义字符（也可以键入 \033） 
\h 主机名的第一部分（如 "mybox"） 
\H 主机的全称（如 "mybox.mydomain.com"） 
\j 在此 shell 中通过按 ^Z 挂起的进程数 
\l 此 shell 的终端设备名（如 "ttyp4"） 
\n 换行符 
\r 回车符 
\s shell 的名称（如 "bash"） 
\t 24 小时制时间（如 "23:01:01"） 
\T 12 小时制时间（如 "11:01:01"） 
\@ 带有 am/pm 的 12 小时制时间 
\u 用户名 
\v bash 的版本（如 2.04） 
\V Bash 版本（包括补丁级别） ?/td>; 
\w 当前工作目录（如 "/home/drobbins"） 
\W 当前工作目录的“基名 (basename)”（如 "drobbins"） 
\! 当前命令在历史缓冲区中的位置 
\# 命令编号（只要您键入内容，它就会在每次提示时累加） 
\$ 如果您不是超级用户 (root)，则插入一个 "$"；如果您是超级用户，则显示一个 "#" 
\xxx 插入一个用三位数 xxx（用零代替未使用的数字，如 "\007"）表示的 ASCII 字符 
\\ 反斜杠 
\[ 这个序列应该出现在不移动光标的字符序列（如颜色转义序列）之前。它使 bash 能够正确计算自动换行。 
\] 这个序列应该出现在非打印字符序列之后。 

if [ "$TERM" = "linux" ] 
then 
#we're on the system console or maybe telnetting in 
export PS1="\[\e[32;1m\]\u@\H >; \[\e[0m\]" 
else 
#we're not on the console, assume an xterm 
export PS1="\[\e]2;\u@\H \w\a\e[32;1m\]>;\[\e[0m\] " 
fi 

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

location at :
/ruby/lib/ruby/gems/1.8/gems/activerecord-1.15.3/lib/active_record/connection_adapters/abstract_adapter.rb
        def format_log_entry(message, dump = nil)
          if ActiveRecord::Base.colorize_logging
            if @@row_even
              @@row_even = false
              message_color, dump_color = "4;36;1", "0;1"
            else
              @@row_even = true
              message_color, dump_color = "4;35;1", "0"
            end

            log_entry = "  \e[#{message_color}m#{message}\e[0m   "
            log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
            log_entry
          else
            "%s  %s" % [message, dump]
          end
        end

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

查找异常线程:
shell >mysqladmin proc stat -i2 (-i2每隔两秒显示一次)

杀死线程: shell >mysqladmin kill id

授权
mysql>grant all on productcenter.* to 'user'@'localhost' identified by 'password';(指定的user用户拥有productcenter数据库中的所有表的所有权限(select ,insert,update,delete.....)
mysql>grant select on productcenter.* to 'user'@'localhost' identified by 'password';(只拥有select 权限)

#>find ./ -name *~ -type f -exec rm -rf {} \; 
(删除当前目录及子目录下所有以 ~ 结尾的文件.)

#>find ./ -name .svn -type d -exec rm -rf {} \;
(删除当前目录以及子目录下所有名为 .svn 的目录)

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

The following is a list of all of the methods public methods offered by the JavaScriptGenerator. These methods are called on the page object in your RJS templates.

Since RJS is all about generating JavaScript, it is nice to know what is going on behind the scenes. Knowing about the JavaScript that is generated makes it much easier to debug problems and create more complex applications. At some point, your RJS code may become too complex or there may be a task that you can't perform elegantly with RJS. If you understand how RJS generates JavaScript, you can easily port your code into a JavaScript library and use RJS to access your new JavaScript objects and methods.

Therefore, for all of the following definitions, I have placed the JavaScript that the method generates after the Ruby code. The Ruby code is marked with the comment # Ruby code, and the JavaScript is marked with // Generated JavaScript.



<<(javascript)

Writes raw JavaScript to the page.
        
        
[](id)

Returns a JavaScriptElementProxy for the DOM element with the specified id. Methods can be called on the returned element. Multiple method calls can also be chained together.
        
        # Ruby code
        page['header'].show
        
        // Generated JavaScript
        $("header").show();
        
        # Ruby code
        page['header'].first.second
        
        // Generated JavaScript
        $("header").first().second();
        
        


assign(variable, value)

Assigns a value to the JavaScript variable specified. Ruby objects are automatically converted to JavaScript objects by calling the object's to_json method if it has one, or inspect if it doesn't.
        
        # Ruby code
        page.assign 'name', { :first => "Cody", :last => "Fauser" } 
        
        // Generated JavaScript
        name = { "first": "Cody", "last": "Fauser" };
        
        


alert(message)

Displays a JavaScript alert dialog box with the provided message.
        
        # Ruby code
        page.alert 'An error occurred while processing your request'
        
        // Generated JavaScript
        alert("An error occurred while processing your request");
        
        


call(function, arg, ...)

Calls a JavaScript function and passes in zero or more arguments.
        
        # Ruby code
        page.call 'displayError', 'An error occurred', 'Critical' 
        
        // Generated JavaScript
        displayError("An error occurred", "Critical");
        
        
        
        You can call methods on custom objects that you've added to your page by specifying the variable name and the method call.
        
        # Ruby code
        page.call 'inventory.showTotal' 
        
        // Generated JavaScript
        inventory.showTotal();
        
        


delay(seconds = 1)

Executes the code within the block after delaying for the specified number of seconds.
        
        # Ruby code
        page.delay(5) do
          page.visual_effect :highlight, 'navigation'
        end
        
        // Generated JavaScript
        setTimeout(function() {
        ;
        new Effect.Highlight("navigation", {});
        }, 5000);
        
        


draggable(id, options = {})

Makes the DOM element specified by the id draggable.
        
        # Ruby code
        page.draggable('photo', :revert => true)
        
        // Generated JavaScript
        new Draggable('photo', {revert: true});
        
        


drop_receiving( id, options = {})

Makes the DOM element specified by the id receive dropped draggable elements. Draggable elements are created using the RJS draggable method or by using draggable_element() Scriptaculous helper.
        
        # Ruby code
        page.drop_receiving('photo', :url => { :action => 'add' })
        
        // Generated JavaScript
        Droppables.add("photo", {onDrop:function(element){new
        Ajax.Request('/hello_world/add', {asynchronous:true, evalScripts:true,
        parameters:'id=' + encodeURIComponent(element.id)})}});
        
        


hide(id, ...)

Hides one or more DOM elements. Specify the elements to hide by their DOM ids.
        
        # Ruby code
        page.hide('first', 'second')
        
        // Generated JavaScript
        Element.hide("first", "second");
        
        


insert_html(position, id, *options_for_render)

Inserts the HTML into the specified position in relation to the element.
        
        The available positions are:
        
        
        


:before

The content is inserted into the page before the element.
        
        
:after

The content is inserted into the page after the element.
        
        
:top

The content is inserted into the element before the element's existing content.
        
        
:bottom

The content is inserted into the element after the element's existing content.
        
        # Ruby code
page.insert_html(:bottom, 'products', '<li>Refrigerator</li>')

// Generated JavaScript
new Insertion.Bottom("products", "<li>Refrigerator</li>");





redirect_to(location)

Redirect the browser to the location specified. redirect_to() passes the location to url_for(), so any of the arguments you normally use with url_for() can also be used with redirect_to().
        
        # Ruby code
        page.redirect_to('http://www.google.com')
        
        // Generated JavaScript
        window.location.href = "http://www.google.com";
        
        # Ruby code
        page.redirect_to(:controller => 'inventory', :action => 'list')
        
        // Generated JavaScript 
        window.location.href = "http://localhost:3000/inventory/list";
        
        


remove(id, ...)

Removes one or more DOM elements from the page.
        
        # Ruby code
        page.remove('first', 'second')
        
        // Generated JavaScript
        ["first", "second"].each(Element.remove);
        
        


replace(id, *options_for_render)

Replaces the entire element specified or outerHTML. replace is useful with partial templates so that the entire partial, which includes a container element, can be rendered and used to replace content during an RJS call. An example is an unordered list. A partial containing a  <li>  tag can be rendered instead of having to replace the innerHTML of the  <li> . Replacing just the innerHTML would require the  <li>  tag to be moved out of the partial.
        
        # Ruby code
        product.replace 'banner', '<id="banner">Welcome back Cody</div>'
        
        // Generated JavaScript
        Element.replace("banner", "<id=\"banner\">Welcome back Cody</div>");
        
        


replace_html(id, *options_for_render)

Replaces the content or innerHTML of the DOM element with the id with either a String or the output of a rendered partial template.
        
        # Ruby code
        page.replace_html 'timestamp', Time.now
        
        // Generated JavaScript
        Element.update("timestamp", "Sat Apr 29 15:14:24 EDT 2006");
        
        


select(pattern)

Selects DOM elements using CSS-based selectors. Returns a JavaScriptElementCollectionProxy that can then receive proxied enumerable methods. See the JavaScriptCollectionProxy methods in the next section.
        
        # Ruby code
        page.select "#content p"
        
        // Generated JavaScript
        # => $$("#content p");
        
        


sortable(id, options = {})

Makes the element with the DOM ID id sortable using drag and drop. The options are the same as the options for ScriptaculousHelper#sortable_element().
        
        # Ruby code
        # Assuming the current controller is ProjectsController
        page.sortable 'project-65', :url => { :action => 'sort' }
        
        // Generated JavaScript
        Sortable.create("project-65", {onUpdate:function(){
          new Ajax.Request('/projects/sort', {
            asynchronous:true, evalScripts:true, parameters:Sortable.serialize("project-65")
            }
          )}
        });
        
        


show(id, ...)

Makes one or more hidden DOM elements visible. As with hide(), the elements are specified by their DOM ids.
        
        # Ruby code
        page.show 'element-20', 'element-30'
        
        // Generated JavaScript
        Element.show("element-20", "element-30");
        
        


toggle(id, ...)

Toggles the visibility of one or more DOM objects.
        
        # Ruby code
        page.toggle 'product-1', 'product-2', 'product-3'
        
        // Generated JavaScript
        Element.toggle("product-1", "product-2", "product-3");
        
        


visual_effect(name, id = nil, options = {})

Creates a new Scriptaculous visual effect to the element with the DOM id. See the following section on visual effects for a list of the visual effects shipping with Rails 1.1.
        
        # Ruby code
        page.visual_effect :highlight, 'list-item-69', :duration => 5
        
        // Generated JavaScript
        new Effect.Highlight("list-item-69",{duration:5});

The JavaScriptElementProxy is a proxy to a real DOM object. You can proxy method calls to the any of the DOM object's JavaScript methods. A few additional methods have been added to the proxy objects to make them more useful. This reference covers those enhanced non-JavaScript methods.



replace_html(*options_for_render)

Replaces the innerHTML of the DOM object. See the JavaScriptGenerator#replace_html() method for more information.
        
        
replace(*options_for_render)

Replaces the outerHTML for the DOM object. See JavaScriptGenerator#replace() method for more information.
        
        
reload

Reloads the content for the element by re-rendering a partial with the same name as the DOM element's id.
        
        page['header'].reload
            
        # Equivalent to:
            
        page['header'].replace :partial => 'header'

The JavaScriptCollectionProxy is the most difficult part of RJS to understand and work with. This section will first cover some of the trickier aspects of the enumerable support and the actual reference will begin. This will help you avoid trouble and maintain your productivity.


Block Variables and the Enumerable methods
JavaScriptGenerator#select() returns an instance of the JavaScriptElementCollectionProxy class. JavaScriptElementCollectionProxy inherits from JavaScriptCollectionProxy, which provides all of the functionality. The trickiest part about the collection proxy enumerable methods is the code that goes within the block. The code within the block is translated into a JavaScript iterator function. Another tricky aspect of the enumerable block is that you can use any variable names you like for the block parameters, but in the generated JavaScript iterator function the variable names used are always value and index. This rule applies to any expression you use within the block that isn't a simple method called on the proxy object.

The first block parameter is always the element and the second is always the index, except with inject() and pluck(). If you don't access the value or index within the block, then you don't have to pass them into the block. In the following example, the block parameter is named element.

# Ruby code
page.select('#elements span').all('allVisible') do |element, index|
  element.visible
end

// Generated JavaScript
var allVisible = $$("#elements span").all(function(value, index) {
return value.visible();
});



As you can see from the generated JavaScript, the variable value was used and not element, as it was named in the Ruby code. This works well, as long as the code within the block is a simple proxied method call, as it was in the preceding code. More complex expressions need to be written as a string and passed to the << method of the page object.

When using a direct element proxy rather than a string passed to <<, the generator assumes that the proxied call is a method call and automatically adds (). This means that you can't directly proxy an element's property, such as element.innerHTML.

page.select('#elements span').any('allVisible') do |value, index|
  page << '!value.visible()'
end



The last expression in the block is the statement appended to the return statement in the generated JavaScript code, so it is possible to safely add more method calls to the block.


Inspecting the Results of the Enumerations
The one problem with the enumerable functions is that it is difficult to inspect the return JavaScript variables assigned by the function. The FireBug console is unable to display the assigned variable when the variable is assigned during the execution of eval() after an Ajax call. I used a small Logger class that uses the printfire() method discussed in the FireBug chapter to log to the JavaScript console. I then created a simple class to inspect the JavaScript variables assigned by the enumerable functions. You can define the class in public/javascripts/application.js.

var Inspector = {}

Inpsector = {
  inspect: function(val) {
    if (val.innerHTML) {
      Logger.log(val.innerHTML);
    } else {
      Logger.log(val);
    }
  },

  inspectArray: function(array) {
    array.each(this.inspect);
  }
}



Following is an example of the usage of the Logger class for inspecting the variable assigned by the return value of sort_by(). In this case sort_by() sorts all the paragraphs in the page by the length of their content and stores the sorted objects in an Array named sortedParagraphs.

page.select('p').sort_by('sortedParagraphs') do |value, index|
  page << 'value.innerHTML.length;'
end

page << 'Logger.inspectArray(sortedParagraphs);'



This code simply iterates through the sorted paragraphs and displays the HTML content of each object to the FireBug console. Feel free to expand and improve on the code to meet your own needs.


Method Reference
All of the following enumerable methods are simply proxies to the Prototype enumerable method of the same name. For each method (except for pluck), there is a corresponding Ruby enumerable method with the same name. The Ruby enumerable method may have an added ? (e.g., all?). The Prototype methods were meant to mimic Ruby's enumerable methods. Therefore, you can get a pretty good idea of the overall intent of each method by examining the Ruby version.



all(variable) {|value,index| block }

Each element is passed to the block. The block is converted to a JavaScript iterator function. The JavaScript variable is set to TRue if the iterator function never returns false or null.
        
        # Ruby code
        page.select('#line-items li').all('allVisible') do |value, index|
          value.visible
        end
        
        // Generated JavaScript
        var allVisible = $$("#line-items li").all(function(value, index) {
        return value.visible();
        });
        
        


any(variable){|value, index| block }

Each element is passed to the block. The block is converted to a JavaScript iterator function. The JavaScript variable is set to TRue if the iterator function never returns false or null.
        
        # Ruby code
        page.select('#line-items li').any('anyVisible') do |value, index|
          value.visible
        end
        
        // Generated JavaScript    
        var anyVisible = $$("#line-items li").any(function(value, index) {
        return value.visible();
        });
        
        


collect(variable){|value, index| block }

The block is converted to a JavaScript iterator. This method assigns a new JavaScript Array to the JavaScript variable containing the results of executing the iterator function once for each element.
        
        # Ruby code
        page.select('#orders tr').collect('heights') do |value, index|
          value.get_height
        end
            
        // Generated JavaScript
        var heights = $$("#orders tr").collect(function(value, index) {
        return value.getHeight();
        });
        
        


detect(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to the first element for which the iterator function does not return false.
        
        # Ruby code
        page.select('#content p').detect('first_visible') do |value, index|
          value.visible
        end
        
        // Generated JavaScript    
        var first_visible = $$("#content p").detect(function(value, index) {
        return value.visible();
        });
        
        


each{|value, index| block }

Passes each element to the block, which is converted to a JavaScript iterator function. The iterator function is called once for each element.
        
        # Ruby code
        page.select('#content p').each do |value, index|
          page << 'alert(value.innerHTML);'
        end
            
        // Generated JavaScript
        $$("p").each(function(value, index) {
        alert(value.innerHTML);
        });
        
        


find(variable){|value, index| block }

A synonym for JavaScriptCollectionProxy#detect().
        
        
find_all(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to an Array of all elements for which the iterator function does not return false.
        
        # Ruby code
        page.select('#content p').find_all('empty_paragraphs') do |value, index|
          value.empty
        end
        
        // Generated JavaScript    
        var empty_paragraphs = $$("#content p").collect(function(value, index) {
        return value.empty();
        });
        
        


grep(variable, pattern){|value, index| block }

Each DOM element with a toString() matching the Regexp pattern is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to an Array containing the results of executing the iterator function once for each element.
        
        This method isn't entirely useful in the context of RJS. Its only real use is matching DOM elements using the pattern based on their type, which is output by the toString() method. The toString() method outputs [object HTMLDivElement] for a  <div>  element. Use the FireBug console to view the toString() output for other elements.
        
        # Ruby code
        page.select('#content p').grep('hidden', /Div|Paragraph/) do |value, index|
          value.hidden
        end
        
        // Generated JavaScript    
        var hidden = $$("#content p").grep(/Div|Paragraph/, function(value, index) {
        return value.hidden();
        });
        
        


inject(variable, memo){|memo, value, index| block }

Each element and the accumulator value memo is passed to the given block. The block is converted to a JavaScript iterator function. The iterator function is called once for each element and the result is stored in memo. The result returned to the JavaScript variable is the final value of memo. The initial value of memo is set in one of two ways. The value of the parameter memo is used as the initial value if a non nil value is passed in to the method. Otherwise, the first element of the collection is used as the initial value.
        
        # Ruby code
        page.select('#content .columns').inject('totalWidth', 0) do |memo, value, index|
           page << '(memo + value.offsetWidth)'
        end
        
        // Generated JavaScript
        var totalWidth = $$(".columns").inject(0, function(memo, value, index) {
        return(memo + value.offsetWidth);
        });
        
        


map(variable){|value, index| block }

Synonym for JavaScriptCollectionProxy#collect().
        
        
max(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to the largest value returned by the iterator function.
        
        # Ruby code
        page.select('p').max('longestParagraphLength') do |value, index|
          page << 'value.innerHTML.length'
        end
            
        // Generated JavaScript
        var longestParagraphLength = $$("p").max(function(value, index) {
        return value.innerHTML.length;
        });
        
        


min(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to the smallest value returned by the iterator function.
        
        # Ruby code
        page.select('p').min('shortestParagraphLength') do |value, index|
          page << 'value.innerHTML.length'
        end
            
        // Generated JavaScript
        var shortestParagraphLength = $$("p").min(function(value, index) {
        return value.innerHTML.length;
        });
        
        


partition(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function and is executed once for each element. The JavaScript variable is set to an Array containing to Arrays. The first Array contains all of the elements for which the iterator function evaluated to true. The second Array contains all of the remaining elements.
        
        # Ruby code
        page.select('.products').partition('productsByVisibility') do |value, index|
          value.visible
        end
        
        // Generated JavaScript
        var productsByVisibility = $$(".products").partition(function(value, index) {
        return value.visible();
        });
        
        


pluck(variable, property)

Iterates through the collection creating a new Array from the value of the given property of each object without a function call. The resulting Array is assigned to the JavaScript variable.
        
        # Ruby code
        page.select('.amounts').pluck('amounts', 'innerHTML')
            
        // Generated JavaScript
        var amounts = $$(".amounts").pluck("innerHTML");
        
        


reject(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. The JavaScript variable is assigned to an Array of all elements for which the iterator function returns false.
        
        # Ruby code
        page.select('p').reject('paragraphsWithContent') do |value, index|
          value.empty
        end
        
        // Generated JavaScript
        var paragraphsWithContent = $$("p").reject(function(value, index) {
        return value.empty();
        });
        
        


select(variable){|value, index| block }

A synonym for JavaScriptCollectionProxy#find_all().
        
        
sort_by(variable){|value, index| block }

Each element is passed to the given block. The block is converted to a JavaScript iterator function. Assigns the JavaScript variable to an Array of the elements sorted using the result of the iterator function as keys for the comparisons when sorting.
        
        # Ruby code
        page.select('p').sort_by('sortedParagraphs') do |value, index|
          page << 'value.innerHTML.length;'
        end
            
        // Generated JavaScript
        var sortedParagraphs = $$("p").sortBy(function(value, index) {
        return value.innerHTML.length;
        });
        
        


zip(variable, arg1, ...){|value, index| block }

Merges elements with the arrays passed as parameters. Elements in the corresponding index of each array form a new array. The resulting array of arrays is assigned to the JavaScript variable. If a block is provided it is converted to an iterator function and is applied to each resulting Array. The name of the parameter to the iterator function is array.
        
        For this example, assume that the page has the following paragraph elements:
        
        <p id="first">First Paragraph</p>
        <p id="second">Second Paragraph</p>
        
        
        
        First, applying zip without a block:
        
        # Ruby code
        page.select('p').zip('zipped', [1, 2], [3,4])
            
        // Generated JavaScript
        var zipped = $$('p').zip([1,2], [3,4]);
        
        
        
        The resulting array of arrays, where the paragraphs (represented by their ids) are DOM objects:
        
        [[< id="first">, 1, 3], [<p id="second" >, 2, 4]]
        
        
        
        Applying zip with a block:
        
        # Ruby code
        page.select('p').zip('zipped', [1, 2], [3,4]) do |array|
          page.call 'array.reverse'
        end
            
        // Generated JavaScript
        var zipped = $$("p").zip([1,2], [3,4], function(array) {
        return array.reverse();
        });
        
        
        
        The resulting Array of arrays, where the paragraphs (represented by their ids) are DOM objects:
        
        [[3, 1, <p id="first">], [4, 2, <p id="second" >]]

For the purposes of RJS templates, all visual effects are accessed using the name of the effect as a symbol, e.g.,