Przełącz dwa elementy w tablicy asocjacyjnej

Tylko trochę krótsze i mniej skomplikowane niż rozwiązanie Arcaneerudite:

<?php

if(!function_exists('array_swap_assoc')) {

 function array_swap_assoc($key1, $key2, $array) {

 $newArray = array ();

 foreach ($array as $key => $value) {

 if ($key == $key1) {

 $newArray[$key2] = $array[$key2];

 } elseif ($key == $key2) {

 $newArray[$key1] = $array[$key1];

 } else {

 $newArray[$key] = $value;

 }

 }

 return $newArray;

 }

}$array = $arrOrig = array( 'fruit' => 'pear',

 'veg' => 'cucumber',

 'tuber' => 'potato',

 'meat' => 'ham');$newArray = array_swap_assoc('veg', 'tuber', $array);var_dump($array, $newArray);

?>

Przetestowane i działa dobrze

Oto moja wersja funkcji swap:

function array_swap_assoc(&$array,$k1,$k2) {

 if($k1 === $k2) return;// Nothing to do $keys = array_keys($array); 

 $p1 = array_search($k1, $keys);

 if($p1 === FALSE) return;// Sanity check...keys must exist $p2 = array_search($k2, $keys);

 if($p2 === FALSE) return; $keys[$p1] = $k2;// Swap the keys

 $keys[$p2] = $k1; $values = array_values($array);// Swap the values

 list($values[$p1],$values[$p2]) = array($values[$p2],$values[$p1]); $array = array_combine($keys, $values);

}

jeśli tablica pochodzi z bazy danych, dodaj pole sort_order, aby zawsze mieć pewność, w jakiej kolejności elementy znajdują się w tablicy.

Nie jestem pewien, czy został wymieniony, ale jest to trudne, ponieważ nie jest indeksowane.
Weźmy:

$arrOrig = array( 'fruit'=>'pear',

 'veg'=>'cucumber',

 'tuber'=>'potato');

Zdobądź klucze:

$arrKeys = array_keys($arrOrig);

print_r($arrKeys);

Array( [0]=>fruit

 [1]=>veg

 [2]=>tuber)

Pobierz wartości:

$arrVals = array_values($arrOrig);

print_r($arrVals);

Array( [0]=>pear

 [1]=>cucumber

 [2]=>potato)

Teraz masz 2 tablice numeryczne. Zamień indeksy na te, które chcesz zamienić, a następnie przeczytaj drugą tablicę z powrotem w kolejności zmodyfikowanej tablicy liczbowej. Powiedzmy, że chcemy zamienić „owoce” i „warzywa”:

$arrKeysFlipped = array_flip($arrKeys);

print_r($arrKeysFlipped);

Array ( [fruit]=>0

 [veg]=>1

 [tuber]=>2)

$indexFruit = $arrKeysFlipped['fruit'];

$indexVeg = $arrKeysFlipped['veg'];

$arrKeysFlipped['veg'] = $indexFruit;

$arrKeysFlipped['fruit'] = $indexVeg;

print_r($arrKeysFlipped);

Array ( [fruit]=>1

 [veg]=>0

 [tuber]=>2)

Teraz możesz zamienić tablicę z powrotem:

$arrKeys = array_flip($arrKeysFlipped);

print_r($arrKeys);

Array ( [0]=>veg

 [1]=>fruit

 [2]=>tuber)

Możesz teraz zbudować tablicę, przechodząc przez tablicę oringal do „kolejności” przegrupowanych kluczy.

$arrNew = array ();

foreach($arrKeys as $index=>$key) {

 $arrNew[$key] = $arrOrig[$key];

}

print_r($arrNew);

Array ( [veg]=>cucumber

 [fruit]=>pear

 [tuber]=>potato)

Nie testowałem tego - ale tego się spodziewałem. Czy to pomaga? Powodzenia :)
Możesz umieścić to w funkcji

$ arrNew = array_swap_assoc ($ key1, $ key2, $ arrOld);

<?php

