垦荒学园 - 以垦荒之心，赴成长之约

切换主题

Ruby 哈希（Hash） ​

哈希是Ruby中另一种重要的数据结构，用于存储键值对集合。哈希类似于数组，但使用键而不是索引来访问元素。Ruby哈希功能强大且灵活，支持多种键类型和丰富的操作方法。本章将详细介绍Ruby中哈希的创建、操作和处理方法。

🎯 哈希基础 ​

哈希定义 ​

Ruby提供了多种方式来创建哈希：

ruby
# 使用字面量语法（Ruby 1.9+推荐方式）
person = {
  name: "张三",
  age: 25,
  city: "北京"
}

# 传统方式使用=>符号
person = {
  :name => "张三",
  :age => 25,
  :city => "北京"
}

# 使用字符串作为键
person = {
  "name" => "张三",
  "age" => 25,
  "city" => "北京"
}

# 使用Hash.new创建空哈希
empty_hash = Hash.new
default_hash = Hash.new("默认值")  # 设置默认值

# 使用Hash[]方法创建
fruits = Hash["苹果", 5, "香蕉", 3, "橙子", 8]
# 或者使用数组对
pairs = [["苹果", 5], ["香蕉", 3], ["橙子", 8]]
fruits = Hash[pairs]

# 使用Hash.new块设置默认值
counter = Hash.new { |hash, key| hash[key] = 0 }
counter["苹果"] += 1
puts counter["苹果"]  # 1
puts counter["香蕉"]  # 0 (自动初始化)

哈希访问 ​

ruby
person = {
  name: "张三",
  age: 25,
  city: "北京",
  skills: ["Ruby", "Python", "JavaScript"]
}

# 通过键访问值
puts person[:name]     # 张三
puts person[:age]      # 25
puts person[:skills]   # ["Ruby", "Python", "JavaScript"]

# 使用字符串键访问
data = {
  "name" => "李四",
  "age" => 30
}
puts data["name"]  # 李四

# 使用fetch方法（更安全）
puts person.fetch(:name)        # 张三
puts person.fetch(:salary, 0)   # 0 (默认值)
# person.fetch(:salary)         # 抛出KeyError异常

# 使用fetch带块处理缺失键
salary = person.fetch(:salary) { |key| "未设置#{key}" }
puts salary  # 未设置salary

# 检查键是否存在
puts person.key?(:name)     # true
puts person.key?(:salary)   # false
puts person.has_key?(:name) # true (key?的别名)

puts person.value?("张三")   # true
puts person.has_value?("张三") # true (value?的别名)

📏 哈希属性 ​

哈希大小和比较 ​

ruby
person = {
  name: "张三",
  age: 25,
  city: "北京"
}

# 获取哈希大小
puts person.length  # 3
puts person.size    # 3 (length的别名)
puts person.count   # 3

# 检查哈希是否为空
puts person.empty?  # false
puts Hash.new.empty?  # true

# 比较哈希
hash1 = {a: 1, b: 2}
hash2 = {a: 1, b: 2}
hash3 = {b: 2, a: 1}  # 顺序不同但内容相同

puts hash1 == hash2  # true
puts hash1 == hash3  # true (哈希比较不考虑键的顺序)
puts hash1.eql?(hash2)  # true

# 对象标识比较
puts hash1.equal?(hash2)  # false
puts hash1.equal?(hash1)  # true

➕ 哈希操作 ​

添加和修改键值对 ​

ruby
person = {
  name: "张三",
  age: 25
}

# 添加新的键值对
person[:city] = "北京"
person[:skills] = ["Ruby", "Python"]

# 使用store方法
person.store(:email, "zhangsan@example.com")

# 批量更新
person.merge!({
  age: 26,
  department: "技术部"
})

puts person.inspect
# {:name=>"张三", :age=>26, :city=>"北京", :skills=>["Ruby", "Python"], :email=>"zhangsan@example.com", :department=>"技术部"}

# 使用merge创建新哈希而不修改原哈希
new_person = person.merge({title: "工程师"})
puts person.key?(:title)   # false (原哈希未改变)
puts new_person.key?(:title)  # true (新哈希有title键)

删除键值对 ​

ruby
person = {
  name: "张三",
  age: 25,
  city: "北京",
  salary: 10000,
  department: "技术部"
}

