Ruby迭代器 #

[1, 2, 3, 4, 5].each do |n|
  puts n
end

[1, 2, 3, 4, 5].each { |n| puts n }

["a", "b", "c"].each_with_index do |item, index|
  puts "#{index}: #{item}"
end

["a", "b", "c"].each.with_index do |item, index|
  puts "#{index}: #{item}"
end

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

{ a: 1, b: 2, c: 3 }.each_key do |key|
  puts key
end

{ a: 1, b: 2, c: 3 }.each_value do |value|
  puts value
end

[1, 2, 3, 4, 5]
  .select { |n| n.even? }
  .each { |n| puts n }

result = [1, 2, 3].each { |n| puts n }
result

[1, 2, 3, 4, 5].map { |n| n * 2 }

["a", "b", "c"].map { |s| s.upcase }

[1, 2, 3].map(&:to_s)
[1, 2, 3].map { |n| n.to_s }

["hello", "world"].map(&:upcase)

result = [1, 2, 3].each { |n| n * 2 }
result

result = [1, 2, 3].map { |n| n * 2 }
result

arr = [1, 2, 3]
arr.map! { |n| n * 2 }
arr

[1, 2, 3].collect { |n| n * 2 }
[1, 2, 3].map { |n| n * 2 }

names = ["alice", "bob", "charlie"]
names.map(&:capitalize)

prices = [100, 200, 300]
prices.map { |p| p * 1.1 }

users = [{ name: "Alice" }, { name: "Bob" }]
users.map { |u| u[:name] }

[1, 2, 3, 4, 5].select { |n| n.even? }

["apple", "banana", "cherry"].select { |s| s.length > 5 }

[1, 2, 3, 4, 5].select(&:even?)

["hello", "", "world"].select(&:empty?)
["hello", "", "world"].reject(&:empty?)

[1, 2, 3, 4, 5].reject { |n| n.even? }

["apple", "banana", "cherry"].reject { |s| s.include?("a") }

arr = [1, 2, 3, 4, 5]
arr.select! { |n| n.even? }
arr

arr = [1, 2, 3, 4, 5]
arr.reject! { |n| n.even? }
arr

[1, 2, 3, 4, 5].filter { |n| n.even? }
[1, 2, 3, 4, 5].select { |n| n.even? }

users = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Charlie", age: 35 }
]

users.select { |u| u[:age] > 28 }

users.reject { |u| u[:age] < 30 }

[1, 2, 3, 4, 5].find { |n| n > 3 }

["apple", "banana", "cherry"].find { |s| s.include?("n") }

[1, 2, 3, 4, 5].detect { |n| n > 3 }
[1, 2, 3, 4, 5].find { |n| n > 3 }

[1, 2, 3, 4, 5].find_all { |n| n > 3 }
[1, 2, 3, 4, 5].select { |n| n > 3 }

users = [
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
  { id: 3, name: "Charlie" }
]

users.find { |u| u[:id] == 2 }

[1, 2, 3, 4, 5].reduce { |sum, n| sum + n }

[1, 2, 3, 4, 5].reduce(0) { |sum, n| sum + n }

[1, 2, 3, 4, 5].reduce(:+)
[1, 2, 3, 4, 5].reduce(0, :+)

[1, 2, 3, 4, 5].reduce(:*)
[1, 2, 3, 4, 5].reduce(1, :*)

[1, 2, 3, 4, 5].inject { |sum, n| sum + n }
[1, 2, 3, 4, 5].reduce { |sum, n| sum + n }

[1, 2, 3, 4, 5].reduce({}) do |hash, n|
  hash[n] = n ** 2
  hash
end

["a", "b", "c"].reduce([]) do |arr, s|
  arr << s.upcase
end

prices = [100, 200, 300]
total = prices.reduce(0) { |sum, p| sum + p }

words = ["Hello", "World"]
sentence = words.reduce("") { |s, word| s + " " + word }.strip

