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相关的介绍。。。
分享到:
相关推荐
Ruby学习笔记 01 类的属性与方法 02 访问控制 03 Container(Array/Hash) 04 Iterator 05 简单数据类型 06 范围 07 方法 08 条件控制 09 异常处理
Ruby是一种面向对象的脚本语言,它以其简洁、优雅的语法和强大的功能而闻名。...通过安装Ruby和DevKit,你可以轻松地编写、编译和运行Ruby代码,同时结合学习笔记,可以深入理解Ruby语言及其生态系统。
ruby基础笔记,自学笔记,ruby基础语法非常全面ruby基础笔记,自学笔记,ruby基础语法非常全面
学习 Ruby 的旅程即将开始! Ruby 是一种功能强大、灵活的编程语言,广泛应用于 Web 开发、脚本编写和系统管理等领域。下面是学习 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的笔记以及...
Ruby 学习笔记 1、简介 定义:一种简单快捷的面向对象脚本语言 开发者:松本行弘 开发时间:1995年 设计目的:A PROGRAMMER'S BEST FRIEND【程序员的最佳朋友】 文件扩展名:rb 2、语言特性 真正的面向对象编程语言 ...
笔记: Ruby会默认返回方法中的最后一个值。 如果需要返回多个值,可以用数组来实现。 可以通过强制声明return来返回值。 基础的输出方法是用puts(输出一行),print(直接打印)。 基础的输入方法是gets(读入一行,...
ruby语言跟c#的一些重要差别在于: 1.ruby是动态语言,c#是静态语言–即对象在new出来以后,ruby还可以动态... …其它地方,等学习深入了再写出来 最后上一段测试代码,展示了ruby中类的基本用法: 代码如下: class Peop
这篇学习笔记将详细介绍 `gem` 命令及其相关工具,如 RVM (Ruby Version Manager) 的使用。 首先,我们通过 `ruby -v` 命令来查看当前系统中安装的 Ruby 版本。这有助于确保我们正在使用的是正确的版本。如果需要...
单从技术而言,ruby本身确实很爽,令程序员的工作变得轻松有趣! 下面的代码演示了如何找出100以内的素数: 代码如下: using System; namespace Mersenne { class Program { static void Main(string[] args) { for ...
本资源“学习 Ruby 的笔记以及 Demo.zip”显然包含了关于Ruby编程的学习资料和一些实际示例代码,旨在帮助初学者理解并掌握Ruby的基础及进阶特性。 首先,让我们深入了解一下Ruby的核心特性: 1. 面向对象:Ruby是...
Ruby是一种纯粹的面向对象编程语言。它由日本的松本行弘(まつもとゆきひろ/Yukihiro Matsumoto)创建于1993年。 您可以在 www.ruby-lang.org 的 Ruby 邮件列表上找到松本行弘(まつもとゆきひろ/Yukihiro ...
以上是Ruby自学笔记中提及的关键知识点的详细解读,如果要学好Ruby语言,深入理解这些基础知识是非常必要的。Ruby语言的这些特性与规则构成了其独特的编程范式,使得它在动态语言领域中占有一席之地。
脚本语言真是太强了。 我的目的是把我的默认代码头功能加到Vim里面。 /****************************************************************************** ...* ----Stay Hungry Stay Foolish---- ...