Ruby赋值运算符 #

a = 1
name = "Ruby"
arr = [1, 2, 3]
hash = { a: 1, b: 2 }

a = b = c = 0
a
b
c

def get_value
  42
end

result = get_value
result

a = 10

a += 5
a -= 3
a *= 2
a /= 4
a %= 3
a **= 2

a = 10

a += 5
a = a + 5

a *= 2
a = a * 2

s = "Hello"
s += " World"
s << "!"

s *= 2

arr = [1, 2]
arr += [3, 4]
arr -= [2]

a = nil
a ||= 1
a

a ||= 2
a

a ||= b

a = a || b

a || a = b

def get_name
  @name ||= "Default"
end

def cache
  @cache ||= {}
end

def settings
  @settings ||= load_settings
end

def load_settings
  puts "Loading..."
  { timeout: 30, retry: 3 }
end

settings
settings

a = false
a ||= true
a

a = 0
a ||= 1
a

a = ""
a ||= "default"
a

a = 10
a &&= 20
a

a = nil
a &&= 20
a

a &&= b

a = a && b

a && a = b

def update_if_exists(hash, key, value)
  hash[key] &&= value
end

hash = { a: 1, b: 2 }
update_if_exists(hash, :a, 10)
update_if_exists(hash, :c, 30)
hash

a, b = 1, 2
a
b

a, b, c = 1, 2, 3
a
b
c

a, b = 1, 2
a, b = b, a
a
b

arr = [1, 2, 3]
a, b, c = arr
a
b
c

a, *rest = [1, 2, 3, 4, 5]
a
rest

first, *, last = [1, 2, 3, 4, 5]
first
last

a, (b, c) = [1, [2, 3]]
a
b
c

def min_max(arr)
  [arr.min, arr.max]
end

min, max = min_max([3, 1, 4, 1, 5, 9])
min
max

class Person
  attr_writer :name, :age

  def initialize
    @name = "Unknown"
    @age = 0
  end
end

person = Person.new
person.name = "Ruby"
person.age = 30

hash = {}
hash[:a] = 1
hash[:b] = 2
hash.store(:c, 3)
hash

arr = [1, 2, 3]
arr[0] = 10
arr[1, 2] = [20, 30]
arr

age = 20
status = age >= 18 ? "成年" : "未成年"
status

def get_status(score)
  if score >= 90
    "优秀"
  elsif score >= 60
    "及格"
  else
    "不及格"
  end
end

result = get_status(85)
result

def get_grade(score)
  case score
  when 90..100 then "A"
  when 80...90 then "B"
  when 70...80 then "C"
  when 60...70 then "D"
  else "F"
  end
end

grade = get_grade(85)
grade

[[1, 2], [3, 4]].each do |a, b|
  puts "#{a}, #{b}"
end

{ a: 1, b: 2 }.each do |key, value|
  puts "#{key}: #{value}"
end

def process((a, b))
  puts "a: #{a}, b: #{b}"
end

process([1, 2])
process([3, 4, 5])

class Config
  attr_accessor :host, :port, :timeout

  def initialize(options = {})
    @host = options[:host] || "localhost"
    @port = options[:port] || 3000
    @timeout = options[:timeout] || 30
  end
end

config = Config.new(host: "example.com")
config.host
config.port

class LazyLoader
  def data
    @data ||= load_data
  end

  private

  def load_data
    puts "Loading data..."
    (1..100).to_a
  end
end

loader = LazyLoader.new
loader.data
loader.data

def parse_point(point)
  x, y = point
  puts "Point(#{x}, #{y})"
end

parse_point([10, 20])

def parse_user(user_data)
  name, age, *rest = user_data
  puts "Name: #{name}, Age: #{age}"
end

parse_user(["Ruby", 30, "Beijing", "Developer"])

def swap(arr, i, j)
  arr[i], arr[j] = arr[j], arr[i]
end

arr = [1, 2, 3, 4, 5]
swap(arr, 0, 4)
arr

def assign_attributes(obj, attributes)
  attributes.each do |key, value|
    obj.send("#{key}=", value) if obj.respond_to?("#{key}=")
  end
end

class User
  attr_accessor :name, :email, :age
end

user = User.new
assign_attributes(user, { name: "Ruby", email: "ruby@example.com", age: 30 })
user.name
user.email

def settings
  @settings ||= {}
end

def name
  @name ||= "Default"
end

a, b = b, a

a = b = c = []
a << 1
b
c

a = []
b = []
c = []

result, error = perform_operation

if error
  handle_error(error)
else
  process_result(result)
end