В PHP, как вы меняете ключ элемента массива?

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

То, как вы это сделаете, и сохранить порядок массива, – это положить ключи массива в отдельный массив, найти и заменить ключ в этом массиве, а затем объединить его со значениями.

Вот функция, которая делает именно это:

 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 ); } 

если ваш array построен из запроса базы данных, вы можете напрямую изменить ключ из инструкции mysql :

вместо

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

используйте что-то вроде:

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

Вы можете использовать второй ассоциативный массив, который отображает читаемые человеком имена в идентификаторы. Это также обеспечило бы отношения «Много к одному». Затем сделайте что-то вроде этого:

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

Ответ от KernelM хорош, но для того, чтобы избежать проблемы, поднятой Грегом в комментарии (конфликтующие ключи), использование нового массива было бы безопаснее

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

Если вы хотите, чтобы позиция нового ключа массива была такой же, как и предыдущая, вы можете это сделать:

 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; } 

Мне нравится решение 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 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; } 

Вот вспомогательная функция для достижения этого:

 /** * 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; } } с /** * 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); 

Он вернет true при успешном переименовании, иначе false .

Легкий материал:

эта функция будет принимать целевой хэш $, а $ replacements также является хешем, содержащим newkey => ассоциации oldkey .

Эта функция сохранит исходный порядок , но может быть проблематичной для очень больших (например, более 10 тыс. Записей) массивов относительно производительности и памяти .

 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; } 

эта альтернативная функция будет делать то же самое, с гораздо более высокой производительностью и использованием памяти, ценой потери первоначального заказа (что не должно быть проблемой, так как это hashtable!)

 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; } с 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; } 

этот код поможет изменить старый ключ на новый.

 $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); с $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"); 

 $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; с $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); } 

Существует альтернативный способ изменения ключа элемента массива при работе с полным массивом – без изменения порядка массива. Это просто, чтобы скопировать массив в новый массив.

Например, я работал со смешанным многомерным массивом, содержащим индексированные и ассоциативные ключи, – и я хотел заменить целые ключи своими значениями, не нарушая порядок.

Я сделал это, переключив ключ / значение для всех числовых записей массива – здесь: ['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 ) ) 

Если вы хотите сразу заменить несколько ключей (порядок сохранения):

 /** * 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); }