Ruby学习笔记

Ruby现在很火啊，那就看看吧。。。。
看得Little Book of Ruby（附件）。原因，够简练。。。。先入个门。用的intellij idea7.04。现在ruby插件好像开发得不错了，我用着挺爽。

第一章
1.Ruby里什么都是对象，基本类型也不例外，比java还oo。。。
示例代码：
经典到烂的Hello World。比java省事很多。。。

puts "Hello World"

print("Please input your name:")
name = gets()
puts "hello #{name}".upcase

(1)print与puts的区别。print不换行，puts换行。。。。
(2)在ruby里，你想什么时候使用变量就什么时候使用，不必要事先定义，ruby会自己判断变量类型。
(3)ruby和java一样是大小写敏感的。
(4)gets后的括号，和print,puts后的括号一样，都是可选择的，只要不引起误解，都可以去掉。（不建议。）
(5)#{}取变量值贝。。。

puts("#{1*2+3}")

2.Ruby中的方法。使用def定义，后面跟方法名，要小写。

def saysomething
   puts("Hello")
end

#invoke
saysomething

传参数

def saysomething(name)
 puts("Hello #{name}")
end

#invoke
saysomething("Ivan")

def saysomething(name)
 return ("Hello #{name}")
end

#invoke
puts (saysomething("Ivan"))
puts ("HOHO,#{saysomething("Ivan")}")

(1)#号为注释符号,相当于java里的//
(2)再看看#{}的效果吧。。。。

3数字和string一样简单

subtotal = 100
taxrate = 0.175
tax = subtotal * taxrate
puts "Tax on $#{subtotal} is $#{tax}, so grand total is $#{subtotal+tax}" 

taxrate = 0.175 
print "Enter price (ex tax): " 
s = gets 
subtotal = s.to_f 
if (subtotal < 0.0)    then 
        subtotal = 0.0 
end 
tax = subtotal * taxrate 
puts "Tax on $#{subtotal} is $#{tax}, so grand total is $#{subtotal+tax}"

(1)s.to_f是字符串里的一个方法，作用是将字符串转化为float,如果无法转化，则返回0.0。比如"Hello World".to_f.
(2)if...then...end。就是java里的if，if后面的括号也不是必须的。但是如果这一句写在了一行上面，那么括号就是必须的了。end也是必须的，否则无法运行


第二章
1.Ruby的类定义，与java也类似,也以class 开头，加类名

class MyClass
end

ob = MyClass.new

很简单。
(1)在这个类里面，虽然什么都没有定义，但是Ruby会自动的继承Object类。所以，可以调用ob.class
(2)类名的第一个字母必须大写。

2.类实例和实例变量

class Dog
    def set_name(name)
        @dogname = name
    end

    def get_name()
        return @dogname
    end
end

dog = Dog.new
dog.set_name("Jack")
puts dog.get_name

(1)@dogname此为实例变量，属于Dog实例，不需要事先声明
(2)如果不给@dogname设值，即不先调用dog.set_name("Jack")，而直接puts dog.get_name，不会像java那样获得空指针异常，返回一个nil

class Dog
    def initialize(init_name)
        @dogname = init_name
    end
    def set_name(name)
        @dogname = name
    end

    def get_name()
        return @dogname
    end

    def to_s
        return "Hello"
    end
end

dog = Dog.new "Jack"
#dog.set_name("Jack")
puts dog.inspect
p dog
puts dog
puts dog.get_name

(1)def initialize(init_name)
        @dogname = init_name
    end
相当于java里的构造方法。。。
(2)def to_s
        return "Hello"
    end
是从Object继承的，和java也类似toString()方法。。。。
(3)dog.inspect会打印关于实例的信息。
(4)p dog为上面的简写。


第三章
1继承，与java一样，也是单继承。

class Thing      
      def initialize( aName, aDescription )
        @name         = aName
        @description  = aDescription
      end
      
      def get_name
		return @name
      end
      
      def set_name( aName )
		@name = aName
      end
      
      def get_description
		return @description
      end
      
      def set_description( aDescription )
		@description = aDescription 
      end
end      
    
    
class Treasure < Thing      # Treasure descends from Thing
      def initialize( aName, aDescription, aValue )
          super( aName, aDescription )
          @value = aValue
      end
      
      def get_value
		return @value
      end
      
      def set_value( aValue )
		@value = aValue
      end
