Comment réindexer un tableau en PHP?

voici le meilleur moyen :

# Array
$array = array('tomato', '', 'apple', 'melon', 'cherry', '', '', 'banana');

qui retourne

Array
(
    [0] => tomato
    [1] => 
    [2] => apple
    [3] => melon
    [4] => cherry
    [5] => 
    [6] => 
    [7] => banana
)

en faisant ceci

$array = array_values(array_filter($array));

vous obtenez ce

Array
(
    [0] => tomato
    [1] => apple
    [2] => melon
    [3] => cherry
    [4] => banana
)

explication

array_values() : renvoie numériquement les valeurs du tableau d'entrées et des index.

array_filter() : filtre les éléments d'un tableau avec un fonction définie par l'utilisateur (UDF si aucune n'est fournie , toutes les entrées dans le tableau d'entrée évaluées FALSE seront supprimées .)

pourquoi réindexer? Il suffit d'ajouter 1 à l'index:

foreach ($array as $key => $val) {
    echo $key + 1, '<br>';
}

modifier après que la question a été clarifiée: vous pouvez utiliser le array_values pour réinitialiser l'index à partir de 0. Ensuite, vous pouvez utiliser l'algorithme ci-dessus si vous voulez juste imprimé éléments pour commencer à 1.

je viens de découvrir que vous pouvez aussi faire un

array_splice($ar, 0, 0);

qui fait la ré-indexation inplace, de sorte que vous ne finissez pas avec une copie du tableau original.

Eh bien, je voudrais penser que pour quel que soit votre objectif final est, vous ne seriez pas réellement besoin de modifier le tableau pour être basé sur 1 plutôt que sur 0, mais pourrait au lieu de le gérer au moment de l'itération comme Gumbo posté.

Toutefois , pour répondre à votre question, cette fonction doit convertir tout type de tableau dans un 1-en fonction de la version

function convertToOneBased( $arr )
{
    return array_combine( range( 1, count( $arr ) ), array_values( $arr ) );
}

EDIT

Voici une fonction plus réutilisable / flexible, devrait vous le désirer

$arr = array( 'a', 'b', 'c' );

echo '<pre>';
print_r( reIndexArray( $arr ) );
print_r( reIndexArray( $arr, 1 ) );
print_r( reIndexArray( $arr, 2 ) );
print_r( reIndexArray( $arr, 10 ) );
print_r( reIndexArray( $arr, -10 ) );
echo '</pre>';

function reIndexArray( $arr, $startAt=0 )
{
    return ( 0 == $startAt )
        ? array_values( $arr )
        : array_combine( range( $startAt, count( $arr ) + ( $startAt - 1 ) ), array_values( $arr ) );
}

Cela va faire ce que vous voulez:

<?php

$array = array(2 => 'a', 1 => 'b', 0 => 'c');

array_unshift($array, false); // Add to the start of the array
$array = array_values($array); // Re-number

// Remove the first index so we start at 1
$array = array_slice($array, 1, count($array), true);

print_r($array); // Array ( [1] => a [2] => b [3] => c ) 

?>

une solution plus élégante: "151900920"

vous pouvez reindex un tableau de sorte que le nouveau tableau commence avec un index de 1 comme ceci;

$arr = array(
  '2' => 'red',
  '1' => 'green',
  '0' => 'blue',
);

$arr1 = array_values($arr);   // Reindex the array starting from 0.
array_unshift($arr1, '');     // Prepend a dummy element to the start of the array.
unset($arr1[0]);              // Kill the dummy element.

print_r($arr);
print_r($arr1);

la sortie de La ci-dessus;

Array
(
    [2] => red
    [1] => green
    [0] => blue
)
Array
(
    [1] => red
    [2] => green
    [3] => blue
)

