Java转Ruby【快速入门】

zoukankan html css js c++ java

Java转Ruby【快速入门】
最近参加实习了，公司的技术栈中需要用到 Ruby 以及 Rails 框架，所以算是开始了踩坑之旅吧..

Ruby 简介

网上的简介要搜都能搜到，具体涉及的包括历史啦之类这里不再赘述，提几个关键词吧：
- 1993 年由日本的松本行弘创建
- 纯粹面相对象编程/ 脚本语言/ 解释型/ 动态类型
对于准备迈入 Ruby 的 Java 程序员来说，有几个地方需要特别的去了解一下。
- 纯粹面相对象
  其实经过论证，Java 同 Ruby 一样都是纯粹的面相对象的语言，这也就意味着包含所有的数字等在内都是对象，注意所有的都是。
- 脚本语言
  这意味着你写的程序不用编译就能运行，甚至实时生效。
- 解释型
  同 Java 一样，Ruby 有自己的虚拟机，运行需要一定的环境，也就是 Ruby 解释器，它会负责把 Ruby 翻译成及其能够执行的代码。
- 动态类型
  Ruby 中的数据更像是一种符号，在使用的时候不检查类型，而是在运行时动态的检查。
为什么是 Ruby ？
- 原因很简单：高效/ 灵活/ 优雅/ 简单
如果你再稍微花一些心思搜索一下 Ruby on Rails 这个 Web 开发框架，并且打开一些详细说明了体验之后的文章或者是多年经验开发者的分享，你可能会对它产生一些兴趣，这一Part就留着之后介绍了，这也是为以后学习 RoR 框架做准备的。

总之我们要明确我们目的：知道最基本的语法，理解其中的一些关键概念即可。

Ruby 初体验

Mac OX 中有默认的 Ruby 环境，我们可以来一个最短的 "Hello World" 程序，首先在控制台中输入 irb 命令，然后输入 puts "Hello World!" 命令：
```
irb
irb(main):001:0> puts "Hello World!"
Hello World!
=> nil
```
你就能看到紧跟着你的输入会有一个 Hello World! 的输出以及一个 nil （对应 Java 中的 null）的返回。

再来一个更加复杂的例子，我们这一次来创建一个数组然后循环输出它：
```
irb(main):002:0> properties = ['name','age','sex']
=> ["name", "age", "sex"]
irb(main):003:0> properties
=> ["name", "age", "sex"]
irb(main):005:0> properties.each {|property| puts "This is #{property}."}
This is name.
This is age.
This is sex.
=> ["name", "age", "sex"]
```
不知道感觉如何？至少我们可以直观的感受到：
- 不用生命变量，直接 = 就好
- 每条 Ruby 代码都会返回某个值
从 Java 到 Ruby

Java 非常成熟，并且通过 Spring 的加持得到了许多企业的青睐，但是不知道大家有没有感受到一点：它或许有些啰嗦...（我乱说的啊，我也不知道，别问我啊..）从 Java 到 Ruby 据说可以预见性的将代码的规模量大大缩小，因此也能使用更少的时间来输出产品原型。

相似点

Ruby 与 Java 有一些相似的地方...
- 垃圾回收器帮你管理内存。
- 强类型对象。
- 有 public、 private 和 protected 方法。
- 拥有嵌入式文档工具（Ruby 的工具叫 rdoc）。rdoc 生成的文档与 javadoc 非常相似。
不同点

