[huayang]
因为macOS自带ruby这里就不说怎么安装了
因为是临阵磨枪只有半天的时间学习就不讲很详细了
Ruby 语法
新建个文件123.rb,写入
puts "hello word"
在命令使用ruby打印出来就行了
ruby 123.rb
Ruby 中的 Here Document
建立多行字符串
print <<EOF
这是第一种方式创建here document 。
多行字符串。
EOF
print <<"EOF"; # 与上面相同
这是第二种方式创建here document 。
多行字符串。
EOF
print <<`EOC` # 执行命令
echo hi there
echo lo there
EOC
print <<"foo", <<"bar" # 您可以把它们进行堆叠
I said foo.
foo
I said bar.
bar
Ruby BEGIN 语句
声明 code 会在程序运行之前被调用
puts "这是主 Ruby 程序"
BEGIN {
puts "初始化 Ruby 程序"
}
Ruby END 语句
声明 code 会在程序的结尾被调用。
puts "这是主 Ruby 程序"
END {
puts "停止 Ruby 程序"
}
BEGIN {
puts "初始化 Ruby 程序"
}
Ruby 数据类型
您可以使用序列 #{ expr } 替换任意 Ruby 表达式的值为一个字符串。在这里,expr 可以是任意的 Ruby 表达式。
#!/usr/bin/ruby -w
puts "相乘 : #{24*60*60}";
这将产生以下结果:
相乘 : 86400
Ruby 类和对象
在 Ruby 中定义类
在 Ruby 中,类总是以关键字 class 开始,后跟类的名称。类名的首字母应该大写
class Customer
end
您可以使用关键字 end 终止一个类。类 中的所有数据成员都是介于类定义和 end 关键字之间。
Ruby 类中的变量
Ruby 提供了四种类型的变量:
- 局部变量:局部变量是在方法中定义的变量。局部变量在方法外是不可用的。在后续的章节中,您将看到有关方法的更多细节。局部变量以小写字母或 _ 开始。
- 实例变量:实例变量可以跨任何特定的实例或对象中的方法使用。这意味着,实例变量可以从对象到对象的改变。实例变量在变量名之前放置符号(@)。
- 类变量:类变量可以跨不同的对象使用。类变量属于类,且是类的一个属性。类变量在变量名之前放置符号(@@)。
- 全局变量:类变量不能跨类使用。如果您想要有一个可以跨类使用的变量,您需要定义全局变量。全局变量总是以美元符号($)开始。
使用类变量 @@no_of_customers,您可以判断被创建的对象数量,这样可以确定客户数量。
class Customer
@@no_of_customers=0
end
在 Ruby 中使用 new 方法创建对象
cust1 = Customer. new
cust2 = Customer. new
在这里,cust1 和 cust2 是两个对象的名称。对象名称后跟着等号(=),等号后跟着类名,然后是点运算符和关键字 new。
下面的实例将创建类 Sample 的一个对象,并调用 hello 方法:
class Sample
def hello
puts "Hello Ruby!"
end
end
# 使用上面的类来创建对象
object = Sample. new
object.hello
这将会产生下面的结果:
Hello Ruby!
Ruby 变量
Ruby 支持五种类型的变量。
- 一般小写字母、下划线开头:变量(Variable)。
$
开头:全局变量(Global variable)。@
开头:实例变量(Instance variable)。@@
开头:类变量(Class variable)类变量被共享在整个继承链中- 大写字母开头:常数(Constant)。
Ruby 全局变量
全局变量以 $ 开头
用法:
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$global_variable = 10
class Class1
def print_global
puts "全局变量在 Class1 中输出为 #$global_variable"
end
end
class Class2
def print_global
puts "全局变量在 Class2 中输出为 #$global_variable"
end
end
class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global
在这里,$global_variable 是全局变量。这将产生以下结果:
注意:在 Ruby 中,您可以通过在变量或常量前面放置 # 字符,来访问任何变量或常量的值。
全局变量在 Class1 中输出为 10 全局变量在 Class2 中输出为 10
Ruby 实例变量
实例变量以 @ 开头
用法:
#!/usr/bin/ruby
class Customer
def initialize(id, name, addr)
@cust_id=id
@cust_name=name
@cust_addr=addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
end
end
# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")
# 调用方法
cust1.display_details()
cust2.display_details()
结果:
Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala
Ruby 类变量
类变量以 @@ 开头,且必须初始化后才能在方法定义中使用
#!/usr/bin/ruby
class Customer
@@no_of_customers=0
def initialize(id, name, addr)
@cust_id=id
@cust_name=name
@cust_addr=addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
end
def total_no_of_customers()
@@no_of_customers += 1
puts "Total number of customers: #@@no_of_customers"
end
end
# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")
# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()
结果
Total number of customers: 1
Total number of customers: 2
Ruby 局部变量
局部变量以小写字母或下划线 _ 开头
局部变量的作用域从 class、module、def 或 do 到相对应的结尾或者从左大括号到右大括号 {}。
Ruby 常量
常量以大写字母开头
定义在类或模块内的常量可以从类或模块的内部访问,定义在类或模块外的常量可以被全局访问。
常量不能定义在方法内。引用一个未初始化的常量会产生错误。对已经初始化的常量赋值会产生警告
Ruby 伪变量
- self: 当前方法的接收器对象。
- true: 代表 true 的值。
- false: 代表 false 的值。
- nil: 代表 undefined 的值。
- __FILE__: 当前源文件的名称。
- __LINE__: 当前行在源文件中的编号。
Ruby 判断
支持elsif
Ruby if 修饰符
if修饰词组表示当 if 右边之条件成立时才执行 if 左边的式子。即如果 conditional 为真,则执行 code。
#!/usr/bin/ruby
$debug=1
print "debug\n" if $debug
以上实例输出结果:
debug
Ruby unless 语句
如果 conditional 为假,则执行 code。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$var = 1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var
$var = false
print "3 -- 这一行输出\n" unless $var
以上实例输出结果:
1 -- 这一行输出 3 -- 这一行输出
Ruby case 语句
case先对一个 expression 进行匹配判断,然后根据匹配结果进行分支选择。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$age = 5
case $age
when 0 .. 2
puts "婴儿"
when 3 .. 6
puts "小孩"
when 7 .. 12
puts "child"
when 13 .. 18
puts "少年"
else
puts "其他年龄段的"
end
以上实例输出结果为:
小孩
Ruby 循环
Ruby while 语句
语法中 do 或 : 可以省略不写。但若要在一行内写出 while 式,则必须以 do 或 : 隔开条件式或程式区块。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$i = 0
$num = 5
while $i < $num do
puts("在循环语句中 i = #$i" )
$i +=1
end
以上实例输出结果为:
在循环语句中 i = 0 在循环语句中 i = 1 在循环语句中 i = 2 在循环语句中 i = 3 在循环语句中 i = 4
Ruby while 修饰符
当 conditional 为真时,执行 code。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$i = 0
$num = 5
begin
puts("在循环语句中 i = #$i" )
$i +=1
end while $i < $num
以上实例输出结果为:
在循环语句中 i = 0 在循环语句中 i = 1 在循环语句中 i = 2 在循环语句中 i = 3 在循环语句中 i = 4
Ruby until 语句
当 conditional 为假时,执行 code。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$i = 0
$num = 5
until $i > $num do
puts("在循环语句中 i = #$i" )
$i +=1;
end
以上实例输出结果为:
在循环语句中 i = 0 在循环语句中 i = 1 在循环语句中 i = 2 在循环语句中 i = 3 在循环语句中 i = 4 在循环语句中 i = 5
Ruby until 修饰符
当 conditional 为 false 时,执行 code。
如果 until 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面,code 会在 conditional 判断之前执行一次。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
$i = 0
$num = 5
begin
puts("在循环语句中 i = #$i" )
$i +=1;
end until $i > $num
以上实例输出结果为:
在循环语句中 i = 0 在循环语句中 i = 1 在循环语句中 i = 2 在循环语句中 i = 3 在循环语句中 i = 4 在循环语句中 i = 5
Ruby for 语句
先计算表达式得到一个对象,然后针对 expression 中的每个元素分别执行一次 code。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
for i in 0..5
puts "局部变量的值为 #{i}"
end
在这里,我们已经定义了范围 0..5。语句 for i in 0..5 允许 i 的值从 0 到 5(包含 5)。
以上实例输出结果为:
局部变量的值为 0 局部变量的值为 1 局部变量的值为 2 局部变量的值为 3 局部变量的值为 4 局部变量的值为 5
Ruby break 语句
终止最内部的循环。如果在块内调用,则终止相关块的方法(方法返回 nil)。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
for i in 0..5
if i > 2 then
break
end
puts "局部变量的值为 #{i}"
end
以上实例输出结果为:
局部变量的值为 0 局部变量的值为 1 局部变量的值为 2
Ruby next 语句
跳到循环的下一个迭代。如果在块内调用,则终止块的执行(yield 表达式返回 nil)。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
for i in 0..5
if i < 2 then
next
end
puts "局部变量的值为 #{i}"
end
以上实例输出结果为:
局部变量的值为 2 局部变量的值为 3 局部变量的值为 4 局部变量的值为 5
Ruby redo 语句
重新开始最内部循环的该次迭代,不检查循环条件。如果在块内调用,则重新开始 yield 或 call。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
for i in 0..5
if i < 2 then
puts "局部变量的值为 #{i}"
redo
end
end
这将产生以下结果,并会进入一个无限循环:
局部变量的值为 0 局部变量的值为 0 ............................
Ruby retry 语句
如果 retry 出现在 begin 表达式的 rescue 子句中,则从 begin 主体的开头重新开始。
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
for i in 1..5
retry if i > 2
puts "局部变量的值为 #{i}"
end
这将产生以下结果,并会进入一个无限循环:
局部变量的值为 1 局部变量的值为 2 局部变量的值为 1 局部变量的值为 2 局部变量的值为 1 局部变量的值为 2 ............................
Ruby 方法
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
def test(a1="Ruby", a2="Perl")
puts "编程语言为 #{a1}"
puts "编程语言为 #{a2}"
end
test "C", "C++"
test
以上实例运行输出结果为:
编程语言为 C 编程语言为 C++ 编程语言为 Ruby 编程语言为 Perl
Ruby return 语句
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
def test
i = 100
j = 200
k = 300
return i, j, k
end
var = test
puts var
以上实例运行输出结果为:
100 200 300
可变数量的参数
假设您声明了一个带有两个参数的方法,当您调用该方法时,您同时还需要传递两个参数。
但是,Ruby 允许您声明参数数量可变的方法。让我们看看下面的实例:
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
def sample (*test)
puts "参数个数为 #{test.length}"
for i in 0...test.length
puts "参数值为 #{test[i]}"
end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"
在这段代码中,您已经声明了一个方法 sample,接受一个参数 test。但是,这个参数是一个变量参数。这意味着参数可以带有不同数量的变量。以上实例运行输出结果为:
参数个数为 3 参数值为 Zara 参数值为 6 参数值为 F 参数个数为 4 参数值为 Mac 参数值为 36 参数值为 M 参数值为 MCA
类方法
当方法定义在类的外部,方法默认标记为 private。另一方面,如果方法定义在类中的,则默认标记为 public。
我们已经知道方法 return_date 是如何声明的。它是通过在类名后跟着一个点号,点号后跟着方法名来声明的。您可以直接访问类方法,如下所示:
Accounts.return_date
如需访问该方法,您不需要创建类 Accounts 的对象。
Ruby alias 语句
这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写,方法的别名也保持方法的当前定义。
alias foo bar
alias $MATCH $&
在这里,我们已经为 bar 定义了别名为 foo,为 $& 定义了别名为 $MATCH。
Ruby undef 语句
这个语句用于取消方法定义。undef 不能出现在方法主体内。
下面的实例取消名为 bar的方法定义: undef bar
Ruby 块
- 块由大量的代码组成。
- 您需要给块取个名称。
- 块中的代码总是包含在大括号 {} 内。
- 块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test,那么您要使用函数 test 来调用这个块。
- 您可以使用 yield 语句来调用块。
yield 语句
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
def test
puts "在 test 方法内"
yield
puts "你又回到了 test 方法内"
yield
end
test {puts "你在块内"}
以上实例运行结果为:
在 test 方法内 你在块内 你又回到了 test 方法内 你在块内
现在,看下面的语句:
test {|i| puts "你在块 #{i} 内"}
在这里,值 5 会在变量 i 中收到。现在,观察下面的 puts 语句:
puts "你在块 #{i} 内"
这个 puts 语句的输出是: 你在块5 内
如果您想要传递多个参数,那么 yield 语句如下所示:
yield a, b
此时,块如下所示:
test {|a, b| statement}
参数使用逗号分隔。
块和方法
您已经看到块和方法之间是如何相互关联的。您通常使用 yield 语句从与其具有相同名称的方法调用块。
但是如果方法的最后一个参数前带有 &,那么您可以向该方法传递一个块,且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中,& 应放在后面
#!/usr/bin/ruby
def test(&block)
block.call
end
test { puts "Hello World!"}
BEGIN 和 END 块
每个 Ruby 源文件可以声明当文件被加载时要运行的代码块(BEGIN 块),以及程序完成执行后要运行的代码块(END 块)。
#!/usr/bin/ruby
BEGIN {
# BEGIN 代码块
puts "BEGIN 代码块"
}
END {
# END 代码块
puts "END 代码块"
}
# MAIN 代码块
puts "MAIN 代码块"
一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。当执行时,上面的程序输出以下结果:
BEGIN 代码块 MAIN 代码块 END 代码块
Ruby 模块(Module)
模块(Module)是一种把方法、类和常量组合在一起的方式。模块(Module)为您提供了两大好处。
- 模块提供了一个命名空间和避免名字冲突。
- 模块实现了 mixin 装置。
模块(Module)定义了一个命名空间,相当于一个沙盒,在里边您的方法和常量不会与其他地方的方法常量冲突。
模块类似与类,但有以下不同:
- 模块不能实例化
- 模块没有子类
- 模块只能被另一个模块定义
Ruby require 语句
如果一个第三方的程序想要使用任何已定义的模块,则可以简单地使用 Ruby require 语句来加载模块文件:
require filename
Ruby include 语句
您可以在类中嵌入模块。为了在类中嵌入模块,您可以在类中使用 include 语句:
如果模块是定义在一个单独的文件中,那么在嵌入模块之前就需要使用 require 语句引用该文件。
include modulename
Ruby 字符串(String)
Ruby 字符串分为单引号字符串(’)和双引号字符串(”),区别在于双引号字符串能够支持更多的转义字符。
Ruby 数组(Array)
创建数组
有多种方式创建或初始化数组。一种方式是通过 new 类方法:
names = Array.new
您可以在创建数组的同时设置数组的大小:
names = Array.new(20)
#!/usr/bin/ruby
names = Array.new(4, "mac")
puts "#{names}"
以上实例运行输出结果为:
["mac", "mac", "mac", "mac"]
数组内建方法
我们需要有一个 Array 对象的实例来调用 Array 方法。下面是创建 Array 对象实例的方式:
#!/usr/bin/ruby
digits = Array(0..9)
num = digits.at(6)
puts "#{num}"
以上实例运行输出结果为:6
[/huayang]
FROM:浅浅淡淡[hellohy]
- 左青龙
- 微信扫一扫
-
- 右白虎
- 微信扫一扫
-
评论