嗯。。类型定义应该要先跑一遍。。宏的话我自己都还不会用= =

有了类型之后又会想要积类型 和类型，递归类型，依存类型。。。在没有完美的类型体系之前我觉得鸭子类型才是最好的。。。

能跳 js 和 go 说明不懂 ruby 的一分一毫啊...

红轴比茶轴好。。茶轴杂音多而且毛毛的触感，你喜欢轻的话茶轴会不够轻，品牌可以随意，只要是 cherry 原厂轴就行

md5 是摘要算法，不可逆，1g 的文件 md5 也是 32 个字符

嗯，你可以用 htop 看看内存使用情况，一般而言 128m 对 rails 进程是不够的，刚刚试了一下，一个空的 rails 项目，开发环境启动就要 68M，进行一个空页面的请求之后已经 96M 了。

底下有 rescue

128m…估计炸得不能再炸了……

如果项目大，开发环境渲染 views 确实可以占到几秒甚至十几秒，但是我觉得你这个应该是爆内存然后跑到 swap 导致慢

正常来讲不是应该一个 api 一个域名么。。不然怎么区分哪个 url 是哪个用户的，难道添加的时候先检查占用？所以直接开多个 Rails 应用，然后把数据库里的路由导入成 rails 路由就可以了。。。

另外我觉得这个 controller 怎么设计也还很多疑问，如果开应用成本太高，不一定要用 rails 的。。

感觉开 repo 和发帖对于刷题来说就是 flag 一样的存在....

#9 楼 @kimmg 传 nil 是不可能报 argument error 的，他的 cart.rb 写的有问题，报错在 cart.rb:2

yehuda 的博客说过 ruby 的 db adapter 在多线程下都是不会阻塞的，file 的话不清楚，如果对 file 的接口做同样的处理，那么是不是即使不用 em，普通的多线程也可以把 cpu 跑满呢？

当你有几个子类要继承同一个父类，但是并不是 STI 的时候，在父类声明 abstract_class，在子类声明各自的 table_name http://api.rubyonrails.org/classes/ActiveRecord/Inheritance/ClassMethods.html

ApplicationRecord 就是个 abstract class，他是 ActiveRecord::Base 和你的实际 model 中间的一层，使你对 ApplicationRecord 的扩展不会影响 ActiveRecord::Base。而要做到这个，常规情况你需要有个名为 application_records 的表。

因为要用 uglify.js 压缩 js 代码

按需取用吧，**的好处是以下情况可以正确捕获

def t a = 1, b, **c
  p a,b,c
end

def t2 a = 1, *b, **c
  p a,b,c
end

t 1, a: 1      #=> 1   1            {:a=>1}
t 1, 'a' => 1  #=> 1   {"a"=>1}     {}

t2 1, a: 1     #=> 1   []           {:a=>1}
t2 1, 'a' => 1 #=> 1   [{"a"=>1}]   {}

行为各异，能用就好

https://ruby-china.org/topics/29703 用这个你还可以用 lisp 开发 ruby，不用任何扩展

#5 楼 @flemon1986 应该也行，还差个 foreign_key，只是用 Product 还是用 ReviewSummary 来实例化的问题，反正 avg_star 肯定读的到的

熊没了....

#3 楼 @flemon1986 我找到办法了

class Product
  has_many :reviews
  has_one :review_summary
end

class ReviewSummary < ApplicationRecord
  self.table_name = 'reviews'
  default_scope {
    from('products').
      joins('INNER JOIN reviews ON reviews.product_id = products.id').
      select('products.id as product_id, avg(stars) as avg_star')
  }

end

然后

p = Product.includes(:review_summary).first
p.review_summary.avg_star # => 平均评分

这样就可以利用 includes 把统计数据都查出来了，生成的查询是这样的

SELECT products.id as product_id, avg(stars) as avg_star FROM products INNER JOIN reviews ON reviews.product_id = products.id WHERE "reviews"."product_id" IN (1, 2)

上面是用 reviews.product_id 用来做 where 条件的，可能有点巧合的感觉，一种更好的配法是

class ReviewSummary < ApplicationRecord
  self.table_name = 'products'

  default_scope {
    joins('INNER JOIN reviews ON reviews.product_id = products.id').
      select('products.id as id, avg(stars) as avg_star')
  }

end

class Product < ApplicationRecord
  has_many :reviews
  has_one :review_summary, foreign_key: :id
end

生成的查询是：

SELECT products.id as product_id, avg(stars) as avg_star FROM products INNER JOIN reviews ON reviews.product_id = products.id WHERE "products"."id" IN (1, 2)