Ruby 与 Java 不同的地方...
- 你不需要编译你的代码。你只需要直接运行它。
- 有几个不同的流行的第三方GUI工具包。Ruby 用户可以尝试 WxRuby、 FXRuby、 Ruby-GNOME2、 Qt 或 Ruby 内置的 Tk。
- 定义像类这样的东西时，可以使用 end 关键字，而不使用花括号包裹代码块。
- 使用 require 代替 import。
- 所有成员变量为私有。在外部，使用方法获取所有你需要的一切。
- 方法调用的括号通常是可选的，经常被省略。
- 一切皆对象，包括像 2 和 3.14159 这样的数字。
- 没有静态类型检查。
- 变量名只是标签。它们没有相应的类型。
- 没有类型声明。按需分配变量名，及时可用（如：a = [1,2,3] 而不是 int[] a = {1,2,3};）。
- 没有显式转换。只需要调用方法。代码运行之前，单元测试应该告诉你出现异常。
- 使用 foo = Foo.new("hi") 创建新对象，而非 Foo foo = new Foo("hi")。
- 构造器总是命名为“initialize” 而不是类名称。
- 作为接口的替代，你将获得“混入（mixins）”。
- 相比 XML，倾向于使用 YAML。
- nil 替代 null。
- Ruby 对 == 和 equals() 的处理方式与 Java 不一样。测试相等性使用 ==（Java 中是 equals()）。测试是否为同一对象使用 equals?()（Java 中是 ==）。
以上的相同与不同来自：https://www.ruby-lang.org/zh_cn/documentation/ruby-from-other-languages/to-ruby-from-java/
延伸阅读：https://gquintana.github.io/2017/01/08/From-Java-to-Ruby.html

Ruby 基础

在大致了解了 Ruby 一些基础信息之后，我们开始 Ruby 基础语法的学习，虽然面对一门新的语言，语法啊特性啊之类的了解很有必要，但还是想在了解之前看一看 Ruby 的一些代码规范，好让自己能快速了解 Ruby 的基础上还能养成一个良好的编码习惯。

学习之前必备 - 代码规范

或许有些语句还不能理解，没关系，有一个基础印象就好。
- 一般来讲，Ruby 中的变量名和方法名使用下划线命名法(小写字母 + _)，类名和模块名使用 Java 类似的驼峰命名法
- 每个缩进级别使用两个 space（又名软 tabs），不要使用硬 tabs
```
# bad - four spaces
def some_method
    do_something
end

# good
def some_method
  do_something
end
```
- 不用使用 ; 来分割语句和表达式。以此推论 - 一行使用一个表达式
```
# bad
puts 'foobar'; # superfluous semicolon

puts 'foo'; puts 'bar' # two expression on the same line

# good
puts 'foobar'

puts 'foo'
puts 'bar'

puts 'foo', 'bar' # this applies to puts in particular
```
- 避免单行方法。即便还是会受到一些人的欢迎，这里还是会有一些古怪的语法用起来很容易犯错. 无论如何 - 应该一行不超过一个单行方法.
```
# bad
def too_much; something; something_else; end

# okish - notice that the first ; is required
def no_braces_method; body end

# okish - notice that the second ; is optional
def no_braces_method; body; end

# okish - valid syntax, but no ; make it kind of hard to read
def some_method() body end

# good
def some_method
  body
end
```
空方法是这个规则的例外。
```
# good
def no_op; end
```
- 当赋值一个条件表达式的结果给一个变量时，保持分支的缩排在同一层。
```
# bad - pretty convoluted
kind = case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
when 1910..1929 then 'New Orleans Jazz'
when 1930..1939 then 'Swing'
when 1940..1950 then 'Bebop'
else 'Jazz'
end

result = if some_cond
  calc_something
else
  calc_something_else
end

# good - it's apparent what's going on
kind = case year
       when 1850..1889 then 'Blues'
       when 1890..1909 then 'Ragtime'
       when 1910..1929 then 'New Orleans Jazz'
       when 1930..1939 then 'Swing'
       when 1940..1950 then 'Bebop'
       else 'Jazz'
       end

result = if some_cond
           calc_something
         else
           calc_something_else
         end

# good (and a bit more width efficient)
kind =
  case year
  when 1850..1889 then 'Blues'
  when 1890..1909 then 'Ragtime'
  when 1910..1929 then 'New Orleans Jazz'
  when 1930..1939 then 'Swing'
  when 1940..1950 then 'Bebop'
  else 'Jazz'
  end

result =
  if some_cond
    calc_something
  else
    calc_something_else
  end
```
- 在方法定义之间使用空行并且一个方法根据逻辑段来隔开。
```
def some_method
  data = initialize(options)

  data.manipulate!

  data.result
end

def some_methods
  result
end
```
- 不要使用区块注释。它们不能由空白引导（=begin 必须顶头开始），并且不如普通注释容易辨认。
```
# bad
== begin
comment line
another comment line
== end

# good
# comment line
# another comment line
```
- 使用括号将def的参数括起来。当方法不接收任何参数的时候忽略括号。
```
# bad
def some_method()
  # body omitted
end

# good
def some_method
  # body omitted
end

# bad
def some_method_with_arguments arg1, arg2
  # body omitted
end

# good
def some_method_with_arguments(arg1, arg2)
  # body omitted
end
```
- 从来不要使用 for，除非你知道使用它的准确原因。大多数时候迭代器都可以用来替 for。for 是由一组 each 实现的 (因此你正间接添加了一级)，但是有一个小道道 - for 并不包含一个新的 scope (不像 each)并且在它的块中定义的变量在外面也是可以访问的。（这里有些像 Java 中不用 for-each 语句类似，感兴趣的也可以去搜一搜）
```
arr = [1, 2, 3]

# bad
for elem in arr do
  puts elem
end

# note that elem is accessible outside of the for loop
elem #=> 3

# good
arr.each { |elem| puts elem }

# elem is not accessible outside each's block
elem #=> NameError: undefined local variable or method `elem'
```
- 利用 if and case 是表达式这样的事实它们返回一个结果。
```
# bad
if condition
  result = x