end
    

 # This is where our program starts... 
  t1 = Treasure.new("Sword", "an Elvish weapon forged of gold",800)
  t2 = Treasure.new("Dragon Horde", "a huge pile of jewels", 550)  
  puts "This is treasure1: #{t1.inspect}"
  puts "This is treasure2: #{t2.inspect}"
  puts "t1 name=#{t1.get_name}, description=#{t1.get_description}, value=#{t1.get_value}"
  t1.set_value( 100 )
  t1.set_description(" (now somewhat tarnished)")
  puts "t1 (NOW) name=#{t1.get_name}, description=#{t1.get_description}, value=#{t1.get_value}"

(1)继承写法如下class Treasure < Thing
(2)super( aName, aDescription )与java功能相同


第四章
1如果嫌get,set方法太麻烦了。可以这么写

class Thing
    def name=(aName)
        @name = aName
    end
    def adescription=(desc)
        @description = desc
    end
    def name
        return @name
    end
    def adescription
        return @description
    end
end

thing = Thing.new
thing.adescription="HHHH"
puts thing.adescription

注意def adescription=(desc)等号之间不能有空格。。。

更简单的写法

class Thing
    attr_reader:adescription
    attr_writer:adescription
end

thing = Thing.new
thing.adescription ="HHHH"
puts thing.adescription

再简单点。。。

class Thing
    attr_accessor:adescription
end

thing = Thing.new
thing.adescription ="HHHH"
puts thing.adescription

2类变量
写法
@@变量名
,和java里的类属性（静态属性）作用相同。

第五章
1.ruby中的array与java中的有区别。它可以在一个array里存放多种类型。

a = ['hello',1.0,1]

puts(a[0],a[1])

2.ruby可以数组越界。。。。超出数组返回nil
3.ruby数组可以存放方法。

def hello
    return "hi"
end

a = ['hello',hello,1]

puts(a[0],a[1])

4多维数组创建方法，先创建一个数组，再在该数组里添加数组。

a = Array.new(2) 
a[0]= Array.new(2,'hello') 
a[1]= Array.new(2,'world')

或者直接写

a = [    [1,2,3,4], 
         [5,6,7,8], 
         [9,10,11,12], 
         [13,14,15,16]  ] 

5,数组遍历使用for...in...end，与java里的foreach循环很相似

a = [['one','two','three','four'],[1,2,3,4]]

for i in a
    for j in i
       puts j 
    end
end

还可以这么写

a = [['one','two','three','four'],[1,2,3,4]]

for (a,b,c,d) in a
    puts "a = #{a},b = #{b},c = #{c},d = #{d}"
end

6对数组下标的操作，-1表示最后一位

arr = ['h','e','l','l','o',' ','w','o','r','l','d'] 

print( arr[0,5] )                #=> ,hello' 
print( arr[-5,5 ] )              #=> ,world' 
print( arr[0..4] )               #=> ,hello' 
print( arr[-5..-1] )             #=> ,world'

在1，2两个输出中的第二个参数表示向后几位，不是下标，3，4两个输出的第二个数字才是下标。
7，通过下标也能改变数组

arr2 = ['h','e','l','l','o',' ','w','o','r','l','d'] 

arr2[0] = 'H' 
arr2[2,2] = 'L', 'L' 
arr2[4..6] = 'O','-','W' 
arr2[-4,4] = 'a','l','d','o' 

# arr2 now contains: 
# ["H", "e", "L", "L", "O", "-", "W", "a", "l", "d", "o"] 

第六章
1.ruby里的hash应该就是java里的map了。创建方法

h1 = Hash.new
h2 = Hash.new("hello")

这两个都创建了一个Hash，区别是，在h1里如果找不到对应的值则返回nil,h2则返回hello

2.向Hash里添加数据，和数组类似，区别是数组是数字，而Hash只要是独一无二的数据即可

h1['a'] = 'hi'

还可以这样添加数据

h1 = {'a'=>'hh','b'=>'hehe'}

3获取Hash的值，和java里的map相同，通过key来获取，如果没有则返回默认值，见1.可以通过Hash里的default来设置默认值

h1.default = "hi"

4对Hash的操作，看代码体会吧。

h1 = {'key1'=>'val1', 'key2'=>'val2', 'key3'=>'val3', 'key4'=>'val4'} 
h2 = {'key1'=>'val1', 'KEY_TWO'=>'val2', 'key3'=>'VALUE_3', 
'key4'=>'val4'} 

p( h1.keys & h2.keys )                         # set intersection (keys) 
#=> ["key1", "key3", "key4"] 

p( h1.values & h2.values )                     # set intersection (values) 
#=> ["val1", "val2", "val4"] 

p( h1.keys+h2.keys )                           # concatenation 
#=> [ "key1", "key2", "key3", "key4", "key1", "key3", "key4", "KEY_TWO"] 

