根据另一个查找/映射数组替换数组中的键

您可以使用第二个关联数组将人类可读的名称映射到id。这也将提供多对1关系。然后这样做:

echo 'Widgets: ' . $data[$humanreadbleMapping['Widgets']];

$arr[$newkey] = $arr[$oldkey];
unset($arr[$oldkey]);

如果你的array是由数据库查询构建的，你可以直接从mysql语句中更改键:

而不是

"select ´id´ from ´tablename´..."

可以使用以下语句:

"select ´id´ **as NEWNAME** from ´tablename´..."

KernelM的答案很好，但是为了避免Greg在评论中提出的问题(键冲突)，使用一个新的数组会更安全

$newarr[$newkey] = $oldarr[$oldkey];
$oldarr=$newarr;
unset($newarr);

我喜欢KernelM的解决方案，但是我需要一些能够处理潜在的密钥冲突(新密钥可能与现有密钥匹配)的解决方案。以下是我想到的:

function swapKeys( &$arr, $origKey, $newKey, &$pendingKeys ) {
if( !isset( $arr[$newKey] ) ) {
$arr[$newKey] = $arr[$origKey];
unset( $arr[$origKey] );
if( isset( $pendingKeys[$origKey] ) ) {
// recursion to handle conflicting keys with conflicting keys
swapKeys( $arr, $pendingKeys[$origKey], $origKey, $pendingKeys );
unset( $pendingKeys[$origKey] );
}
} elseif( $newKey != $origKey ) {
$pendingKeys[$newKey] = $origKey;
}
}

然后你可以像这样循环数组:

$myArray = array( '1970-01-01 00:00:01', '1970-01-01 00:01:00' );
$pendingKeys = array();
foreach( $myArray as $key => $myArrayValue ) {
// NOTE: strtotime( '1970-01-01 00:00:01' ) = 1 (a conflicting key)
$timestamp = strtotime( $myArrayValue );
swapKeys( $myArray, $key, $timestamp, $pendingKeys );
}
// RESULT: $myArray == array( 1=>'1970-01-01 00:00:01', 60=>'1970-01-01 00:01:00' )

    $datos = array
(
'0' => array
(
'no' => 1,
'id_maquina' => 1,
'id_transaccion' => 1276316093,
'ultimo_cambio' => 'asdfsaf',
'fecha_ultimo_mantenimiento' => 1275804000,
'mecanico_ultimo_mantenimiento' =>'asdfas',
'fecha_ultima_reparacion' => 1275804000,
'mecanico_ultima_reparacion' => 'sadfasf',
'fecha_siguiente_mantenimiento' => 1275804000,
'fecha_ultima_falla' => 0,
'total_fallas' => 0,
),


'1' => array
(
'no' => 2,
'id_maquina' => 2,
'id_transaccion' => 1276494575,
'ultimo_cambio' => 'xx',
'fecha_ultimo_mantenimiento' => 1275372000,
'mecanico_ultimo_mantenimiento' => 'xx',
'fecha_ultima_reparacion' => 1275458400,
'mecanico_ultima_reparacion' => 'xx',
'fecha_siguiente_mantenimiento' => 1275372000,
'fecha_ultima_falla' => 0,
'total_fallas' => 0,
)
);

函数如下:

function changekeyname($array, $newkey, $oldkey)
{
foreach ($array as $key => $value)
{
if (is_array($value))
$array[$key] = changekeyname($value,$newkey,$oldkey);
else
{
$array[$newkey] =  $array[$oldkey];
}


}
unset($array[$oldkey]);
return $array;
}

做到这一点并保持数组顺序的方法是将数组键放入一个单独的数组中，找到并替换该数组中的键，然后将其与值组合起来。

这里有一个函数就是这样做的:

function change_key( $array, $old_key, $new_key ) {


if( ! array_key_exists( $old_key, $array ) )
return $array;


$keys = array_keys( $array );
$keys[ array_search( $old_key, $keys ) ] = $new_key;


return array_combine( $keys, $array );
}

如果你还想让新数组键的位置与旧数组键的位置相同，你可以这样做:

