Ruby语言学习

print "enter: "
name = gets #使用gets获取输入
puts("Hello " + name + "you are 2b") #会自动把后面的内容换行
print "enter again: "
name_new = gets.chomp() #消除自动换行!!!
puts("Hello " + name_new + "! you are 2b") #不换行

（4）注释

1.使用#进行注释

2.使用=begin,=end进行注释（等号前面不能有空格），两个=开头的行之间会被注释

#单行注释
#puts test   不会打印

#多行注释
=begin
使用等号（前面不能有空格）进行注释
puts test  不会打印
=end

二、数据类型与应用

（1）基本数据类型

常用的数据类型为字符串，num（整数，浮点数），其基本用法如下：

1.使用puts进行打印的时候，最好加括号（可读性更高）

2.拼接方式为“string content” + var

3.也可以使用字符串格式化进行打印

注：拼接操作必须为字符串，若为其他类型，需要进行类型转换

name = "Believe" #字符串
age = 20 #整形
gpa = 3.2 #浮点型
nothis = nil #类似python中的None
# puts ("try print" + nothis)
# if (nothis == nil)
puts ("gpa is %s"%gpa)
puts ("age is %s"%age)#数值不能拼接，需要用字符串格式化
puts ("age is " + age.to_s)#使用.to_s
puts "%s is beautiful"%name
puts (name + " is beautiful")#字符串拼接
puts "Her name is "+name
puts ("Her name is "+name) #可加括号

字符串类型的常用操作

length：计算长度

include?"string"：该字符串是否包含string这个字符（串）

切片：用逗号 “,” 连接

index：找出对应元素的索引

upcase：转大写

phase = "main phase"
puts phase.length() #长度包括空格
puts phase.include?"main" #某字符是否在当前字符串中->T or F
puts phase[0,3] #索引访问元素,0-based,切片用逗号,访问,不包括末尾
puts phase.index("a",2) #找出对应元素的索引(默认找出第一个),参数("str",start-index)
puts phase.upcase() #转大写

num类型的常用操作

abs：取绝对值

round：取整

num = 20
numcontrast = -20
numfloat = 20.687
puts num % 3 
puts ("-20's abs: " + numcontrast.abs().to_s) #abs
puts ("20.687's round: " + num.round().to_s) #取整
puts ("num is " + num.to_s) #num2str，使用.to_s
puts ("log2(2): " + Math.log2(2).to_s) #内置关键字进行计算
puts ("1.0+7: " + (1.0 + 7).to_s) #float calculate with int -> float

注：采用gets方法获取num的输入，需要进行类型转换才能成功计算

print "enter num1: "
num1 = gets.chomp() 
print "enter num2: "
num2 = gets.chomp()
puts("num1 + num2: " + (num1 + num2))#会出现1+2=12 -> gets会把输入变成str
puts("num1 + num2: " + (num1.to_i + num2.to_i).to_s)#类型转换
puts("1+1="+(1+1).to_s)#直接计算不需要to_i进行转换，打印1+1=2

字符串拼接/格式化

对字符串进行拼接/格式化有三种方法

直接用""和+进行拼接

使用%进行字符串格式化

使用#{}

name = 1
puts("a:"+name.to_s)
puts("a:%s"%name)
puts("a:#{name}")

（2）数据类型转换

通用格式为var.to_xx，主要有以下5种转换

  num = 2                       
  to_c:to complex复数 -> 2+0i  
  to_r:to fraction分数 -> 2/1  
  to_f:to float -> 2.0         
  to_i:to int -> 2             
  to_s:to str -> 2

（3）其它数据类型

array（类似列表）

创建形式有三种：

1.有元素：xx=Array[xx]

2.有元素：xx=[xx]

3.创建空array：xx=Array.new

array通过索引对元素进行访问，可以有空白元素

常用方法有length()、include?、reverse、sort等

friends = Array[2,'pig','dragon','bird',1] 
puts friends
puts friends[1] #索引访问
friends_unknow = Array.new #创建未知array
friends_unknow[0] = 'dog' #赋值
friends_unknow[5] = 'cat' #赋值
puts friends_unknow #中间空缺的为空白
puts friends_unknow.length() #元素数量
puts friends_unknow.include?"dog" #是否包含元素 -> T or F
puts friends_unknow.reverse()#翻转
numss = [1,2,4,3]
puts numss.sort() #排序

哈希hash（类似字典）

其基本形式如下，使用箭头表示附属关系

