目前项目团队不支持 remote，因为常需要使用公司的内网络环境以及需要面对面沟通。。（但是平时工作不加班个人时间充裕，偶尔有私事的话也可以在家办公

从 Senior 到 Principle 都考虑，欢迎投简历！！

还需要招几个人，从 junior，senior 到 principle 都可以，大家请尽快发简历哦 :)

#5 楼 @darkbaby123 "You Don't Know JS" +1 还有还有，Ruby 和 JS 的内部原理都差不多，都源自 smalltalk+scheme_lisp, 强烈推荐

如果是求 >=4 的 10 个随机数，就比较简单：

def samples_for_sum(sum, k) # generate k rand values greater than 1, whose sum is 'sum'
  seq = [0] + (1...sum).to_a.sample(k-1).sort + [sum]
  seq.each_cons(2).map{|pre, cur| cur-pre}
end

def sum_samples_at_least(min, sum, k)
  cut = min-1
  samples_for_sum(sum-k*cut, k)
    .map{|i| i+cut}
end

all = sum_samples_at_least(4,80,10)
p all, all.inject(:+)

是的，上面说的都很清楚了。

x = Object.new
x.do_it #=> 就会去x的类里（也就是Object里）找do_it方法

Object.do_it #=>就会去Object的类里，也就是 Class里找do_it，因为找不到就会去Class的超类也就是Object里找do_it

1. Ruby MRI 为了线程安全，用了 GIL 只支持单核。任何时刻只有一个线程在运行：当一个 Thread 阻塞时（比如 IO, sleep 等），就会切换到另个一线程。 所以就算用了 celluloid, puma 自动创建多线程的，MRI 下每个进程还是单核。
2. 而 Rubinius，JRuby 则没有 GIL，支持多核（每个线程分配一个 cpu）。
3. 如果 MRI 下要用多核，就要用 sidekiq 之类的跑多个 worker 进程。
4. 单核不一定比多核慢，很多时候瓶颈不在 CPU，而 MRI 多线程可以保证 IO 并发，所以性能可能是一样的。
5. 多进程消耗内存，而且进程间难以通信 (只能通过 IO 之类的)。多线程，直接共享变量（内存）。

既然知道类，为什么不直接用实例或者直接定义成类方法呢？klass.new.foo

class C
  def bar; 'instance bar' end
  def baz; 'instance baz' end
end

class C
  def self.become_evil(*names)
    obj = new
    names.each{|name| define_singleton_method(name, &obj.method(name.to_sym))}
  end

  become_evil :baz, :bar
end

C.bar
C.baz

#8 楼 @cicholgricenchos 呵呵，应该是的，我也不是太确定。。。

运行到定义 proc 代码的时候，把当时的本地变量表从 stack 复制一份到 heap 上，然后让这个 proc 引用它。所以后边再声明的变量都不会加到这个 heap 复制表（而是加到 stack 上），所以新加的变量都找不到。

然后，应该是直接编译成类似 self.send(:b) 了，而不是运行时才查询变量表链，这样效率挺高的。

哈哈，推荐这本书，配图讲的比较清楚，我看完后比以前明白了一点。

1. closure(包括 block, proc, lambda) 语法作用域是绑定死的，动态的部分只有参数表和 self(通过 instance_eval 等改变)。
2. 执行一个 proc 的时候，先检查 lexical_scope_chain 每个本地变量表，如果没有再检查当前 self 的方法表。
3. 创建 proc 时，只会到绑定当时的变量表（会把当时的变量表复制到堆上，再引用），所以之后定义的变量都看不到；但是方法表是通过 self 在运行时找的，所以之后定义的方法可以看到。
4. binding 只能取得 proc 的语法作用域，不能修改

b = lambda{ p local_variables }
a = lambda { |b|
  c = 1
  (lambda &b).call
}
p a.call(b) 
#=>等价于
p b.call
#=>等价于
p self.send(:local_variables) 

a = lambda{ p b } #这里只绑定了此时此刻的变量表（链），所以它永远看不到b变量，所以会编译成self.send(:b)
b = 1
a.call    #这里才执行self.send(:b)，但是当前self没有b方法

a = lambda{ p b } # 这里编译时先找变量b找不到，所以会编译成执行self.send(:b)
def b
  1
end
a.call # => 1   #这里才执行self.send(:b)，所以没问题

*** extconf.rb failed *** Could not create Makefile due to some reason, probably lack of necessary libraries and/or headers. Check the mkmf.log file for more details. You may need configuration options.

检查下 mkmf.log 错误报告，也可以去 stackoverflow 搜看看..

没有啊，引号在双引号里会转义的："\"...\"" 可以用 File.foreach:

result = File.foreach(filename,encoding:'utf-8').map{|line| line[/([^(]+)/,1]}

检查下 from 地址写全了么？比如：

default from: "your_username@mail_host.com"

comment.author 等于 nil 了 比如： 你是用current_user.coments.create吗？ 检查 scheme.rb, 看看 foreign_key 是不是都是'user_id'？

#4 楼 @bwlinux 哈哈，不客气，我也复习了一下！

#4 楼 @frankking 哈哈，确实好多没想到诶，特别是要小心破坏性操作。谢谢，共同进步！

module Enumerable
  def my_inject(acc=nil, meth=nil, &blk)
    meth,acc = [acc,nil] unless blk || meth
    raise "shouldn't provide both method_name and block" if meth && blk
    meth ||= blk
    raise "should provide method_name or block" unless meth && meth.respond_to?(:to_proc)

    acc,all = acc ? [acc, self] : [first, drop(1)]
    all.safe_inject(acc, &meth.to_proc)
  end
  def safe_inject(acc)
    each {|v| acc = yield acc,v}
    acc
  end
end

考虑情况一多，代码就矬了。。。

nice！！ 感觉还需要再重构一下：

1. 尽量不要用注释，用方法名代替注释 -- 把注释的代码段重构成方法
2. 想办法把 if/else 去掉，比如：用幂等方法 to_a, to_proc, to_h, Array() ...

嘿嘿，我也试一试：

module Enumerable
  def my_inject(acc=nil, meth=nil, &blk)
    meth,acc = [acc,nil] unless blk || meth
    meth = blk || meth
    raise "should provide method_name or block" unless meth && meth.respond_to?(:to_proc)

    to_a.arr_inject(acc, &meth.to_proc)
  end
  def arr_inject(acc)
    acc ||= shift
    each {|v| acc = yield acc,v}
    acc
  end
end
p (1..10).my_inject(:+)
p (1..10).my_inject(&:+)
p (1..10).my_inject(10, :+)
p (1..10).my_inject(10, &:+)
p (1..10).my_inject(0)

呵呵，如果不介意逻辑太散，可以多重构一点，把逻辑都分开：

#假设，输入是这样:
require 'ostruct'
def list
  @list ||= [
    {name:'tom', format: :a},
    {name:'bob', format: :b},
    {name:'dav', format: :c}
  ].map{|v| OpenStruct.new(v)}
end

# 那么:
def rule
  @rule ||= {a:'xxx', b:'yyy', c:'zzz'}
end
def parse_format(format)
  rule[format]
end
def info_from_item(item)
  {item.name => parse_format(item.format)}
end

def hello
  list.map(&method(:info_from_item)).reduce({},&:merge)
end
p hello

# 如果要加情况就:
rule.merge!(new_format: new_info)
```ruby

includes 自己推测要不要 left join。推测算法有 bug? 新版本 rails 可能不会了。

#2 楼 @luffycn 输入是什么样的呢？keys 是给定的吗？ 变长是 ok 的。假如，输入是 arrys 和 keys：

one = ['a', 'b', 'c']
two = ['A', 'B', 'C']
three=['m', 'n', 'k', 'h']
four=%w(x y )

#假设输入为 arrays, keys:
arrays = [one,two,three,four]
keys = %w{one two three four}
#or
keys = %w{one two three four five six seven ...}.first(arrays.size)

#那么可以这样:
klass = Struct.new(*keys.map(&:to_sym))
objects = arrays.reduce(&:zip).map{|tup| klass.new(*tup.flatten)}.map(&:to_h)

def hash_from_arr(arr)
  arr.reduce({}) do |res, element|
    i = res.size
    res.merge!(i=>element)
  end
end
hash_from_arr(objects)

http://www.ruby-doc.org/core-2.1.5/String.html#method-i-5B-5D 可以用问号 pry 查文档： 比如查字符串的[]方法：? ""[]

str[/.../]
#等价于
str =~ /.../ && $&

str[/.../,3]
#等价于
str =~ /.../ && $3

class << ChangeLog
  ...
end
#等价于打开对象的singleton_class
ChangeLog.singleton_class.class_eval do
  ...
end

one.zip(two).map{|one,two| {one:one,two:two}}

#或者
one.zip(two).map{|one,two| {one:one,two:two}}
  .each_with_index.map{|e,i| {i=>e}}.reduce({},&:merge)

#或者
Hash[*one.zip(two).map{|one,two| {one:one,two:two}}.each_with_index.to_a.map(&:reverse).flatten]

#或者
one.zip(two).reduce({}) do |res, zp|
  one,two = zp
  i = res.size
  res.merge!(i=>{one:one,two:two})
end