longest = ["apple", "banana", "cherry"].reduce do |max, word|
  word.length > max.length ? word : max
end

[1, 2, 3, 4, 5].any? { |n| n > 3 }
[1, 2, 3, 4, 5].any?(&:even?)

[1, 2, 3, 4, 5].all? { |n| n > 0 }
[1, 2, 3, 4, 5].all?(&:positive?)

[1, 2, 3, 4, 5].none? { |n| n < 0 }
[1, 2, 3, 4, 5].none?(&:negative?)

[1, 2, 3, 4, 5].one? { |n| n == 3 }
[1, 2, 3, 4, 5].one? { |n| n > 4 }

[1, 2, 3, 4, 5].count
[1, 2, 3, 4, 5].count { |n| n.even? }
[1, 2, 3, 4, 5].count(3)

[1, 2, 3, 4, 5].sum
[1, 2, 3, 4, 5].sum { |n| n * 2 }
["a", "b", "c"].sum("")

[3, 1, 4, 1, 5, 9, 2, 6].min
[3, 1, 4, 1, 5, 9, 2, 6].max
[3, 1, 4, 1, 5, 9, 2, 6].minmax

["apple", "banana", "cherry"].min_by(&:length)
["apple", "banana", "cherry"].max_by(&:length)

[3, 1, 4, 1, 5, 9, 2, 6].sort
[3, 1, 4, 1, 5, 9, 2, 6].sort.reverse

["apple", "banana", "cherry"].sort_by(&:length)
["apple", "banana", "cherry"].sort_by { |s| -s.length }

[1, 2, 3, 4, 5, 6].group_by { |n| n.even? }

["apple", "banana", "cherry"].group_by { |s| s[0] }

users = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Charlie", age: 25 }
]
users.group_by { |u| u[:age] }

[1, 2, 3, 4, 5, 6].partition { |n| n.even? }

even, odd = [1, 2, 3, 4, 5, 6].partition(&:even?)

[1, 2, 3, 4, 5].first
[1, 2, 3, 4, 5].first(3)
[1, 2, 3, 4, 5].last
[1, 2, 3, 4, 5].last(3)

[1, 2, 3, 4, 5].take(3)
[1, 2, 3, 4, 5].drop(3)
[1, 2, 3, 4, 5].take_while { |n| n < 4 }
[1, 2, 3, 4, 5].drop_while { |n| n < 4 }

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  .select { |n| n.even? }
  .map { |n| n * 2 }
  .reduce(:+)

users = [
  { name: "Alice", age: 25, active: true },
  { name: "Bob", age: 30, active: false },
  { name: "Charlie", age: 35, active: true }
]

active_names = users
  .select { |u| u[:active] }
  .map { |u| u[:name] }

total_age = users
  .select { |u| u[:active] }
  .reduce(0) { |sum, u| sum + u[:age] }

(1..).lazy
     .select { |n| n.even? }
     .map { |n| n * 2 }
     .take(5)
     .to_a

(1..).lazy.select(&:prime?).first(10)

(1..).lazy.map { |n| n ** 2 }.take(5).to_a

large_array.lazy.select { |x| expensive_check(x) }.first(10)

data = [
  { name: "alice", score: 85 },
  { name: "bob", score: 92 },
  { name: "charlie", score: 78 }
]

result = data
  .map { |d| { name: d[:name].capitalize, score: d[:score], grade: grade(d[:score]) } }
  .select { |d| d[:score] >= 80 }
  .sort_by { |d| -d[:score] }

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

stats = {
  sum: numbers.sum,
  avg: numbers.sum.to_f / numbers.size,
  min: numbers.min,
  max: numbers.max,
  count: numbers.count,
  even_count: numbers.count(&:even?)
}

def paginate(items, page, per_page)
  items
    .drop((page - 1) * per_page)
    .take(per_page)
end

items = (1..100).to_a
paginate(items, 2, 10)