states = {
    3 => 1,
    "b" => 2
}
puts states
puts states['b'] #访问字符'b'对应的value
puts states[3] #访问3对应的value

三、控制流

（1）条件控制语句

if

基本格式为：if...elsif...else...end（注意是elsif）

使用and表示逻辑与

结尾要有end

###if elsif else###
ismale = false
if ismale
    puts "man"
elsif 2 > 1 and 3 > 2  
    #elsif
    #多条件，用and
    puts "num compare"
else
    puts "none"
end  #要有end

case

使用case和when、else组合，else类似default的作用

结尾要有end

def get_day_name(day)
    day_name = ""
    case day
    when "mon"  #when与case搭配。需要end
        day_name = "Monday"
    when "tue"
        day_name = "Tuesday"
    else
        day_name = "Invalid"  #等同于default
    end
    puts day_name
end
get_day_name("")

（2）循环语句

while

基本形式为while...end

index = 1
while index <= 5
    puts index
    index += 1
end

for

基本形式为for...end

friends = ['mike','chenjie','john']
for friend in friends1
    puts friend
end

指定次数遍历（类似python的range）

注：与range不同，尾元素也会被包括进来

for i in 1..5 #使用..进行连接头尾
    puts i
end
#输出
#1
#2
#3
#4
#5

each

基本形式为.each...do...end

注：do后面可省略，即当不需要子元素用于后续计算，则可以省略（见times中cal_pow）

friends = ['mike','chenjie','john']
friends.each do |friend| #被遍历对象使用.each，每个子元素使用||表示
    puts friend
end

times

基本形式为.times...do...end

6.times do |i| #表示循环6次，从0开始
    puts i
end

与for、each等循环结构相比，times可以指定次数，当作为函数的参数进行传递时更加方便，如计算幂次方

def cal_pow(base_num,pow_num)
    result = 1
    pow_num.times do #|index|可省略
        result = result * base_num
    end
    puts result
end

cal_pow(2,3) #输出8

四、函数

函数定义及基本使用

基本格式为def...end

可带默认参数

可以array的形式返回全部值，也可以分别返回多个值

def sayhi #可不加括号
    puts "Hello!"
end  #要加end
sayhi

def sayhi_param(data="no name") #参数化,默认值
    puts ("Hello!" + data)
    return 1,2 #return返回值
end  #要加end

data = 'sb'
return_val = sayhi_param(data)
puts return_val[1] #多个值可像数组一样访问，或返回多个值
val1,val2 = sayhi_param(data)
#这里rerurn_val等于val1，val2的集合

五、IO

文件读写

基本形式：File.open("filename","Mode")

分为块形式和非块形式

其Mode如下

文件读

按行读取方式有三种：read，readline，readlines

read：一次性去读全部内容，不可遍历

readline：读取单行

readlines：读取全部内容，作为array，可遍历

按字符读取：readchar

注：文件只能读取一次，当使用read读取文件后，指针已经跳转到文件末尾，后续的读取无效

块形式

注：自动关闭文件

File.open("a.txt","r") do |file|
    #第一段程序，读取了file，因此后续的代码全部读取
    puts file.read()
    #第二段程序，因为指针到了文件尾部，所以读取不到内容，会输出false
    puts file.read().include? "bb"
    #第三段程序，读取失败
    puts file.readline()
    #第四段程序，读取失败
    puts file.readlines()
end

File.open("a.txt","r") do |file|
    content = file.read()#使用content对读取内容进行存储
    puts content
    puts content.include? "bb"#输出ture
    #不会继续输出，因为已经读取过了
    puts file.readline()
    puts file.readlines()
end

非块形式

注：需要加上file.close()手动关闭文件

file = File.open("a.txt","r") 
    content = file.readlines()
    for i in content
        puts i
    end
 
file.close()

文件写

以块形式为例，使用write完成写入操作，可以结合readchar、readline等完成特定位置的写入

File.open("a.txt","r+") do |file|
    file.readchar()
    file.write("Mike")
end

六、异常处理

使用异常处理，当执行到可能发生错误的语句时，可以使用其它提示语句代替它，类似python的try...expect

基本形式为 begin...rescue...end

多个rescue语句只会响应第一个

#可能的错误语句卸载begin和rescue之间
begin
    puts 10/0
rescue
#替换语句卸载rescue和end之间
    puts "0 can not be divide"
end

可以指定抛出的错误类型，如ZeroDivisionError、TypeError等，它们自带提示语句

可以将错误赋予变量，通过打印变量，实现自动提示

