web-dev-qa-db-fra.com

Comment réindexer un tableau en PHP?

J'ai le tableau suivant, que je voudrais réindexer afin que les clés soient inversées (idéalement à partir de 1):

Tableau actuel ( edit: le tableau ressemble en réalité à ceci):

Array (

[2] => Object
    (
        [title] => Section
        [linked] => 1
    )

[1] => Object
    (
        [title] => Sub-Section
        [linked] => 1
    )

[0] => Object
    (
        [title] => Sub-Sub-Section
        [linked] => 
    )

)

Comment ça devrait être:

Array (

[1] => Object
    (
        [title] => Section
        [linked] => 1
    )

[2] => Object
    (
        [title] => Sub-Section
        [linked] => 1
    )

[3] => Object
    (
        [title] => Sub-Sub-Section
        [linked] => 
    )

)
phparraysindexing
127
meleyal

Si vous souhaitez réindexer à partir de zéro, procédez comme suit:

$iZero = array_values($arr);

Si vous en avez besoin pour commencer à un, utilisez les éléments suivants:

$iOne = array_combine(range(1, count($arr)), array_values($arr));

Voici les pages de manuel pour les fonctions utilisées:

375
Andrew Moore

Voici le meilleur moyen :

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

qui revient

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

en faisant cela

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

vous obtenez ceci

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

Explication

array_values(): renvoie les valeurs du tableau en entrée et les indexes numériquement.

array_filter(): Filtre les éléments d'un tableau avec une fonction définie par l'utilisateur (UDF Si aucun n'est fourni , toutes les entrées de la table d'entrée valeur FALSE seront supprimées .)

51
Sandra

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

array_splice($ar, 0, 0);

Cela fait la réindexation en place, ainsi vous ne vous retrouvez pas avec une copie du tableau original.

8
imagiro

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

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

Éditer Une fois la question clarifiée: vous pouvez utiliser le array_values pour réinitialiser l'index à partir de 0. Vous pouvez également utiliser l'algorithme ci-dessus si vous souhaitez que les éléments imprimés commencent à 1.

8
Gumbo

Eh bien, j'aimerais penser que, quel que soit votre objectif final, vous n'auriez pas besoin de modifier le tableau pour qu'il soit basé sur 1 plutôt que sur 0, mais que vous puissiez le gérer au moment de l'itération, comme Gumbo posté.

Cependant , pour répondre à votre question, cette fonction devrait convertir n'importe quel tableau en version à 1

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

MODIFIER

Voici une fonction plus réutilisable/flexible, si vous le désirez

$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 ) );
}
6
Peter Bailey

Vous pouvez réindexer un tableau pour que le nouveau tableau commence par 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 ce qui précède est;

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

Cela fera 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 ) 

?>
5
Greg

Une solution plus élégante: 

$list = array_combine(range(1, count($list)), array_values($list));

5
Ionuţ Pleşca

Semblable à @monowerker, j'avais besoin de réindexer 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);

Cela a abouti à:

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
        )
)
4
Nick

Vous voudrez peut-être réfléchir à la raison pour laquelle vous souhaitez utiliser un tableau basé sur 1. Les tableaux basés sur zéro (lorsque vous utilisez des tableaux non associatifs) sont assez classiques, et si vous souhaitez générer une sortie vers une interface utilisateur, la plupart des utilisateurs géreraient la solution en augmentant simplement l'entier lors de la sortie vers l'interface utilisateur.

Pensez à la cohérence, à la fois dans votre application et dans le code avec lequel vous travaillez, lorsque vous songez aux indexeurs basés sur 1 pour les tableaux.

4
Michael Trausch

Si vous n'essayez pas de réorganiser le tableau, vous pouvez simplement faire:

$ array = array_reverse ($ array);
$ array = array_reverse ($ array);

Array_reverse est très rapide et se réorganise au fur et à mesure qu'il inverse. Quelqu'un m'a montré cela il y a longtemps. Donc, je ne peux pas prendre le crédit pour l'avoir proposé. Mais c'est très simple et rapide.

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

suppression des doublons et réindexation d'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);
?>
2
Sam T

Voici ma propre implémentation. Les clés du tableau en entrée seront renumérotées avec des clés incrémentées à 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);
}
1
Mustapha Hadid

Le tri est juste un sort () , la réindexation semble un peu bête, mais si nécessaire, cela le fera. Bien que pas en place. Utilisez array_walk () si vous voulez faire cela dans un tas d'endroits, utilisez simplement une boucle for-key-value s'il s'agit d'une opération unique.

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

?>
1
monowerker

Semblable à la contribution de Nick, je suis arrivé à la même solution pour réindexer un tableau, mais en améliorant un peu la fonction car depuis la version 5.4 de PHP, cela ne fonctionnait pas, car les variables étaient passées par référence. Voici un exemple de fonction de réindexation utilisant la clé use:

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

Faites simplement ceci:

<?php

array_Push($array, '');
$array = array_reverse($array);
array_shift($array);
0
Roham Rafii

Vous pouvez facilement le faire après avoir utilisé les fonctions array_values ​​() et array_filter () ensemble pour supprimer les éléments de tableau vides et les réindexer d'un tableau en PHP.

Fonction array_filter () La fonction PHP array_filter () supprime les éléments ou valeurs de tableau vides d'un tableau en PHP. Cela supprimera également les valeurs vides, nulles, fausses et nulles (zéro).

Fonction array_values ​​() La fonction PHP array_values ​​() renvoie un tableau contenant toutes les valeurs d'un tableau. Le tableau retourné aura des clés numériques, commençant à 0 et augmentant de 1.

Supprimer les éléments de tableau vides et réindexer

Voyons d’abord la sortie du tableau $ stack:

<?php
  $stack = array("PHP", "HTML", "CSS", "", "JavaScript", null, 0);
  print_r($stack);
?>

Sortie:

Array
(
    [0] => PHP
    [1] => HTML
    [2] => CSS
    [3] => 
    [4] => JavaScript
    [5] => 
    [6] => 0
)

Dans la sortie ci-dessus, nous souhaitons supprimer les valeurs vides, nulles, nuls (0), puis réindexer les éléments du tableau. Nous allons maintenant utiliser les fonctions array_values ​​() et array_filter () comme dans l'exemple ci-dessous:

<?php
  $stack = array("PHP", "HTML", "CSS", "", "JavaScript", null, 0);
  print_r(array_values(array_filter($stack)));
?>

Sortie:

Array
(
    [0] => PHP
    [1] => HTML
    [2] => CSS
    [3] => JavaScript
)
0
Star