function change_array_key( $array, $old_key, $new_key) {
if(!is_array($array)){ print 'You must enter a array as a haystack!'; exit; }
if(!array_key_exists($old_key, $array)){
return $array;
}


$key_pos = array_search($old_key, array_keys($array));
$arr_before = array_slice($array, 0, $key_pos);
$arr_after = array_slice($array, $key_pos + 1);
$arr_renamed = array($new_key => $array[$old_key]);


return $arr_before + $arr_renamed + $arr_after;
}

这段代码将帮助将旧密钥更改为新密钥

$i = 0;
$keys_array=array("0"=>"one","1"=>"two");


$keys = array_keys($keys_array);


for($i=0;$i<count($keys);$i++) {
$keys_array[$keys_array[$i]]=$keys_array[$i];
unset($keys_array[$i]);
}
print_r($keys_array);

显示如

$keys_array=array("one"=>"one","two"=>"two");

简单的东西:

此函数将接受目标$哈希值，$replacement也是包含newkey =祝辞oldkey关联的哈希值。

这个函数将保留原有秩序，但对于非常大的(如10k以上的记录)关于性能,内存的数组可能会有问题。

function keyRename(array $hash, array $replacements) {
$new=array();
foreach($hash as $k=>$v)
{
if($ok=array_search($k,$replacements))
$k=$ok;
$new[$k]=$v;
}
return $new;
}

这个替代函数也会做同样的事情，使用更好的性能 &内存使用，代价是丢失原来的顺序(这应该不是问题，因为它是哈希表!)

function keyRename(array $hash, array $replacements) {


foreach($hash as $k=>$v)
if($ok=array_search($k,$replacements))
{
$hash[$ok]=$v;
unset($hash[$k]);
}


return $hash;
}

这里有一个帮助函数来实现这一点:

/**
* Helper function to rename array keys.
*/
function _rename_arr_key($oldkey, $newkey, array &$arr) {
if (array_key_exists($oldkey, $arr)) {
$arr[$newkey] = $arr[$oldkey];
unset($arr[$oldkey]);
return TRUE;
} else {
return FALSE;
}
}

基于@KernelM回答。

用法:

_rename_arr_key('oldkey', 'newkey', $my_array);

如果重命名成功，它将返回真正的，否则返回假。

$array = [
'old1' => 1
'old2' => 2
];


$renameMap = [
'old1' => 'new1',
'old2' => 'new2'
];


$array = array_combine(array_map(function($el) use ($renameMap) {
return $renameMap[$el];
}, array_keys($array)), array_values($array));


/*
$array = [
'new1' => 1
'new2' => 2
];
*/

这适用于重命名第一个键:

$a = ['catine' => 'cat', 'canine'  => 'dog'];
$tmpa['feline'] = $a['catine'];
unset($a['catine']);
$a = $tmpa + $a;

然后，print_r($a)呈现一个修复后的有序数组:

Array
(
[feline] => cat
[canine] => dog
)

这适用于重命名任意键:

$a = ['canine'  => 'dog', 'catine' => 'cat', 'porcine' => 'pig']
$af = array_flip($a)
$af['cat'] = 'feline';
$a = array_flip($af)

print_r(美元)

Array
(
[canine] => dog
[feline] => cat
[porcine] => pig
)

广义函数:

function renameKey($oldkey, $newkey, $array) {
$val = $array[$oldkey];
$tmp_A = array_flip($array);
$tmp_A[$val] = $newkey;


return array_flip($tmp_A);
}

如果你想一次替换多个键(保持顺序):

/**
* Rename keys of an array
* @param array $array (asoc)
* @param array $replacement_keys (indexed)
* @return array
*/
function rename_keys($array, $replacement_keys)  {
return array_combine($replacement_keys, array_values($array));
}

用法:

$myarr = array("a" => 22, "b" => 144, "c" => 43);
$newkeys = array("x","y","z");
print_r(rename_keys($myarr, $newkeys));
//must return: array("x" => 22, "y" => 144, "z" => 43);

嗯，我没有测试之前，但我认为这段代码工作

function replace_array_key($data) {
$mapping = [
'old_key_1' => 'new_key_1',
'old_key_2' => 'new_key_2',
];


$data = json_encode($data);
foreach ($mapping as $needed => $replace) {
$data = str_replace('"'.$needed.'":', '"'.$replace.'":', $data);
}


return json_decode($data, true);
}

