嗯，偶尔来看看。你工作量也不大嘛，看你经常回帖。

只贴代码不说话，怕被打 ^_^

# 两行版
arr = [1, 2, 3, 4]

# 通俗易懂版
0.upto(arr.size - 1).collect { |len| arr[0..len].join('/') }
# => ["1", "1/2", "1/2/3", "1/2/3/4"]

# 需自行看Array#new代码版
Array.new(arr.size) { |len| arr[0..len].join('/') }
# => ["1", "1/2", "1/2/3", "1/2/3/4"]

# 单行版, 仅限ruby 2.5.0以上
[1, 2, 3, 4].yield_self { |arr| Array.new(arr.size) { |len| arr[0..len].join('/') } }
# => ["1", "1/2", "1/2/3", "1/2/3/4"]

require 'benchmark/ips'

arr = [["小黄", "2000"], ["小猪", "2500"], ["小猪", "2500"], ["小黄", "1500"]]

Benchmark.ips do |x|
  x.report('luikore') { Hash.new(0).tap { |h| arr.each { |(k, v)| h[k] += v.to_i } } }
  x.report('angelfan') { arr.each_with_object(Hash.new(0)) { |v, h| h[v[0]] += v[1].to_i } }
  x.report('swordray') { arr.group_by(&:first).transform_values { |v| v.map(&:last).sum(&:to_i) } }
  x.report('zfjoy520') { arr.each_with_object(Hash.new(0)) { |(k, v), r| r[k] += v.to_i } }
  x.compare!
end

^_^，，luikore 的 Hash.new(0).tap { |h| arr.each { |(k, v)| h[k] += v.to_i } } 完胜

Warming up --------------------------------------
             luikore    23.217k i/100ms
            angelfan    22.538k i/100ms
            swordray    16.002k i/100ms
            zfjoy520    21.387k i/100ms
Calculating -------------------------------------
             luikore    318.464k (± 5.9%) i/s -      1.602M in   5.049108s
            angelfan    255.619k (±13.8%) i/s -      1.262M in   5.063771s
            swordray    188.619k (± 9.6%) i/s -    944.118k in   5.083054s
            zfjoy520    266.406k (±11.2%) i/s -      1.326M in   5.056312s

Comparison:
             luikore:   318464.1 i/s
            zfjoy520:   266405.9 i/s - 1.20x  slower
            angelfan:   255619.2 i/s - 1.25x  slower
            swordray:   188619.3 i/s - 1.69x  slower

如果不要 div 里面的 li, p, div 等标签，只取内容的话可以试试这个。

Nokogiri::HTML(str).xpath('//*[text()]').map(&:text) #  => ["text_1", "test_2", "test_3"]

Welcome to CD.

@miserytan 拿去，不谢！^_^

require 'openssl'

# DES加密
def encrypt(context, key: '8b57d0d3')
  cipher = OpenSSL::Cipher::DES.new.encrypt.tap { |obj| obj.key = obj.iv = key }
  (cipher.update(context) + cipher.final).unpack1('H*').upcase
end

2.5.0 :001 > encrypt('2018h03e29h11eng') == 'D8B5E8E040EAFDB4E7D02A4D235A2462193D557C7DEE2D0E'
 => true

# DES解密
def decrypt(context, key: '8b57d0d3')
  cipher = OpenSSL::Cipher::DES.new.decrypt.tap { |obj| obj.key = obj.iv = key }
  cipher.update([context].pack('H*')) + cipher.final
end

2.5.0 :002 > decrypt('D8B5E8E040EAFDB4E7D02A4D235A2462193D557C7DEE2D0E') == '2018h03e29h11eng'
 => true

想法不错，好与坏不做评论，有点类似 serverless 的味道，只是离 serverless 还很遥远，鼓励一下。

居然没人回复，唉。。国内 ruby 的没落

成都人民欢迎你~！

是。没有代码示例确实有点枯燥

换 rack + sequel 吧，rails 只能堆机器 + 各种优化来弥补性能上的损失

不要引入 active X 系列 activemodel activerecord activesupport

太占内存，rails 系列，随便一个进程 150M+ 内存是无压力的，代码质量差点，跑的时间久点，内存是会涨的，300M，500M/进程 无压力。

查询加缓存

非必要实时写入 (指你当前时段写入的数据，在本次并发查询【一定】不会用到)，可以考虑做延迟写入； 如果 DB 是 mysql，精通 mysql 的话，可以自己做 binlog 收集及批量导入，不精通就算了，风险指数略高。

rack + sequel + puma 多 worker，在目前公司项目中，内存 50M 一个进程，几月稳定跑，进程不假死，内存固定不涨，不能说太多，说多了算是在黑 Rails 了。

变量和字符串的拼接

> ['我爱你', user.name].join
> ['我爱你', user.name] * ''
> '我爱你' << user.name
> '我爱你'.concat(user.name)
> format('我爱你%s', user.name)
> '我爱你%s' % user.name
.......

还有其他的一些方法，当然执行效率是有差别的，也有些是 rubocop 不建议使用的，这里就不啰嗦了

其中，array#*(arg) 这个要复杂些，可以看下源码及 DOC(http://ruby-doc.org/core-2.4.0/Array.html#method-i-2A)

默默地看你们搞事，我还是继续撸我的 Ruby、Rack、Lua、DPDK，...

Bye， Rails！

#40 楼 @trenttian 看贴子里面你们都没有提 Rails，而是只提了 Ruby，现在你们公司应该没有用 Rails 来写 API 了吧，我猜你们是自己用 Rack 定制的一套 Ruby API 简易框架，我们这边也在这么干。 ^_^