#可能的错误语句在begin和rescue之间
num = [1,2]
begin
    puts 10/0 #该语句会触发ZeroDivisionError
    num1 = num['dog'] #若仅存在该语句，则由于rescue指定了抛出错误类型，因此puts语句不会执行
rescue ZeroDivisionError
#替换语句在rescue和end之间
    puts "0 can not be divide"
rescue TypeError => e#同理，该错误类型只会响应num1 = num['dog']
    #puts "num has not element as string"
    puts e #输出no implicit conversion of String into Integer
end

七、类

（1）声明和创建

基本形式为class...end（不用冒号）

类的属性使用attr_accessor来声明，搭配冒号和，第一个冒号前要有空格

类的创建使用new完成

使用object.attribute完成调用和赋值

注：Ruby类名开头必须大写！！！

class Building
    attr_accessor :name, :country, :people
end

build1 = Building.new()
build1.name="one"
build1.country="CHINA"
build1.people="Chinese"
puts build1.name

使用initialize对属性进行初始化，new的时候传参

使用@开头给属性赋值

对方法的调用也用点.实现

class Building
    attr_accessor :name, :country, :people
    def initialize(name,country,people) #初始化
        @name = name #传递值
        @country = country
        @people = people
    end

    def find_country()
        if @country == "CHINA"
            puts "Best Country"
        else
            puts "None"
        end
    end
end

build1 = Building.new("one","CHINA","Chinese") #传参
# build1.name="one"
# build1.country="CHINA"
# build1.people="Chinese"
puts build1.people
build1.find_country() #调用方法

（2）类的继承

使用<进行类的继承

class Example
    def print_test()
        puts "test"
    end
end
class New_example < Example #类继承

end
exp = New_example.new()
exp.print_test()

八、Module（打包）

module是类、方法、常量的集合

module名也必须以大写字母开头

module可以嵌入到类中

其中的常量开头要大写

module Module_Name
    class
    def
    Var #开头大写
end

（1）模块的导入

同模块导入之include

在同个文件中导入module，只需要include

module My_module
    def print_test()
        puts "test"
    end
end

include My_module
puts My_module.print_test()

跨文件导入之require_relative、include

relative指相对路径

#文件test.rb
module My_module
    def print_test()
        puts "test"
    end
end


#文件import.rb
require_relative "test.rb"
include My_module

（2）调用类、方法和常量

使用module.def来调用方法

使用module::var来调用常量

使用module::class来声明类

module My_module
    def print_test()
        puts "test"
    end
    Val = 1
end

include My_module
puts My_module.print_test()
puts My_module::Val

module中声明类

module My_module
    class Print_test
        def print_test()
            puts "test"
        end
    end
    Val = 1
end

include My_module
# puts My_module::Print_test.print_test()
puts My_module::Val
inst_print = My_module::Print_test.new()
inst_print.print_test()

（3）在类中嵌入Module

在类中嵌入Module，类可以等同于该Module，直接调用Module内嵌的元素

class Insert_Module
    include My_module
    
end

puts Insert_Module::Val

乐奇 Rokid 开放社区

更多推荐

【应用方案】智能眼镜一站式解决方案：交互与感知技术赋能下一代穿戴体验

乐奇 Rokid 开放社区

全球 AI / 科技简报｜2026 年 9 月 4 日

乐奇 Rokid 开放社区

腾讯WorkBuddy宣布开放平台上线，首批引入超百家伙伴，打造 Agent 新生态

乐奇 Rokid 开放社区

所有评论(0)

查看更多评论

蓝色正义

@weixin_44764783

已为社区贡献1条内容

Ruby语言学习

蓝色正义

一、基本操作

（1）打印

（2）反斜杠转义

（3）读取输入

（4）注释

二、数据类型与应用

（1）基本数据类型

字符串类型的常用操作

num类型的常用操作

字符串拼接/格式化

（2）数据类型转换

（3）其它数据类型

array（类似列表）

哈希hash（类似字典）

三、控制流

（1）条件控制语句

if

case

（2）循环语句

while

for

each

times

四、函数

函数定义及基本使用

五、IO

文件读写

文件读

块形式

非块形式

文件写

六、异常处理

七、类

（1）声明和创建

（2）类的继承

八、Module（打包）

（1）模块的导入

同模块导入之include

跨文件导入之require_relative、include

（2）调用类、方法和常量

（3）在类中嵌入Module

所有评论(0)

温馨提示：您尚未绑定手机号

蓝色正义