例如，我正在处理一个混合的多维数组，其中包含索引键和关联键——我想用它们的值替换整数键，而不破坏顺序。

我通过为所有数值数组项切换键/值来做到这一点-这里:['0'=>'foo']。注意，顺序是完整的。

<?php
$arr = [
'foo',
'bar'=>'alfa',
'baz'=>['a'=>'hello', 'b'=>'world'],
];


foreach($arr as $k=>$v) {
$kk = is_numeric($k) ? $v : $k;
$vv = is_numeric($k) ? null : $v;
$arr2[$kk] = $vv;
}


print_r($arr2);

输出:

Array (
[foo] =>
[bar] => alfa
[baz] => Array (
[a] => hello
[b] => world
)
)

一种简单易懂的保存秩序的方法:

function rename_array_key(array $array, $old_key, $new_key) {
if (!array_key_exists($old_key, $array)) {
return $array;
}
$new_array = [];
foreach ($array as $key => $value) {
$new_key = $old_key === $key
? $new_key
: $key;
$new_array[$new_key] = $value;
}
return $new_array;
}

你可以基于array_walk使用这个函数:

function mapToIDs($array, $id_field_name = 'id')
{
$result = [];
array_walk($array,
function(&$value, $key) use (&$result, $id_field_name)
{
$result[$value[$id_field_name]] = $value;
}
);
return $result;
}


$arr = [0 => ['id' => 'one', 'fruit' => 'apple'], 1 => ['id' => 'two', 'fruit' => 'banana']];
print_r($arr);
print_r(mapToIDs($arr));

它给:

Array(
[0] => Array(
[id] => one
[fruit] => apple
)
[1] => Array(
[id] => two
[fruit] => banana
)
)


Array(
[one] => Array(
[id] => one
[fruit] => apple
)
[two] => Array(
[id] => two
[fruit] => banana
)
)

最好的方法是使用引用，而不是使用unset(这是清理内存的另一个步骤)

$tab = ['two' => [] ];

解决方案:

$tab['newname'] = & $tab['two'];

你有一份原件和一份有新名字的参考资料。

或者如果你不想在一个值中有两个名字是很好的，让另一个TAB和foreach引用

foreach($tab as $key=> & $value) {
if($key=='two') {
$newtab["newname"] = & $tab[$key];
} else {
$newtab[$key] = & $tab[$key];
}
}

迭代键比克隆所有数组更好，如果你有长数据，如100行+++等，清洗旧数组。

您可以编写一个简单的函数，将回调应用到给定数组的键。类似于到

<?php
function array_map_keys(callable $callback, array $array) {
return array_merge([], ...array_map(
function ($key, $value) use ($callback) { return [$callback($key) => $value]; },
array_keys($array),
$array
));
}


$array = ['a' => 1, 'b' => 'test', 'c' => ['x' => 1, 'y' => 2]];
$newArray = array_map_keys(function($key) { return 'new' . ucfirst($key); }, $array);


echo json_encode($array); // {"a":1,"b":"test","c":{"x":1,"y":2}}
echo json_encode($newArray); // {"newA":1,"newB":"test","newC":{"x":1,"y":2}}

这里是一个要点https://gist.github.com/vardius/650367e15abfb58bcd72ca47eff096ca#file-array_map_keys-php。

两种解决方案的简单基准比较。

解决方案1复制和删除(顺序丢失，但更快)https://stackoverflow.com/a/240676/1617857

<?php
$array = ['test' => 'value', ['etc...']];


$array['test2'] = $array['test'];
unset($array['test']);

解决方案2重命名键https://stackoverflow.com/a/21299719/1617857

<?php
$array = ['test' => 'value', ['etc...']];


$keys = array_keys( $array );
$keys[array_search('test', $keys, true)] = 'test2';
array_combine( $keys, $array );

基准:

<?php
$array = ['test' => 'value', ['etc...']];




for ($i =0; $i < 100000000; $i++){
// Solution 1
}




for ($i =0; $i < 100000000; $i++){
// Solution 2
}

结果:

php solution1.php  6.33s  user 0.02s system 99% cpu 6.356  total
php solution1.php  6.37s  user 0.01s system 99% cpu 6.390  total
php solution2.php  12.14s user 0.01s system 99% cpu 12.164 total
php solution2.php  12.57s user 0.03s system 99% cpu 12.612 total