# 删除指定键
deleted_value = person.delete(:salary)
puts deleted_value  # 10000
puts person.key?(:salary)  # false

# 删除满足条件的键值对
person.delete_if { |key, value| key == :department }
puts person.key?(:department)  # false

# 保留满足条件的键值对
filtered_person = person.keep_if { |key, value| key != :age }
puts person  # {:name=>"张三", :city=>"北京"} (原哈希被修改)

# 清空哈希
person.clear
puts person.inspect  # {}

更新和替换 ​

ruby
# 使用update方法（merge!的别名）
original = {a: 1, b: 2}
additional = {b: 3, c: 4}
original.update(additional)
puts original  # {:a=>1, :b=>3, :c=>4} (b的值被更新)

# 使用块处理重复键
hash1 = {a: 1, b: 2}
hash2 = {b: 3, c: 4}
result = hash1.merge(hash2) { |key, old_val, new_val| old_val + new_val }
puts result  # {:a=>1, :b=>5, :c=>4} (b的值相加)

# 条件更新
person = {name: "张三", age: 25}
person[:age] = 26 if person[:age] < 30
puts person[:age]  # 26

🔍 哈希查找和筛选 ​

查找键值对 ​

ruby
scores = {
  "张三" => 85,
  "李四" => 92,
  "王五" => 78,
  "赵六" => 96
}

# 查找满足条件的第一个键值对
high_scorer = scores.find { |name, score| score > 90 }
puts high_scorer  # ["李四", 92]

# 查找所有满足条件的键值对
high_scorers = scores.select { |name, score| score > 85 }
puts high_scorers  # {"李四"=>92, "赵六"=>96}

# 查找不满足条件的键值对
low_scorers = scores.reject { |name, score| score > 85 }
puts low_scorers  # {"张三"=>85, "王五"=>78}

# 查找键或值
names_with_high_scores = scores.keys.select { |name| scores[name] > 85 }
puts names_with_high_scores  # ["李四", "赵六"]

scores_above_threshold = scores.values.select { |score| score > 85 }
puts scores_above_threshold  # [92, 96]

哈希筛选和分组 ​

ruby
# 使用slice获取指定键的子哈希
person = {
  name: "张三",
  age: 25,
  city: "北京",
  salary: 10000,
  department: "技术部"
}

basic_info = person.slice(:name, :age, :city)
puts basic_info  # {:name=>"张三", :age=>25, :city=>"北京"}

# 使用except排除指定键
detailed_info = person.except(:salary, :department)
puts detailed_info  # {:name=>"张三", :age=>25, :city=>"北京"}

# 分组
students = [
  {name: "张三", grade: "A", subject: "数学"},
  {name: "李四", grade: "B", subject: "数学"},
  {name: "王五", grade: "A", subject: "英语"},
  {name: "赵六", grade: "C", subject: "英语"}
]

grouped_by_grade = students.group_by { |student| student[:grade] }
puts grouped_by_grade
# {"A"=>[{:name=>"张三", :grade=>"A", :subject=>"数学"}, {:name=>"王五", :grade=>"A", :subject=>"英语"}],
#  "B"=>[{:name=>"李四", :grade=>"B", :subject=>"数学"}],
#  "C"=>[{:name=>"赵六", :grade=>"C", :subject=>"英语"}]}

# 按键分组
data = {a1: 1, a2: 2, b1: 3, b2: 4}
grouped_by_prefix = data.group_by { |key, value| key.to_s[0] }
puts grouped_by_prefix
# {"a"=>[[:a1, 1], [:a2, 2]], "b"=>[[:b1, 3], [:b2, 4]]}

🔧 哈希变换 ​

映射和转换 ​

ruby
prices = {
  "苹果" => 5.0,
  "香蕉" => 3.0,
  "橙子" => 4.0
}

# 转换键
symbol_keys = prices.transform_keys { |key| key.to_sym }
puts symbol_keys  # {:苹果=>5.0, :香蕉=>3.0, :橙子=>4.0}

# 转换值
discount_prices = prices.transform_values { |price| price * 0.9 }
puts discount_prices  # {"苹果"=>4.5, "香蕉"=>2.7, "橙子"=>3.6}

# 同时转换键和值
formatted_data = prices.transform_keys(&:upcase).transform_values { |price| "¥#{price}" }
puts formatted_data  # {"苹果"=>"¥5.0", "香蕉"=>"¥3.0", "橙子"=>"¥4.0"}

