在PHP中对数组的一部分进行排序

我有这个阵列：

array ('project'=>'My project','leader'=>'Michael Phepps','partner1'=>'John Campbell','partner2'=>'Phillip Prescott','agepartner1'=>25, 'agepartner2'=>'44', 'budget'=>'80000');

数组是不同表中某些查询的结果： 项目表字段：项目、领导、预算。 合作伙伴字段：合作伙伴、年龄

数组的顺序由用户定义，执行方式如下：

foreach ($userarray as $field) {loadField($field)};

由于该操作是针对每个字段的，因此我在“partner1”之后获得“partner2”，但我需要在“partner1”之后获得“agepartner1”，因为在这之后它们将显示在html表中

我可以得到任何建议：

array ('project'=>'My project','leader'=>'Michael Phepps','partner1'=>'John Campbell', 'agepartner1'=>25, 'partner2'=>'Phillip Prescott', 'agepartner2'=>'44', 'budget'=>'80000');

---

虽然可能不是你想要的答案，但我认为有更好的方法来处理你的情况：

$data = array('key1' => 'is', 'key2' => 'test', 'key3' => 'This');
$order = array('key3', 'key1', 'key2');

foreach($order as $key){
  print_r($data[$key]);
}

输出：

This is test.

Keys:
array(7) {
  [0]=>
  string(7) "project"
  [1]=>
  string(6) "leader"
  [2]=>
  string(8) "partner1"
  [3]=>
  string(8) "partner2"
  [4]=>
  string(11) "agepartner1"
  [5]=>
  string(11) "agepartner2"
  [6]=>
  string(6) "budget"
}
Categories:
array(5) {
  ["project"]=>
  array(1) {
    [0]=>
    string(7) "project"
  }
  ["leader"]=>
  array(1) {
    [0]=>
    string(6) "leader"
  }
  [1]=>
  array(2) {
    [0]=>
    string(8) "partner1"
    [1]=>
    string(11) "agepartner1"
  }
  [2]=>
  array(2) {
    [0]=>
    string(8) "partner2"
    [1]=>
    string(11) "agepartner2"
  }
  ["budget"]=>
  array(1) {
    [0]=>
    string(6) "budget"
  }
}
Groups:
array(3) {
  [0]=>
  array(1) {
    [1]=>
    array(2) {
      [0]=>
      array(1) {
        [0]=>
        string(7) "project"
      }
      [1]=>
      array(1) {
        [0]=>
        string(6) "leader"
      }
    }
  }
  [1]=>
  array(1) {
    [2]=>
    array(2) {
      [0]=>
      array(2) {
        [0]=>
        string(8) "partner1"
        [1]=>
        string(11) "agepartner1"
      }
      [1]=>
      array(2) {
        [0]=>
        string(8) "partner2"
        [1]=>
        string(11) "agepartner2"
      }
    }
  }
  [2]=>
  array(1) {
    [1]=>
    array(1) {
      [0]=>
      array(1) {
        [0]=>
        string(6) "budget"
      }
    }
  }
}
Un-Grouped:
array(7) {
  [0]=>
  string(7) "project"
  [1]=>
  string(6) "leader"
  [2]=>
  string(8) "partner1"
  [3]=>
  string(11) "agepartner1"
  [4]=>
  string(8) "partner2"
  [5]=>
  string(11) "agepartner2"
  [6]=>
  string(6) "budget"
}
Sorted:
array(7) {
  ["project"]=>
  string(10) "My project"
  ["leader"]=>
  string(14) "Michael Phepps"
  ["partner1"]=>
  string(13) "John Campbell"
  ["agepartner1"]=>
  int(25)
  ["partner2"]=>
  string(16) "Phillip Prescott"
  ["agepartner2"]=>
  string(2) "44"
  ["budget"]=>
  string(5) "80000"
}

因此，根据您的数据：

$userarray = array ('project'=>'My project',
                    'leader'=>'Michael Phepps',
                    'partner1'=>'John Campbell',
                    'partner2'=>'Phillip Prescott',
                    'agepartner1'=>25, 
                    'agepartner2'=>'44', 
                    'budget'=>'80000');

$order = array('project',
               'leader',
               'partner1', 
               'agepartner1', 
               'partner2', 
               'agepartner2', 
               'budget');

foreach($order as $field) {
  loadField($userarray[$field]);
}

---

不能直接订购数组的一部分。您只能将数组划分为要排序的部分，然后对这些部分进行排序，然后对数组数据应用该排序。因为你也不能改变按键的位置。正如蒂姆·莱特尔建议的那样，拿到钥匙，对它们进行排序，然后你就有了解决方案。这稍微减少了一点问题

自然有解决办法。但是，请记住，您的数据结构很难排序。我做了以下工作：

• 拿到钥匙
• 对键进行分类：如果不包含数字，则类别为键本身；如果包含数字，则类别为数字
• 根据类别将所有关键帧划分为组。这意味着，每次类别更改时，都会有一个新的组开始：

  ALPHA，DIGIT，ALPHA

• 打通了所有的小组并处理了他们<代码>数字组可能需要排序，因此我对它们进行了排序（例如，如果

  agepartner

  位于

  partner

  之前，我只进行了a-z排序+反向排序）
• 再次将所有部分展平为键阵列。键排序完成
• 根据新的键顺序和原始数组中的值创建一个

  $sorted

  数组

如果您需要对数字进行排序（例如，先1，然后2），您还可以通过内部数组的键排序（