p( h1.values-h2.values )                       # difference 
#=> ["val3"]

p( (h1.keys << h2.keys)  )                        # append 
#=> ["key1", "key2", "key3", "key4", ["key1", "key3", "key4", "KEY_TWO"] 
] 

p( (h1.keys << h2.keys).flatten.reverse  ) # ,un-nest' arrays and reverse 
#=> ["KEY_TWO", "key4", "key3", "key1", "key4", "key3", "key2", "key1"] 

a =[1,2,3] 
b =[4,5,6] 
c = a + b                         #=> c=[1, 2, 3, 4, 5, 6]       a=[1, 2, 3] 
a << b                            #=> a=[1, 2, 3, [4, 5, 6]] 

a=[1, 2, 3, [4, 5, 6]] 
a.flatten                         #=> [1, 2, 3, 4, 5, 6]  

第七章
1.for循环，上面有用过，类似java的foreach循环

for i in [1,2,3] do
    puts i
end

do可省略
另一种写法，有点陌生

[1,2,3].each do |i|
    puts i
end

2.while循环，看代码。

while tired 
   sleep 
end 
 

sleep while tired 

这两段代码效果相同。不是java里while与do...while的区别.如果要do...while的效果，要这么写

begin puts(x) end while (x < 1)

3.until循环

i = 10 

until i == 10 do puts(i) end            # never executes 

until i == 10                           # never executes 
   puts(i) 
   i += 1 
end 

puts(i) until i == 10                   # never executes 

begin                                   # executes once 
   puts(i) 
end until i == 10 

第八章
1.if...then前面就有了。

if (subtotal < 0.0) then 
        subtotal = 0.0 
end 

2.if...then...else

if aDay == 'Saturday' or aDay == 'Sunday' 
   daytype = 'weekend' 
else 
   daytype = 'weekday' 
end 

如果代码在一行，则then不能省略，或者用:代替，不在一行则可省略
3.and...or...not

if aDay == 'Saturday' or aDay == 'Sunday' and not working_overtime

#Ruby takes the test to mean: “If the day is Saturday and I am  
#not  working  overtime,  or  if  the  day  is  Sunday  and  I  am  #not  working  overtime” 
#whereas what I really meant was  “If the day is Saturday; or if the #day is Sunday  
#and I am not working overtime”.  

if aDay == 'Saturday' or (aDay == 'Sunday' and not working_overtime) 

and(&&),or(||),not(!)

4.if...elsif

while input != 'q' do 
   puts("Enter a number between 1 and 1000 (or 'q' to quit)") 
   print("?- ") 
   input = gets().chomp() 
   if input == 'q' 
     puts( "Bye" ) 
   elsif input.to_i > 800 
     puts( "That's a high rate of pay!" ) 
   elsif input.to_i <= 800 
     puts( "We can afford that" ) 
   end 
end 

5.unless

unless aDay == 'Saturday' or aDay == 'Sunday' 
  daytype = 'weekday' 
else 
  daytype = 'weekend' 
end 

等价于

if !(aDay == 'Saturday' or aDay == 'Sunday') 
  daytype = 'weekday' 
else 
  daytype = 'weekend' 
end 

6.if,unless的其他写法

sleep if tired 

begin 
  sleep 
  snore 
end if tired 

sleep unless not tired 

begin 
  sleep 
  snore 
end unless not tired 

7,case

case( i ) 
  when 1 : puts("It's Monday" ) 
  when 2 : puts("It's Tuesday" ) 
  when 3 : puts("It's Wednesday" ) 
  when 4 : puts("It's Thursday" ) 
  when 5 : puts("It's Friday" ) 
  when (6..7) : puts( "Yippee! It's the weekend! " ) 
  else puts( "That's not a real day!" ) 
end 

和java很类似啦，里面:可以替换为then

第九章
1.module(不知道翻译成模块对不对，就不翻译了)。创建方法和类很相似

module MyModule
    HE = 'hello'

    def sayHello
        return "hi,#{HE}"
    end
end

module和类的区别，类有实例，有父类，可以有子类。module一个都没有。

2.module的第一个作用，作为namespace
module可以当作一些方法，类，属性的集合。在这个集合里他们可以互相访问，外面则不行。
module很像java里的package。。。。

class MyClass 
  include MyModule 

  def sayHi 
   puts( sayHello) 
  end 

end 

如果不是在同一个文件里，那么先调用文件

require("***.rb")

该文件必须在当前目录或类路径，或在$:这个数组里。添加到数组里的方法是。

$:<<"***.rb"

第十章
对一些类库，ruby相关的介绍。。。