#40 楼 @trenttian 哈哈。。Robin 还是一如既往的腼腆。

@trenttian 瞟了一眼，好像照片上木有佘伟大大了，是不在超有爱了么？

目前正在用 dotenv 来管理 env https://github.com/bkeepers/dotenv

ActiveRecord::Relation.pluck(:name, :model, :date).group_by(&:shift).transform_values { |x|
  x.group_by(&:shift).transform_values(&:flatten)
}
=> {"人名1"=>{"机种1"=>["日期1", "日期2", "日期3"], "机种2"=>["日期4"]}, "人名2"=>{"机种2"=>["日期5"]}}

Usage：

require 'thread_safe'

sa = ThreadSafe::Array.new # supports standard Array.new forms
sh = ThreadSafe::Hash.new # supports standard Hash.new forms
cache = ThreadSafe::Cache.new

Rails 4.0+ 默认是引入了 'thread_safe' 这个 gem 的。

https://github.com/ruby-concurrency/thread_safe

代码

string = "Ruby China is a community of Ruby developers."
# 加长string长度, 增加游戏难度
string_1000 = string * 1000
# 随机生成100个不定长串
keywords = 100.times.collect { SecureRandom.hex(rand(5) + 1) }
# 预先拼接好正则式
reg = Regexp.union(keywords)
# 匹配整词
reg_fullword = Regexp.new("\\b#{Regexp.escape(keywords.join('|'))}\\b")

n = 1_000

Benchmark.bm do |x|
  puts 'string'
  # 使用select
  x.report { n.times { keywords.select { |keyword| string.include?(keyword) } } }
  # 使用index
  x.report { n.times { string.index(reg).nil? } }
  # 使用index匹配整词
  x.report { n.times { string.index(reg_fullword).nil? } }
  # 使用any
  x.report { n.times { keywords.any? { |k| string.include?(k) } } }

  puts

  puts 'string_1000'
  x.report { n.times { keywords.select { |keyword| string_1000.include?(keyword) } } }
  x.report { n.times { string_1000.index(reg).nil? } }
  x.report { n.times { string_1000.index(reg_fullword).nil? } }
  x.report { n.times { keywords.any? { |k| string_1000.include?(k) } } }
end

结果

       user     system      total        real
string
   0.030000   0.000000   0.030000 (  0.027699)
   0.000000   0.000000   0.000000 (  0.001021)
   0.000000   0.000000   0.000000 (  0.000865)
   0.020000   0.000000   0.020000 (  0.025702)

string_1000
   2.170000   0.010000   2.180000 (  2.175521)
   0.000000   0.000000   0.000000 (  0.001211)
   0.020000   0.000000   0.020000 (  0.012870)
   2.130000   0.000000   2.130000 (  2.136878)

#3 楼 @hiveer 赞。 其实用两个参数，只是为了在不传参数的时候抛出异常，用数组参数，是可以不传参数的哟。

为学习精神点赞，祖国需要你这样的人，^_^

对如此没有诚意、薪资跨度如此大的招聘帖表示呵呵。

1、没谈做啥。现在随便拉个三五个人做点小玩艺儿，做半年，然后项目砍掉，很伤程序猿的心，虽然程序猿没有心，只有骨油。

2、给个跨度 10K 的待遇，你那个 24K，只是拿来忽悠人的吧。要么你中、高级分开发能力需求，再列出对应的薪资表。

nested hash key 转成数组：

def flat_hash(obj, k = [])
  return {k => obj} unless obj.is_a?(Hash)
  obj.inject({}) { |h, v| h.merge! flat_hash(v[-1], k + [v[0]]) }
end

hash = {a: 1, b: 2, c: {d: 4, e: 5}}
flat_hash(hash)
=> {[:a]=>1, [:b]=>2, [:c, :d]=>4, [:c, :e]=>5}

nested hash key value 拼接：

def flat_hash(obj, k = [])
  obj.is_a?(Hash) ? obj.inject([]) { |h, v| h += flat_hash(v[-1], k + [v[0]]) } : [[k + [obj]].join('_')]
end

hash = {a: 1, b: 2, c: {d: 4, e: 5}}
flat_hash(hash)
=> ["a_1", "b_2", "c_d_4", "c_e_5"]

剩下一步，自己 x.join(',') 吧

@mumu 。。又做回.net 么？可惜呢

@mumu

remove with:
ssh-keygen -f "/home/dbp/.ssh/known_hosts" -R 10.68.2.17

注意看这一行，意思是你本机的 /home/dbp/.ssh/known_hosts 文件里面有远程机器：10.68.2.17 的一些信息，但不正确了，你可以试着把 本机 known_hosts 文件里面，与这个 IP 相关的那一行删除掉，先重新 ssh 一次，输入 yes，再重新部署一次

另外，部署推荐 mina： http://nadarei.co/mina/ https://github.com/mina-deploy/mina

文档比较全，学习成本也不高哈。

fluentd、logstash 这些都看过，虽然比较成熟，但过于复杂，看重 kids 的轻量级

@small_fish__ 不是哈。^_^

相当赞的一篇文章 @taojay315 我抄了你这个文章的思想和大部分代码，然后结合知乎的 Kids 简单写了个 demo，见：

https://github.com/zfjoy520/lograge_service_demo

代码写得不好的地方，还请各位手下留情。

这个东西一年前研究过一下，那个时候只支持几个简单的类型，性能确实跟 redis 差别不太大，号称 360 就在用，现在没怎么关注了。