else
  result = y
end

# good
result =
  if condition
    x
  else
    y
  end
```
- 布尔表达式使用&&/||, and/or用于控制流程。（经验Rule:如果你必须使用额外的括号（表达逻辑），那么你正在使用错误的的操作符。）
```
# boolean expression
if some_condition && some_other_condition
  do_something
end

# control flow
document.save? or document.save!
```
- 永远不要使用 unless 和 else 组合。将它们改写成肯定条件。
```
# bad
unless success?
  puts 'failure'
else
  puts 'success'
end

# good
if success?
  puts 'success'
else
  puts 'failure'
end
```
- 不用使用括号包含 if/unless/while 的条件。
```
# bad
if (x > 10)
  # body omitted
end

# good
if x > 10
  # body omitted
end
```
- 倾向使用 module，而不是只有类方法的 class。类别应该只在创建实例是合理的时候使用。
```
# bad
class SomeClass
  def self.some_method
    # body omitted
  end

  def self.some_other_method
  end
end

# good
module SomeClass
  module_function

  def some_method
    # body omitted
  end

  def some_other_method
  end
end
```
- 当你希望将模块的实例方法变成 class 方法时，偏爱使用 module_function 胜过 extend self。
```
module Utilities
  extend self

  def parse_something(string)
    # do stuff here
  end

  def other_utility_method(number, string)
    # do some more stuff
  end
end

# good
module Utilities
  module_function

  def parse_something(string)
    # do stuff here
  end

  def other_utility_method(number, string)
    # do some more stuff
  end
end
```
- 总是为你自己的类提供 to_s 方法, 用来表现这个类（实例）对象包含的对象.
```
class Person
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end

  def to_s
    "#@first_name #@last_name"
  end
end
```
- 考虑使用 Struct.new, 它可以定义一些琐碎的 accessors, constructor（构造函数）和 comparison（比较）操作。
```
# good
class Person
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end
end

# better
class Person < Struct.new(:first_name, :last_name)
end
```
- 考虑使用 Struct.new，它替你定义了那些琐碎的存取器（accessors），构造器（constructor）以及比较操作符（comparison operators）。
```
# good
class Person
  attr_accessor :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end
end

# better
Person = Struct.new(:first_name, :last_name) do
end
```
- 不要去 extend 一个 Struct.new - 它已经是一个新的 class。扩展它会产生一个多余的 class 层级并且可能会产生怪异的错误如果文件被加载多次。
- 鸭子类型（duck-typing）优于继承。
```
# bad
class Animal
  # abstract method
  def speak
  end
end

# extend superclass
class Duck < Animal
  def speak
    puts 'Quack! Quack'
  end
end

# extend superclass
class Dog < Animal
  def speak
    puts 'Bau! Bau!'
  end
end

# good
class Duck
  def speak
    puts 'Quack! Quack'
  end
end

class Dog
  def speak
    puts 'Bau! Bau!'
  end
end
```
- 当访问一个数组的第一个或者最后一个元素，倾向使用 first 或 last 而不是 [0] 或 [-1]。
- 优先使用 字符串插值 来代替 字符串串联。
```
# bad
email_with_name = user.name + ' <' + user.email + '>'

