Ruby方法定义 #

def greet
  puts "Hello, Ruby!"
end

greet

def greet(name)
  puts "Hello, #{name}!"
end

greet("Ruby")
greet "Ruby"

def add(a, b)
  a + b
end

add(1, 2)
add 1, 2

def add(a, b)
  return a + b
end

def add(a, b)
  a + b
end

def add(a, b)
  result = a + b
  result
end

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

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

def valid_name
end

def valid_name?
end

def dangerous_method!
end

def setter=(value)
end

def _private_method
end

def even?(n)
  n % 2 == 0
end

def sort!(arr)
  arr.sort!
end

def name=(value)
  @name = value
end

greet
greet()
greet("Ruby")
greet "Ruby"

"hello".upcase.reverse
[1, 2, 3].map(&:to_s).join("-")

user&.name
user&.profile&.avatar

"hello".send(:upcase)
"hello".send(:+, " world")
"hello".public_send(:upcase)

method(:puts)
method(:puts).call("Hello")
method(:puts)["Hello"]

:upcase.to_proc
["a", "b", "c"].map(&:upcase)

def apply(value, func)
  func.call(value)
end

apply("hello", method(:upcase))
apply("hello", ->(s) { s.reverse })

class Person
  def greet
    "Hello!"
  end
end

Person.new.greet

class Person
  def initialize(name)
    @name = name
  end

  def introduce
    "Hello, I'm #{name}"
  end

  private

  def name
    @name
  end
end

person = Person.new("Ruby")
person.introduce
person.name

class Person
  def initialize(age)
    @age = age
  end

  def older_than?(other)
    age > other.age
  end

  protected

  def age
    @age
  end
end

alice = Person.new(30)
bob = Person.new(25)
alice.older_than?(bob)

class Person
  def self.create(name)
    Person.new(name)
  end

  class << self
    def count
      @@count
    end
  end
end

Person.create("Ruby")

Person.create("Ruby")
Person::create("Ruby")

def present?(value)
  !value.nil? && value != "" && value != []
end

def blank?(value)
  !present?(value)
end

def presence(value)
  value if present?(value)
end

def valid_email?(email)
  email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
end

def valid_phone?(phone)
  phone.match?(/\A\d{11}\z/)
end

def to_boolean(value)
  case value
  when true, "true", "1", 1 then true
  when false, "false", "0", 0 then false
  else nil
  end
end

def to_snake_case(str)
  str.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/, '')
end

def to_camel_case(str)
  str.split('_').map(&:capitalize).join
end

def memoize(name)
  define_method(name) do |*args|
    cache = instance_variable_get("@_#{name}_cache") || {}
    instance_variable_set("@_#{name}_cache", cache)
    cache[args] ||= super(*args)
  end
end

def process(data)
  return unless valid?(data)
  
  transformed = transform(data)
  saved = save(transformed)
  notify(saved)
end

def valid?(data)
  data && !data.empty?
end

def transform(data)
  data.map(&:upcase)
end

def create_user(params)
  user = build_user(params)
  validate_user(user)
  save_user(user)
  send_welcome_email(user)
  user
end

def calculate_total_price(items)
  items.sum { |item| item.price * item.quantity }
end

def apply_discount(total, discount_percent)
  total * (1 - discount_percent / 100.0)
end