`
Ivan_Pig
  • 浏览: 386846 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

Ruby学习笔记

    博客分类:
  • 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相关的介绍。。。
分享到:
评论
2 楼 脑袋雷劈的 2009-01-05  
System.out.println("跟着楼主一起学吧!!");
System.out.println("楼主要坚持啊!!");
1 楼 evancess 2008-08-28  
System.out.println("不错哦 刚开始学习这个 入门了~");

相关推荐

    Ruby学习笔记(学习心得)

    Ruby学习笔记 01 类的属性与方法 02 访问控制 03 Container(Array/Hash) 04 Iterator 05 简单数据类型 06 范围 07 方法 08 条件控制 09 异常处理

    rubyinstaller-devkit-3.0.2-1-x64 and Ruby 学习笔记.7z

    Ruby是一种面向对象的脚本语言,它以其简洁、优雅的语法和强大的功能而闻名。...通过安装Ruby和DevKit,你可以轻松地编写、编译和运行Ruby代码,同时结合学习笔记,可以深入理解Ruby语言及其生态系统。

    ruby学习笔记

    ruby基础笔记,自学笔记,ruby基础语法非常全面ruby基础笔记,自学笔记,ruby基础语法非常全面

    RubyStudy-master-ruby学习笔记

    学习 Ruby 的旅程即将开始! Ruby 是一种功能强大、灵活的编程语言,广泛应用于 Web 开发、脚本编写和系统管理等领域。下面是学习 Ruby 的一些实用建议:首先,了解 Ruby 的基本概念和语法。 Ruby 是一种面向对象的...

    个人ruby学习笔记

    从给定的文件信息中,我们可以提炼出一系列关于Ruby编程语言的重要知识点,涵盖基础语法、变量类型、...以上总结了Ruby的一些基础知识点,这些内容对于初学者掌握Ruby编程语言至关重要,同时也是进一步深入学习的基石。

    精华ruby学习笔记和代码

    这个笔记里包含了ruby的整型,字符串,浮点数,布尔等基础数据类型,还有数组,哈希hash的用法, 类的定义,函数方法,以及对象定义,其他高级用法解释,除了笔记记录的语法糖之外,还包含了一些解释性的代码,帮助...

    学习Ruby的笔记以及Demo源码.zip

    学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及...

    学习 Ruby 的笔记以及 Demo(简介、语言特性、应用场景、Ruby 注释、Ruby 文件的构造与析构语句Ruby 变量等)

    Ruby 学习笔记 1、简介 定义:一种简单快捷的面向对象脚本语言 开发者:松本行弘 开发时间:1995年 设计目的:A PROGRAMMER'S BEST FRIEND【程序员的最佳朋友】 文件扩展名:rb 2、语言特性 真正的面向对象编程语言 ...

    Ruby学习笔记一

    笔记: Ruby会默认返回方法中的最后一个值。 如果需要返回多个值,可以用数组来实现。 可以通过强制声明return来返回值。 基础的输出方法是用puts(输出一行),print(直接打印)。 基础的输入方法是gets(读入一行,...

    ruby 学习笔记(2) 类的基本使用

    ruby语言跟c#的一些重要差别在于: 1.ruby是动态语言,c#是静态语言–即对象在new出来以后,ruby还可以动态... …其它地方,等学习深入了再写出来 最后上一段测试代码,展示了ruby中类的基本用法: 代码如下: class Peop

    Ruby学习笔记之gem 命令详解

    这篇学习笔记将详细介绍 `gem` 命令及其相关工具,如 RVM (Ruby Version Manager) 的使用。 首先,我们通过 `ruby -v` 命令来查看当前系统中安装的 Ruby 版本。这有助于确保我们正在使用的是正确的版本。如果需要...

    ruby 学习笔记(1) 初识语法

    单从技术而言,ruby本身确实很爽,令程序员的工作变得轻松有趣! 下面的代码演示了如何找出100以内的素数: 代码如下: using System; namespace Mersenne { class Program { static void Main(string[] args) { for ...

    ruby笔记1ruby笔记1ruby笔记1

    标题中的"ruby笔记1ruby笔记1ruby笔记1"暗示了这是一份关于Ruby编程语言的学习笔记,可能包含了作者在学习过程中的重点、难点以及心得体验。描述中的内容重复了标题,进一步强调了这是关于Ruby的深入学习记录。标签...

    学习 Ruby 的笔记以及 Demo.zip

    本资源“学习 Ruby 的笔记以及 Demo.zip”显然包含了关于Ruby编程的学习资料和一些实际示例代码,旨在帮助初学者理解并掌握Ruby的基础及进阶特性。 首先,让我们深入了解一下Ruby的核心特性: 1. 面向对象:Ruby是...

    ruby编程学习笔记及demo

    Ruby是一种纯粹的面向对象编程语言。它由日本的松本行弘(まつもとゆきひろ/Yukihiro Matsumoto)创建于1993年。 您可以在 www.ruby-lang.org 的 Ruby 邮件列表上找到松本行弘(まつもとゆきひろ/Yukihiro ...

    Ruby自学笔记

    以上是Ruby自学笔记中提及的关键知识点的详细解读,如果要学好Ruby语言,深入理解这些基础知识是非常必要的。Ruby语言的这些特性与规则构成了其独特的编程范式,使得它在动态语言领域中占有一席之地。

Global site tag (gtag.js) - Google Analytics