用 products.id 来写 where 正是我们想要的行为，完美。。这样虚拟出关联还是相当好玩的，不用 create view 了

#6 楼 @mizuhashi 都说了 Price 类没有 Bicycle 的知识。。STI 和多态关联是两套独立的系统，多态关联只要把 STI 相关的过程委托给 STI 的基类就可以了，根本不需要知道他有什么子类。。。

你如果发现取不出正确的数据可以讨论一下，如果是觉得实现不爽，或者是哪里还要用数据表这个栏位，那你只能自己去改 AR 的查询代码，反正 ruby 有打开类，按你喜欢的实现就好了

#5 楼 @Qcoder 多态关联存基类很正常....因为 price 没有 bicycle 的知识，他只能 Car.find(1) 然后再由 Car 根据 type 初始化成 Bicycle，我觉得在有 type 字段的时候，应该能初始化出 Bicycle，sql 语句用 car 应该没啥问题

这个不属于 STI 吧，如果是 STI 的话你的 car 表应该有 type 列，然后初始化的时候应该就会初始化成 Bicycle

#1 楼 @flemon1986 foreign_key 有的，例如select products.id as product_id, avg(stars) as avg_star from products join reviews，可以把 products_id 作为这个表的外键

#5 楼 @emanon 并不是纠结概念，因为要做 side project，只是为了确认 repository 是无意义的，便可以从选型中去掉了，而且 lotus 这么多人捧不可能这些基础的都没考虑过啊…

目前的状况看 lotus 划的抽象比较蠢，写法也十分繁琐，肯定不会用他了，虽然我觉得他的 container 比 rails engine 简洁很多…

#12 楼 @aldrich 吞噬神明的艾尔德里奇

#2 楼 @tablecell 就是换了个写法的链式调用

#2 楼 @xnnyygn 你这个就是普通的 service 嘛，我说放 controller 换成放 service 也一样，两者的抽象层次是等同的，问题是在这种情况下看不出 Repository 有什么意义，而且事实上也不能和别的 Repository/Service 解耦。

测试的话，其实厂妹也可以没有数据库的时候测试啊，或者用 sqlite::memory 也行，而且 repository 现实中不见得就能多数据源，因为 join 这些操作也不是所有数据源都有实现的。

再来一个

class DelayedMethod
  attr_reader :proc_chain

  def initialize proc
    @proc_chain = [proc]
  end

  def >> another
    @proc_chain.concat another.proc_chain
    self
  end
end

_ = Object.new
class << _
  def method_missing name, *args, &block
    DelayedMethod.new(->(x){ x.send(name, *args, &block ) })
  end

  def log
    DelayedMethod.new(->(x){ p x })
  end
end

class Object
  def >> delayed_method
    delayed_method.proc_chain.reduce(self){|acc, x| x.(acc)}
  end
end

[1,2,3] >> _.map{|x| %w{a b c d}[x] } >> _.join >> _.capitalize >> _.log # => "Bcd"

#9 楼 @jackalcooper 我讲模式匹配你又跟我讲 actor。。erlang 那点东西我又不是不知道，ruby 的对象和 actor 本来就是等同的抽象，ruby 的send就是 erl 的!，ruby 有私有状态，actor 的尾递归就不是私有状态了？你要不要记 pid？还有不知道你说的类变量是什么，我写 ruby 没用过类变量。

#3 楼 @chenge 模式匹配是不符合 ruby 哲学的，模式匹配相当于把对象剖开，但是 OO 哲学里对象内部对于外界都是不可见的，一切操作要以消息传递实现，就像现实中你不能随便拆开一个人的大脑查看。

[a,b] = [1,2] 这种语法糖，你已经钦定了一种数组实现，但是 OO 中数组只是一种能反应:[]消息的对象。

类似地，你要如何实现 ActiveRecord::Relation 的模式匹配呢？

当你{total_count, records} = relation，你已经在relation.instance_eval{|x| @total_count} 了，问题是，你怎么知道 relation 里有@records和@total_count？

当然，ruby 里也不是没有模式匹配，线性表的(a, (b, c)) = [1,[2,3]]是没问题的。

还有 @Artoria 的面对接口的模式匹配：

OO 的哲学是模拟，FP 的哲学是推导。FP 喜欢赤裸着的纯数据，而 OO 则把每个对象看成“有自己主见的人”。二者的比较其实没有什么意义，完全在于你怎么看世界。纯数据操作当然是 FP 更方便，但是类似游戏这种模拟领域，OO 的好处就非常明显了。