在关联数组中切换两个元素

例子：


$arr = array/

 'apple' => 'sweet',

 'grapefruit' => 'bitter',

 'pear' => 'tasty',

 'banana' => 'yellow'

/;


我想切换葡萄柚的位置 pear, 这样阵列是


$arr = array/

 'apple' => 'sweet',

 'pear' => 'tasty',

 'grapefruit' => 'bitter',

 'banana' => 'yellow'

/


我知道我想要切换的物品的键和价值，有一种简单的方法吗？ 或者这需要一个周期。 + 创建一个新数组？

谢
2021-03-20 添加评论
分享

没有找到相关结果

    已邀请:

    八刀丁二

    赞同来自:

    比解决方案略微较短，困难 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/;
    
?>


    验证并工作正常
    2021-03-20 0 0
    分享

    小明明

    赞同来自:

    这是我的交换功能版本：


    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/;
    
}
    2021-03-20 0 0
    分享

    三叔

    赞同来自:

    如果阵列来自数据库，则添加一个字段 sort_order, 始终自信，在阵列中的订单中。
    2021-03-20 0 0
    分享

    快网

    赞同来自:

    它不确定是提到的，但原因是难的原因是它没有索引。

    让我们来：


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


    获取键：


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


    获取值：


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


    现在你有 2 巨大的，这是数字。 更改要更改位置的人的索引，然后在修改的数字阵列中读回另一个数组。 假设我们想要改变地方 'fruit' 和 'veg':


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


    现在，您可以返回阵列：


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


    现在，您可以构建通过数组的数组 oringal 在 'order' 重新排列的钥匙。


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


    我没有检查一下 - 但这就是我的预期。 它至少有一些帮助吗？ 祝你好运 :/

    你可以把它放在一个函数中
    $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;
    
 }
    
}
    
?>


    WARNING: 请在使用之前测试和调试它 - 根本没有测试。
    2021-03-20 0 0
    分享

    江南孤鹜

    赞同来自:

    根据您的特定使用选项，这可能是或不成为选项，但如果初始化您的数组值 null 在填写其数据之前，使用适当的键，您可以按任何顺序设置值，并且将保存键的源键。 因此，而不是更换项目，您可以防止需要完全替换它们：


    $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
    
/
    2021-03-20 0 0
    分享

    知食

    赞同来自:

    没有简单的方法，只是循环或数组的新定义。
    2021-03-20 0 0
    分享

    君笑尘

    赞同来自:

    经典关联阵列未定义并且不保证元素序列。 为此，有一个简单的数组/向量。 如果您使用的是关联数组，则假设您需要随机访问，但不一致。 对我来说，你使用数组 assoc 对于未创建的任务。
    2021-03-20 0 0
    分享

    喜特乐

    赞同来自:

    是的，我同意Lex如果使用关联数组来存储数据，为什么不使用您的逻辑处理如何处理它们，而不是根据它们在数组中的位置。

    如果您真的想确保它们是正确的顺序，请尝试创建水果对象，然后将它们放在常规阵列中。
    2021-03-20 0 0
    分享

    卫东

    赞同来自:

    没有简单的方法来做。 这听起来像你的小逻辑错误，它导致你试图在有更好的方法做你想做的事情时做到这一点。 你能告诉我们你为什么要这样做吗？

    你这么说
    I know the keys and values of the elements I want to switch

    , 是什么让我觉得你真正想要的 - 这是一种排序功能，因为您可以在您想要的任何时间轻松访问所需的项目。


    $value = $array[$key];


    如果是这样，我会使用
    http://us.php.net/manual/en/function.sort.php
    ,
    http://us.php.net/manual/en/function.ksort.php
    或许多其他排序函数中的一种，以获取您想要的数组。 你甚至可以使用 usort//
    http://us.php.net/manual/en/function.usort.php
    Sort an array by values using a user-defined comparison function

    .

    另外，你可以使用
    http://us.php.net/manual/en/fu ... e.php
    , 如果您需要更改值或键。
    2021-03-20 0 0
    分享

    知食

    赞同来自:

    这是两个解决方案。 第一个更长，但不创建一个临时数组，所以它可以节省内存。 第二个可能更快地工作，但使用更多内存：


    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;
    
}
    2021-03-20 0 0
    分享

    冰洋

    赞同来自:

    有一种简单的方法：


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


    你得到：


    $result = array/
    
 'apple' => 'sweet',
    
 'pear' => 'tasty',
    
 'grapefruit' => 'bitter',
    
 'banana' => 'yellow'
    
/
    2021-03-20 0 0
    分享

    小明明

    赞同来自:

    fwiw 以下是用于更换两个相邻物品以实现实现功能 moveUp// 或者 moveDown// 在一个没有的关联阵列中 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//; 
    
}
    2021-03-20 0 0
    分享

    小明明

    赞同来自: 

    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;
    
}
    2021-03-20 0 0
    分享

    诸葛浮云

    赞同来自:

    我还将分享我的简短版本，它既用数字和关联阵列工作。


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


    返回一个新的数组，更改两个元素。 如果指定了它们，它会保存原始键。 核实 FALSE, 如果找不到键。


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


    例如：


    $arr = array_swap/$arr, 'grapefruit', 'pear'/;
    2021-03-20 0 0
    分享

    涵秋

    赞同来自:

    好吧，这只是一个问题排序键。 为此，我们可以使用
    uksort

    . 他需要一个关键的比较功能，我们只需要知道它必须返回什么 0, 留下钥匙完整的位置，但其他东西 0, 向上或向下移动钥匙。

    请注意，只有您要更改位置的钥匙才能彼此相邻。


    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/;
    2021-03-20 0 0
    分享

    喜特乐

    赞同来自:

    我写了一个更通用的目的，这意味着这个问题。

    数组与着名钥匙

    在第二个阵列中指定键的顺序 /$订单数组的键表示关键位置/

    功能 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 $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 /


    我希望它是相关的 / 对某人有用
    2021-03-20 0 0
    分享

    卫东

    赞同来自:

    PHP中的数组是有序地图。


    $arr = array/'apple'=>'sweet','grapefruit'=>'bitter','
    
pear'=>'tasty','banana'=>'yellow'/;


    这并不意味着第一元素是相等的 'apple'=>'sweet', 最后一个 - 'banana'=>'yellow' 只是因为你放了 'apple' 首先，我。 'banana' 最新的。 实际上， 'apple'=>'sweet' 将是第一个I.
    'banana'=>'yellow' 由于排序升序的字母顺序将是第二个。
    2021-03-20 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    Copyright © 2023, All Rights Reserved