Commutateur de deux éléments dans un tableau associatif

Juste un peu plus court et moins complexe que la solution de 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);
?>

Testé et fonctionne très bien

OriginalL'auteur metti

si le tableau provient de la db, ajouter un sort_order le terrain de sorte que vous pouvez toujours être sûr dans quel ordre les éléments dans le tableau.

OriginalL'auteur dazz

Pas entièrement sûr si cela a été mentionné, mais, la raison c'est délicat, parce que c'est non-indexés.

Prenons:

$arrOrig = array(
  'fruit'=>'pear',
  'veg'=>'cucumber',
  'tuber'=>'potato'
);

Obtenir les clés:

$arrKeys = array_keys($arrOrig);
print_r($arrKeys);
Array(
 [0]=>fruit
 [1]=>veg
 [2]=>tuber
)

Obtenir les valeurs:

$arrVals = array_values($arrOrig);
print_r($arrVals);
Array(
  [0]=>pear
  [1]=>cucumber
  [2]=>potato
)

Maintenant vous avez 2 tableaux numériques. Permuter les indices de celles que vous souhaitez changer, puis de lire l'autre tableau dans l'ordre de la modification du tableau numérique. Disons que nous voulons inverser "fruits" et "légumes": les

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

Maintenant, vous pouvez revenir à l'écran initial du tableau:

$arrKeys = array_flip($arrKeysFlipped);
print_r($arrKeys);
Array (
 [0]=>veg
 [1]=>fruit
 [2]=>tuber
)

Maintenant, vous pouvez construire un tableau en passant par la oringal tableau dans l'ordre de la réarrangés clés.

$arrNew = array ();
foreach($arrKeys as $index=>$key) {
  $arrNew[$key] = $arrOrig[$key];
}
print_r($arrNew);
Array (
 [veg]=>cucumber
 [fruit]=>pear
 [tuber]=>potato
)

Je n'ai pas testé mais c'est ce à quoi je m'attends. Est-ce à moins de fournir de l'aide? Bonne chance 🙂

Vous pourriez mettre cela dans une fonction $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;
    }
}
?>

AVERTISSEMENT: s'il vous Plaît tester et déboguer ce avant de l'utiliser - aucun test n'a été fait à tous.

OriginalL'auteur arcaneerudite

ouais je suis d'accord avec Lex, si vous utilisez un tableau associatif pour contenir des données, pourquoi ne pas utiliser votre logique poignée de la façon dont ils sont accessibles au lieu de dépendre de la façon dont ils sont disposés dans le tableau.

Si vous avez vraiment envie de s'assurer qu'ils étaient dans un bon ordre, en essayant de créer des fruits des objets et de les mettre dans un tableau normal.

OriginalL'auteur Bryan Clark

Voici deux solutions. Le premier est plus long, mais ne pas créer un tableau temporaire, de sorte qu'il économise de la mémoire. Le deuxième court sans doute plus rapide, mais utilise plus de mémoire:

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

OriginalL'auteur Matthew

Il existe un moyen simple:

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

et vous obtenez:

$result = array(
'apple'      => 'sweet',
'pear'       => 'tasty',
'grapefruit' => 'bitter',
'banana'     => 'yellow'
)

OriginalL'auteur Eugene Kaurov

Bien c'est juste une clé de tri problème. Nous pouvons utiliser uksort à cette fin. Il a besoin d'une touche de fonction de comparaison et nous avons seulement besoin de savoir qu'il doit retourner 0 pour laisser les clefs de la position intacte et autre chose que 0 pour déplacer touche vers le haut ou vers le bas.

Avis qu'il ne fonctionnera que si vos clés, vous voulez échanger sont les unes à côté des autres.

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

OriginalL'auteur Karol Samborski

J'ai écrit une fonction avec plus d'usage général, avec ce problème à l'esprit.

1. tableau connus avec des touches de
2. spécifier l'ordre de clés dans un second tableau ($afin clés du tableau indiquent la position de la clé)

fonction order_array($array, $ordre) {

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

J'espère que c'est pertinent et utile pour quelqu'un

OriginalL'auteur G4Hu