我喜欢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' )

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

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

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

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

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

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

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

有一种替代方法可以在处理完整数组时更改数组元素的键，而不改变数组的顺序。 它只是将数组复制到一个新的数组中。

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

我通过为所有数值数组项切换键/值来做到这一点-这里:['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
        )
)

简单的东西:

此函数将接受目标$哈希值，$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;       
}