Ruby 语法.整理

方法名中带参数,

简写参数方法def set_from from ... end ，完整方法名写法set_form(form) ，Ruby 中不少地方都将 “( )” 省略，简化代码

class Apple
  def color= color
    @color = color
  end

  def set_from from
    @@from = from
  end
end

red_one = Apple.new
red_one.color = 'red'
puts red_one.color
# => 'red'
red_one.set_from 'Japan'
puts red_one.get_from
# => 'Japan'

Symbol 不变的字符串,可作常量

学习 Ruby 时，经常会遇到Symbol，例如 :post、:model、:controller、:action等等。这是一个 Ruby 基础概念，简单解释一下。

Ruby 中一切都是对象

每个变量、字符串、数字等都是对象。所有 Ruby 才能写出这样的简单直白的代码：5.times { puts “hello” } ，5 是一个对象，所有才可以在后面加上 method 方法。

Ruby 一切都是对象的特性，有一个很大的影响：Ruby 处理每一个对象时，都会在内存中生成新的对象，每一个对象都不相同。因为，Ruby 每一次处理一个对象，都是读取、写入内存，所以每一个对象都是不同的的。这也就是 Rails 为何强调 DRY 原则，只要有重复的代码出现，不仅后期维护难度增加，Ruby 也会重复读取对象，浪费内存降低效能。从以下的 object_id 这个 method 可以证明。

"hello".object_id
# => 70318367784340

"hello".object_id
# => 70318367777740

利用变量储存重复的字符串，就可以解决这个问题。

a = "hello"
a.object_id
# => 70318367761840
a.object_id
# => 70318367761840

Symbol 就是独特的对象

效果就如上方例子中解决重复字符串的变量，每次使用 Symbol 符合，不会消耗多余的内存，提高效能。

简单理解——不变的对象，常用为不变的字符串。在 Rails 中，经常当做常量使用。

Ruby method自动生成Symbol

在定义 method 时，Ruby 会自动为 method 生成一个 Symbol，例如：

class Greeting
    def self.hello
        puts "hello world"
    end
end

Greeting.hello
# => "hello world"
Greeting.send(:hello)
# => "hello world"
say_hello = Greeting.method(:hello)
say_hello.call
# => "hello world"

先定义好 class 与 method 之后，使用以上三种方式皆可呼叫hello 这个 method 。发现提到 Symbol :hello 时，对应一定就是 hello method 。

参考文章：

• Ruby Symbol 简单介绍 (那些带着冒号的字符串)
• Ruby及Rails當中的:symbol代表什麼意思？

block, Proc, lambda的区别

都是代码块，proc和lambda可以转化成为block，当做参数传递给方法。但是，block 只能使用在方法调用，不可单独调用。

lambda和proc的两个重要区别是:

• Proc对象对参数数量检查不严格, lambda对象则要求参数的数量精确匹配
• Proc对象和lambda对象对return关键字的处理不一样

Ruby 迭代器——map、each、collect

(1)each只是遍历数组的每个元素，并不生成新的数组；
(2)map和collect相同用法，遍历每个元素，用处理之后的元素组成新的数组，并将新数组返回；
(3)map！同collect！

ruby中的join，split，send，map，each，collect，inject方法总结

1.join的用法：
join把数组中的元素变成一个字符串，其中mysql数据库不支持数组的形式存入，换成字符串的形式。

2.split方法与join方法相反，是把字符串变成数组的方法

3.inject
(5..10).inject(1) {|sum, item| sum * item } #=> 151200
#inject()函数如果没有带参数而是直接带的block的话，那么将会把第一个元素复制给sum，第二个元素复制给item，每次inject运算完成后将运算结果都保存给sum，item表示数组中的每个元素 

4.send方法
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"#该方法是在给hello方法送去参数

参考资料：

• Ruby之map、each、collect、map!、collect!揭秘
• ruby中的join，split，send，map，each，collect，inject方法总结

Ruby 题

一个数组有一千条数据，其中一组数据重复出现2次，找出来

information = ['1','1','1','2','2','2','3','3','3','4','5','6','6','6','7','7','8','8','8']
# => ["1", "1", "1", "2", "2", "2", "3", "3", "3", "4", "5", "6", "6", "6", "7", "7", "8", "8", "8"]

counts = Hash.new(0)
information.each{|info| counts[info] += 1}
counts.each{|k,v| puts k if v == 2 }

# => 7
{"1"=>3, "2"=>3, "3"=>3, "4"=>1, "5"=>1, "6"=>3, "7"=>2, "8"=>3}

information.each{|info| counts[info] += 1} ，第一个数组的值当作 hash 的 key ，相同的 key 出现一次，key 对应的值 +1，这相当于实现了重复值的计数器 。counts.each{|k,v| puts k if v == 2 }，如果hash 的值为 2 ，打印出 key ，实现了找出重复出现 2 的数据。

information = ['1','1','1','2','2','2','3','3','3','4','5','6','6','6','7','7','8','8','8']

counts = {}
information.group_by(&:itself).each { |k,v| counts[k] = v.length }
counts.each{|k,v| puts k if v == 2 }

# => 7
{"1"=>3, "2"=>3, "3"=>3, "4"=>1, "5"=>1, "6"=>3, "7"=>2, "8"=>3}

优化了上方的代码，使用 ruby 的内置分组功能 group_by 。