# 就地转换
prices.transform_keys! { |key| key.to_sym }
puts prices  # {:苹果=>5.0, :香蕉=>3.0, :橙子=>4.0}

排序和反转 ​

ruby
# 按键排序
data = {c: 3, a: 1, b: 2}
sorted_by_key = data.sort
puts sorted_by_key.inspect  # [[:a, 1], [:b, 2], [:c, 3]]

sorted_hash = data.sort.to_h
puts sorted_hash  # {:a=>1, :b=>2, :c=>3}

# 按值排序
sorted_by_value = data.sort_by { |key, value| value }
puts sorted_by_value.inspect  # [[:a, 1], [:b, 2], [:c, 3]]

# 按键降序排序
desc_sorted = data.sort { |a, b| b[0] <=> a[0] }
puts desc_sorted.to_h  # {:c=>3, :b=>2, :a=>1}

# 反转键值对
inverted = data.invert
puts inverted  # {1=>:a, 2=>:b, 3=>:c}
# 注意：如果值有重复，反转后会有数据丢失

🔁 哈希迭代 ​

基本迭代 ​

ruby
person = {
  name: "张三",
  age: 25,
  city: "北京"
}

# 迭代键值对
person.each { |key, value| puts "#{key}: #{value}" }
# name: 张三
# age: 25
# city: 北京

# 只迭代键
person.each_key { |key| puts "键: #{key}" }
# 键: name
# 键: age
# 键: city

# 只迭代值
person.each_value { |value| puts "值: #{value}" }
# 值: 张三
# 值: 25
# 值: 北京

# 使用each_pair（each的别名）
person.each_pair { |key, value| puts "#{key} => #{value}" }

高级迭代 ​

ruby
scores = {
  "张三" => 85,
  "李四" => 92,
  "王五" => 78,
  "赵六" => 96
}

# 使用map处理键值对
grade_messages = scores.map { |name, score| "#{name}的分数是#{score}分" }
puts grade_messages.inspect
# ["张三的分数是85分", "李四的分数是92分", "王五的分数是78分", "赵六的分数是96分"]

# 使用with_object累积结果
total_and_count = scores.each_with_object({sum: 0, count: 0}) do |(name, score), acc|
  acc[:sum] += score
  acc[:count] += 1
end
average = total_and_count[:sum].to_f / total_and_count[:count]
puts "平均分: #{average}"  # 平均分: 87.75

# 使用reduce累积
sum = scores.reduce(0) { |total, (name, score)| total + score }
puts "总分: #{sum}"  # 总分: 351

🎯 哈希实践示例 ​

配置管理器 ​

ruby
class ConfigManager
  def initialize(defaults = {})
    @config = defaults.dup
  end
  
  # 获取配置值
  def get(key, default = nil)
    @config.key?(key) ? @config[key] : default
  end
  
  # 设置配置值
  def set(key, value)
    @config[key] = value
  end
  
  # 批量设置配置
  def update(config_hash)
    @config.merge!(config_hash)
  end
  
  # 删除配置项
  def remove(key)
    @config.delete(key)
  end
  
  # 检查配置项是否存在
  def exists?(key)
    @config.key?(key)
  end
  
  # 获取所有配置项
  def all
    @config.dup
  end
  
  # 重置配置
  def reset(defaults = {})
    @config = defaults.dup
  end
  
  # 深度合并配置（处理嵌套哈希）
  def deep_merge(other_hash)
    deep_merge_hash(@config, other_hash)
  end
  
  private
  
  def deep_merge_hash(hash1, hash2)
    hash2.each do |key, value|
      if hash1.key?(key) && hash1[key].is_a?(Hash) && value.is_a?(Hash)
        hash1[key] = deep_merge_hash(hash1[key], value)
      else
        hash1[key] = value
      end
    end
    hash1
  end
end

# 使用配置管理器
defaults = {
  database: {
    host: "localhost",
    port: 5432,
    username: "user"
  },
  logging: {
    level: "info",
    file: "app.log"
  }
}

config = ConfigManager.new(defaults)
puts config.get(:database)  # {:host=>"localhost", :port=>5432, :username=>"user"}

# 更新配置
config.update({
  database: {
    host: "production.db.com",
    password: "secret"
  },
  cache: {
    enabled: true,
    ttl: 3600
  }
})

