Wie ändern Sie in PHP den Schlüssel eines Array -Elements?

StackOverflow https://stackoverflow.com/questions/240660

  •  04-07-2019
  •  | 
  •  

Frage

Ich habe ein assoziatives Array in der Form key => value Wenn der Schlüssel ein numerischer Wert ist, ist er jedoch kein sequentieller numerischer Wert. Der Schlüssel ist tatsächlich eine ID -Nummer und der Wert ist eine Anzahl. Dies ist für die meisten Fälle in Ordnung, aber ich möchte eine Funktion, die den menschlich-lesbaren Namen des Arrays erhält und diese für den Schlüssel verwendet, ohne den Wert zu ändern.

Ich habe keine Funktion gesehen, die dies tut, aber ich gehe davon aus, dass ich den alten Schlüssel und den neuen Schlüssel (beide ich habe) bereitstellen und das Array transformieren muss. Gibt es eine effiziente Möglichkeit, dies zu tun?

War es hilfreich?

Lösung 

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

Andere Tipps

Die Art und Weise, wie Sie dies tun und die Bestellung des Arrays bewahren würden, besteht darin, die Array -Tasten in ein separates Array einzufügen, den Schlüssel in diesem Array zu finden und zu ersetzen und dann mit den Werten zurück zu kombinieren.

Hier ist eine Funktion, die genau das tut:

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

wenn dein array Erstellt aus einer Datenbankabfrage können Sie den Schlüssel direkt von der ändern mysql Aussage:

Anstatt von

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

Verwenden Sie so etwas wie:

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

Die Antwort von Kernelm ist nett, aber um das von Greg im Kommentar (widersprüchliche Schlüssel) angesprochene Problem zu vermeiden, wäre es sicherer

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

Sie könnten ein zweites assoziatives Array verwenden, das menschliche lesbare Namen in die IDs ordnet. Das würde auch eine viele bis 1 Beziehung bieten. Dann machen Sie so etwas:

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

Wenn Sie möchten, dass auch die Position des Neuarray -Schlüssels mit der alten entspricht, können Sie dies tun:

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

Wenn Ihr Array rekursiv ist, können Sie diese Funktion verwenden: Testen Sie diese Daten:

    $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,
            )
    );

Hier ist die Funktion:

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

$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
];
*/

Ich mag die Lösung von Kernelm, aber ich brauchte etwas, das potenzielle Schlüsselkonflikte bewirken würde (wo ein neuer Schlüssel mit einem vorhandenen Schlüssel übereinstimmt). Hier ist, was ich mir ausgedacht habe:

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

Sie können dann ein Array wie dieses durchlaufen:

$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' )

Hier ist eine Helferfunktion, um dies zu erreichen:

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

hübsch basierend auf @Kernelm Antwort.

Verwendungszweck:

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

Es wird zurückkehren Stimmt bei erfolgreicher Umbenennung, sonst FALSCH.

Einfaches Zeug:

Diese Funktion akzeptiert das Ziel $ Hash und $ ersetzt ist auch ein Hash, der enthält NewKey => OldKey Associations.

Diese Funktion wird Originalbestellung bewahren, könnte aber für sehr große (wie über 10K -Aufzeichnungen) Arrays in Bezug auf sehr große (wie über 10 km) sein Leistung & Speicher.

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

Diese alternative Funktion würde dasselbe tun mit weitaus bessere Leistung & Speicherverbrauch, auf Kosten des Verlusts der ursprünglichen Bestellung (was kein Problem sein sollte, da es Hashtable ist!)

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

Dieser Code hilft, den Oldkey in einen neuen zu wechseln

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

Anzeige wie

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

Dies funktioniert für die Umbenennung des ersten Schlüssels:

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

Dann macht Print_r ($ a) ein repariertes In-Ordnung-Array:

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

Dies funktioniert für die Umbenennung eines willkürlichen Schlüssels:

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

print_r ($ a)

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

Eine verallgemeinerte Funktion:

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

    return array_flip($tmp_A);
}

Wenn Sie mehrere Schlüssel gleichzeitig ersetzen möchten (Erhaltungsreihenfolge):

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

Verwendungszweck:

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

Es gibt eine alternative Möglichkeit, den Schlüssel eines Array -Elements bei der Arbeit mit einem vollständigen Array zu ändern - ohne die Reihenfolge des Arrays zu ändern. Es soll einfach das Array in ein neues Array kopieren.

Zum Beispiel arbeitete ich mit einem gemischten, mehrdimensionalen Array, das indizierte und assoziative Schlüssel enthielt - und ich wollte die Ganzzahltasten durch ihre Werte ersetzen, ohne die Reihenfolge zu brechen.

Ich habe dies getan, indem ich den Schlüssel/Wert für alle numerischen Array -Einträge gewechselt habe - hier: ['0' => 'foo']. Beachten Sie, dass die Bestellung intakt ist.

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

Ausgabe:

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

Sie können diese Funktion basierend auf array_walk verwenden:

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

Es gibt:

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

Hmm, ich bin vorher nicht getestet, aber ich denke, dieser Code funktioniert funktioniert

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

Eine, die bestellt wird, die einfach zu verstehen ist:

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

Der beste Weg ist die Verwendung der Referenz und nicht die Verwendung von Unser (die einen weiteren Schritt zum Reinigen des Speichers ermöglichen)

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

Lösung: 

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

Sie haben ein Original und eine Referenz mit neuem Namen.

Oder wenn Sie nicht zwei Namen in einem Wert haben möchten, ist gut. Machen Sie eine andere Registerkarte und finden Sie auf Referenz

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

Die ITration ist bei Tasten besser als Klon -All -Array und Reinigung des alten Arrays, wenn Sie lange Daten wie 100 Zeilen +++ usw. haben.

Sie können eine einfache Funktion schreiben, die den Rückruf auf die Schlüssel des angegebenen Arrays anwendet. Ähnlich zu Array_Map

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

Hier ist ein Kern https://gist.github.com/vardius/650367e15abfb58bcd72ca47eff096ca#file-array_Map_keys-php.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top