# good
email_with_name = "#{user.name} <#{user.email}>"

# good
email_with_name = format('%s <%s>', user.name, user.email)
```
- 在对象插值的时候不要使用 Object#to_s，它将会被自动调用。
- 操作较大的字符串时, 避免使用 String#+ 做为替代使用 String#<<。就地级联字符串块总是比 String#+ 更快，它创建了多个字符串对象。
```
# good and also fast
html = ''
html << '<h1>Page title</h1>'

paragraphs.each do |paragraph|
  html << "<p>#{paragraph}</p>"
end
```
- RuboCop
  RuboCop 是一个基于本指南的 Ruby 代码风格检查工具。 RuboCop 涵盖了本指南相当大的部分，支持 MRI 1.9 和 MRI 2.0，而且与 Emacs 整合良好。
- RubyMine
  RubyMine 的代码检查是部分基于本指南的。
基于下面链接简化了大部分，因为有一些编码风格能从 Java 自然的切换过来，而且我们也可以使用相应的工具来检查我们的代码，更多可以看这里：https://ruby-china.org/wiki/coding-style

Ruby 语言基础

其实通过上面的语法规范，我们或多或少能感知到一些 Ruby 的语法，有一些细节的地方可以自行去菜鸟教程or其他网站能看到，下面我们就着一些重要的东西快速的学习一遍吧..

数据类型

Ruby 中有以下几种不同的数据类型：
- 数字/ 字符串/ 符号/ 哈希/ 数组/ 布尔
  比较在意的是 Ruby 并没有 Java 中的枚举类型，可能是出于安全方面的考虑吧..（我也不知道...）
- 符号就像字符串。一个符号之前是冒号（:）。例如：
```
:abcd
```
它们不包含空格。含有多个单词的符号用(_)写成。字符串和符号之间的一个区别是，如果文本是一个数据，那么它是一个字符串，但如果它是一个代码，它是一个符号。

符号是唯一的标识符，表示静态值，而字符串表示更改的值。

示例：
```
irb(main):011:0> "string".object_id
=> 26922000
irb(main):012:0> "string".object_id
=> 29115220
irb(main):013:0> :symbol.object_id
=> 788188
irb(main):014:0> :symbol.object_id
=> 788188
```
- 哈希将其值分配给其键。它们可以用键关联指定值。键的值由 => 符号分配。键/值对之间用逗号分隔，所有对都用大括号括起来。例如：
```
{"key1" => "value1", "key2" => "Chemistry", "key3" => "Maths"}
```
示例：
```
data = {"key1" => "Physics", "key2" => "Chemistry", "key3" => "Maths"}   
puts data["key1"]   
puts data["key2"]   
puts data["key3"]
```
执行上述代码，得到以下结果：
```
Physics
Chemistry
Maths
```
变量

Ruby 有四种类型的变量，变量的命名方式决定了变量的种类：
- 局部变量
  以英文小写字母或者 _ 开头，作用域等同于 Java 局部变量。
- 全局变量
  以 $ 开头，作用域等同于 Java 全局变量。只要全局变量的名称相同，不管变量在程序的哪个部分使用，程序都认为是它们是同一个变量。未初始化的全局变量的值会被初始化为：nil。建议不要使用全局变量，因为它们使程序变得秘密和复杂。
示例：
```
$global_var = "GLOBAL"   
class One   
  def display   
     puts "Global variable in One is #$global_var"   
  end   
end   
class Two   
  def display   
     puts "Global variable in Two is #$global_var"   
  end   
end   

oneobj = One.new   
oneobj.display   
twoobj = Two.new   
twoobj.display
```
执行代码输出结果如下：
```
Total number of states written: 4
Total number of states written: 4
Total number of states written: 4
Total number of states written: 4
```
- 实例变量
  以 @ 开头，在同一个实例中，程序可以超越方法定义，任意引用、修改实例变量。它属于类的一个实例，可以从方法中的类的任何实例访问。它们只能访问一个特定的类的实例。它们不需要初始化，未初始化的实例变量的值是：nil 。
示例：
```
class States   
   def initialize(name)   
      @states_name=name   
   end   
   def display()   
      puts "States name #@states_name"   
    end   
end   