puts config.get(:database)
# {:host=>"production.db.com", :port=>5432, :username=>"user", :password=>"secret"}

数据统计分析器 ​

ruby
class DataAnalyzer
  def initialize(data)
    @data = data
  end
  
  # 计算频率分布
  def frequency
    freq = Hash.new(0)
    @data.each { |item| freq[item] += 1 }
    freq
  end
  
  # 计算百分比分布
  def percentage
    freq = frequency
    total = @data.length
    freq.transform_values { |count| (count.to_f / total * 100).round(2) }
  end
  
  # 找出最常见的元素
  def most_common(n = 1)
    frequency.sort_by { |key, value| -value }.first(n).to_h
  end
  
  # 找出最不常见的元素
  def least_common(n = 1)
    frequency.sort_by { |key, value| value }.first(n).to_h
  end
  
  # 统计数值数据
  def numeric_stats
    return {} unless @data.all? { |item| item.is_a?(Numeric) }
    
    {
      count: @data.length,
      sum: @data.sum,
      mean: @data.sum.to_f / @data.length,
      min: @data.min,
      max: @data.max,
      range: @data.max - @data.min
    }
  end
  
  # 分组统计
  def group_by(&block)
    @data.group_by(&block)
  end
  
  # 条件筛选
  def filter(&block)
    @data.select(&block)
  end
end

# 使用数据分析器
# 字符串数据分析
words = ["apple", "banana", "apple", "cherry", "banana", "apple", "date"]
analyzer = DataAnalyzer.new(words)

puts "频率分布: #{analyzer.frequency}"
# 频率分布: {"apple"=>3, "banana"=>2, "cherry"=>1, "date"=>1}

puts "百分比分布: #{analyzer.percentage}"
# 百分比分布: {"apple"=>42.86, "banana"=>28.57, "cherry"=>14.29, "date"=>14.29}

puts "最常见的3个: #{analyzer.most_common(3)}"
# 最常见的3个: {"apple"=>3, "banana"=>2, "cherry"=>1}

# 数值数据分析
scores = [85, 92, 78, 96, 88, 91, 83, 89]
score_analyzer = DataAnalyzer.new(scores)

puts "数值统计: #{score_analyzer.numeric_stats}"
# 数值统计: {:count=>8, :sum=>702, :mean=>87.75, :min=>78, :max=>96, :range=>18}

哈希验证器 ​

ruby
class HashValidator
  # 验证哈希结构
  def self.validate_structure(hash, required_keys = [], optional_keys = [])
    return false unless hash.is_a?(Hash)
    
    keys = hash.keys
    missing_keys = required_keys - keys
    
    missing_keys.empty?
  end
  
  # 验证键值类型
  def self.validate_types(hash, type_map)
    return false unless hash.is_a?(Hash)
    
    type_map.all? do |key, expected_type|
      hash.key?(key) && hash[key].is_a?(expected_type)
    end
  end
  
  # 验证值范围
  def self.validate_ranges(hash, range_map)
    return false unless hash.is_a?(Hash)
    
    range_map.all? do |key, range|
      hash.key?(key) && hash[key].is_a?(Numeric) && range.include?(hash[key])
    end
  end
  
  # 综合验证
  def self.validate(hash, schema)
    return false unless hash.is_a?(Hash)
    
    # 验证必需键
    required_keys = schema[:required] || []
    return false unless validate_structure(hash, required_keys)
    
    # 验证类型
    type_map = schema[:types] || {}
    return false unless validate_types(hash, type_map)
    
    # 验证范围
    range_map = schema[:ranges] || {}
    validate_ranges(hash, range_map)
  end
end

# 使用哈希验证器
person = {
  name: "张三",
  age: 25,
  email: "zhangsan@example.com",
  salary: 10000
}

# 验证结构
schema = {
  required: [:name, :age],
  types: {
    name: String,
    age: Integer,
    email: String,
    salary: Numeric
  },
  ranges: {
    age: 18..65,
    salary: 0..100000
  }
}

is_valid = HashValidator.validate(person, schema)
puts "验证结果: #{is_valid}"  # 验证结果: true

# 验证失败示例
invalid_person = {
  name: "李四",
  age: 15,  # 年龄不在范围内
  email: "lisi@example.com"
}

is_valid = HashValidator.validate(invalid_person, schema)
puts "验证结果: #{is_valid}"  # 验证结果: false

🔄 哈希与其它数据结构 ​

哈希与数组转换 ​

ruby
# 哈希转换为数组
person = {
  name: "张三",
  age: 25,
  city: "北京"
}

# 转换为键值对数组
pairs = person.to_a
puts pairs.inspect  # [[:name, "张三"], [:age, 25], [:city, "北京"]]

# 只获取键或值
keys = person.keys
puts keys.inspect   # [:name, :age, :city]

values = person.values
puts values.inspect # ["张三", 25, "北京"]

# 使用flatten扁平化
flattened = person.to_a.flatten
puts flattened.inspect  # [:name, "张三", :age, 25, :city, "北京"]

# 数组转换为哈希
pairs = [["name", "张三"], ["age", 25], ["city", "北京"]]
person_hash = pairs.to_h
puts person_hash.inspect  # {"name"=>"张三", "age"=>25, "city"=>"北京"}

# 使用关联数组
keys = [:name, :age, :city]
values = ["王五", 30, "上海"]
person_hash = keys.zip(values).to_h
puts person_hash.inspect  # {:name=>"王五", :age=>30, :city=>"上海"}

哈希与JSON ​

ruby
require 'json'

# 哈希转换为JSON
person = {
  name: "张三",
  age: 25,
  skills: ["Ruby", "Python", "JavaScript"],
  address: {
    city: "北京",
    district: "朝阳区"
  }
}

json_string = person.to_json
puts json_string
# {"name":"张三","age":25,"skills":["Ruby","Python","JavaScript"],"address":{"city":"北京","district":"朝阳区"}}

# JSON转换为哈希
parsed_hash = JSON.parse(json_string)
puts parsed_hash.inspect
# {"name"=>"张三", "age"=>25, "skills"=>["Ruby", "Python", "JavaScript"], "address"=>{"city"=>"北京", "district"=>"朝阳区"}}

# 注意：JSON解析后的键是字符串而不是符号
puts parsed_hash["name"]  # 张三
puts parsed_hash[:name]   # nil

# 转换键为符号
symbolized_hash = parsed_hash.deep_symbolize_keys rescue parsed_hash
puts symbolized_hash[:name]  # 张三

📊 哈希性能优化 ​

大哈希处理 ​

ruby
# 使用默认值避免键检查
# 低效方式
counter = {}
data = ["a", "b", "a", "c", "b", "a"]
data.each do |item|
  if counter[item]
    counter[item] += 1
  else
    counter[item] = 1
  end
end

# 高效方式
counter = Hash.new(0)
data.each { |item| counter[item] += 1 }

# 使用default_proc处理复杂默认值
cache = Hash.new do |hash, key|
  # 模拟耗时计算
  hash[key] = expensive_calculation(key)
end

def expensive_calculation(key)
  # 模拟复杂计算
  key.to_s.reverse.to_sym
end

puts cache[:hello]  # :olleh
puts cache[:world]  # :dlrow

哈希操作优化 ​

ruby
# 高效的哈希合并
# 避免创建中间哈希
base_config = {host: "localhost", port: 3000}
env_config = {port: 5432, database: "myapp"}

# 低效方式
# final_config = base_config.merge(env_config)

# 更高效的方式（直接修改）
final_config = base_config.dup
env_config.each { |key, value| final_config[key] = value }

# 使用merge!就地修改
base_config.merge!(env_config)

# 预分配哈希容量（Ruby 2.7+）
if Hash.respond_to?(:new_with_capacity)
  large_hash = Hash.new_with_capacity(1000)
else
  large_hash = {}
end

# 批量操作
def bulk_update(hash, updates)
  updates.each { |key, value| hash[key] = value }
  hash
end

🎯 哈希最佳实践 ​

1. 选择合适的键类型 ​

ruby
# 推荐使用符号作为键（性能更好）
person = {
  name: "张三",
  age: 25,
  city: "北京"
}

# 字符串键适用于动态键
dynamic_key = "user_#{Time.now.to_i}"
data = {
  dynamic_key => "动态值"
}

# 混合键类型要小心
mixed_keys = {
  :symbol_key => "符号键值",
  "string_key" => "字符串键值",
  123 => "数字键值"
}