if(!function_exists('array_swap_assoc')) {

 function array_swap_assoc($key1='',$key2='',$arrOld=array()) {

 $arrNew = array ();

 if(is_array($arrOld) && count($arrOld) > 0) {

 $arrKeys = array_keys($arrOld);

 $arrFlip = array_flip($arrKeys);

 $indexA = $arrFlip[$key1];

 $indexB = $arrFlip[$key2];

 $arrFlip[$key1]=$indexB;

 $arrFlip[$key2]=$indexA;

 $arrKeys = array_flip($arrFlip);

 foreach($arrKeys as $index=>$key) {

 $arrNew[$key] = $arrOld[$key];

 }

 } else {

 $arrNew = $arrOld;

 }

 return $arrNew;

 }

}

?>

OSTRZEŻENIE: proszę przetestować i zdebugować to przed samym użyciem - żadne testy nie zostały w ogóle wykonane.

Może to być opcja lub nie, w zależności od konkretnego przypadku użycia, ale jeśli zainicjujesz swoją tablicę do wartości null za pomocą odpowiednich kluczy przed wypełnieniem jej danymi, możesz ustawić wartości w dowolnej kolejności i oryginalny klucz porządek zostanie zachowany. Tym samym zamiast wymieniać elementy można uniknąć konieczności ich całkowitej wymiany:

$arr = array('apple' => null,

 'pear' => null,

 'grapefruit' => null,

 'banana' => null);

...

$arr['apple'] = 'sweet';

$arr['grapefruit'] = 'bitter';// set grapefruit before setting pear

$arr['pear'] = 'tasty';

$arr['banana'] = 'yellow';

print_r($arr);>>> Array

( [apple] => sweet

 [pear] => tasty

 [grapefruit] => bitter

 [banana] => yellow)

Nie ma prostego sposobu, wystarczy pętla lub nowa definicja tablicy.

Klasyczna tablica asocjacyjna w żaden sposób nie definiuje ani nie gwarantuje kolejności elementów. Do tego celu służy prosta tablica/wektor. Jeśli używasz tablicy asocjacyjnej, zakłada się, że chcesz uzyskać dostęp losowy, ale nie sekwencyjny. W moim przypadku używasz tablicy assoc do zadania, dla którego nie została utworzona.

tak, zgadzam się z Lexem, jeśli używasz tablicy asocjacyjnej do przechowywania danych, dlaczego nie użyć swojej logiki do obsługi dostępu do nich, a nie w zależności od tego, jak znajduje się w tablicy.
Jeśli naprawdę chcesz się upewnić, że są we właściwej kolejności, spróbuj utworzyć obiekty z owocami, a następnie umieść je w zwykłej tablicy.

Nie ma na to łatwego sposobu. Brzmi to jak mały błąd logiczny z Twojej strony, który skłonił Cię do podjęcia próby zrobienia tego, gdy istnieje lepszy sposób na zrobienie tego, co chcesz. Czy możesz nam powiedzieć, dlaczego chcesz to zrobić?
Mówisz, że

znam klucze i wartości elementów, które chcę zmienić

, co sprawia, że ​​myślę, że to, czego naprawdę chcesz, to funkcja sortowania, ponieważ w każdej chwili możesz łatwo uzyskać dostęp do elementów, które chcesz chcesz, tak jak oni.

$value = $array[$key];

Jeśli tak, to użyłbym

sort()
http://us.php.net/manual/en/function.sort.php
,

ksort()
http://us.php.net/manual/en/function.ksort.php
lub jedną z wielu innych funkcji sortowania, aby uzyskać tablicę tak, jak chcesz. Możesz nawet użyć usort ()

-
http://us.php.net/manual/en/function.usort.php

Sort an array by values using a user-defined comparison function

.
Alternatywnie możesz użyć

array_replace()
http://us.php.net/manual/en/fu ... e.php
jeśli kiedykolwiek będziesz musiał zamienić wartości lub klucze.

Oto dwa rozwiązania. Pierwsza jest dłuższa, ale nie tworzy tymczasowej tablicy, więc oszczędza pamięć. Drugi jest prawdopodobnie szybszy, ale zużywa więcej pamięci:

function swap1(array &$a, $key1, $key2)