ksort

）对每个

数字

组进行排序。由于您的数据结构如此复杂，下面的代码示例包含调试输出和一些注释，因此您至少可以更轻松地浏览和使用它：

$array = array ('project'=>'My project','leader'=>'Michael Phepps','partner1'=>'John Campbell','partner2'=>'Phillip Prescott','agepartner1'=>25, 'agepartner2'=>'44', 'budget'=>'80000');

// reduce the problem: If we can sort the keys, we have the solution.
$keys = array_keys($array);
echo "Keys:\n";
var_dump($keys);

// categorize keys: alpha-only or alpha and digits at the end
$categories = array();
foreach($keys as $key)
{
    $r = preg_match('/^([a-z]+)(\d*)$/', $key, $matches);
    assert('$r !== FALSE');
    list(,$alpha, $digits) = $matches;
    $category = $digits ? $digits : $alpha; 
    $categories[$category][] = $key;
}
echo "Categories:\n";
var_dump($categories);

// group categories together in their order: ALPHA blocks and DIGIT blocks
define('GROUP_ALPHA', 1);
define('GROUP_DIGIT', 2);
$last = GROUP_ALPHA;
$group = array(); // start with an empty group to add to, pointer
$groups = array(array(GROUP_ALPHA => &$group));
foreach($categories as $vkey => $category)
{
    $current = is_int($vkey) ? GROUP_DIGIT : GROUP_ALPHA;
    if ($current != $last)
    {
        // add new group
        unset($group);
        $group = array();
        $groups[] = array($current => &$group);
    }
    $group[] = $category;
    $last = $current;
}
unset($group); // remove pointer
echo "Groups:\n";
var_dump($groups);

// sort and flatten groups
$ungroup = array();
foreach($groups as $type => $group)
{
    if ($type == GROUP_DIGIT)
    {
        // if digit groups need to be sorted: partner, agepartner
        foreach($group as &$items)
        {
            sort($items);
            array_reverse($items);
            unset($items);
        }
    }
    // flatten the group
    $group = call_user_func_array('array_merge', $group);
    $group = call_user_func_array('array_merge', $group);
    $ungroup = array_merge($ungroup, $group);
}
echo "Un-Grouped:\n";
var_dump($ungroup);

// solve
$sorted = array();
foreach($ungroup as $key)
{
    $sorted[$key] = $array[$key];
}

echo "Sorted:\n";
var_dump($sorted);

输出：

This is test.

Keys:
array(7) {
  [0]=>
  string(7) "project"
  [1]=>
  string(6) "leader"
  [2]=>
  string(8) "partner1"
  [3]=>
  string(8) "partner2"
  [4]=>
  string(11) "agepartner1"
  [5]=>
  string(11) "agepartner2"
  [6]=>
  string(6) "budget"
}
Categories:
array(5) {
  ["project"]=>
  array(1) {
    [0]=>
    string(7) "project"
  }
  ["leader"]=>
  array(1) {
    [0]=>
    string(6) "leader"
  }
  [1]=>
  array(2) {
    [0]=>
    string(8) "partner1"
    [1]=>
    string(11) "agepartner1"
  }
  [2]=>
  array(2) {
    [0]=>
    string(8) "partner2"
    [1]=>
    string(11) "agepartner2"
  }
  ["budget"]=>
  array(1) {
    [0]=>
    string(6) "budget"
  }
}
Groups:
array(3) {
  [0]=>
  array(1) {
    [1]=>
    array(2) {
      [0]=>
      array(1) {
        [0]=>
        string(7) "project"
      }
      [1]=>
      array(1) {
        [0]=>
        string(6) "leader"
      }
    }
  }
  [1]=>
  array(1) {
    [2]=>
    array(2) {
      [0]=>
      array(2) {
        [0]=>
        string(8) "partner1"
        [1]=>
        string(11) "agepartner1"
      }
      [1]=>
      array(2) {
        [0]=>
        string(8) "partner2"
        [1]=>
        string(11) "agepartner2"
      }
    }
  }
  [2]=>
  array(1) {
    [1]=>
    array(1) {
      [0]=>
      array(1) {
        [0]=>
        string(6) "budget"
      }
    }
  }
}
Un-Grouped:
array(7) {
  [0]=>
  string(7) "project"
  [1]=>
  string(6) "leader"
  [2]=>
  string(8) "partner1"
  [3]=>
  string(11) "agepartner1"
  [4]=>
  string(8) "partner2"
  [5]=>
  string(11) "agepartner2"
  [6]=>
  string(6) "budget"
}
Sorted:
array(7) {
  ["project"]=>
  string(10) "My project"
  ["leader"]=>
  string(14) "Michael Phepps"
  ["partner1"]=>
  string(13) "John Campbell"
  ["agepartner1"]=>
  int(25)
  ["partner2"]=>
  string(16) "Phillip Prescott"
  ["agepartner2"]=>
  string(2) "44"
  ["budget"]=>
  string(5) "80000"
}

---

可能的重复如果您只传递整个数组，并且在输出HTML的任何地方，只要回显正确的值，不是更容易吗？嗨@Tim，谢谢您的回答。你的建议很好。我的情况使练习更加复杂。我不知道每个项目会有多少合作伙伴。我在sql查询之后就知道了。然后，一旦有了结果，就可以创建order数组了。或者，与我的示例在已知字段中循环的方式类似，您可以在

partnerX

中循环，直到找到未设置的。