# 访问时要注意键类型
puts mixed_keys[:symbol_key]    # 符号键值
puts mixed_keys["symbol_key"]   # nil

2. 安全处理哈希 ​

ruby
class SafeHashHandler
  # 安全访问嵌套哈希
  def self.safe_dig(hash, *keys)
    return nil unless hash.is_a?(Hash)
    
    keys.reduce(hash) do |current, key|
      return nil unless current.is_a?(Hash) && current.key?(key)
      current[key]
    end
  end
  
  # 深度合并哈希
  def self.deep_merge(hash1, hash2)
    return hash2 unless hash1.is_a?(Hash)
    return hash1 unless hash2.is_a?(Hash)
    
    merged = hash1.dup
    hash2.each do |key, value|
      if merged.key?(key) && merged[key].is_a?(Hash) && value.is_a?(Hash)
        merged[key] = deep_merge(merged[key], value)
      else
        merged[key] = value
      end
    end
    merged
  end
  
  # 安全删除键
  def self.safe_delete(hash, *keys)
    return hash unless hash.is_a?(Hash)
    
    keys.each { |key| hash.delete(key) }
    hash
  end
end

# 使用安全处理
nested_hash = {
  user: {
    profile: {
      name: "张三",
      age: 25
    },
    settings: {
      theme: "dark"
    }
  }
}

# 安全访问
name = SafeHashHandler.safe_dig(nested_hash, :user, :profile, :name)
puts name  # 张三

invalid_access = SafeHashHandler.safe_dig(nested_hash, :user, :profile, :salary)
puts invalid_access  # nil

# 深度合并
config1 = {
  database: {
    host: "localhost",
    port: 3000
  },
  logging: {
    level: "info"
  }
}

config2 = {
  database: {
    port: 5432,
    username: "admin"
  },
  cache: {
    enabled: true
  }
}

merged_config = SafeHashHandler.deep_merge(config1, config2)
puts merged_config
# {:database=>{:host=>"localhost", :port=>5432, :username=>"admin"}, :logging=>{:level=>"info"}, :cache=>{:enabled=>true}}

3. 哈希验证和清理 ​

ruby
class HashSanitizer
  # 清理哈希（移除nil值和空字符串）
  def self.clean(hash)
    return hash unless hash.is_a?(Hash)
    
    hash.reject { |key, value| value.nil? || (value.is_a?(String) && value.strip.empty?) }
  end
  
  # 验证必需字段
  def self.require_fields(hash, *required_fields)
    return false unless hash.is_a?(Hash)
    
    required_fields.all? { |field| hash.key?(field) && !hash[field].nil? }
  end
  
  # 类型转换
  def self.convert_types(hash, type_map)
    return hash unless hash.is_a?(Hash)
    
    converted = hash.dup
    type_map.each do |key, type|
      next unless converted.key?(key)
      
      begin
        case type
        when Integer
          converted[key] = Integer(converted[key])
        when Float
          converted[key] = Float(converted[key])
        when String
          converted[key] = converted[key].to_s
        when Symbol
          converted[key] = converted[key].to_sym
        when Array
          converted[key] = Array(converted[key])
        when Hash
          converted[key] = Hash(converted[key])
        end
      rescue ArgumentError
        # 转换失败时保持原值或设置默认值
        converted[key] = nil
      end
    end
    converted
  end
end

# 使用哈希清理和验证
raw_data = {
  name: "张三",
  age: "25",
  email: "",
  salary: "10000.50",
  skills: "Ruby,Python",
  metadata: nil
}

# 清理数据
cleaned_data = HashSanitizer.clean(raw_data)
puts cleaned_data
# {:name=>"张三", :age=>"25", :salary=>"10000.50", :skills=>"Ruby,Python"}

# 类型转换
type_map = {
  age: Integer,
  salary: Float,
  skills: Array
}

converted_data = HashSanitizer.convert_types(cleaned_data, type_map)
puts converted_data
# {:name=>"张三", :age=>25, :salary=>10000.5, :skills=>["Ruby,Python"]}

📚 下一步学习 ​

掌握了Ruby哈希操作后，建议继续学习：

继续您的Ruby学习之旅吧！

本站内容仅供学习和研究使用。

Copyright 2025 垦荒教程 kenhuang.com All Rights Reserved. 备案号：粤ICP备17084064号-3 | 免责声明