{

 if (!array_key_exists($key1, $a) || !array_key_exists($key2, $a) || $key1 == $key2) return false; $after = array();

 while (list($key, $val) = each($a))

 {

 if ($key1 == $key)

 {

 break;

 }

 else if ($key2 == $key)

 {

 $tmp = $key1;

 $key1 = $key2;

 $key2 = $tmp;

 break;

 }

 } $val1 = $a[$key1];

 $val2 = $a[$key2]; while (list($key, $val) = each($a))

 {

 if ($key == $key2)

 $after[$key1] = $val1;

 else

 $after[$key] = $val;

 unset($a[$key]);

 } unset($a[$key1]);

 $a[$key2] = $val2; while (list($key, $val) = each($after))

 {

 $a[$key] = $val;

 unset($after[$key]);

 } return true;

}function swap2(array &$a, $key1, $key2)

{ 

 if (!array_key_exists($key1, $a) || !array_key_exists($key2, $a) || $key1 == $key2) return false; $swapped = array(); foreach ($a as $key => $val)

 {

 if ($key == $key1)

 $swapped[$key2] = $a[$key2];

 else if ($key == $key2)

 $swapped[$key1] = $a[$key1];

 else

 $swapped[$key] = $val;

 } $a = $swapped; return true;

}

Jest na to prosty sposób:

$sourceArray = array( 'apple' => 'sweet',

 'grapefruit' => 'bitter',

 'pear' => 'tasty',

 'banana' => 'yellow');

// set new order

