【KWDB 创作者操持】_ruby底子语法
以下是 Ruby 底子语法的简明总结，得当快速入门：一、变量与常量
1. 局部变量
小写字母或下划线开头，作用域为当前代码块。
name = "Alice"
_age = 20
//局部变量附加：{{{{
声明与命名规则
[*] 命名格式
[*]以小写字母或下划线 _ 开头，如 name、_count。
[*]后续字符可包含字母、数字和下划线。
[*]制止与 Ruby 关键字（如 class、def）冲突。
[*] 声明方式
[*]通过赋值 = 隐式声明，无需显式类型。
age = 25 # 声明局部变量 age
_message = "Hello" # 声明局部变量 _message
作用域规则
[*] 代码块内外的可见性
[*] 块参数会掩藏外部变量：
x = 10
3.times do |x| # 块参数 x 遮蔽外部变量
puts x # 输出 0, 1, 2
end
puts x # 输出 10（外部变量未被修改）
[*] 无块参数时可访问外部变量：
x = 5
3.times do
x = 10 # 修改外部变量 x
end
puts x # 输出 10
[*] 方法内的局部变量
[*] 方法内部变量对外不可见：
def test_method
local_var = "内部变量"
end
test_method
puts local_var # NameError: undefined local variable
[*] 方法无法访问界说它的外部局部变量：
outer_var = "外部变量"
def show_var
puts outer_var# NameError: undefined local variable
end
show_var
[*] 条件与循环中的变量
[*] 纵然条件未执行，变量也会被声明（初始化为 nil）：
if false
a = 1 # 代码未执行，但变量 a 已声明
end
puts a # 输出 nil
[*] 循环（如 while）不创建新作用域：
i = 0
while i < 3
inner = i
i += 1
end
puts inner # 输出 2
变量掩藏与覆盖
[*] 内部作用域掩藏外部变量
x = 100
1.times do
x = 200 # 直接修改外部变量 x
y = 300 # 声明新变量 y（作用域在块内）
end
puts x # 输出 200
puts y # NameError: undefined local variable
[*] 方法参数与局部变量同名
def demo(x)
x = 20 # 修改的是参数 x，不影响外部变量
puts x # 输出 20
end
x = 10
demo(x)
puts x # 输出 10
特别场景
[*] 顶层作用域的局部变量
[*]在文件或交互式情况（如 irb）顶层界说的局部变量，作用域为当前文件或会话：top_var = "顶层变量"
def show_top_var
puts top_var # NameError: undefined local variable
end
show_top_var
[*] 类/模块界说中的局部变量
[*]在类或模块界说中声明的局部变量，仅在该界说范围内有用：class MyClass
class_var = "类定义内的局部变量"
def self.show_var
puts class_var # NameError: undefined local variable
end
end
最佳实践
[*]制止变量掩藏：谨慎使用与外部作用域同名的变量。
[*]限定作用域：在最小须要范围内界说变量，减少副作用。
[*]明确命名：使用有意义的变量名（如 user_count 而非 uc）。
总结
场景行为块内无参数赋值可读写外部变量块带同名参数掩藏外部变量，内部操作不影响外部方法内部变量仅在方法内有用，外部不可见条件/循环中的变量纵然代码未执行，变量也会被声明（值为 nil）类界说中的变量仅在类界说过程中有用，类方法无法访问 理解局部变量的作用域规则是编写可维护 Ruby 代码的底子，尤其在处理复杂逻辑时能制止意外的变量污染或覆盖。
//局部变量附加竣事}}}}
2. 实例变量
以 @ 开头，属于对象实例。
@name = "Bob"
//实例变量附加：{{{{
实例变量（Instance Variables）是面向对象编程的核心概念，用于存储对象的状态。以下是其详细规则和使用方法：
界说与根本特性
[*] 命名规则
[*]以 @ 符号开头，如 @name、@age。
[*]后续字符可包含字母、数字和下划线。
[*]默认值为 nil（未显式赋值时）。
[*] 作用域
[*]属于对象实例：每个对象的实例变量独立存在。
[*]在类的方法中可访问：在类的任何实例方法中均可读写。
声明与访问
[*]直接赋值
class Person
def initialize(name)
@name = name# 在 initialize 方法中初始化
end
def greet
"Hello, #{@name}!"# 在方法中访问
end
end
person = Person.new("Alice")
puts person.greet# => "Hello, Alice!"
//class Person代码的解释开始：
这段 Ruby 脚本界说了一个 Person 类，并演示了如何创建对象实例和调用方法。以下是逐行解释：
[*]界说 Person 类
class Person
# 类体开始
end
[*]class Person：界说一个名为 Person 的类。
[*]Ruby 的类名需以 大写字母开头，接纳驼峰式命名。
[*]构造方法 initialize
def initialize(name)
@name = name# 初始化实例变量 @name
end
[*]initialize：类的构造方法，在调用 Person.new 时自动执行。
[*]name：构造方法的参数，用于吸收外部传入的值。
[*]@name = name：将参数 name 赋值给实例变量 @name。
[*]@name：以 @ 开头的变量是实例变量，属于对象实例的私有状态。
[*]实例方法 greet
def greet
"Hello, #{@name}!"# 使用实例变量 @name 拼接字符串
end
[*]greet：界说一个名为 greet 的实例方法。
[*]#{@name}：字符串插值语法，将 @name 的值嵌入字符串中。
[*]方法返回值为字符串（Ruby 中方法的末了一行的值会被自动返回）。
[*]创建对象实例
person = Person.new("Alice")
[*]Person.new("Alice")：调用 Person 类的 new 方法创建实例。
[*]new 方法会触发 initialize 方法，并将 "Alice" 作为参数传递。
[*]此时 @name 被赋值为 "Alice"。
[*]person：变量指向新创建的 Person 实例对象。
[*]调用方法并输出效果
puts person.greet# => "Hello, Alice!"
[*]person.greet：调用 person 实例的 greet 方法。
[*]方法返回字符串 "Hello, Alice!"。
[*]puts：输出字符串到控制台。
//class Person代码的解释竣事
[*]通过访问器方法
Ruby 提供快捷方法生成 getter 和 setter：
[*]attr_reader：生成 getter 方法。
[*]attr_writer：生成 setter 方法。
[*]attr_accessor：生成 getter 和 setter。
class User
attr_accessor :email# 自动生成 @email 的读写方法
attr_reader :id # 只生成 @id 的读方法
def initialize(id)
@id = id
end
end
user = User.new(1)
user.email = "alice@example.com"
puts user.email# => "alice@example.com"
//访问器方法代码解释 开始
属性访问器（Attribute Accessors），属性访问器（Attribute Accessors）是一种元编程机制，用于快速生成实例变量的 getter（读方法）和 setter（写方法）。Ruby 提供了三个核心方法简化操作：
三种属性访问器
[*] attr_reader
生成 只读方法（getter），答应外部读取实例变量。
class User
attr_reader :id# 生成 def id; @id; end
def initialize(id)
@id = id
end
end
user = User.new(1)
puts user.id # => 1
user.id = 2 # NoMethodError（无写方法）
[*] attr_writer
生成 只写方法（setter），答应外部修改实例变量。
class User
attr_writer :email# 生成 def email=(value); @email = value; end
def initialize(email)
@email = email
end
end
user = User.new("alice@example.com")
user.email = "bob@example.com"# 修改成功
puts user.email # NoMethodError（无读方法）
[*] attr_accessor
生成 读写方法（getter + setter），最常用。
class Product
attr_accessor :price# 生成读方法和写方法
def initialize(price)
@price = price
end
end
product = Product.new(100)
product.price = 150
puts product.price# => 150
访问器的底层原理
[*] 手动实现等效代码
class User
# attr_reader :name 的等效代码
def name
@name
end
# attr_writer :name 的等效代码
def name=(value)
@name = value
end
end
[*] 动态生成方法
attr_* 方法本质是通过元编程动态界说方法：
class Class
def my_attr_reader(name)
define_method(name) do
instance_variable_get("@#{name}")
end
end
end
高级用法与本领
[*] 批量界说访问器
class Person
attr_accessor :name, :age, :gender# 多个属性
end
[*] 添加自界说逻辑
class Temperature
attr_reader :celsius
def celsius=(value)
raise "温度不能低于绝对零度" if value < -273.15
@celsius = value
end
end
temp = Temperature.new
temp.celsius = -300# RuntimeError
[*] 结合初始化方法
class Book
attr_accessor :title, :author
def initialize(title, author)
@title = title
@author = author
end
end
book = Book.new("Ruby指南", "松本行弘")
book.title = "Ruby高级编程"
[*] 继续行为
父类的访问器方法会被子类继续：
class Admin < User
end
admin = Admin.new(1)
admin.email = "admin@example.com"# 正常执行（继承 attr_accessor）
//访问器方法代码解释 竣事
实例变量的特性
[*]封装性
[*]实例变量默认是 私有 的，外部无法直接访问。
[*]必须通过方法暴露（如 attr_accessor）。
[*]动态增删
可在运行时动态添加或删除实例变量：
obj = Object.new
obj.instance_variable_set(:@x, 10)
# 动态添加 @x
puts obj.instance_variable_get(:@x) # => 10
obj.remove_instance_variable(:@x)
# 删除 @x
//动态增删附加 开始：
这段 Ruby 脚本演示了如何通过反射机制 动态管理实例变量，
代码逐行剖析
[*]创建新对象
obj = Object.new
[*]作用：创建一个 Object 类的匿名实例。
[*]对象状态：此时 obj 没有任何预界说的实例变量。
[*]动态添加实例变量 @x
obj.instance_variable_set(:@x, 10)
[*]instance_variable_set 方法
[*]功能：直接为对象设置实例变量。
[*]参数：
[*]第一个参数：符号情势的变量名（必须包含 @，如 :@x）。
[*]第二个参数：变量值（可以是任意对象）。
[*]效果：对象 obj 新增实例变量 @x，值为 10。
[*]读取实例变量 @x 的值
puts obj.instance_variable_get(:@x) # => 10
[*]instance_variable_get 方法
[*]功能：直接读取对象的实例变量值。
[*]参数：符号情势的变量名（如 :@x）。
[*]返回值：变量的当前值，若变量不存在则返回 nil。
[*]删除实例变量 @x
obj.remove_instance_variable(:@x)
[*]remove_instance_variable 方法
[*]功能：从对象中删除指定的实例变量。
[*]参数：符号情势的变量名（如 :@x）。
[*]返回值：被删除变量的值。
[*]注意：若变量不存在会抛出 NameError。
关键方法和注意事项
方法名用途注意事项instance_variable_set动态设置实例变量变量名必须以 @ 开头，否则抛出 NameErrorinstance_variable_get动态读取实例变量变量不存在时返回 nil，不会报错remove_instance_variable动态删除实例变量变量不存在时抛出 NameError，需确保变量存在或使用 begin rescue 处理 使用场景
[*] 动态对象构造
在运行时根据条件动态添加属性：
data = { name: "Alice", age: 20 }obj = Object.new
data.each { |key, value| obj.instance_variable_set("@#{key}", value) }
[*] 元编程和框架开发
在编写机动的程序结构时（如 ORM、序列化工具）：
class Serializer
def serialize(obj)
obj.instance_variables.each_with_object({}) do |var, hash|
hash = obj.instance_variable_get(var)
end
end
end
[*] 调试和探索性编程
快速检察或修改对象内部状态：
user = User.find(1)user.instance_variable_set(:@password, "hacked") # 伤害操作！仅用于演示obj = Object.new
obj.instance_variable_set(:@不存在的方法, 100) # 合法但可能导致后续逻辑混乱# 使用下判定if obj.instance_variable_defined?(:@x)obj.remove_instance_variable(:@x)
end
// 动态增删附加 竣事
[*]与类变量的对比
实例变量 (@var)类变量 (@@var)作用域对象实例内类及其所有实例共享继续行为子类对象不继续父类实例变量子类共享父类的类变量 高级用法
5. 元编程访问
class Dog
def initialize(name)
@name = name
end
end
dog = Dog.new("Buddy")
# 获取所有实例变量名
dog.instance_variables# => [:@name]
# 检查是否存在实例变量
dog.instance_variable_defined?(:@name)# => true
[*]在模块中界说实例变量
module Loggable
def log(message)
@logs ||= []# 若 @logs 不存在则初始化为空数组
@logs << message
end
end
class Service
include Loggable
end
service = Service.new
service.log("Event 1")
service.instance_variable_get(:@logs)# => ["Event 1"]
注意事项
[*] 制止未初始化访问
实例变量未赋值时为 nil，需注意空值问题：
class Product
def print_price
"Price: #{@price}"# @price 未初始化时为 nil
end
end
Product.new.print_price# => "Price: "
[*] 命名冲突
子类可能意外覆盖父类的实例变量：
class Animal
def initialize
@name = "Animal"
end
end
class Cat < Animal
def initialize
@name = "Cat"# 覆盖父类的 @name
end
end
总结
场景实例变量的行为对象初始化通过 initialize 方法赋值方法间共享同一对象的实例方法均可访问动态管理支持运行时增删封装性必须通过方法暴露给外部 实例变量是 Ruby 面向对象的核心机制，合理使用它们可以高效管理对象状态！
//实例变量附加竣事}}}}
3. 类变量
以 @@ 开头，属于整个类。
@@count = 0
// 类变量 附加开始{{{{
在 Ruby 中，类变量（Class Variables）是一种特别类型的变量，用于在类层级共享数据。
界说与根本特性
[*] 命名规则
[*]以 @@ 开头，如 @@count、@@config。
[*]后续字符遵照变量命名规范（字母、数字、下划线）。
[*]必须显式初始化（否则抛出 NameError）。
[*] 作用域
[*]类层级共享：类变量属于类自己，被所有实例和子类共享。
[*]全局可见：在类界说、实例方法、类方法中均可访问。
根本用法示例
1. 类变量初始化与访问
class Counter@@count = 0
# 初始化类变量def self.increment @@count += 1enddef self.total @@countendendCounter.incrementCounter.incrementputs Counter.total# => 2
[*]实例方法访问类变量
class User
@@users = []
def initialize(name)
@name = name
@@users << self# 将实例自身加入类变量数组
end
def self.all_users
@@users
end
end
alice = User.new("Alice")
bob = User.new("Bob")
puts User.all_users.size# => 2
类变量的继续行为
[*]子类共享父类的类变量
class Parent
@@value = 100
def self.value
@@value
end
end
class Child < Parent
def self.change_value
@@value = 200
end
end
Child.change_value
puts Parent.value# => 200（父类的类变量被子类修改）
[*]所有子类共享同一变量
class A
@@list = []
end
class B < A; end
class C < A; end
B.class_variable_get(:@@list) << "item"
puts C.class_variable_get(:@@list)# => ["item"]
类变量的替换方案：类实例变量
由于类变量的共享特性容易导致意外修改，Ruby 开发者常使用 类实例变量 作为替换：
[*]类实例变量特性
[*]以 @ 开头，属于类对象（而非类自己）。
[*]不被子类继续，每个类独立拥有自己的副本。
[*]通过类方法中的 attr_accessor 界说。
[*]示例对比
class Parent
@count = 0# 类实例变量
class << self
attr_accessor :count# 定义类实例变量的访问器
end
end
class Child < Parent; end
Parent.count = 5
Child.count = 10
puts Parent.count# => 5（不受子类影响）
puts Child.count # => 10
类变量使用场景
场景示例全局类级计数器统计实例数目、方法调用次数共享配置数据库毗连、日记级别设置缓存数据存储类级别的计算效果或暂时数据 注意事项与陷阱
[*] 初始化位置
类变量必须在类或模块内部初始化（不能在其他作用域）。
class Demo
@@value = 0# 正确：在类体内初始化
end
# @@value = 0# 错误：顶层作用域无法初始化类变量
[*] 线程安全问题
类变量在多线程情况中可能引发竞态条件，需加锁掩护：
class Counter@@mutex = Mutex.new@@count = 0
def self.safe_increment @@mutex.synchronize { @@count += 1 }endend
[*] 制止过度共享
类变量的全局性容易导致代码耦合，应谨慎使用。
总结对比
特性类变量 (@@var)类实例变量 (@var)作用域类及其所有子类共享仅在界说它的类中有用继续行为子类修改影响父类和其他子类不继续，每个类独立初始化位置必须在类或模块内部可在类方法或类体内初始化适用场景需要跨继续树共享数据需要类级别的私有状态 //类变量 附加竣事}}}}
4. 全局变量
以 $ 开头，作用域全局。
$debug_mode = true
//全局变量附件开始
全局变量（Global Variables）是作用域覆盖整个程序（包括所有模块、类和方法的变量）。
全局变量的核心规则
[*] 命名规则
[*]以 $ 开头，如 $counter、$logger。
[*]后续字符遵照变量命名规范（字母、数字、下划线）。
[*] 作用域
[*]全局可见：在程序的任何位置（包括类、模块、方法、块）均可读写。
[*] 默认值
[*]未初始化的全局变量值为 nil。
根本用法示例
[*]声明与赋值
$app_name = "MyApp"# 定义全局变量
class User
def print_app_name
puts $app_name# 在类内访问全局变量
end
end
def log_message
$app_name = "NewApp"# 在方法内修改全局变量
end
log_message
User.new.print_app_name# 输出 "NewApp"
[*]预界说全局变量
Ruby 有一些内置的全局变量（如 $!、$@），用于访问体系信息或异常上下文：
begin
1 / 0
rescue => e
puts $!# 输出最后抛出的异常信息（等同 e.message）
puts $@# 输出异常堆栈跟踪（等同 e.backtrace）
end
全局变量的优缺点
优点
[*]快速共享数据：无需通过参数传递，直接跨作用域访问。
[*]暂时调试工具：快速记录程序状态。
缺点
[*]粉碎封装性：导致代码耦合，难以追踪修改来源。
[*]命名冲突风险：全局变量名可能被意外覆盖。
[*]维护困难：大型项目中难以管理。
使用场景（谨慎选择！）
场景示例跨模块共享配置日记级别、情况变量暂时调试或性能监控记录方法调用次数单例模式简朴实现全局唯一的数据库毗连对象 替换方案（推荐优先使用）
[*] 常量（全大写命名）
module Config
APP_NAME = "MyApp"# 常量，可被修改但会警告
end
puts Config::APP_NAME
[*] 类/模块变量
class AppState
@@instance_count = 0# 类变量
def self.increment
@@instance_count += 1
end
end
[*] 单例模式
require 'singleton'
class Logger
include Singleton
attr_accessor :level
def initialize
@level = "INFO"
end
end
Logger.instance.level = "DEBUG"
注意事项
[*] 制止滥用：仅在无其他替换方案时使用。
[*] 命名规范：使用明确的前缀（如 $myapp_logger），制止与内置全局变量冲突。
[*] 线程安全：多线程情况中需加锁掩护。
$counter = 0
$counter_mutex = Mutex.new
def increment_counter
$counter_mutex.synchronize { $counter += 1 }
end
[*] 重置全局变量：可通过赋值 nil 释放资源。
$db_connection = nil# 断开数据库连接并释放内存
内置全局变量
变量用途$!末了抛出的异常对象$@末了异常的堆栈跟踪信息$?末了执行的子进程状态$0当前执行的脚本文件名$:Ruby 的加载路径（等同 $LOAD_PATH）$_末了读取的输入行（如 gets 效果） 最佳实践：除非须要，优先使用常量、类变量或依赖注入模式替换全局变量。
//全局变量附件竣事
5. 常量
全大写字母，约定不可修改（修改会告诫）。
PI = 3.14159
//常量附加开始
常量（Constants）是一种用于存储固定值的标识符，其命名以大写字母开头，通常用于界说配置、枚举值或全局共享数据。
常量的根本规则
[*] 命名规范
[*]必须以大写字母开头（如 PI、MAX_SIZE）。
[*]约定全大写加下划线（如 DEFAULT_TIMEOUT），但也可用驼峰式（如 AppConfig）。
[*] 赋值与修改
[*]应保持不可变：Ruby 答应修改常量，但会发出告诫。
[*]重新赋值触发告诫：PI = 3.14PI = 3.14159
# 输出 warning: already initialized constant PI
[*] 作用域
[*]界说在类、模块或顶层作用域。
[*]通过命名空间访问（如 MyClass::CONST）。
常量的界说与访问
[*]顶层常量（全局可见）
APP_NAME = "MyApp"# 顶层常量
class User
def show_app_name
APP_NAME# 直接访问
end
end
puts APP_NAME# => "MyApp"
[*]类/模块内的常量
class MathUtilsPI = 3.14159
# 类常量def circle_area(radius) PI * radius ** 2endendputs MathUtils::PI# => 3.14159
[*]模块中的常量
module Colors
RED = "#FF0000"
end
class Car
include Colors
end
puts Car::RED# => "#FF0000"（通过 include 引入）
常量的查找规则
[*]继续链查找
子类会继续父类的常量，但可覆盖：
class Parent
VALUE = 100
end
class Child < Parent
VALUE = 200# 覆盖父类常量
end
puts Parent::VALUE# => 100
puts Child::VALUE # => 200
[*]作用域剖析运算符 ::
module Outer
CONST = "Outer"
module Inner
CONST = "Inner"
def self.show
puts CONST # => "Inner"
puts Outer::CONST# => "Outer"
end
end
end
Outer::Inner.show
常量 vs 类变量
特性常量 (CONST)类变量 (@@var)命名规则大写字母开头@@ 开头可修改性可修改（有告诫）可随意修改作用域类/模块或全局类及其子类共享继续行为子类可覆盖子类共享同一变量 最佳实践
[*] 制止修改常量
如需可变配置，改用类方法或单例模式：
class Config
def self.timeout
@timeout ||= 10# 可修改且无警告
end
end
[*] 冻结常量（不可变对象）
防止常量引用的对象被修改：
COLORS = { red: "#FF0000" }.freeze
COLORS[:red] = "#FF1234"# RuntimeError: can't modify frozen Hash
[*] 使用模块构造常量
module Settings
TIMEOUT = 30
API_KEY = "secret"
end
puts Settings::API_KEY
动态操作常量
[*]动态界说与访问
class Dynamic
const_set(:MAX, 100) # 定义常量 MAX
puts const_get(:MAX) # => 100
puts constants.include?(:MAX) # => true
end
[*]检查常量存在性
if MyClass.const_defined?(:VERSION)
puts MyClass::VERSION
end
常见错误
[*] 未初始化的常量
puts UNDEFINED_CONST# NameError: uninitialized constant UNDEFINED_CONST
[*] 命名空间遗漏
module A
module B
CONST = 1
end
end
puts B::CONST# NameError: uninitialized constant B（需写 A::B::CONST）
//常量附加竣事
二、数据类型
1. 数值（Numberic）
以下是 Ruby 中 数值类型（Numeric） 的详细剖析，涵盖整数、浮点数、数值运算、类型转换以及实用本领。
数值类型分类
Ruby 的数值类型分为 整数 和 浮点数，所有数值均为对象，属于 Numeric 类的子类。
类型类名说明示例整数Integer包括小整数（Fixnum）和大整数（Bignum），Ruby 自动处理类型转换42, 12345678901234567890浮点数Float双精度浮点数，遵照 IEEE 754 尺度3.14, 6.022e23有理数Rational精确分数（需手动创建或引入库）Rational(3, 4) => 3/4复数Complex复数类型（需手动创建或引入库）Complex(2, 3) => 2+3i 整数（Integer）
[*]表示方式
[*]十进制：默认写法，如 123。
[*]二进制：以 0b 或 0B 开头，如 0b1010（十进制的 10）。
[*]八进制：以 0 或 0o 开头，如 0o755（十进制的 493）。
[*]十六进制：以 0x 开头，如 0xFF（十进制的 255）。
[*]自动大整数支持
Ruby 自动处理整数溢出，小整数（Fixnum）和大整数（Bignum）无缝切换：
a = 123 # => 123（Fixnum）
b = 1234567890 * 9876543210# => 12193263113702179500（Bignum）
[*]常用方法
方法说明示例times { |i| }循环指定次数3.times { |i| puts i } 输出 0,1,2even?, odd?判定奇偶4.even? => trueto_s(base)转换为字符串（指定进制）255.to_s(16) => "ff"abs绝对值-5.abs => 5 浮点数（Float）
5. 表示方式
[*]通例写法：3.14, -0.001。
[*]科学计数法：6.022e23（6.022 × 10²³）。
[*]精度问题与办理方案
浮点数计算可能因精度丢失导致弊端：
0.1 + 0.2# => 0.30000000000000004（并非精确的 0.3）
办理方案：
[*]使用 Rational 类型：(Rational(1, 10) + Rational(2, 10)).to_f# => 0.3
[*]BigDecimal 库（高精度计算）：require 'bigdecimal'
a = BigDecimal("0.1")
b = BigDecimal("0.2")
a + b# => 0.3e0
数值运算
[*]根本运算符
运算符说明示例+加法5 + 3 => 8-减法5 - 3 => 2*乘法5 * 3 => 15/除法5 / 2 => 2（整数除法）
5.to_f / 2 => 2.5%取模5 % 2 => 1**幂运算2 ** 3 => 8
[*]除法行为
[*]整数除法：效果自动向下取整。7 / 3 # => 2
[*]浮点除法：强制转换为浮点数。7.to_f / 3# => 2.333...
7 / 3.0 # => 2.333...
[*]链式比力
Ruby 支持数学中的链式比力：
1 < 2 < 3 # => true
5 <= x <= 10# 判断 x 是否在 5 到 10 之间
类型转换
目的类型方法示例整数转浮点to_f5.to_f => 5.0浮点转整数to_i（截断）3.9.to_i => 3四舍五入round3.6.round => 4向上取整ceil3.2.ceil => 4向下取整floor3.9.floor => 3字符串转数值to_i, to_f"42".to_i => 42 实用本领
[*]随机数生成
rand(10) # 生成 0~9 的随机整数
rand(5.0..10.0) # 生成 5.0 到 10.0 的随机浮点数
[*]数值格式化
sprintf("%.2f", 3.1415)# => "3.14"
3.1415.round(2) # => 3.14（四舍五入保留两位小数）
[*]数值范围检查
(1..100).cover?(50)# => true（检查数值是否在范围内）
[*] 字符串（String）
单引号（不转义）或双引号（支持转义和插值）。
str1 = 'Hello \n World'# 输出换行符
str2 = "Hello #{name}" # 插值：Hello Alice
[*] 符号（Symbol）
轻量级字符串，以 : 开头，常用于哈希键。
:user_id
[*] 数组（Array）
有序集合，通过索引访问。
nums =
nums# => 1
[*] 哈希（Hash）
键值对集合，键可以是任意对象。
person = { name: "Alice", age: 20 }
person[:name]# => "Alice"
[*] 范围（Range）
表示连续区间，常用于迭代。
(1..5).each { |n| puts n }# 1到5
(1...5).each { |n| puts n } # 1到4
三、运算符
[*] 算术运算符
+, -, *, /, %, **（幂运算）。
2 ** 3# => 8
10 % 3# => 1
[*] 比力运算符
==, !=, >, <, >=, <=, <=>（返回 -1, 0, 1）。
5 <=> 3# => 1（5 > 3）
[*] 逻辑运算符
&&, ||, !（也可用 and, or, not，但优先级不同）。
true && false# => false
[*] 赋值运算符
=, +=, -=, *=, /=, %=。
x = 5
x += 3# => 8
四、控制结构
[*] 条件判定
# if/elsif/else
if age >= 18
puts "Adult"
elsif age > 0
puts "Child"
else
puts "Invalid"
end
# 三元运算符
result = (score > 60) ? "Pass" : "Fail"
[*] 循环
# while 循环
i = 0
while i < 3
puts i
i += 1
end
# until 循环
until i >= 3
puts i
i += 1
end
# for 循环（较少使用）
for num in
puts num
end
[*] 迭代器
# each 方法
(1..3).each { |n| puts n }
# map 方法
doubled = .map { |n| n * 2 }# =>
五、方法界说
[*] 根本语法
def greet(name)
"Hello, #{name}!"
end
greet("Ruby")# => "Hello, Ruby!"
[*] 默认参数
def add(a, b = 1)
a + b
end
add(3) # => 4
add(3, 5) # => 8
[*] 可变参数
def sum(*nums)
nums.sum
end
sum(1, 2, 3)# => 6
六、异常处理
begin
# 可能出错的代码
result = 10 / 0
rescue ZeroDivisionError => e
puts "Error: #{e.message}"
ensure
puts "Cleanup code here"
end
七、解释
[*] 单行解释
# 这是一个注释
[*] 多行解释
=begin
这是一个多行注释
可以写多行内容
=end
八、特别语法
[*] % 符号快捷语法
%w# => ["apple", "banana", "cherry"]（字符串数组）
%i # => [:red, :green, :blue]（符号数组）
[*] 并行赋值
a, b = 1, 2# a=1, b=2
a, b = b, a # 交换值：a=2, b=1
九、代码块（Block）
[*] 使用 {} 或 do...end
# 单行用 {}
.each { |n| puts n }
# 多行用 do...end
.each do |n|
puts "Number: #{n}"
end
[*] 自界说担当块的方法
def repeat(times)
times.times { yield }# yield 调用块
end
repeat(3) { puts "Hello!" }# 输出 3 次 Hello
十、常用方法示例
[*] 字符串操作
"ruby".upcase # => "RUBY"
"HELLO".downcase # => "hello"
"test".strip # => "test"
[*] 数组操作
.include?(2)# => true
.push(4) # =>
.join("-") # => "1-2-3"
十一、ruby保留关键词
以下是 Ruby 的 全部关键字列表（基于 Ruby 3.x 版本），这些单词具有特别语法含义，不可用作变量名或方法名：
控制流
关键字说明if条件判定else条件分支elsif多条件分支unless反向条件判定case多条件匹配whencase 语句的分支条件then简化条件语法end竣事代码块 循环与迭代
关键字说明while条件循环until反向条件循环for遍历循环（较少使用）in用于 for 或 casedo界说循环/块的开始break跳出循环next跳过当前迭代redo重新执行当前迭代retry重新开始循环（已废弃） 类与模块
关键字说明class界说类module界说模块def界说方法undef取消方法界说alias方法别名super调用父类方法self当前对象 异常处理
关键字说明begin异常处理块开始rescue捕获异常ensure确保执行（雷同 finally）raise抛出异常throw抛出符号（与 catch 共同）catch捕获符号 访问控制
关键字说明public公开方法private私有方法protected受掩护方法 逻辑与运算符
关键字说明and逻辑与（低优先级）or逻辑或（低优先级）not逻辑非true布尔真值false布尔假值nil空值 其他核心关键字
关键字说明return从方法返回值yield调用块__FILE__当前文件名（伪变量）__LINE__当前行号（伪变量）BEGIN程序启动前执行的代码块END程序退出前执行的代码块defined?检查标识符是否已界说 模式匹配（Ruby 2.7+）
关键字说明in模式匹配分支 注意：
[*] 非关键字但需谨慎使用：
puts、gets 等是全局方法，而非关键字。
proc、lambda 是类或方法，可被覆盖（但猛烈发起不要这样做）。
[*] 版本差别：
retry 在循环中已废弃（但仍可用于 begin/rescue 块）。
in 在 Ruby 2.7+ 中用于模式匹配。
完备列表（按字母排序）：
__FILE__, __LINE__, BEGIN, END, alias, and, begin, break, case, catch, class, def, defined?, do, else, elsif, end, ensure, false, for, if, in, module, next, nil, not, or, redo, rescue, retry, return, self, super, then, true, undef, unless, until, when, while, yield
总结
Ruby 语法以简洁机动著称，核心特点是：
[*]无分号，代码块通过缩进或 end 竣事。
[*]动态类型，无需声明变量类型。
[*]一切皆对象，方法调用可链式操作。
发起通过现实编码练习巩固语法，比方尝试编写小型脚本或使用 Ruby Playground 在线工具。
— END —
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]