Ruby 在递归方法中向数组添加值

方法：在\u groupsgroupname中获取\u用户\u 目的：从组和任何嵌套组的成员中获取所有成员

方法的英文翻译：

get group information
if group has members, 
    add members to users[]
end
If group has nested_groups,
    for nested_group in nested_groups
        get nested_groupname
        get_users_in_groups(nested_groupname)
    end
end

目前，我在方法属性中传递用户数组。但是，这似乎不是在递归方法中访问数组的正确方法

通过递归方法向用户数组添加成员的最佳方法是什么

我想我可能已经找到了解决办法

users = []
get group information
if group has members, 
   users.concat( members[] )
end
If group has nested_groups,
    for nested_group in nested_groups
        get nested_groupname
        users.concat( get_users_in_groups(nested_groupname) )
    end
end
users.uniq

这是最好的方法吗

很抱歉，我本想包括一个

isc员工 嵌套组：isc管理员、isc教师、isc段落 成员：无

isc管理员 嵌套组：无 成员：adminone、admintwo

isc教师 嵌套组：sped教师 成员：教师一，教师二

isc，第19-27段 嵌套组：无 成员：paraone、paratwo

速成教师 嵌套组：无 成员：spedteacherone、spedteachertwo

所以我的方法查找isc人员，看到它有isc管理员、isc教师和isc段落，但没有成员，它需要在isc管理员、isc教师和isc段落上运行自己。 当它在isc管理员上运行时，应该将成员添加到用户[] 当它在isc教师上运行时，它应该将成员添加到用户[]，并通过sped教师自行运行

此信息不存储在数组中，必须从LDAP中提取

这些信息够了吗

该结构看起来类似于

{
 group_name: 'isc-staff',
 nested_groups: [
                 {
                  group_name: 'isc-admins',
                  members: ['adminone', 'admintwo']
                 },
                 {
                  group_name: 'isc-teachers',
                  members: ['teacherone', 'teachertwo'],
                  nested_groups: [
                                  {
                                   group_name: 'sped-teachers',
                                   members: ['spedteacherone']
                                  }
                                 ]
                 },
                 {
                  group_name: 'isc-paras',
                  members: ['paraone', 'paratwo']
                 }
 ]
}

结果应该是：

['adminone','admintwo','teacherone','teachertwo','spedteacherone','paraone','paratwo']

---

我的解决办法相当笼统。您的结构可以是数组或散列，递归地包含数组、散列和任意深度的文本。我假设您想要的值是数组中的字符串，并且所有数组都不包含字符串或仅包含字符串，尽管那些不包含字符串的数组可能包含嵌套的字符串数组，这将被找到

代码

注意，您在示例哈希中犯了几个小错误

解释

当e是数组或散列时调用getem。返回值是数组a，第一次调用getem时默认为空数组

我们使用case语句来测试对象的类。这是因为case使用而不是==来确定true或false

如果getem的第一个参数是数组，那么我们将看到第一个元素是否是字符串。如果是，我们假设所有元素都是字符串，并将它们添加到数组a中。否则，我们递归地为数组或散列中的每个元素调用getem

如果getem的第一个参数是散列，那么我们将递归地为数组或散列中的每个值调用getem。因为我们不在块中使用散列键，所以我们可以写| u v |，而不是| k，v |

---

假设您的数据结构是带有符号键的散列，则简单的递归函数可以实现以下功能：

def all_group_members group
  members = []
  members.concat group[:members] if group[:members]
  if group[:nested_groups]
    group[:nested_groups].each { |g| members.concat all_group_members(g) }
  end
  members
end

---

根据我在过去几天里对递归查询的了解，我想出了这个方法。这行吗

def self.get_users_in_group(groupname)
            users = []
            if exists?(groupname)
                params = [
                            "GroupMembership",
                            "NestedGroups"
                        ]
                DSQuery.generate_dscl("read","/Groups/#{groupname}",params)
                output = DSQuery.run
                # Add members of group to users array.
                if output.has_key?('dsAttrTypeStandard:GroupMembership')
                    users.concat(output['dsAttrTypeStandard:GroupMembership'])
                end
                # if group contains nested groups,
                # get_users_in_group for each nested group and add to users array.
                if output.has_key?('dsAttrTypeStandard:NestedGroups')
                    output['dsAttrTypeStandard:NestedGroups'].each do |generate_dscldUID|
                        results = find('GeneratedUID',generate_dscldUID)
                        if !results.empty?
                            result = results[0]
                            length_of_nested_group_name = result.index("\t") - "\t".length
                            nested_group_name = result.slice(0..length_of_nested_group_name)
                            users.concat( get_users_in_group(nested_group_name) )
                        end
                    end
                end
            end
            users.uniq
        end

---

菲利普，这里的一个例子就相当于1000个字。可能会给出一个具有两级嵌套[[]]的数组，以及所需的结果数组。添加了两个示例，第一个以段落形式描述如何实际获取数据，读取数据，然后获取更多数据，第二个以哈希/数组形式将其放入。这是一个很好的示例。这使你的问题非常清楚。

def all_group_members group
  members = []
  members.concat group[:members] if group[:members]
  if group[:nested_groups]
    group[:nested_groups].each { |g| members.concat all_group_members(g) }
  end
  members
end

def self.get_users_in_group(groupname)
            users = []
            if exists?(groupname)
                params = [
                            "GroupMembership",
                            "NestedGroups"
                        ]
                DSQuery.generate_dscl("read","/Groups/#{groupname}",params)
                output = DSQuery.run
                # Add members of group to users array.
                if output.has_key?('dsAttrTypeStandard:GroupMembership')
                    users.concat(output['dsAttrTypeStandard:GroupMembership'])
                end
                # if group contains nested groups,
                # get_users_in_group for each nested group and add to users array.
                if output.has_key?('dsAttrTypeStandard:NestedGroups')
                    output['dsAttrTypeStandard:NestedGroups'].each do |generate_dscldUID|
                        results = find('GeneratedUID',generate_dscldUID)
                        if !results.empty?
                            result = results[0]
                            length_of_nested_group_name = result.index("\t") - "\t".length
                            nested_group_name = result.slice(0..length_of_nested_group_name)
                            users.concat( get_users_in_group(nested_group_name) )
                        end
                    end
                end
            end
            users.uniq
        end