# Create Objects   
first=States.new("Hainan")   
second=States.new("GuangDong")   
third=States.new("Beijing")   
fourth=States.new("ShangDong")   

# Call Methods   
first.display()   
second.display()   
third.display()   
fourth.display()
```
执行代码输出结果如下：
```
States name GuangDong
States name Beijing
States name ShangDong
```
- 类变量
  以 @@ 开头，作用域为该类的所有实例。需要在使用前进行初始化，由类的所有后代共享，未初始化的变量将导致错误。
示例：
```
class States   
   @@no_of_states=0   
   def initialize(name)   
      @states_name=name   
      @@no_of_states += 1   
   end   
   def display()   
     puts "State name #@state_name"   
    end   
    def total_no_of_states()   
       puts "Total number of states written: #@@no_of_states"   
    end   
end   

# Create Objects   
first=States.new("Assam")   
second=States.new("Meghalaya")   
third=States.new("Maharashtra")   
fourth=States.new("Pondicherry")   

# Call Methods   
first.total_no_of_states()   
second.total_no_of_states()   
third.total_no_of_states()   
fourth.total_no_of_states()
```
执行上面代码输出结果如下：
```
Total number of states written: 4
Total number of states written: 4
Total number of states written: 4
Total number of states written: 4
```
类和对象

Object 类是所有 Ruby 对象的默认根。 Ruby 对象继承自 BasicObject(它是Ruby中所有类的父类)类，允许创建替代对象层次结构。

首先与 Java 很不同的是创建对象：
```
Object newObject = new Object(); // Java 中新建对象
```
对比 Ruby：
```
objectName = className.new
```
每个 Ruby 类都是 Class 类的一个实例。通常对于类名，使用驼峰命名规则，类的名称始终以大写字母开头。定义类是用 end 关键字完成的。

语法
```
class ClassName  
    codes...  
end
```
我们使用上面学习过的语法规范来创建一个 Person 类（写上 to_s 方法）：
```
class Person
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end

  def to_s
    "#@first_name #@last_name"
  end
end
```
注意这里的 attr_reader 对应在 Java 中相当于为 first_name 和 last_name 定义了 getter ，在 Ruby 中，从对象外部不能直接访问实例变量或对实例变量赋值，需要通过方法来访问对象的内部，如果像 Java 那样一遍一遍为每一个变量写 getter/setter 就有些冗杂了，Ruby 为我们提供了一些方便的存取器。

定义意义

attr_reader :name 只读（定义 name 方法）

attr_writer :name 只写（定义 name= 方法）

attr_accessor :name 读写（定义以上两个方法）

另外一点上面有一个非常有趣的规范是使用 Struct.new 来简化代码，我觉得很酷也想把它应用在上述 Person 类的创建中，但是发现失败了（不能在其中定义其他功能性的代码），所以可能结论是：这样的简化只适用于一些实体类保存数据的类吧。

方法

Ruby 方法使用 def 关键字开始，最后还需要使用 end 关键字来表示方法定义结束。

语法：
```
def methodName  
    code...  
end
```
示例：
```
def method_defining(a1 = "Ruby", a2 = "Python")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
method_defining "C", "C++"
method_defining
```
运行上面的代码执行结果如下：
```
The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Python
```
方法返回值：

在初探 Ruby 的时候我们就感受到，貌似每一条指令都会返回一个返回值，方法也是这样，在 Ruby 中每个方法都有一个返回值，这个返回的值将是最后一个语句的值。例如：
```
def my_method
   i = 100
   j = 10
   k = 1