$orderArray = array( 'apple' => '',//this values would be replaced

 'pear' => '',

 'grapefruit' => '',

//it is not necessary to touch all elemets that will remains the same);

$result = array_replace($orderArray, $sourceArray);

print_r($result);

i otrzymujesz:

$result = array( 'apple' => 'sweet',

 'pear' => 'tasty',

 'grapefruit' => 'bitter',

 'banana' => 'yellow')

fwiw jest tutaj funkcją do zamiany dwóch sąsiednich elementów w celu zaimplementowania moveUp () lub moveDown () na tablicy asocjacyjnej bez foreach ()

/**

 * @param array $array to modify

 * @param string $key key to move

 * @param int $direction +1 for down | -1 for up

 * @return $array

 */

protected function moveInArray($array, $key, $direction = 1)

{

 if (empty($array)) {

 return $array;

 }

 $keys = array_keys($array);

 $index = array_search($key, $keys);

 if ($index === false) {

 return $array;// not found

 } 

 if ($direction < 0) {

 $index--;

 }

 if ($index < 0 || $index >= count($array) - 1) {

 return $array;// at the edge: cannot move

 }  $a = $keys[$index];

 $b = $keys[$index + 1];

 $result = array_slice($array, 0, $index, true);

 $result[$b] = $array[$b];

 $result[$a] = $array[$a];

 return array_merge($result, array_slice($array, $index + 2, null, true)); 

}

function arr_swap_keys(array &$arr, $key1, $key2, $f_swap_vals=false) {

// if f_swap_vals is false, then

// swap only the keys, keeping the original values in their original place

// ( i.e. do not preserve the key value correspondence )

// i.e. if arr is (originally)

// [ 'dog' => 'alpha', 'cat' => 'beta', 'horse' => 'gamma' ]

// then calling this on arr with, e.g. key1 = 'cat', and key2 = 'horse'

// will result in arr becoming: 

// [ 'dog' => 'alpha', 'horse' => 'beta', 'cat' => 'gamma' ]

// 

// if f_swap_vals is true, then preserve the key value correspondence

// i.e. in the above example, arr will become:

// [ 'dog' => 'alpha', 'horse' => 'gamma', 'cat' => 'beta' ]

// 

//  $arr_vals = array_values($arr);// is a (numerical) index to value mapping

 $arr_keys = array_keys($arr);// is a (numerical) index to key mapping

 $arr_key2idx = array_flip($arr_keys);

 $idx1 = $arr_key2idx[$key1];

 $idx2 = $arr_key2idx[$key2];

 swap($arr_keys[$idx1], $arr_keys[$idx2]);

 if ( $f_swap_vals ) {

 swap($arr_vals[$idx1], $arr_vals[$idx2]);

 }

 $arr = array_combine($arr_keys, $arr_vals);

}function swap(&$a, &$b) {

 $t = $a;

 $a = $b;

 $b = $t;

}

Podzielę się również moją krótką wersją, działa zarówno z tablicami numerycznymi, jak i asocjacyjnymi.

array array_swap ( array $array , mixed $key1 , mixed $key2 [, bool $preserve_keys = FALSE [, bool $strict = FALSE ]] )

Zwraca nową tablicę ze zmienionymi dwoma elementami. Zachowuje oryginalne klucze, jeśli są dostępne. Zwróć FALSE, jeśli nie znaleziono żadnych kluczy.

function array_swap(array $array, $key1, $key2, $preserve_keys = false, $strict = false) {

 $keys = array_keys($array);

 if(!array_key_exists($key1, $array) || !array_key_exists($key2, $array)) return false;

 if(($index1 = array_search($key1, $keys, $strict)) === false) return false;

 if(($index2 = array_search($key2, $keys, $strict)) === false) return false;

 if(!$preserve_keys) list($keys[$index1], $keys[$index2]) = array($key2, $key1);

 list($array[$key1], $array[$key2]) = array($array[$key2], $array[$key1]);

 return array_combine($keys, array_values($array));

}

Na przykład:

$arr = array_swap($arr, 'grapefruit', 'pear');

Cóż, to tylko kluczowy problem z sortowaniem. W tym celu możemy użyć

uksort

. Potrzebuje funkcji porównania klucza i musimy tylko wiedzieć, że powinien zwrócić 0, aby pozostawić pozycję kluczową nienaruszoną, i coś innego niż 0, aby przesunąć klucz w górę lub w dół.
Zauważ, że zadziała to tylko wtedy, gdy klucze, które chcesz zamienić, znajdują się obok siebie.

<?php$arr = array( 'apple' => 'sweet',

 'grapefruit' => 'bitter',

 'pear' => 'tasty',

 'banana' => 'yellow');uksort( $arr,

 function ($k1, $k2) {

 if ($k1 == 'grapefruit' && $k2 == 'pear') return 1;

 else return 0;

 });var_dump($arr);

Z myślą o tym problemie napisałem bardziej ogólną funkcję.

• tablica ze znanymi kluczami
• określić kolejność kluczy w drugiej tablicy (klucze w tablicy $ order wskazują położenie klucza)

function order_array ($ array, $ order) {

foreach (array_keys($array) as $k => $v) {

 $keys[++$k] = $v;

 }

 for ($i = 1; $i <= count($array); $i++) {

 if (isset($order[$i])) {

 unset($keys[array_search($order[$i], $keys)]);

 }

 if ($i === count($array)) {

 array_push($keys, $order[$i]);

 } else {

 array_splice($keys, $i-1, 0, $order[$i]);

 }

 }

 }

 foreach ($keys as $key) {

 $result[$key] = $array[$key];

 }

 return $resu<

 } else {

 return false;

 }

}$order = array(1 => 'item3', 2 => 'item5');

$array = array("item1" => 'val1', "item2" => 'val2', "item3" => 'val3', "item4" => 'val4', "item5" => 'val5');print_r($array); -> Array ( [item1] => val1 [item2] => val2 [item3] => val3 [item4] => val4 [item5] => val5 ) print_r(order_array($array, $order)); -> Array ( [item3] => val3 [item5] => val5 [item1] => val1 [item2] => val2 [item4] => val4 )

Mam nadzieję, że jest to dla kogoś istotne/pomocne

Tablice w php to uporządkowane mapy.

$arr = array('apple'=>'sweet','grapefruit'=>'bitter','

pear'=>'tasty','banana'=>'yellow');

nie oznacza to, że pierwszy element to „jabłko” = & > „słodki”, a ostatni to „banan” = & > „żółty” tylko dlatego, że słowo „jabłko” zostało umieszczone na pierwszym miejscu, a „banan” na końcu. Właściwie „jabłko” = & > „słodki” będzie pierwszym i
„banan” = & > „żółty” będzie na drugim miejscu ze względu na rosnącą kolejność alfabetyczną.