Perl 数组散列的散列（自动生存？？）_Perl_Ruby_Arrays_Hash

Perl 数组散列的散列（自动生存？？）

perl ruby arrays hash

Perl 数组散列的散列（自动生存？？）,perl,ruby,arrays,hash,Perl,Ruby,Arrays,Hash,我已经做了相当长的时间，因此这是困惑我没有结束。我正在收集来自不同地方的以下数据，并希望采用以下格式： { :"user_100" => { :user_policy => [ "userpolicy_100", "userpolicy_200" ], :group_policy => [ "grouppolicy_300", "grouppolicy_400"

我已经做了相当长的时间，因此这是困惑我没有结束。我正在收集来自不同地方的以下数据，并希望采用以下格式：

{
   :"user_100" => {
      :user_policy => [
         "userpolicy_100",
         "userpolicy_200"
      ],
      :group_policy => [
         "grouppolicy_300",
         "grouppolicy_400"
      ],
   },
   :"user_200" => {
      :user_policy => [
         "userpolicy_300",
         "userpolicy_400"
      ],
      :group_policy => [
         "grouppolicy_300",
         "grouppolicy_400"
      ],
   },
}

上面的结构是数组散列的散列，我只是无法在ruby中使用它。顺便说一句，我已经手动编写了上述代码，因此可能存在语法错误

我试过：

hash = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }

但只有当我有

嵌套哈希

并且

没有数组

时，这才有效

然后我试着：

hash = Hash.new{ |h,k| h[k] = [] }

但这只适用于数组的

散列

，而不适用于数组的

散列

我需要在一个地方捕获这些数据，我可以想象用上面代码片段中显示的perl方式来完成

问题：

如何在ruby中创建数组哈希的

哈希


是否有更通用的方法初始化任何深度嵌套哈希/数组组合
还是我没有用红宝石般的方式思考，有没有更好的方法来解决我的根本问题
更新：
这是我的实际代码：
array_users = Array.new
hash_user_polices = Hash.new{ |h,k| h[k] = [] }

iam = Aws::IAM.new

iam.list_users().each do |resp|
  resp.users.each do |x|
    array_users << x.user_name
  end
end

array_users.each do |user|
  iam.list_user_policies(:user_name => user).each do |resp|
    resp.each do |x|
      x.policy_names.each do |y|
        hash_user_polices[:"#{user}"] << y.to_s
      end
    end
  end
end

array\u users=array.new
hash_user_policys=hash.new{h，k | h[k]=[]
iam=Aws:：iam.new
iam.list_users（）。每个do|resp|
每个用户都有| x|
数组|用户）。每个do | resp|
各do | x|
x、 政策名称。每个都有|
hash_user_policies[：“#{user}”]您可以这样做（但是，如果不知道数据的结构，很难说）
iam=Aws:：iam.new
array\u users=iam.list\u users.map（&:users）.flant.map（&:user\u name）
散列[
数组_users.map do | user|
[
user.to_sym，
{user_policy:iam.list_user_policy（：user_name=>user）.map（&:resp）.flatte.map（&:policy_name）.flatte.map（&:to_s），
集团政策：
}
[        
结束
[完]
您可以这样做（但是如果不知道数据的结构，很难说）
iam=Aws:：iam.new
array\u users=iam.list\u users.map（&:users）.flant.map（&:user\u name）
散列[
数组_users.map do | user|
[
user.to_sym，
{user_policy:iam.list_user_policy（：user_name=>user）.map（&:resp）.flatte.map（&:policy_name）.flatte.map（&:to_s），
集团政策：
}
[        
结束
[完]
您可以这样做（但是如果不知道数据的结构，很难说）
iam=Aws:：iam.new
array\u users=iam.list\u users.map（&:users）.flant.map（&:user\u name）
散列[
数组_users.map do | user|
[
user.to_sym，
{user_policy:iam.list_user_policy（：user_name=>user）.map（&:resp）.flatte.map（&:policy_name）.flatte.map（&:to_s），
集团政策：
}
[        
结束
[完]
您可以这样做（但是如果不知道数据的结构，很难说）
iam=Aws:：iam.new
array\u users=iam.list\u users.map（&:users）.flant.map（&:user\u name）
散列[
数组_users.map do | user|
[
user.to_sym，
{user_policy:iam.list_user_policy（：user_name=>user）.map（&:resp）.flatte.map（&:policy_name）.flatte.map（&:to_s），
集团政策：
}
[        
结束
[完]
如果结构始终为hash.hash.array，则可以结合使用两种尝试：
hash = Hash.new do |oh,ok|
  oh[ok] = Hash.new do |ih,ik|
    ih[ik] = []
  end
end

就我个人而言，我不会使用哈希和数组来实现这一点；ruby有一个非常强大的对象模型，我会为每个嵌套级别创建类（特别是“用户”级别，它似乎有一组定义良好的属性）。不过，您可能会发现有点过分。
如果结构始终为hash.hash.array，您可以结合使用两种尝试：
hash = Hash.new do |oh,ok|
  oh[ok] = Hash.new do |ih,ik|
    ih[ik] = []
  end
end

就我个人而言，我不会使用哈希和数组来实现这一点；ruby有一个非常强大的对象模型，我会为每个嵌套级别创建类（特别是“用户”级别，它似乎有一组定义良好的属性）。不过，您可能会发现有点过分。
如果结构始终为hash.hash.array，您可以结合使用两种尝试：
hash = Hash.new do |oh,ok|
  oh[ok] = Hash.new do |ih,ik|
    ih[ik] = []
  end
end

就我个人而言，我不会使用哈希和数组来实现这一点；ruby有一个非常强大的对象模型，我会为每个嵌套级别创建类（特别是“用户”级别，它似乎有一组定义良好的属性）。不过，您可能会发现有点过分。
如果结构始终为hash.hash.array，您可以结合使用两种尝试：
hash = Hash.new do |oh,ok|
  oh[ok] = Hash.new do |ih,ik|
    ih[ik] = []
  end
end

就我个人而言，我不会使用哈希和数组来实现这一点；ruby有一个非常强大的对象模型，我会为每个嵌套级别创建类（特别是“用户”级别，它似乎有一组定义良好的属性）。不过，您可能会发现这有点过火。
如何将代码拆分为更容易理解的内容，直到它变得对您来说更容易
def add_policy(hash, user, policy)
  # create a subhash for the user key if the hash doesn't exist
  hash[user] ||= {}

  # get the policy key: :group_policy or :user_policy
  # if policy_key can not be determined from the policy, 
  # you could pass an extra param for the policy_key
  policy_key = ( policy.include?("group") ? :group_policy : :user_policy )

  # create an array for the user's policy if none exists
  hash[user][policy_key] ||= []

  # push the policy into the array
  hash[user][policy_key] << policy

  hash
end



h = {}
add_policy(h, "user_100", "userpolicy_100")
add_policy(h, "user_100", "userpolicy_200")
add_policy(h, "user_100", "grouppolicy_300")
add_policy(h, "user_100", "grouppolicy_400")
add_policy(h, "user_200", "userpolicy_300")
add_policy(h, "user_200", "userpolicy_400")
add_policy(h, "user_200", "grouppolicy_300")
add_policy(h, "user_200", "grouppolicy_400")

=> {"user_100"=>
  {:user_policy=>["userpolicy_100", "userpolicy_200"],
   :group_policy=>["grouppolicy_300", "grouppolicy_400"]},
 "user_200"=>
  {:user_policy=>["userpolicy_300", "userpolicy_400"],
   :group_policy=>["grouppolicy_300", "grouppolicy_400"]}}

def添加策略（散列、用户、策略）
#如果散列不存在，则为用户密钥创建子散列
散列[用户]| |={}
#获取策略密钥：：组策略或：用户策略
#如果无法根据策略确定策略密钥，
#您可以为策略密钥传递一个额外的参数
策略\密钥=（策略。包括？（“组”）？：组\策略：：用户\策略）
#如果用户的策略不存在，请为其创建数组
散列[用户][策略_键]| |=[]
#将策略推送到阵列中
哈希[用户][策略密钥]{“用户\u 100”=>
{:user_policy=>[“userpolicy_100”，“userpolicy_200”]，
：group_policy=>[“grouppolicy_300”，“grouppolicy_400”]}，
“用户_200”=>
{:user_policy=>[“userpolicy_300”，“userpolicy_400”]，
：group_policy=>[“grouppolicy_300”，“grouppolicy_400”]}
如何将代码拆分为更容易理解的内容，直到它变得更容易理解
def add_policy(hash, user, policy)
  # create a subhash for the user key if the hash doesn't exist
  hash[user] ||= {}

  # get the policy key: :group_policy or :user_policy
  # if policy_key can not be determined from the policy, 
  # you could pass an extra param for the policy_key
  policy_key = ( policy.include?("group") ? :group_policy : :user_policy )

  # create an array for the user's policy if none exists
  hash[user][policy_key] ||= []

  # push the policy into the array
  hash[user][policy_key] << policy

  hash
end



h = {}
add_policy(h, "user_100", "userpolicy_100")
add_policy(h, "user_100", "userpolicy_200")
add_policy(h, "user_100", "grouppolicy_300")
add_policy(h, "user_100", "grouppolicy_400")
add_policy(h, "user_200", "userpolicy_300")
add_policy(h, "user_200", "userpolicy_400")
add_policy(h, "user_200", "grouppolicy_300")
add_policy(h, "user_200", "grouppolicy_400")

=> {"user_100"=>
  {:user_policy=>["userpolicy_100", "userpolicy_200"],
   :group_policy=>["grouppolicy_300", "grouppolicy_400"]},
 "user_200"=>
  {:user_policy=>["userpolicy_300", "userpolicy_400"],
   :group_policy=>["grouppolicy_300", "grouppolicy_400"]}}

def添加策略（散列、用户、策略）
#如果散列不存在，则为用户密钥创建子散列
散列[用户]| |={}
#获取策略密钥：：组策略或：用户策略
#如果无法根据策略确定策略密钥，
#你可以通过