end
```
上面代码中，最后方法的返回值是 1。

Ruby return 语句

Ruby 中的 return 语句用于从 Ruby 方法中返回一个或多个值

示例：
```
def method
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = method
puts var
```
上面代码结果如下：
```
100
200
300
```
可变参数：

假设声明一个方法需要两个参数，每当调用这个方法时，需要传递两个参数。但是，Ruby允许您声明使用可变数量参数的方法。让我们来看一下这个示例：
```
def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Maxsu", "6", "F"
sample "Mac", "38", "M", "MCA"
```
执行上面代码，得到如下结果：
```
The number of parameters is 3
The parameters are Maxsu
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 38
The parameters are M
The parameters are MCA
```
类方法：

当方法在类定义之外定义时，默认情况下该方法被标记为 private。另一方面，默认情况下，类定义中定义的方法被标记为 public。模块的默认可见性和 private 标记可以通过模块的 public 或 private 更改。

Ruby 给出一种不用实例化一个类就可以访问一个方法。下面来看看看如何声明和访问类方法 -
```
class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end
```
访问类方法 -
```
Accounts.return_date
```
模板

Ruby 模块是方法和常量的集合。暂时你可简单的理解为一个不能实例化的类，这样做的好处是一来可以提供一个命名空间避免名字冲突，另一个是实现了 mixin 的功能。

不知道您有没有发现，Ruby 没有提供多重继承的功能，但 Ruby 的模板几乎消除了多重继承的需要，提供了一种名为 mixin 的装置。

示例：
```
module A
  def a1
  end
  def a2
  end
end
module B
  def b1
  end
  def b2
  end
end

class Sample
  include A
  include B
  def s1
  end
end

samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1
```
块

Ruby 代码在其他编程语言中被称为闭包。它由一组代码组成，它们始终用大括号括起来，或者在 do..end 之间书写。大括号语法总是具有比 do..end 语法更高的优先级。也就是说大括号优先级高，do..end 优先级低。

语法：
```
block_name{
   statement1
   statement2
   ..........
}
```
yield语句：
```
def test
   puts "在 test 方法内"
   yield
   puts "你又回到了 test 方法内"
   yield
end
test {puts "你在块内"}
```
上面代码运行结果如下：
```
在 test 方法内
你在块内
你又回到了 test 方法内
你在块内
```
块和方法：
```
def test
  yield
end
test{ puts "Hello world"}
```
本实例是实现块的最简单的方式。您使用 yield 语句调用 test 块。

但是如果方法的最后一个参数前带有 &，那么您可以向该方法传递一个块，且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中，& 应放在后面。
```
def test(&block)
   block.call
end
test { puts "Hello World!"}
```
上述代码运行结果如下：
```
Hello World!
```
这一部分建议再去看一下慕课网上的教程，看关于第三章的内容即可：Ruby语言快速入门：https://www.imooc.com/learn/765

总结

经过以上简单的学习，我们对 Ruby 有了一个大致的了解，算是简单入了个门（有一些简单的例如循环啊，判断啊，运算符之类的简单我就没有写了），更多的东西需要自己平时的编码中去总结学习（肯定有一些坑需要自己去填的）。

参考文章：
1.Ruby 教程 - 菜鸟驿站 - http://www.runoob.com/ruby/ruby-intro.html
2.Ruby 教程 - 易百教程 - https://www.yiibai.com/ruby
3.20分钟体验 Ruby - https://www.ruby-lang.org/zh_cn/documentation/quickstart/
4.笨方法学 Ruby - https://lrthw.github.io/intro/
5.Ruby 快速入门 - https://wdxtub.com/2016/03/30/ruby-first-step/

按照惯例黏一个尾巴：

欢迎转载，转载请注明出处！
简书ID：@我没有三颗心脏
github：wmyskxz
欢迎关注公众微信号：wmyskxz
分享自己的学习 & 学习资料 & 生活
想要交流的朋友也可以加qq群：3382693
查看全文

相关阅读:
poj 3122 Pie （二分）
poj 1905 Expanding Rods（二分）
poj 3258 River Hopscotch (二分）
poj 3273 Monthly Expense（二分穷举）
最小最大堆
 最小—最大堆
 zend studio 9 字体，颜色，快捷键等相关设置
 javascript onbeforeunload
php DOMDocument 不能解析引用外部DTD的XML
phpdoc 注释关键字含义

原文地址：https://www.cnblogs.com/wmyskxz/p/10772690.html

定义	意义
attr_reader :name	只读（定义 name 方法）
attr_writer :name	只写（定义 name= 方法）
attr_accessor :name	读写（定义以上两个方法）

Java转Ruby【快速入门】

Ruby 简介

为什么是 Ruby ？

Ruby 初体验

从 Java 到 Ruby

相似点

不同点

Ruby 基础

学习之前必备 - 代码规范

Ruby 语言基础

数据类型

变量

类和对象

方法

模板

块

总结