Quelle est une meilleure façon de remplacer les ID dans un tableau avec leur valeur contrepartie?

Question

I ont le tableau ci-dessous qui comprend id:

[Key1] => 1 
[Key2] => 2, 3 

Je souhaite remplacer ces identificateurs par leur nom respectif à partir de ce second réseau:

[0] => Array 
    (
     [ID] => 1 
     [Name] => Name1 
    ) 

[1] => Array 
    (
     [ID] => 2 
     [Name] => Name2 
    ) 

[2] => Array 
    (
     [ID] => 3 
     [Name] => Name3 

La sortie souhaitée:

[Key1] => Name1 
[Key2] => Name2, Name3 

J'ai le code suivant qui fonctionne mais je sais que ce n'est pas la bonne façon. Si quelqu'un pouvait me dire quel serait le meilleur moyen d'y parvenir, ce serait grandement apprécié.

Qu'est-ce que mon code ressemble:

$var1 = explode(", ", $array1["Key1"]); // No need to explode in this example but "Key1" sometimes includes more than 1 ID 
$var2 = explode(", ", $array1["Key2"]); 

$array1["Key1"] = $var1 ; // This row is for the new array generated from "explode" to be a sub-array 
$array1["Key2"] = $var2 ; // Same 

for ($i = 0; $i < 83; $i++){ 
    if($array1["Key1"][0] == $array2[$i]["ID"]){ 
     $array1["Key1"][0] = $array2[$i]["Name"]; 
    } 
    if($array1["Key1"][1] == $array2[$i]["ID"]){ 
     $array1["Key1"][1] = $array2[$i]["Name"]; 
    } 
// (etc) 
    if($array1["Key2"][0] == $array2[$i]["ID"]){ 
     $array1["Key2"][0] = $array2[$i]["Name"]; 
    } 
    if($array1["Key2"][1] == $array2[$i]["ID"]){ 
     $array1["Key2"][1] = $array2[$i]["Name"]; 
    } 
// (etc) 

} 

$var1 = implode(", ", $array1["Key1"]); 
$var2 = implode(", ", $array1["Key2"]); 

$array1["Key1"] = $var1 ; 
$array1["Key2"] = $var2 ; 

Answer 1

extrayez la ID et Name en une seule dimension et l'utiliser comme paramètres de recherche et de remplacer. Nous devons modifier les ID s de rechercher et de les transformer en un modèle /\b$v\b/ où \b est une limite de mot, de sorte que 1 ne remplacera pas le 1 à 164 par exemple:

$replace = array_column($array2, 'Name', 'ID'); 
$search = array_map(function($v) { return "/\b$v\b/"; }, array_keys($replace)); 

$array1 = preg_replace($search, $replace, $array1); 

Answer 2

Vous devez nicher quelques boucles. Voici un sample qui devrait fonctionner:

//Processing Array 
$arrayOne = array(
    "Key1" => "1", 
    "Key2" => "2, 3"); 

//Lookup Array 
$arrayTwo = array(
    array(
     "ID" => "1", 
     "Name" => "Name1"), 
    array(
     "ID" => "2", 
     "Name" => "Name2"), 
    array(
     "ID" => "3", 
     "Name" => "Name3")); 

var_dump($arrayOne); 

//Loop through all values in our original array 
foreach($arrayOne as &$arrValue) { 
    //Split the value in the original array into another temporary array 
    //if there are multiple values. 
    $valueArray = explode(", ", $arrValue); 
    $outputArray = array(); 
    foreach($valueArray as &$myValue) { 
     //Now do a lookup to replace each value 
     foreach($arrayTwo as &$lookupValue) { 
      //Find a match 
      if($myValue==$lookupValue["ID"]) { 
       $myValue = $lookupValue["Name"]; 
       //We found the value we want, so let's break out of this loop 
       break; 
      } 
     } 
     //Append the value 
     array_push($outputArray, $myValue); 
    } 
    //Convert back to string 
    $arrValue= implode(", ", $outputArray); 
} 

var_dump($arrayOne); 

Il y a des améliorations que vous pourriez faire à ce code si vos données entrant a toujours été triée, mais je suppose que c'est juste le cas pour votre exemple ci-dessus.

Answer 3

J'ai une approche pour le faire. Vous pouvez essayer si vous souhaitez voir ici: - https://eval.in/839823. J'utilise array_column pour mapper la paire clé => valeur puis simple foreach utilisé.

<?php 
$main = ['Key1' => 1,'Key2' => '2, 3']; 

$match = [ 
    [ 
     'ID' => 1, 
     'Name' => 'Name1' 
    ], 

    [ 
     'ID' => 2, 
     'Name' => 'Name2' 
    ], 
    [ 
     'ID' => 3, 
     'Name' => 'Name3' 
    ] 
]; 

$final_array=[]; 
$mapped = array_column($match, 'Name', 'ID'); 
foreach($main as $k=>$v){ 
    $r = explode(',',$v); 
    if(count($r)>1){ 
     $final_array[$k] = $mapped[$r[0]]. ", ".$mapped[intval($r[1])]; 
    }else{ 
     $final_array[$k] = $mapped[$r[0]]; 
    } 
}  
print '<pre>'; 
//print_r($mapped); 
print_r($final_array); 
print '</pre>'; 

Sortie:

Array 
(
    [Key1] => Name1 
    [Key2] => Name2,Name3 
) 

Modifier: Comme par commentaire de Josh Maag,

Mon code ne fonctionnera que s'il ne dispose que d'un maximum de 2 valeurs Key2. Si Key3 contient "4, 5, 6" ce code laissera les 6 intacts.

<?php 


$main = ['Key1' => 1,'Key2' => '2,3','Key3' => '4,5,6']; 

    $match = [ 
     [ 
      'ID' => 1, 
      'Name' => 'Name1' 
     ], 

     [ 
      'ID' => 2, 
      'Name' => 'Name2' 
     ], 
     [ 
      'ID' => 3, 
      'Name' => 'Name3' 
     ], 
     [ 
      'ID' => 4, 
      'Name' => 'Name4' 
     ], 
     [ 
      'ID' => 5, 
      'Name' => 'Name5' 
     ], 
     [ 
      'ID' => 6, 
      'Name' => 'Name6' 
     ] 
    ]; 

    $final_array=[]; 
    $mapped = array_column($match, 'Name', 'ID'); 
    foreach($main as $k=>$v){ 
     $r = explode(',',$v); 
     if(count($r)>1){ 
      $final_array[$k] = implode(',',array_map(function($key) use ($mapped){ return $mapped[$key]; }, array_values($r))); 
     }else{ 
      $final_array[$k] = $mapped[$r[0]]; 
     } 
    }  

    print '<pre>'; 
    print_r($mapped); 
    print_r($final_array); 
    print '</pre>'; 
    ?> 

Voir la démo Voir ici https://eval.in/839939

Answer 4

La fonction de base qui devrait être utilisé pour cette tâche est preg_replace_callback(). Pourquoi? Parce qu'il est uniquement qualifié pour gérer cette opération dans un appel de fonction unique. Il semble tragique de ne pas utiliser les fonctions php à des fins spécifiques. Au-delà de preg_replace_callback(), seul array_column() est nécessaire pour préparer les données $array2 en tant que tableau de recherche simple.

code: (Demo)

$array1=["Key1"=>"1","Key2"=>"22, 4, 123"]; 
$array2=[["ID"=>"1","Name"=>"Name1"],["ID"=>"22","Name"=>"Name22"],["ID"=>"123","Name"=>"Name123"]]; 
$lookup=array_column($array2,'Name','ID'); // generate array: keys = IDs, vals = Names 

$result=preg_replace_callback('/\d+/',function($m)use($lookup){return isset($lookup[$m[0]])?$lookup[$m[0]]:"*{$m[0]}*";},$array1); 
var_export($result); 

Sortie:

array (
    'Key1' => 'Name1', 
    'Key2' => 'Name22, **4**, Name123', 
) 

Il n'y a pas besoin d'exécuter des préparations (à l'exclusion $lookup) à l'aide de boucles supplémentaires ou des appels de fonction.

Ce modèle correspondra à tous les numéros ID complets de chaque élément de $array1 et les traitera individuellement. Chaque correspondance numérique est envoyée à la fonction de rappel anonyme pour recevoir sa chaîne de remplacement personnalisée - fournie par les données $lookup.

En contrepartie, j'ai inclus un remplacement avec un astérisque lorsqu'un ID n'est pas trouvé dans $lookup.