vous pourriez vouloir considérer pourquoi vous voulez utiliser un tableau 1-basé à tous. Les tableaux à base zéro (lorsqu'on utilise des tableaux non associatifs) sont assez standard, et si vous voulez afficher une interface de sortie, la plupart des utilisateurs traiteraient la solution en augmentant simplement l'entier sur la sortie vers L'interface de sortie.

pensez à la cohérence-à la fois dans votre application et dans le code avec lequel vous travaillez-lorsque vous pensez à des indexeurs 1-base pour les tableaux.

similaire à @monowerker, j'avais besoin de reindexer un tableau en utilisant la clé d'un objet...

$new = array();
$old = array(
  (object)array('id' => 123),
  (object)array('id' => 456),
  (object)array('id' => 789),
);
print_r($old);

array_walk($old, function($item, $key, &$reindexed_array) {
  $reindexed_array[$item->id] = $item;
}, &$new);

print_r($new);

résultat:

Array
(
    [0] => stdClass Object
        (
            [id] => 123
        )
    [1] => stdClass Object
        (
            [id] => 456
        )
    [2] => stdClass Object
        (
            [id] => 789
        )
)
Array
(
    [123] => stdClass Object
        (
            [id] => 123
        )
    [456] => stdClass Object
        (
            [id] => 456
        )
    [789] => stdClass Object
        (
            [id] => 789
        )
)

$tmp = array();
foreach (array_values($array) as $key => $value) {
    $tmp[$key+1] = $value;
}
$array = $tmp;

si vous n'essayez pas de réordonner le tableau vous pouvez juste faire:

$ array = array_reverse ($array);

$array = array_reverse ($array);

le array_reverse est très rapide et il se réarrange comme il inverse. Quelqu'un d'autre m'a montré il y a longtemps. Donc je ne peux pas prendre le crédit pour venir avec elle. Mais il est très simple et rapide.

suppression des doublons et réindexer un tableau:

<?php  
   $oldArray = array('0'=>'php','1'=>'java','2'=>'','3'=>'asp','4'=>'','5'=>'mysql');
   //duplicate removal
   $fillteredArray = array_filter($oldArray);
   //reindexing actually happens  here
   $newArray = array_merge($filteredArray);
   print_r($newArray);
?>

tri est juste un sort () , reindexing semble un peu stupide, mais si elle est nécessaire, cela le fera. Mais pas sur place. Utiliser array_walk() si vous faites cela dans un tas d'endroits, il suffit d'utiliser une valeur-clé de la boucle si c'est une opération ponctuelle.

<?php

function reindex(&$item, $key, &$reindexedarr) {
    $reindexedarr[$key+1] = $item;
}

$arr = Array (2 => 'c', 1 => 'b', 0 => 'a');

sort($arr);
$newarr = Array();
array_walk($arr, reindex, &$newarr);
$arr = $newarr;
print_r($arr); // Array ( [1] => a [2] => b [3] => c )

?>

similaire à la contribution de Nick, je suis venu à la même solution pour reindexer un tableau, mais a amélioré la fonction un peu depuis PHP version 5.4, il ne fonctionne pas à cause de passer des variables par référence. Exemple la fonction reindexing est alors comme ceci en utilisant use fermeture de mot clé:

function indexArrayByElement($array, $element)
{
    $arrayReindexed = [];
    array_walk(
        $array,
        function ($item, $key) use (&$arrayReindexed, $element) {
            $arrayReindexed[$item[$element]] = $item;
        }
    );
    return $arrayReindexed;
}

voici ma propre implémentation. Les clés dans le tableau input seront renumérotées avec les clés incrementantes à partir de $start_index.

function array_reindex($array, $start_index)
{
    $array = array_values($array);
    $zeros_array = array_fill(0, $start_index, null);
    return array_slice(array_merge($zeros_array, $array), $start_index, null, true);
}

S'il est correct de faire un nouveau tableau c'est ceci:

$result = array();
foreach ( $array as $key => $val )
    $result[ $key+1 ] = $val;

si vous avez besoin d'une inversion en place, vous devez faire marche arrière pour ne pas piétiner les index dont vous avez besoin:

for ( $k = count($array) ; $k-- > 0 ; )
    $result[ $k+1 ] = $result[ $k ];
unset( $array[0] );   // remove the "zero" element