这个基本函数处理交换数组键并保持数组的原始顺序…

public function keySwap(array $resource, array $keys)
{
$newResource = [];


foreach($resource as $k => $r){
if(array_key_exists($k,$keys)){
$newResource[$keys[$k]] = $r;
}else{
$newResource[$k] = $r;
}
}


return $newResource;
}

然后你可以循环并将所有的“a”键与“z”键交换。

$inputs = [
0 => ['a'=>'1','b'=>'2'],
1 => ['a'=>'3','b'=>'4']
]


$keySwap = ['a'=>'z'];


foreach($inputs as $k=>$i){
$inputs[$k] = $this->keySwap($i,$keySwap);
}

这个函数将通过结合索引搜索来重命名数组键，并保持其位置。

function renameArrKey($arr, $oldKey, $newKey){
if(!isset($arr[$oldKey])) return $arr; // Failsafe
$keys = array_keys($arr);
$keys[array_search($oldKey, $keys)] = $newKey;
$newArr = array_combine($keys, $arr);
return $newArr;
}

用法:

$arr = renameArrKey($arr, 'old_key', 'new_key');

本页对所要求的内容进行了广泛的解释，因为问题主体中没有最小的、可验证的示例。有些答案仅仅是试图解决“标题”;不去理解题目要求。

键实际上是一个ID数字，值是一个计数。这是 大多数情况下都没问题，但是我想要一个函数 人类可读的数组名称，并使用该名称作为键，无需

PHP键不能是改变了，但它们可以被替换——这就是为什么这么多答案建议使用array_search()(一个相对较差的性能)和unset()。

最终，您希望创建一个新数组，其名称作为与原始计数相关的键。这是通过查找数组最有效地完成的，因为搜索键总是比搜索值更好。

代码(演示):

$idCounts = [
3 => 15,
7 => 12,
8 => 10,
9 => 4
];


$idNames = [
1 => 'Steve',
2 => 'Georgia',
3 => 'Elon',
4 => 'Fiona',
5 => 'Tim',
6 => 'Petra',
7 => 'Quentin',
8 => 'Raymond',
9 => 'Barb'
];


$result = [];
foreach ($idCounts as $id => $count) {
if (isset($idNames[$id])) {
$result[$idNames[$id]] = $count;
}
}
var_export($result);

输出:

array (
'Elon' => 15,
'Quentin' => 12,
'Raymond' => 10,
'Barb' => 4,
)

这种技术保持原始的数组顺序(以防排序问题)，不做任何不必要的迭代，并且因为isset()而非常迅速。

这是一个实验(测试)

初始数组(像0、1、2这样的键)

$some_array[] = '6110';//
$some_array[] = '6111';//
$some_array[] = '6210';//

我必须将键名更改为例如human_readable15， human_readable16， human_readable17

类似于已经发布的内容。在每个循环中，我设置必要的键名，并从初始数组中删除相应的键。

例如，我插入mysql $some_array得到lastInsertId，我需要发送键值对返回jquery。

$first_id_of_inserted = 7;//lastInsertId
$last_loop_for_some_array = count($some_array);




for ($current_loop = 0; $current_loop < $last_loop_for_some_array ; $current_loop++) {


$some_array['human_readable'.($first_id_of_inserted + $current_loop)] = $some_array[$current_loop];//add new key for intial array


unset( $some_array[$current_loop] );//remove already renamed key from array


}

这是带有重命名键的新数组

echo '<pre>', print_r($some_array, true), '</pre>$some_array in '. basename(__FILE__, '.php'). '.php <br/>';

如果human_readable15， human_readable16， human_readable17需要其他东西。然后就能创造出这样的东西

$arr_with_key_names[] = 'human_readable';
$arr_with_key_names[] = 'something_another';
$arr_with_key_names[] = 'and_something_else';




for ($current_loop = 0; $current_loop < $last_loop_for_some_array ; $current_loop++) {


$some_array[$arr_with_key_names[$current_loop]] = $some_array[$current_loop];//add new key for intial array


unset( $some_array[$current_loop] );//remove already renamed key from array


}