J-kanban 玄人志向 » 51CTO技术博客

« Expand/Collapse

51CTO技术博客 (50 unread)

Skip to page: 1 2

August 17, 2008
8:15
PDF开发包ActvieFPDF for Rails 2.1
» ‎ 51CTO技术博客

http://code.google.com/p/cnruby/wiki/RailsPluginActiveFPDF
August 15, 2008
9:52
给TextMate添加zoom快捷键
» ‎ 51CTO技术博客

先确定是否装有xcode

修改TextMate Zoom快捷键。
Application -> 右键 (show package contents) -> contents ->
resources -> English.lproj (前提是你的系统语言为english，
中文比较麻烦) -> 打开MainMenu.nib -> 然后选MainMenu 在弹
出来的菜单栏添加自己要的快捷键就行。
Thanks Michael.
9:17
TextMate里增加Erlang支持
» ‎ 51CTO技术博客

Erlang for mac可以通过 sudo port install erlang来安装，源码编译在mac osx上有点问题，老是编译不过，没有解决，只能用port安装了。

给TextMate添加Erlang Bundles:

mkdir /Library/Application Support/TextMate/Bundles

cd /Library/Application Support/TextMate/Bundles

/Library/Application Support/TextMate/Bundles > svn co [url [macromates.com]

重启TextMate
1:17
看red来帮你用ruby写javascript
» ‎ 51CTO技术博客

http://github.com/jessesielaff/red/tree/master
Red 库可以帮你把ruby转换为js。

安装：
sudo gem install red

创建一个文件：
~/Desktop>mate example.red
class Foo
  def initialize(foo)
    @foo = foo
  end
end

~/Desktop>red example

- example.js
=================================

var Foo = function(foo) { this.foo = foo; };

=================================

~/Desktop>ls

example.js
example.red

very cool ！
August 10, 2008
0:46
Alex学Ruby[ Rails Tip - 一个通用的表格Ajax排序]
» ‎ 51CTO技术博客

曾经多次在项目里用到按某一列给表格Ajax排序的功能，现在从开源项目里redmine里提取出这个sort_helper.rb，稍微修改了下，让它变的更通用：

module SortHelper

 def sort_init(default_key, default_order='asc', name=nil)
 @sort_name = name || params[:controller] + params[:action] + '_sort'
 @sort_default = {:key => default_key, :order => default_order}
 end

 def sort_update()
 if params[:sort_key]
 sort = {:key => params[:sort_key], :order => params[:sort_order]}
 elsif session[@sort_name]
 sort = session[@sort_name] # Previous sort.
 else
 sort = @sort_default
 end
 session[@sort_name] = sort
 end

 def sort_clause()
 session[@sort_name][:key] + ' ' + (session[@sort_name][:order] || 'ASC')
 end

 def sort_link(column, caption, default_order,controller_name,node)
 key, order = session[@sort_name][:key], session[@sort_name][:order]
 if key == column
 if order.downcase == 'asc'
 icon = 'sort_asc.png'
 order = 'desc'
 else
 icon = 'sort_desc.png'
 order = 'asc'
 end
 else
 icon = nil
 order = default_order
 end
 caption = titleize(Inflector::humanize(column)) unless caption

 sort_options = { :sort_key => column, :sort_order => order }
 # don't reuse params if filters are present
 url_options = params.has_key?(:set_filter) ?
 sort_options :
 params.merge(sort_options)

 link_to_remote(caption,{:update => node, :url => url_options},
 {:href => url_for(url_options.merge!("controller" => "#{controller_name}"))}) +
 (icon ? nbsp(2) + p_w_picpath_tag(icon) : '')
 end

 def sort_header_tag(column, options = {})
 caption = options.delete(:caption) || titleize(Inflector::humanize(column))
 default_order = options.delete(:default_order) || 'asc'
 options[:title]= caption unless options[:title]
 content_tag('th',
 sort_link(column, caption, default_order,
 options[:controller_name],options[:update]),
 options)
 end

 private

 # Return n non-breaking spaces.
 def nbsp(n)
 ' ' * n
 end

 # Return capitalized title.
 def titleize(title)
 title.split.map {|w| w.capitalize }.join(' ')
 end

end

这里，url_options.merge!("controller" => "#{controller_name}") 是我修改的地方。因为如果controller有命名空间，比如Admin::Users, 那么这里生成的url会是[url [www.xxx.com] 显然不是我们想要的，params[:controller_name]为admin/users, 那么我们只需要把这个controller_name用merge方法来让它变成我们想要的。从sort_header_tag方法里传进去就行：
用法：

把sort_helper.rb放到lib目录下，然后，

在controller里：
Controller:

 helper :sort
 include SortHelper

 def list
 sort_init 'last_name'
 sort_update
 @items = Contact.find_all nil, sort_clause
 end

Controller (using Pagination module):

 helper :sort
 include SortHelper

 def list
 sort_init 'last_name'
 sort_update
 @contact_pages, @items = paginate :contacts,
 :order_by => sort_clause,
 :per_page => 10
 end

上面的两种用法，第一个是不支持分页的情况;
第二种是支持分页的情况，不过这个分页是rails自带的分页，如果你用will_paginate,还是一样的用法，把:order_by => sort_clause加到后面就行了。

在view里：
View (table header in list.rhtml):

<thead>
 <tr>
 <%= sort_header_tag('id', :title => 'Sort by contact ID',
 :controller_name => "users",
 :update => "div_id") %>
 <%= sort_header_tag('last_name', :caption => 'Name',
 :controller_name => "users",
 :update => "div_id") %>
 <%= sort_header_tag('phone', :controller_name => "users",
 :update => "div_id") %>

 </tr>
</thead>
直接使用sort_header_tag方法就行，:controller_name，如果你没有命名空间，则可以不传这个参数，:update是把你需要更新的div的id传回去，因为是ajax排序.

注：因为我是在rails1.1.6下，所以会有list action，如果是rails2.0＋的版本，使用方法也类似。
August 09, 2008
6:11
中国，加油！
» ‎ 51CTO技术博客

       今天是个特殊的日子，北京奥运会开幕式。
       一直觉得开幕式也就是那样，曾经历届的奥运开幕式都懒的看，可是今天尽管之前是多么的不屑一顾，但还是不由自主的看了，看到升国旗，真的是有种由衷的自豪感啊！我相信现场的人更自豪吧。之后的表演很震撼，相当震撼。。。不愧是张艺谋啊。
       中国，加油！
August 01, 2008
10:28
Alex学Ruby[ inject需要注意的地方 ]
» ‎ 51CTO技术博客

inject真tm的神奇。

inject是我最喜欢用的方法，因为它可以使如下的代码变的更漂亮：
arr1 = []
arr2 = [1,2,3]
arr2.each do |i|
 arr1 < [2, 3, 4]

使用inject：
arr = arr2.inject([]) do|arr1, i|
 arr1 <[2,3,4]

但是，如果这么写：
arr = arr2.inject([]) do |arr1,i|
 arr1 << i+1 if i%2 == 0
 end

就会报错： undefined method `<<' for nil:NilClass

这是值得注意的地方，起码是我常犯错的一个地方。

inject([]) do |item ,i |这样的写法，每一步，item都会被设置为block的返回值。上面的例子里，第一步if语句显然返回了nil，所以当执行第二步迭代的时候，自然给nil对象调用了<< 这个方法，就报错了！

这个问题怎么解决？
当然在判断条件为false的情况下返回当前的这个item值就ok了，像下面这样：
arr = arr2.inject([]) do |arr1,i|
 (i%2) == 0 ? (arr1 << i+1) : arr1
 end

完了来回顾一下inject方法两种用法：
enum.inject(init_value) {|memo,obj| block}
enum.inject{ |memo,obj| block }

第一种，memo以init_value为初始值
第二种，memo以enum里的第一个元素为初始值。
July 31, 2008
1:09
QuickTime Player解码器
» ‎ 51CTO技术博客

A quick and easy solution to how to play .mkv files is to install Perian, which makes QuickTime play .avi, .flv, and .mkv files and handles many different and popular encoding formats for video.

[url [perian.org]
July 29, 2008
8:48
Alex学Ruby[ 数组的find 和 select方法的区别 ]
» ‎ 51CTO技术博客

今天在项目遇到一个问题，我要比对数据库里record的变化，用到了数组的find方法和select方法，以前没有注意两者的区别，今天记录下，以免犯错：

arr = [1,2,3,4]

arr.find{|i| i%2 == 0 }
＃=>2
arr.select{|i| i%2 == 0}
#=>[2, 4]
find返回满足条件的第一条记录，而select返回满足条件的全部记录。要分情况应用不同的方法，否则会产生bug。
8:37
Alex学Ruby[ Ruby Design Pattern - template method]
» ‎ 51CTO技术博客

突然对Ruby实现的设计模式比较感兴趣，边学习边记录一下吧。 Template method模式是最简单的一种设计模式了，下文的解释引自追mm与设计模式一文( 没想到写这文章的哥们是个YD的青年啊，不过也有助于帮助理解设计模式 )：

Template method――看过《如何说服女生上床》这部经典文章吗？女生从认识到上床的不变的步骤分为巧遇、打破僵局、展开追求、接吻、前戏、动手、爱抚、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具体实现)；

模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

以一个例子来说，写一个输出一个不同格式的report generater。可以输出html格式，也可以输出纯文本的内容。

这个例子是hard-coded输出html格式的report类，但是无法处理纯文本格式。

class Report
 def initialize
 @title = 'Monthly Report'
 @text = [ 'Things are going', 'really, really well.' ]
 end
 def output_report
 puts('<html>')
 puts(' <head>')
 puts(" <title>#{@title}</title>")
 puts(' </head>')
 puts(' <body>')
 @text.each do |line|
 puts(" #{line}" )
 end
 puts(' </body>')
 puts('</html>')
 end
end

如果你要处理纯文本，那么只能重新写一个类：
class Report
 def initialize
 @title = 'Monthly Report'
 @text = ['Things are going', 'really, really well.']
 end
 def output_report(format)
 if format == :plain
 puts("*** #{@title} ***")
 elsif format == :html
 puts('<html>')
 puts(' <head>')
 puts(" <title>#{@title}</title>")
 puts(' </head>')
 puts(' <body>')
 else
 raise "Unknown format: #{format}"
 end
 @text.each do |line|
 if format == :plain
 puts(line)
 else
 puts(" #{line}" )
 end
 end
 if format == :html
 puts(' </body>')
 puts('</html>')
 end
 end
end

上面的代码是可以工作的，但是如果将来又有需要让你处理其他格式呢，再重写一遍啊？这个时候template method就起作用了。我们可以把公共的部分抽象出来，也就是说先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。Ruby本身并没有抽象类，那么我们可以像下面方式一样去模拟：
class Report
 def initialize
 @title = 'Monthly Report'
 @text = ['Things are going', 'really, really well.']
 end
 def output_report
 output_start
 output_head
 output_body_start
 output_body
 output_body_end
 output_end
 end
 def output_body
 @text.each do |line|
 output_line(line)
 end
 end
 def output_start
 raise 'Called abstract method: output_start'
 end
 def output_head
 raise 'Called abstract method: output_head'
 end
 def output_body_start
 raise 'Called abstract method: output_body_start'
 end
 def output_line(line)
 raise 'Called abstract method: output_line'
 end
 def output_body_end
 raise 'Called abstract method: output_body_end'
 end
 def output_end
 raise 'Called abstract method: output_end'
 end
end

那么我们可以实现处理html的子类了：
class HTMLReport < Report
 def output_start
 puts('<html>')
 end

 def output_head
 puts(' <head>')
 puts(" <title>#{@title}</title>")
 puts(' </head>')
 end

 def output_body_start
 puts('<body>')
 end

 def output_line(line)
 puts(" #{line}")
 end

 def output_body_end
 puts('</body>')
 end

 def output_end
 puts('</html>')
 end
end

同样，处理文本的子类：
class PlainTextReport < Report
 def output_start
 end

 def output_head
 puts("**** #{@title} ****")
 puts
 end

 def output_body_start
 end

 def output_line(line)
 puts(line)
 end

 def output_body_end
 end

 def output_end
 end
end

看看结果：
report = HTMLReport.new
report.output_report
#=>
<html>
<head>
 <title>Monthly Report</title>
</head>
<body>
Things are going
really, really well.
</body>
</html>

report = PlainTextReport.new
report.output_report
#=>
** Monthly Report ****
Things are going
really, really well.
7:40
记录：上海地铁服务台sb男
» ‎ 51CTO技术博客

me : 你好，请问一下，曲阳路附近有没有移动营业厅
sb男：哪条路？
me : 曲阳路
sb男：几号？
me：我知道几号问你干嘛
sb男：你不知道几号莫名其妙来问。。。
me：无语
July 28, 2008
8:44
GitHub的新服务GIST
» ‎ 51CTO技术博客

[url [gist.github.com]

粘帖的文本会被放进一个git仓库，仓库可以通过一个git 克隆URL访问，还可以用git客户端程序检出。不仅如此，联系还是双向的：将提交送回到仓库，新作的修改（以及新增的文件）就可以在Gist的Web界面上访问到，在Web界面上同样可以编辑文本文件。使用Gist，用户可以从粘帖一小段文本或者代码开始，然后通过Web界面或者git工具展开网上的协作。

引自infoq ： [url [www.infoq.com]
July 26, 2008
11:33
Alex学Ruby[ 给类添加behavior更好的方式 ]
» ‎ 51CTO技术博客

Ruby有个特性，你可以随意打开一个class来添加你需要的方法，类似于下面的情况：
class A
end

class A
   def hello
      p  “hello a”
   end
end

这样A的对象就多了一个hello方法。也许这样满足你的需求，可是你注意到没有，you've made a change to class A.

所以高手Jay Field建议我们，不要这么做。
he said :   Use modules instead of adding behavior directly.

class B
end

module Bextend
   def hello
      p  “hello b”
   end
end

B.send :include,Bextend

B.new.hello
#=>   “hello b”

B.ancestors
#=> [B, Bextend, Object, Kernel]

如果你直接opening class去添加你的行为，会增加耦合性（个人理解，欢迎高手指点），而使用module，会更加灵活。

灵活在哪呢？

好，当你使用opening class的方式添加了一个方法：
class Object
  def hello
    "hello"
  end
end
那么现在给你个任务：change the hello method to include the original behavior and add a name.

你怎么做呢？只能这么做了吧：
class Object
  alias old_hello hello
  def hello(name)
    "#{old_hello} #{name}"
  end
end

但是，如果你使用module来代替opening class的方式定义方法：
class Object
  module Hello
    def hello
      "hello"
    end
  end
  include Hello
end

Object.ancestors
#=> [Object, Hello, Kernel]

你要完成上面的任务只需要：
class Object
  module HelloName
    def hello(name)
      "#{super()} #{name}"
    end
  end
  include HelloName
end

hello("Ali")
# => "hello Ali"
Object.ancestors
=> [Object, HelloName, Hello, Kernel]

上面的例子，如果你想调用老的hello方法，只需要个super就够了。
July 22, 2008
8:24
祝你生日快乐
» ‎ 51CTO技术博客

其实7月22号才是你的生日

以往，每年的7月22号零点我会准时对你说，生日快乐

可是今天，我不敢等待这个特殊的日子的到来

因为我害怕

害怕我对你说生日快乐之后

你会反问我：

你是谁？

。。。

我们已经半年多没有联系了

你是否记得我？是否会想起我？

你不会知道

7月22号，已经不只是你的生日

同时也是属于你我的爱情纪念日

更是属于我的

爱情祭日

。。。

贾潇

祝你生日快乐
July 21, 2008
6:24
Alex学Ruby[ Hash方法汇总 ]
» ‎ 51CTO技术博客

一。给Hash添加默认值：

h = {1,2,3,4} #=> {1 => 2, 3 => 4}
h.default = 7
h[1] #=> 2
h[3] #=> 4
h[4] #=> 7
h[5] #=> 7

二。给Hash添加key-value对：
h = {} #=> {}
h.store("a",1) #=> 1
h["a"] #=> 1
h.fetch("a") #=> 1
h["b"] = 2 #=> 2
h["b"] #=> 2
p h #=> {"a"=>1, "b"=>2}
store和[]= 方法是别名的关系, fetch和[]方法是别名的关系。

三。清除Hash的key-value对：
h = {:a => 1, :b => 2}

删除全部的k-v对，有两种方法：
给hash赋空值
用clear方法（这种方法更快一点）

shift方法随机删除k-v对。
h = {:a => 1, :b => 2, :c => 3}
h.shift #=> [:a, 1]
h #=> {:b=>2, :c=>3}
a = h.shift #=> [:c, 3]
a #=> [:c, 3]

delete, delete_if, reject,reject! 方法删除指定的k-v对：
h = {:a => 1, :b => 2}
h.delete(:a) #=> 1
h #=> {:b=>2}
h = {:a => 1, :b => 2} #=> {:a=>1, :b=>2}
h.delete_if {|k,v| v != 3} #=> {}
h #=> {}
h = {:a => 1, :b => 2} #=> {:a=>1, :b=>2}
h.delete_if {|k,v| v != 1} #=> {:a=>1}
h = {:a => 1, :b => 2} #=> {:a=>1, :b=>2}
h.reject {|k,v| v!=2} #=> {:b=>2}
h #=> {:a=>1, :b=>2}
reject方法相当于dup.delete_if{}

四。颠倒Hash的k-v对。
h = {:a => 1,:b => 1} #=> {:a=>1, :b=>1}
x = h.invert #=> {1=>:b}
invert方法可以颠倒Hash的键－值，可是因为Hash键的唯一性，可能会发生上例那样的数据丢失！

五。 Hash的迭代：
有each, each_key, each_value ,each_pair(each方法的别名)
不举例了。

六。检测Hash中的key，value：
 检测是否有key：
 has_key?(include? 别名, 只能判断key! ) ，key?, member?
 检测是否有value:
 has_value? value?

七。将散列转换为数组：
h = {:a => 1, :b => 2}
 h.to_a #=> [[:a, 1], [:b, 2]] 转换为一个二维数组。
 h.keys #=> [:a, :b]
 h.values #=> [1,2]
 下面的方法有用点：
 h = {:a => 1, :b => '2', :c => 5}
 h.values_at(:a,:b) #=> [1, “2”] 根据指定的key返回对应values的数组

八。根据条件选择key-value对：
 h.detect {|k,v| v == "2"} #=> [:b, "2"]
 detect和find是别名关系，是Enumerable模块里的方法，Hash类mixin这个模块，所以也可以用。select 方法，别名是find_all，可以返回多个匹配的k-v对：
h.select {|k,v| v.is_a?(Integer)} #=> [[:a, 1], [:c, 5]]

九。 Hash的排序：
 可以直接用sort方法，不过会返回一个二维数组。
 值得注意的是，当Hash的key是Symbol类型的时候，sort方法会出错。

十。合并两个Hash:
 使用merge方法，( merge!和update是别名关系 (thx Beck) ) 。
h1 = {:a => 1, :b => 2} #=> {:a=>1, :b=>2}
 h2 = {:b => 3, :d => 3} #=> {:d=>3, :b=>3}
 h1.merge h2 #=> {:a=>1, :d=>3, :b=>3}
 h2.merge h1 #=> {:a=>1, :d=>3, :b=>2}
注意看:b值的变化。
当然我们可以使用block来改变这一结局：
 h1.merge h2 do |k,old,new|
 old < new ? old : new
 end
#=> {:a=>1, :d=>3, :b=>2}
h1.merge h2 do |k,old,new|
 p old
 p new
end
#=>2
#=>3
（当然我们可以使用rails里active_support实现的revert_merge来实现上述效果）。

十一。数组转换为Hash:
当数组元素为偶数个数的时候：
 arr = %w[a b c d] #=> ["a", "b", "c", "d"]
 h = Hash[*arr] #=> {"a"=>"b", "c"=>"d"}
 此时数组必须为偶数个元素。

十二。当Hash的key是动态变化的时候：

x = [1,2] #=> [1, 2]
h = {x => 2} #=> {[1, 2]=>2}
h[x] #=> 2
x[0] = 5 #=> 5
h[x] #=> nil
h.rehash #=> {[5, 2]=>2}
h[x] #=> 2
July 17, 2008
10:35
Alex学Ruby[ method lookup in Ruby 和 include && extend]
» ‎ 51CTO技术博客

Ruby里面方法执行到次序是如何的呢？

>> class Foo
>> include Daffy
>> include Bunny
>> end

>> p Foo.new.name
"Bunny"

>> Foo.ancestors
=> [Foo, Bunny, Daffy, Object, Kernel]

这个ancestors方法返回的数组里元素的顺序已经反映出答案。

再看下面的例子：

>> class Bar
>> include Bunny
>> include Daffy
>> end

>> p Bar.new.name
"daffy"

>> class Too
>> def name
>> "Too foo bar"
>> end
?> include Bunny
>> include Daffy
>> end

>> p Too.new.name
"Too foo bar"

当类Too本身已经实现了name方法，则不会找module里mixin的name方法。

下面例子可以看到include和extend的区别
>> class FooBar
>> include Bunny
>> extend Daffy
>> end

>> p FooBar.new.name
"Bunny"
>>p FooBar.name
“daffy”

include 方式mixin的方法是作为实例方法使用的。
而extend方式则是类方法。
>> class BarFoo
>> include Bunny
>> end

>> b = BarFoo.new

>> b.extend Daffy

>> b.name
=> "daffy"
>> p BarFoo.ancestors
[BarFoo, Bunny, Object, Kernel]

上面的例子说明，extend实际是有向某特定的对象追加模块的功能.extend被称为面向特殊类的include。

>> class Foooo
>> include Bunny
>> end

>> f = Foooo.new

>> f.extend Daffy
>> f.name
=> "daffy"

>> p Foooo.new.name
"Bunny"

>> Foooo.extend Bunny

>> p Foooo.new.name
"Bunny"

>> Foooo.extend Bunny
>> Foooo.name
=> "Bunny"

上面的例子，为类Foooo里添加了同为name的实例方法和类方法。
下面的例子也实现同样的功能。
>> class Barr
>> include Bunny
>> extend Bunny
>> end

>> p Barr.new.name
"Bunny"

>> p Barr.name
"Bunny"

>> p Barr.ancestors
[Barr, Bunny, Object, Kernel]

我们看看下面的例子：

>> module A
>> def a
>> puts "i m in Module"
>> end
>> end

>> module A
>> extend self
>> end
=> A

>> A.a
i m in Module

一句extend self，直接让module 里的所有方法变成了module的类方法。
下面的例子效果和这是一样的。就不多说了。

>> module A
>> def self.b
>> puts "i m in b in module"
>> end
>> end

>> A.b
i m in b in module
=> nil
>> module A
>> class < self
>> def c
>> puts "i m in c"
>> end
>> end
SyntaxError: compile error
(irb):109: syntax error, unexpected '<'
class < self
 ^
 from (irb):113
>> module A
>> class << self
>> def c
>> puts "i m in c"
>> end
>> end
>> end
=> nil
>> A.c
i m in c
=> nil
>> module B
>> def aa
>> "aa in B"
>> end
>>
?> def bb
>> "bb in B"
>> end
>>
?> extend self
>> end
=> B
>> B.aa
=> "aa in B"
>> B.bb
=> "bb in B"
>> module C
>> extend self
>> def cc
>> "cc in B"
>> end
>>
?> def dd
>> "dd in B"
>> end
>> end
=> nil
>> C.cc
=> "cc in B"
>> C.dd
=> "dd in B"
6:57
js的浏览器兼容问题解决tip
» ‎ 51CTO技术博客

今天碰到个问题比较郁闷，我的js水平很菜，解决这个浏览器兼容问题，不得不求助于google，可是一搜，竟然连续3页到搜索结果内容都一样，就是说childNodes方法为什么会导致浏览器不兼容问题，可就是不说怎么解决，让我这个菜鸟傻眼了。不过最终我还是解决了，记录一下解决方法。

childNodes方法会返回childnode list数组，对于ie和ff来说，list的内容不一样，所以，我想到用另一种方法来替代这个方法，使用getElementsByTagName
arr ＝ getElementsByTagName('td')
arr[0].innerHTML

ff只支持 innerHTML,而IE支持innerTEXT 和 innerHTML
July 13, 2008
12:00
Alex学Ruby[ 小tip记录 ]
» ‎ 51CTO技术博客

前几天在项目里碰到个问题，需要通过迭代判断一项数据是否在一个数组里，返回值需要是boolean型。比较郁闷的是，当时竟然不知道有Enumerable#any? 这个方法，郁闷啊。

Enumerable里的方法是mixin到Array里的，所以数组可以直接调用了。

例子：
%w{ ant bear cat}.any? {|word| word.length >= 3}
#=> true
%w{ ant bear cat}.any? {|word| word.length >= 4}
#=> true
[ nil, true, 99 ].any?
#=> true
July 11, 2008
9:36
Alex学Ruby[eval && binding]
» ‎ 51CTO技术博客

先看Ruby参考里面对eval和binding的解释：

eval(expr[, binding[, fname[, lineno=1]]])

 把字符串expr当作Ruby程序来运行并返回其结果。若给第二参数传递Proc对象或Binding对象的话，将在生成该对象的环境中对字符串进行计算。请参考binding。

 def foo
 a = 1
 binding
 end

 eval("p a", foo) # => 1

 若指定了fname 和 lineno的话，将假定字符串位于fname文件lineno行，并且进行编译。这时可以显示栈跟踪(stack trace)等信息。

binding

 生成并返回Binding对象。该对象包含变量、方法等的环境信息，它通常用作Eval的第二参数。

由上面信息不难理解。 eval可以把字符串当作Ruby程序来运行并返回其结果，同时也可以指定该字符串运行的环境，只需要加第二个参数就行了，把binding的环境传过去。

太cool了。

例子：
ruby 1.8.7 (2008-06-20 patchlevel 22) [i686-darwin9.2.1]

irb(main):001:0> def foo
irb(main):002:1> x = 1
irb(main):003:1> binding
irb(main):004:1> end
=> nil

irb(main):005:0> save_binding = foo
=> #<Binding:0x8988c>

irb(main):006:0> p eval("x", save_binding)
1

irb(main):007:0> x = 2

irb(main):008:0> p eval("x", save_binding)
1

irb(main):009:0> p eval("x = 5 ", save_binding)
5

irb(main):010:0> p eval("x", save_binding)
5

上例中，eval的第一个参数放在第二个参数所形成的环境里被执行，同时第一个参数影响着第二个参数的闭包环境。

irb(main):011:0> def foo(my_binding)
irb(main):012:1> eval("x", my_binding)
irb(main):013:1> end

irb(main):014:0> def bar
irb(main):015:1> x = 100
irb(main):016:1> foo(binding)
irb(main):017:1> end

irb(main):018:0> p bar
100

irb(main):019:0> def foo(my_binding)
irb(main):020:1> x = 200
irb(main):021:1> eval("x", my_binding)
irb(main):022:1> end

irb(main):023:0> p bar
100

上例中x的值已经和bar方法里的x绑定好了，任凭你foo方法如何改变都是无用的。

irb(main):024:0> x = 100
=> 100

irb(main):025:0> block_var = lambda{ x }
=> #<Proc:0x00044f98@(irb):25>
irb(main):026:0> def foo(blk)
irb(main):027:1> blk.call
irb(main):028:1> end

irb(main):029:0> p foo(block_var)
100

上例中，lambda对象已经和x ＝ 100 形成了一个闭包。

你call他的时候当然是得到100.

class << Object
 def xxx(name,klass)
 define_method( name ) { eval "@#{name} ||= #{klass}.new" }
 end
end

class << Object
 def attr_init(name, klass)
 eval "define_method(name) { @#{name} ||= #{klass}.new }"
 end
end

这两种写法的区别是：第二种写法只需要调用一次eval方法，而不是在每次进行方法定义时都去重新调用eval。
July 01, 2008
8:05
hope
» ‎ 51CTO技术博客

就等你的一个眼神就能为你长征
为你占领所有边城和天上的星辰
June 27, 2008
2:34
在线测试所有浏览器的兼容性
» ‎ 51CTO技术博客

web开发者的福音

[url [browsershots.org]
June 26, 2008
11:13
Alex学Ruby[ class_eval(module_eval)现形记]
» ‎ 51CTO技术博客

class_eval和module_eval方法一样，都是为一个class增加method的。可以接string和block为参数。此方法是Ruby的动态特性之一。

class Thing
end
a = %q{def hello() "Hello there!" end}

Thing.module_eval(a)
puts Thing.new.hello()
＝> Hello there!

例子：
class Wes
end

Wes.class_eval <<-END
 def hello
 puts "#{y}"
 puts y
 end
END
Wes.new.hello
＝> another hi
NameError: undefined local variable or method `y' for #<Wes:0

那么：what's the diff between puts y and puts "#{y}" in class_eval ？

我真没想到Matz还到ruby－forum里去混，姑且认为是Matz本人吧，他给出的答案是：

用#{y}是在compile time 的时候已经把y的值传给了class_eval.
在运行时， puts “#{y}” 已经变成了 puts “another hi”
而变量y，则因为作用域的不同，外部定义的局部变量y是class_eval无法收到的。

这有个有意思的例子更加说明了这一点：

class T
 def first
 "hello"
 end
 def second
 "chunky bacon"
 end
end

y = "first"

T.class_eval <<-END
 def hello
 puts #{y}
 end
END

T.new.hello
=>prints "hello"

关键点是， #{y}是作为string的一部分传给了class_eval. 此时已经是puts first了。而不是在call hello方法的时候去找y
June 24, 2008
9:44
Alex学Ruby[详解 block和Proc对象 2]
» ‎ 51CTO技术博客

Ruby Block Part Two
本部分内容是基于Ruby 1. 8. 7, 以后的系列都是1.8.7下测试。

例子1 ：
def return_using_procnew
  a_proc = Proc.new { return "Hi" }
  a_proc.call
  "Last line in the method"
end

=>  “ Hi”

def return_using_lambda
  a_proc = lambda { return "Hi" }
  a_proc.call
  "Last line in the method"
end
=> "Last line in the method"
以上例子可以看出lambda和Proc.new的区别，用lambda的时候return会被劫持，而Proc.new则不会。

例子2:
def foo(proc_one,proc_two)
  proc_two.call
  proc_one.call
end

foo(lambda {p "Proc 1"}, lambda {p "Proc 2"})     =>   "Proc 2"  "Proc 1"

def foo(proc_one,proc_two)
  proc_one.call
  proc_two.call
end

foo(lambda {p "Proc 1"}, lambda {p "Proc 2"})     =>   "Proc 1"    "Proc 2"

例子3:

def foo(&my_block)
   my_block.call
end

foo { puts "Hi" }
=>        Hi

foo (lambda{ puts "Hi" })
=> ArgumentError: wrong number of arguments (1 for 0)

def foo(a,&my_block)
  a.call
end

foo (lambda{ puts "Hi" })
=>   Hi

def foo(&my_block)
  my_block.call
end

foo { puts "Hi" }
=>  Hi
例子4:

1.times do
  x = 5
  closure = Proc.new {puts "In clsure value of x is #{x}
end

closure.call
=>     In clsure value of x is 5

x = 1

puts x
=>     1

closure.call
=>     In clsure value of x is 5

由此看出，闭包引用的变量是call这个proc对象时产生的变量，在外部修改其值是没用的。

例子5:
class GreetingGenerator
  def initialize(greeting)
    @my_block = lambda {|name| puts "#{greeting}, #{name}"}
  end
  def greet(name)
    @my_block.call name
  end
end
frenchGreeting = GreetingGenerator.new “Bonjour”
englishGreeting = GreetingGenerator.new “Hello”
frenchGreeting.greet “TinTin”
    =>     Bonjour, TinTin
englishGreeting.greet “Bunny”
    =>     Hello, Bunny
这你能看出来什么？
例子6:
def repeat(n)
  n.times {yield} if block_given?
end
repeat(2) {puts "Hi"}

def repeat2(n, &block)
  n.times {block.call} if block
end
repeat2(2) {puts "Hi2"}

def repeat3(n,&block)
  n.times {yield} if block
end
repeat3(2){ puts "Hi3" }
这三种写法的目的是一样的。
例子7:
  print  "(t)imes or (p)lus"

  times = gets

  print "number:"
  number =  Integer(gets)
  if times =~ /^t/
    calc = lambda {|n| n*number }
  else
    calc = lambda {|n| n + number}
  end

  p((1..10).collect(&calc).join(", "))
这个例子也是闭包的概念。
例子8:
words = %w(Daffy, Bugs, Alvin)
upcase_words = words.map( &:upcase )

p upcase_words
例子的map(&:upcase)相当于map{ |x| x.upcase }
这个是如何实现的？其实Symbol类内部实现了一个to_proc方法：
class Symbol
  def to_proc
    lambda { |x,*args| x.send(self, *args) }
  end
end
map方法只接受代码块，通过使用&可传递proc，来代替显示的使用代码块。而这个时候&被应用于不是proc的对象，而传进来的本身是个符号对象（:&upcase）,所以解释器自然而然的就会调用符号类的to_proc方法来得到一个proc。to_proc方法里的self引用的是对其调用了to_proc的符号。
9:41
Alex学Ruby[详解 block和Proc对象]
» ‎ 51CTO技术博客

Ruby block Part One:
本部分内容是基于Ruby 1. 8. 7

lambda方法：
例子1：
myBlock = lambda {|x| puts x} =>#<Proc:0x00008908@(irb):1>
myBlock.call("Ruby way")
=> Ruby way
puts myBlock.class
=> Proc
由此例子可以看出， lambda方法可以直接生成一个Proc对象。
例子2:
sub_lambda = lambda {|x,y| x - y}
=> #<Proc:0x0007ff44@(irb):4>
sub_lambda(2)
=>NoMethodError: undefined method `sub_lambda' for main:Object
sub_lambda.call(2)
=>ArgumentError: wrong number of arguments (1 for 2)
sub_lambda.call(2,3,4)
=>ArgumentError: wrong number of arguments (3 for 2)
sub_lambda.call(2,"3")
=>TypeError: String can't be coerced into Fixnum
sub_lambda.call(2,3)
=> -1
由此例可以看出，lambda生成的proc对象必须被call才可被调用。而lambda方法会检查传入的参数个数,和参数类型。
例子3:
sub_procnew = Proc.new {|x,y| x-y}
=> #<Proc:0x00052238@(irb):12>
sub_procnew.call(4)
=>TypeError: nil can't be coerced into Fixnum
sub_procnew.call(4,3,5)
=> 1
sub_procnew.call(4,"3",5)
=>TypeError: String can't be coerced into Fixnum
sub_procnew.call(4,3,"5")
=> 1
由此例看出，Proc.new生成的对象不会去检查参数个数，只是多退少补（nil），但是会检查参数数据类型。
例子4:
def call_block_twice
 yield
 puts “going to call the block”
 yield
 puts “Going to call the block again”
end
call_block_twice {puts “This is a block”}

这个例子是两次调用块的例子。
我们可以重写这个方法：
def multiple_yield(n)
 if block_given?
 n.times { yield }
 else
 raise ArgumentError.new(“Block is required to call yield multip times”)
 end
end
multiple_yield(2) { puts “I m a block”}
例子5，你也可以这么写：
def foo(&block)
 block.call
end
foo {puts “Hi”}
9:34
Alex学Ruby[告诉你符号和范围的真相]
» ‎ 51CTO技术博客

符号：
＝＝＝＝＝＝＝＝你知道吗？

Ruby 里Symbol的实例就是一符号。
每个符号只有一个实例对象（类似于Fixnum）。
arr = ["foo","foo","foo",:bar,:bar,:bar]
数组arr里的三个foo字符串分别是独立的三个对象，而那三个:bar是同一个字符对象的三个引用，所有有种说法，符号比字符串节省内存，可提高性能。

一个符合对应一个数字，存储为直接值。可以使用to_i获取该数字。

>> :bar.to_i
=> 20041
>> :foo.to_i
=> 14585

＝＝＝＝＝＝＝＝你知道吗？

一个把字符当作元值的例子：假设一个从网络中获取字符串的方法，可在发生异常时返回非字符串的值。
str = get_string
case str
when String
...
when :eof
#end of file, socket colosed, whatever
when :error
#I/O or network error
when :timeout
# didnt get a reply
end
看起来比异常处理要好，

＝＝＝＝＝＝＝＝你知道吗？
又一个例子：
>> sym1 = :@foo
=> :@foo
>> sym2 = :foo
=> :foo
>> instance_variable_set(sym1,"str1")
=> "str1"
>> instance_variable_set(sym2,"str1")
NameError: `foo' is not allowed as an instance variable name

如果用instance_variable_set必须指定准确的变量名。

＝＝＝＝＝＝＝＝你知道吗？
>> :bar.to_s
=> "bar"
>> :bar.to_str
NoMethodError: undefined method `to_str' for :bar:Symbol
from (irb):10
>> "bar".to_sym
=> :bar

to_s和to_sym方法来进行字符串和符号之间的转换。

＝＝＝＝＝＝＝＝你知道吗？

list = words.map{|x| x.upcase}

我们可以在Symbol类里定义一个to_proc方法，
def to_proc
proc{ |object,*args| object.send(self,*args) }
end

有了这段代码我们可以重写：
list = words.map(:&upcase)

解释： map方法只接受代码块，通过使用&可传递proc，来代替显示的使用代码块。而这个时候&被应用于不是proc的对象，而传进来的本身是个符号对象（:&upcase）,所以解释器自然而然的就会调用符号类的to_proc方法来得到一个proc。to_proc方法里的self引用的是对其调用了to_proc的符号。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－>>>>>>>>>>>>>>>>>>>>>

范围：

范围的起点和终点可以是任何Ruby对象，范围一般用于迭代。

＝＝＝＝＝＝＝＝你知道吗？

>> r1 = "7".."9"
=> "7".."9"
>> r2 = "7".."10"
=> "7".."10"
>> r1.each{|x| puts x}
7
8
9
=> "7".."9"
>> r2.each{|x| puts x}
=> "7".."10"

两个看起来相似的范围对象，为什么迭代以后就有了不同的值呢？

原因在于第二个范围对象r2，其终点是长度不同于r1终点的字符串。对r2进行迭代的时候，一般是以当当前值大于终点值时候结束循环，而字符串"7" 是大于"10"的，所以根本没有循环。用作终点的类，必须定义了有意义的succ方法。不能对浮点数范围进行迭代，因为浮点数没有succ方法。
>> "7" > "10"
=> true
要随时注意使用的范围是否是字符串范围，否则会得到意想不到的结果：
>> r1 = "2".."5"
=> "2".."5"
>> s = "28"
=> "28"
>> r1.include?(s)
=> true

＝＝＝＝＝＝＝＝你知道吗？

将范围用于条件句中，将被特别对待，. . 这种用法这个时候被称为flip-flop运算符。有个例子，想输出一个ruby文件里＝begin和＝end之间的line。
loop do
break if eof?
line = gets
puts line if (line =~ /=begin/) .. (line =~ /=end/)
end

像这种根本不是范围，这个时候不能把它当范围来认知。

＝＝＝＝＝＝＝＝补充
Ruby的遗憾是：
(1..5).to_a #=> [1,2,3,4,5]
(1...5).to_a #=> [1,2,3,4]

不能不包含其起点。。。
9:33
Alex学Ruby[最重要的数据类型‘字符串’]
» ‎ 51CTO技术博客

1. 我最早学的语言是大一学的C语言，现在忘的差不多了，但我还记得C语言里的字符串是以空字符结束的，但Ruby不是，所以，Ruby的字符串里可以包含空字符。

2. Ruby里的字符串分为两种，其中最简单的一种是用单引号括起的字符串，表示的完全是字面意义，唯一支持的转义序列是单引号和反斜杠
>> str = 'i m \'ok\', a u ok\? \\xie \\'
=> "i m 'ok', a u ok\\? \\xie \\"
>> str = 'i m \'ok\', a u ok\? \\xie \''
=> "i m 'ok', a u ok\\? \\xie '"
另外一种就是双引号括起来的字符串，常用的。

3. 我们也可以用其他方法表示字符串，%q和%Q, 后面只需要把字符串包含到一对分隔符之间就行了，你可以用中括号，小括号，大括号。up to u
>> str = %q[\?xxx]
=> "\\?xxx"
>> str = %Q[\?xxx]
=> "?xxx"
>> str = %Q(\?xxx)
=> "?xxx"
同样，你也可以使用非成对分隔符来表示（字母数字空格除外）：
>> str = %Q* \? yyy \? *
=> "? yyy ?"
由此可见，小q代表单引号，大q代表双引号。一般这种字符串写法是有那种需要包含大量元字符的需求下要使用。

4. 我们需要把字符串多行表示，但又不想把缩进也作为字符串的一部分，那么就可以用here文档。关于here文档，我之前只知道其形式：
语法符号<<后面加一对开始结束标记，标记之间放你想要的内容即可。
str = <<EOF
i m ok
a u ok?
EOF
但是，今天，我知道了其需要注意的几个地方；
1）结束标记末尾不能有空格。
>> str = <<EOF
sdfsd
EOF ＃这行结束标记前后都有空格，所以ruby不识别
EOF
=> "sdfsd\n EOF\n"
2) 但是你可以消除结束标记前面的空格，只需要要用<<- 语法符合：
>> str = <<-EOF
sfdsf
EOF ＃前面有空格，后面没有空格，ruby可以识别，但是后面有空格就不行了。
=> "sfdsf\n"

2) 默认的here文档相当于双引号字符串。但是你可以改变其为单引号模式：
>> str = <<'EOF'
\? xx
EOF
=> " \\? xx\n"

5. 读取文件的时候，可以将读取出来的文件存储到字符串里，字符串里就包含了换行符，默认的each方法是按行处理的：
>> str = "tell you a truth \nlong time ago...\nThe end"
=> "tell you a truth \nlong time ago...\nThe end"
>> num = 0
=> 0
>> str.each do |s|
?> num += 1
?> print "LINE #{num} : #{s}"
>> end
LINE 1 : #LINE 1 : tell you a truth
LINE 2 : #LINE 2 : long time ago...
LINE 3 : #LINE 3 : The end

6. 字符串转成字符数组：
>> str = "ABC"
=> "ABC"
>> chars = str.scan(/./)
=> ["A", "B", "C"]

7. 一般的字符串之间比较通常是比较首字母ASCII码值的大小：
>> ?s => 115
>> ?u => 117
>> str1 = "sbu"
=> "sbu"
>> str2 = "usb"
=> "usb"
>> str1 < str2
=> true
>> str1 > str2
=> false
但我们如果想忽略字符串首字母来比较呢？我们可以重写ufo比较符（<=>）:
class String
alias old_compare <=>
def <=>(other)
a = self.dup
b = other.dup
a.gsub!(/^./i,"")
b.gsub!(/^./i,"")
a.strip!
b.strip!
a.old_compare(b)
end
end

>> s1 = "ss" => "ss"
>> s2 = "ub" => "ub"
>> s1 < s2 => false
>> ?s => 115
>> ?u => 117
>> ?b => 98

注意的是，＝＝运算符并不会调用<=>方法，如果我们要自定义的方式来判断字符是否相等，需要我们重写== 方法。

8. 有时候我们需要分解字符串：
>> str = "foo, bar, foobar, , " => "foo, bar, foobar, , "
>> l1 = str.split => ["foo,", "bar,", "foobar,", ","]
>> l1 = str.split(",") => ["foo", " bar", " foobar", " ", " "]
>> l1 = str.split(",",2) => ["foo", " bar, foobar, , "]
>> l1 = str.split(",",4) => ["foo", " bar", " foobar", " , "]
>> l1 = str.split(",",6) => ["foo", " bar", " foobar", " ", " "]
>> l1 = str.split(",",8) => ["foo", " bar", " foobar", " ", " "]
>> l1 = str.split(",",10) => ["foo", " bar", " foobar", " ", " "]
>> l1 = str.split(",",-1) => ["foo", " bar", " foobar", " ", " "]
>> l1 = str.split(",",-2) => ["foo", " bar", " foobar", " ", " "]

9. >> str = "a A b C d D xx" => "a A b C d D xx"
>> str.downcase => "a a b c d d xx"
>> str.upcase => "A A B C D D XX"
>> str.capitalize => "A a b c d d xx"
>> str.swapcase => "A a B c D d XX"

casecmp方法和<=>类似，但是忽略大小写：
>> "AAA".casecmp("aaa") => 0

10. to_s 和 to_str有什么区别：
原则上任何对象都可以转换为某种字符串表示，这也是几乎每个核心类都有to_s方法的原因。这是一种强制转换，但几乎核心类都没有实现to_str方法。to_str被认为是一种隐式转换, 隐式转换的结果应为对象的真正字符串值。 puts方法调用对象的to_s方法以获取其字符串表示，这属于对显示转换的隐式调用。
class Haha
def to_s
"ha"
end

def to_str
"haha"
end
end

h = Haha.new
puts h
>> puts "H is " + h
H is haha
>> puts "H is " << h
H is haha
>> puts "H is #{h}"
H is ha

假如我们有个方法，需要接受一个字符串为参数，但是如果传个非字符串进来会出问题的，我们如何解决这个问题？
1. 可以显示的调用to_s方法把参数转成字符串表示，或者检查是否为String类型，也可以只管往下执行，但是肯定会报错。
2.我们可以这么做： param = param.to_str rescure param.to_s rescure param

11. #{} 对于全局变量，类变量和实例变量可以省略大括号。

12. 其他的一些String自带的操作字符串方法。。。
9:31
Alex学Ruby[字符编码与国际化]
» ‎ 51CTO技术博客

背景：
字符数据是最为重要的数据类型，为什么呢？因为程序是为人服务的，那些能直接读懂二进制数据的超人是很少的。但是如何用二进制数据表示字符呢？这个时候“编码”就诞生了，简单来说，编码就是二进制数据和字符之间建立的映射。ASCII码出现了。但是世界这么大，给你一个字符，你如何知道这是哪种文字的字符属于哪个国家哪种文化呢（火星文除外）？刚开始出现的ASCII码，只是面向英语的，像欧洲国家的人就没有那么福分去享受这个字符集了，于是就出现了所谓的世界字符集Unicode,有人说Unicode只有65530个字符，其实是不对的。实际上它可以表示无限个字符。

要点：
如果你在Ruby中想使用不同的字符集，那么请记住$KCODE这个全局变量，该变量有常用的五种设置，每种设置都是单个不区分大小写的字母：
1. a: ASCII
2. n : NONE(ASCII)
3. e: EUC
4. s: SJIS
5. u: UTF-8
你可以这么设置，$KCODE = 'u' ,也可以这么设置，$KCODE = 'UTF-8' , 仅仅第一个字符（U）管用。

当使用utf－8的时候require jcode这个库会很有帮助。

消息目录是指用特定的语言表示的消息集合，是本地化思想中不可分割的一部分。其思想是，将与语言相关的字符串和应用程序的其他部分分离，这样只需要“插入”不同的目录就可获得用不同语言表示的消息和字符串。Ruby里的GetText-Package库是实现这一功能的最佳方式，这是小日本Masao的劳动结晶（Masao虽然是个小日本，但是我挺佩服这个人的，年纪好像是三十多了吧，除了日常工作，还维护gettext这个库，维护两个blog，一个是日文的，一个是英文的，曾经我也效仿这个小日本写英文blog，但是没有坚持下去，真是失败），Rails的多个国际化插件都是基于Gettext库来实现的。GNU有个gettext程序，小日本写的这个是模仿GNU这个gettext写的ruby实现。

想使用其基本功能，需要require 'gettext'
想使用更有用的实用程序，需要require 'gettext/utils'

Ruby1. 8 .6没有包含这个gettext库，需要自己安装 gem install gettext
关于gettext有三个关键的术语需要解释：
1. po - file : 可移植的对象文件，是人类可读的形式，每个po－file对应一种文化的语言，也叫模板文件。
2. mo - file ：是可移植的二进制消息目录文件，是根据po－file创建的，Ruby库读取的是mo－file，而不是po－file。
3. text domain ：文本域，实际上是mo－file的basename，这个是和应用程序所绑定的。

所以有了文本域，和应用程序绑定以后，我们只需要写一个po－file文件，然后生成mo－file文件，就可以实现本地化了。

网上找了个简单的例子：
require 'gettext'
class Person
include GetText

def initialize(name, age,children_num)
@name, @age, @children_num = name, age, children_num
blindtextdomain("myapp")
end

def show
puts _("information")
puts _("Name: %{name}, Age: %{age}") % {:name => @name, :age => @age}
puts n_("%{name} is an unmarried.", "%{name} has %{num} boy or girl firend.", @firend_num) % {:name => @name, :num => @firend_num }
end
end

alex = Person.new("Alex",26, 0 )
alex.show
mary = Person.new("Mary", 18, 0)
mary.show

上面的例子里,
puts _("Name: %{name}, Age: %{age}") % {:name => @name, :age => @age} ,这种写法我估计是gettext里实现的。
n_方法是除了单复数的。将上面的文件保存为myapp/person.rb，然后再创建一个myapp/Rakefile文件 , 主要目的是为了更新po－file和创建mo－file
require 'gettext/untils'

desc "Update pot/po file"
task :updatepo do
GetText.update_pofiles("myapp", ["person.rb"], "myapp 1.0.0")
end

desc "Create mo-files"
task :makemo do
GetText.create_mofiles
end

上面的代码中，update_pofiles将根据person.rb创建初始的myapp/po/myapp.pot, 当它第二次被调用的时候，会对myapp/po/myapp.pot及所有的myapp/po/#{lang} /myapp.po 文件进行更新和合并。此方法的第二个参数是目标文件组成的数组。
create_mofiles 将创建子目录data/locale/，并根据po－file生成mo－file。

这样，当我们执行rake updatepo这个命令之后，将创建目录 myapp/po/myapp.pot. 打开myapp.pot这个文件会看到对应用程序的一些描述信息，是注释掉的，注释行里有这样一行：

#, fuzzy

这个表示是还没有被翻译的内容或者是需要校译的内容。
然后我们就可以复制myapp.pot这个文件为myapp.po，来发给翻译者了。翻译者把翻译好的po文件（这个时候那个fuzzy就应该被移除）发给开发者，然后把这些po文件放到相应的语言目录下，比如中文的放在：
myapp/po/zh_ch/myapp.po目录下，德文的放在myapp/po/de/myapp.po下。然后我就执行rake makemo，这样程序会根据这些po文件生成mo文件，生成的mo文件将放在myapp/data/locale目录下。整个目录结构如下：
myapp/
Rakefile
person.rb
po/
myapp.pot
zh_cn/myapp.po
de/myapp.po
.
.
data/
locale/
zh_cn/LC_MESSAGES/myapp.mo
de/LC_MESSAGES/myapp.mo
.
.

然后我们可以测试一下：
首先我们需要设置环境变量，
export GETTEXT_PATH="data/locale"
export LANG="zh_CN.UTF-8"
ruby person.rb
这样应用程序会根据变量LANG的设置情况输出对应的值。

以上设置环境变量主要是为了在控制台下测试这个简单程序而已，在本地化应用里将不会使用这个环境变量。
9:30
Alex学Ruby[关于Ruby，你知道吗？]
» ‎ 51CTO技术博客

好久没有支持小废了。今天发一些Ruby语法系列文章，这是第一部分：

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
一。
大家都知道：
foo( a, b, c )
foo a, b, c

上面两组分别是相同的写法，对于一个方法，括号是可以省略的。
插播：关于诗歌模式（poetry model）, 括号可以省略属于诗歌模式，这是Ruby术语，就是省略不必要的标点符号。
现在有三个方法，
>> def x(a)
>> puts "i m a"
>> end

>> def y(b)
>> puts "i m b"
>> end

>> def z
>> puts 'i m c'
>> end
那么：
>> x y z
会输出什么？

(irb):28: warning: parenthesize argument(s) for future version
i m c
i m b
i m a
=> nil

看结果，x y z 相当于 x(y(z))

Ruby解释器会尝试理解它发现的内容，这是Ruby的魅力。但是像x y z这样的写法，是不容易被读懂的，有的人可能会理解为x有两个参数y,z 所以该上括号的时候还是用括号，我们可以这么写
>> x y(z)
i m c
i m b
i m a
=> nil

这样解释器就不会发出警告了。

在什么情况下一定要使用括号呢？
>> def get h
>> puts "i m hash" if h.is_a?(Hash)
>> end

如果你这么调用：
>> get {:a => 1}
会报错，这个时候左括号{ 会被认为是代码块的开始。
>> get ({:a => 1})
i m hash
=> nil
如果hash是唯一的参数，可以省略大括号。
>> get(:a => 1)
i m hash
=> nil

二。

请问：_COUNTES = 1
这个_COUNTES是不是常量？

提示，创建标识符时，下划线是按小写字母处理的。

三。
请问： nil? 和 chop!这种带有问号和叹号的方法中，问号和叹号是标识符的一部分吗？

提示，如果是标识符的一部分，那么是可以把问号和叹号放到标识符的任意一个位置的，但是那是不允许的。

四。
self , nil , true, false, _FILE_, _LINE_ 是伪变量。看起来像局部变量，实际是有特殊的用途。

五。
str = "First" 'second'.center(20) 和 str = "First" + 'second'.center(20) 相同吗？

提示，字符串静态拼接的时候，拼接的优先级要低于方法调用。

六。
如何得到一个字母的ASCII码？

>> ?A
=> 65
>> ?a
=> 97

七。

J-kanban 玄人志向 » 51CTO技术博客

Feeds

51CTO技术博客 (50 unread)