• arr = [["a:1","b:0"],["c:2","b:0","d:5"]]
    
    hash = {}
    arr_size = arr.size
    
    arr.each_with_index do |a, i|
        a.each_with_object({}) do |str, h|
            str =~ /^(.*):(.*)$/
            h[$1] = $2
        end.each do |k, v|
            hash[k] ||= [nil] * arr_size
            hash[k][i] = v
        end
    end
    
    p hash
    
  • 赋值问题 at 2014年05月28日

    你的需求应该subWorkFlowPath = doc.elements.map("library/section") { |e| e.attributes["name"] }

  • 赋值问题 at 2014年05月28日

    ruby 所有的方法都有返回值,Array#each 返回数组本身,即puts subWorkFlowPathputs doc.elements是一样的

  • 用 method_missing 也可以

  • 时间的遍历如何写? at 2014年05月21日

    #4 楼 @QueXuQ 你看 Date 的方法啊,有 next_month, next_year,而且遍历天的时候顺便年月不都遍历了么。

  • 时间的遍历如何写? at 2014年05月20日

    require 'date'
    
    day1 = Date.new(2013, 10, 9)
    day2 = Date.new(2014, 5, 20)
    
    (day1..day2).each do |i| 
    # do something
    end
    
  • 我认为一个对象的单例方法优先级最高,上面的第二段代码跟我下面的代码结果一致。

    module Foo
      def bar
         "bar in the Module Foo"
      end
    end
    
    class FooBar
    end
    
    f = FooBar.new
    
    class << f
        def bar
            "bar in class FooBar"
        end
    end
    
    f.extend Foo
    f.bar
    
  • 主要是 Ruby 的钩子方法,让父类(或 module)对子类(或 include module 的对象)的控制能力异常的强大。

  • 来段小清醒的代码 at 2014年05月07日
    def huiwen str
        0.upto(str.size / 2) {|i| return false if str[i] != str[-(i + 1)]}
        true
    end
    
  • 凑数 at 2014年05月06日

    之前写过凑 24 点的,可以借鉴一下 https://gist.github.com/piecehealth/9342052

  • 求数组的子集 at 2014年05月04日

    #2 楼 @bluexuemei

    a = [*0..9]
    
    def c arr, n
        return arr.map {|i| [i]} if n == 1
        rets = []
        arr.each_with_index do |ele, i|
            rets += c(arr[i + 1, arr.size - i - 1], n - 1).map {|a| [ele, *a]}
        end
        rets
    end
    
    def all_sub_arrs arr
        rets = []
        1.upto(arr.size) do |i|
            rets += c(arr, i)
        end
        rets
    end
    
    require 'benchmark'
    
    Benchmark.bm do |x|
        x.report do
            result = []
            1.upto(a.size) {|i| a.combination(i).each {|sub_arr|  result << sub_arr.to_a}}
        end
        x.report {result = all_sub_arrs a}
    end
    

    自己实现 combination 肯定没有 ruby 自带的快,Array 内置的方法都是 c 写的。

  • 求数组的子集 at 2014年05月04日

    1.upto(a.size) {|i| a.combination(i).map {|sub_arr| puts sub_arr.to_a.join(', ')}}

  • 数字分组 1 at 2014年04月30日
    arr = (0..9).to_a.shuffle
    [arr[0, 2], arr[2, 4], arr[6, 4]].map &:sort
    

    两行不行么

    没看见所有

  • 人家开头就说了,Rails Tutorial 不是面向纯新手的

    Inexperienced programmers: The Rails Tutorial is not aimed principally at beginning programmers, and web applications, even relatively simple ones, are by their nature fairly complex.

    不过对我(非职业 web 开发人员)来说,Rails Guides 更合适一些。

  • 我的《Ruby 元编程》就是在上海书城买的……陪别人逛的时候偶尔看到,马上就买了。

  • #24 楼 @chenge 可以,我没想太多随便写的,你最好修改一下。ruby-china 没有站内信功能么。。。

  • attr_reader :title之后 title 返回的是@title,但是你你看Product.take.instance_variables里根本就没有@title,所以相当于你重写了 Product#title,使其返回一个不存在的@title

  • #12 楼 @reus 因为 Python 中的 foo 跟 foo() 不是一个东西,所以用 Python 写起来更自然。 对方法的引用 Python 是 foo,而 Ruby 是 self.method(:foo),其间并没有另外创建或者包装,因为这个 method object 实际就存在,只是通过一种很不 python 的方式取 (既 self.method(:foo))。 同样,调用一个作为参数的方法 Python 也更简单,加个括号foo()就行了,Ruby 就只能傻傻的 call 了,但是我认为本质都是一样的,只是 python 的马甲 (语法糖) 更好看一些就是了。

    不过话说回来,个人认为修饰器不是很 Ruby way,如#6 楼所说,当你用 Ruby 怀念修饰器的时候,肯定有别的更合适的方案,就算非要用修饰器,自己写一个满足自己需求的也不是很难,一楼已经证明。

  • #10 楼 @chenge 就是想说 ruby method 一样可以是对象,可以当参数传进别的方法。但是本质上没什么用,send 就已经很好用了。

  • #7 楼 @reus 这样算不算可以被引用的对象

    def hello method
        puts "hello, #{method.name}"
        method.call
        puts "goodby, #{method.name}"
    end
    
    def foo
        puts "i am foo"
    end
    
    hello method(:foo)
    
  • #3 楼 @reus Ruby method 可以是对象 http://www.ruby-doc.org/core-2.1.1/Method.html 顺便山寨一下 makeHtmlTag 那个例子

    module Decrorator
    
        def wrap method_name
            WarppedObj.new method_name, self
        end
    
        class WarppedObj
    
            def initialize method_name, context
                @method_name = method_name
                @context = context
                context.class_eval do 
                    @@_warped_counter ||= {}
                    @@_warped_counter[method_name] ||= 0
                end
            end
    
            def with method_name, *args
                warpped_method = @method_name
                @context.class_eval do
                    @@_warped_counter[warpped_method] += 1
                    alias_method :"#{@@_warped_counter[warpped_method]}_#{warpped_method}", warpped_method
                    i = @@_warped_counter[warpped_method]
                    define_method warpped_method do |*_args, &_blk|
                        ret = __send__ :"#{i}_#{warpped_method}", *_args, &_blk                 
                        __send__(method_name, *args) {ret}
                    end
                end
            end
        end
    
    end
    
    
    class HTMLHelper
        extend Decrorator
    
        def makeHtmlTag tag, opts
            "<#{tag} #{opts.map {|key, value| %Q{#{key}="#{value}"}}.join(' ')}>" + yield + "</#{tag}>"
        end
    
        def hello
            'hello world'
        end
    
        wrap(:hello).with :makeHtmlTag, 'i', class: 'italic_css'
        wrap(:hello).with :makeHtmlTag, 'b', class: 'bold_css'
    end
    
    puts HTMLHelper.new.hello # <b class="bold_css"><i class="italic_css">hello world</i></b>
    
  • 看看这道题怎么做, $SAFE=4 at 2014年03月20日

    log.group_by {|l| l[:time]}.values.map {|arr| arr.inject &:merge}

  • Module.class_variables + Module.class_variable_set

  • #3 楼 @diguage 按一楼说的方法把第一个 vm 导出来,然后第二个 vm 基于第一个 vm 导出的 box 文件建。