{}属于最右的调用，do end 属于最左的调用

最简单的就是用Array#replace方法，对于immutable的变量，如果你非要这么做 https://github.com/CicholGricenchos/tricks/tree/master/caller_context_operate

最近也想写一份入门指南，我觉得先介绍define_method比def更好，基于 ruby 是个精简的 oo 内核加糖糖糖糖糖的语言……

这个专利的意思是，当你以任何理由起诉 facebook 的时候，必须立即停止使用 react，也就是 fb 在你还在用 react 的时候就可以肆意侵权了。

alias 就是这么特殊，而且 alias 的冒号还可以省略，用 alias_method 吧

order has_many order_items
order_item has_one product
order has_many packages
package has_many package_items
package_item has_one product

以上是常见的表结构，不知道你的是怎样的，order 和 products 一般是一对多，到 packages 也是一对多，然后 package 到 products 也是一对多。

关联加上 autosave，直接 teacher.students.new(xxx); teacher.save

?在 1.8 的时候是用来查字符的 ascii 码的，?x 相当于'x'.ord 这样，在 1.9 之后就变成返回单个字符本身了，一般很少会这么用。。

正则太 low 了，用宏吧 https://ruby-china.org/topics/29703

想玩魔法的话其实 call 也不用的，也不用 method_missing，在执行 block 之前做个宏替换：

require 'ruby_parser'
require 'ruby2ruby'
require 'method_source'

class Object
  class Proxy < BasicObject
    def call value
      @_ = value
    end

    def _
      @_
    end

    def initialize target
      @_ = target
    end
  end

  def pipe &block
    source = block.source
    block_body = RubyParser.new.process(source).to_a[3]
    head, *sequences = block_body
    sequences.map!{|x| [:call, nil, :call, x]}
    ast = Sexp.from_array([:block, *sequences])
    Proxy.new(self).instance_eval Ruby2Ruby.new.process(ast)
  end
end

#==========业务代码分割线=========

class ServiceA
  def initialize(n); @n = n; end

  def do_something
    p @n
    @n + 1
  end
end

class ServiceB
  def initialize(n); @n = n; end

  def do_something_else
    p @n
  end
end

some_data = 1
some_data.pipe do
  ServiceA.new(_).do_something  # => print 1
  ServiceB.new(_).do_something_else  # => print 2
end

可以的，_就是上一行的结果，call的作用就是赋值给_，https://ruby-china.org/topics/31848

其实 ruby 完全可以定义一些运算符，甚至超算符...

some_data
>> ServiceOne.do_something
>> ServiceOne.do_something_else

用这套配组合子可以玩的很开心……

但是要 ruby way 的话，我想应该是这样子：

some_data.pipe do
  call ServiceOne.new(_).do_something
  call ServiceTwo.new(_).do_something_else
end

因为管道本质上是要把占位符拿出来，这样也许不算太优雅，但是也许有些地方能用到，另外个人觉得 binding.pry 其实比 puts 要方便.....

抄送 @luikore ;-)

cool，那个 class 和 def 是用宏做的吗？

物理机 ubuntu 无桌面环境 i3wm

就

MainCombinePackageItem.joins('INNER JOIN packages main_package ON main_package.id = main_combine_package_items.main_package_id')
                      .joins('INNER JOIN packages combined_package ON combined_package.id = main_combine_package_items.combined_package_id')
                      .where('main_package.state NOT IN ? or combined_package.state NOT IN ?', [9, 10], [9, 10])
                      .where(warehouse_id: 1)

像楼上说的 not in 如果用不到索引的话，可以改成 in，一共有哪些状态是知道的

rails 在 joins 和 eager_load 同一个表的时候会加上别名的：

MainCombinedPackageItem.joins(:main_package, :combined_package)

SELECT "main_combined_package_items".* FROM "main_combined_package_items" INNER JOIN "packages" ON "packages"."id" = "main_combined_package_items"."main_package_id" INNER JOIN "packages" "combined_packages_main_combined_package_items" ON "combined_packages_main_combined_package_items"."id" = "main_combined_package_items"."combined_package_id"

第二个 packages 表加了 combined_packages_main_combined_package_items 的别名，可以直接在 where 用，但是我觉得这样不好，干脆直接写 sql 或者用把 sql 拆成手写的 joins() where()

惊了可还行，怕不是真实猛男（滑稽

不过 ruby 用的不是引用计数，是 mark and sweep： http://blog.jobbole.com/60900/

只要记住 ruby 里传递的永远是引用就好了，包括数字传的也是引用，不提供代码块，只提供一个对象引用的话，这个对象不一定是可复制的（虽然数组可以），所以 Array.new 肯定不会帮你复制

嗯，我看看

有具体点的信息吗？

反正Array#to_proc也没人用，自己定义一个就好了

class Array
  def to_proc
    ->(x){ x[first] }
  end
end

p [{aa: 1}, {aa: 2}].map(&[:aa]) #=> [1, 2]

我觉得你应该要用的是 GetForegroundWindow，参照 http://stackoverflow.com/questions/10740143/get-current-active-window-title-in-c GetActiveWindow 只能 get 你自己进程里的。

另外 win32api 和 dl 已经 deprecate，建议使用 fiddle 或 ffi：

require 'fiddle'
require 'fiddle/import'
require 'fiddle/types'

module User32
  extend Fiddle::Importer
  dlload 'user32'
  include Fiddle::Win32Types

  extern 'HWND GetForegroundWindow()'
  extern 'int GetWindowText(HWND, char*, int)'
end

title = "\0" * 255
hwnd = User32.GetForegroundWindow
length = User32.GetWindowText(hwnd, title, 255)
p title[0...length]

ancestry 不能 includes 和 eager_load，会多很多 n+1 查询的。。closure_tree 可以把 grandparent 之类的实现成真正的关联，用起来方便很多

十行不到的代码也能 yy 出这么多 pattern。。

搞好了，是 nginx 里要用 fullchain.cer，之前用错了。。

建了一个 [email protected]，能看到吗？

好像别人都看不到我，不知道哪里搞错了。。。

ruby 有个钩子叫 method_added，然后拿到名字以后，用 instance_method 把方法拿出来，再 bind(xx).call 就好了，这样可以不用写 eval 字符串（虽然可能更快）

发两次请求还有一种可能是 chrome 插件导致的，可以开隐身窗口排查一下

但是 ruby 的核心之一是打开类，在运行时修改类定义，所以编译期查找方法是不可能的；假如需要缓存方法路径，现在也可以缓存，这个和有没有类型应该没关系。

另外 matz 很讨厌 java 那种手写 types，ruby 不可能会做成 java 这样的。。Ruby3 大概会给你照 respond_to？推一下，类 ruby 的静态类型语言可以参照 crystal，但是我觉得没有意义，想真的要享用类型系统的好处的话，还是建议去用 rust 或者 haskell。。。