Question

我有一个数组，我需要给定值的路径（键）。我已经为它编写了一个函数但是我无法使它工作，数组可以有一个无限深度来控制另一个函数，我还没有确定一个限制但是深度是变量，它实际上工作到一个点，但深度可能是30-40-50深，所以我需要它以这种方式工作，这个功能真的只是用于值识别，数字是模板，标签是模板中的标签，每个标签都有一个与之关联的模板，所有模板名称都是唯一的，标签名称不是因为它们只与单个模板相关联，所以id值由短划线分隔（模板和标签ID中非法），其中模板ID只是数字，标签ID包含波浪线和美元符号{$ TAG}，不必担心重复值，因为禁止无限循环（模板无法链接到自身）或者链接到自身的模板）加上ID只给模板名称唯一的模板。给定数组中名为4的模板的id将为0 - {$ CONTENT} -2 - {$ PARAGRAPH} -4，我丢失它是我的功能赢得超出此深度，感谢您的帮助

array (size=1)
  0 => 
    array (size=4)
      '{$TITLE}' => null
      '{$NAME}' => null
      '{$FRIENDS}' => 
          array (size=1)
            1 => 
              array (size=2)
                '{$friend}' => null
                '{$friends[$i]}' => null
      '{$CONTENT}' => 
        array (size=1)
          2 => 
             '{$HEADING}' => 
               array (size=1)
                 3 => 
                   array (size=0)
                     empty
             '{$PARAGRAPH}' => 
               array (size=1)
                 4 => 
                   array (size=1)
                     '{$AnotherParagraph}' => null

这是我的功能，我为测试目的添加了深度变量，$ this-＆gt; family是上面给出的数组，调用函数：$ id = $ this-＆gt; get_id（4） ;

public function get_id($member, $family=null, $id=null, $depth=0) {
    if (empty($this->family)) {
        return false;
    }
    if (is_null($family)) {
        $family = $this->family;
    }

    foreach ($family as $parent => $tag_child) {
        if ($member === $parent) {
            return $member;
        }

        foreach ($tag_child as $tag => $child) {
            if (is_null($child) || empty($child)) {
                continue;
            }

            $childkey = key($child);

            if ($member === $childkey) {
                $id .= '-'.$parent.'-'.$tag.'-'.$member;
                $id = ltrim($id, '-');
                return $id;
            }

            $family = $child;

            if (!is_null($id) && !empty($id)) {
                $id_array = explode('-', $id);
                foreach ($id_array as $id_value) {
                    if ($id_value !== $childkey) {
                        $new_id_array[] = $id_value;
                    }else{
                        break;
                    }
                }
                $id = implode('-', $new_id_array);
            }

            if ($parent === 0) {
                $id = $parent.'-'.$tag.'-'.$childkey;
            }else{
                $id .= '-'.$tag.'-'.$childkey;
            }

            $id = ltrim($id, '-');

            $depth++;

            $id = $this->get_id($member, $family, $id, $depth);

        }

    }
}

Answer 1

使用递归函数。这是我为了这个目的而写的一个。

public function recurseArray($array, $builtKey = "") {
    $values = array();
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            if (!empty($builtKey)) {
                $values = array_merge($values, recurseArray($value, $builtKey.".".$key));
            } else {
                $values = array_merge($values, recurseArray($value, $key));
            }
        } else {
            if (!empty($builtKey)) {
                $values[$builtKey.".".$key] = $value;
            } else {
                $values[$key] = $value;
            }
        }
    }
    return $values;
}

这会生成一个平面数组，用于转换：

array(
    "key" => array(
        "of" => array(
            "many" => array(
                "depths" => "value"
            )
        )
    ),
    "key2" => "value"
);

进入这个：

array(
    "key.of.many.depths" => "value",
    "key2" => "value"
);

数组值深度多维数组的路径

1 个答案: