J'ai fais la vérif j'avais écrasé une seule clé. Oui une tâche cron qui met à jour le fichier, l'idée est bonne mais avec le peu de modifications annuel de ce tableau, je vais le laisser comme tel celui-là.

Merci encore.

Donc en vrai y a pas de problème, juste que tu as fait une erreur une fois. Sinon je redis, à moins que la requête soit gourmande, il n'y pas vraiment d'intérêt à passer par un tableau. Après tu peux toujours stocker ce tableau dans un fichier à part que tu régénères par un code quand tu ajoutes des valeurs à la base de données. Une sorte de fichier de cache.

$tableau=[
  1=>"une valeur",
  2=>"une valeur",
  3=>"une valeur",
  4=>"une valeur",
  5=>"une valeur",
];

<?=$arr[$DonneesBDD['ma colonne qui contient l'id']]?>

La clé est unique, c'est juste moi qui ai pas fait gaffe une fois en ajoutant des clés qui existaient.

Pour retrouver ma valeur, rien de plus simple:

[PHP]$tableau=[
1=>"une valeur",
2=>"une valeur",
3=>"une valeur",
4=>"une valeur",
5=>"une valeur",
];[/PHP]

Je fais un foreach pour lister les valeurs dans un select (dans un form) puis quand l'utilisateur envoi le formulaire, je vérifie si la clé existe et je l'insère dans la BDD.

Pour l'afficher, je prends la clé dans la BDD en faisant [PHP]<?=$arr[$DonneesBDD['ma colonne qui contient l'id']]?>[/PHP]

Le but de ce tableau est d'économiser de la ressource en évitant de faire une requête en allant chercher les données du tableau, dans une base.

Si la requête est rapide pas besoin de s'enquiquiner, fais une requête. Sinon pour le tableau qu'est ce qui t'empêche de faire des sous tableaux de valeurs ?

Sinon j'ai du mal à comprendre la clé numérique qui te sert à retrouver la ligne en base. Si la clé correspond à plusieurs valeurs tu fais comment pour retrouver la bonne valeur du coup ?

En fait j'ai tout simplement créé un tableau pour pas aller chercher les données dans un base de données, à chaque fois que la page se charge, ce tableau est sous la forme de mon exemple dans mon premier post (clé numérique => valeur format string), la clé numérique me servant à retrouver la string correspondante quand j'insère une clé dans la BDD.

Mon problème étant quand je rajoute des nouvelles clé/valeurs (environ une dizaine tous les ans), je dois respecter un ordre alphabétique (car entouré avec des optgroup pour l'insérer dans un select, je dois le faire manuellement, j'aurais pu utiliser une fonction de tri des tableau sinon), du coup pour rajouter une ligne je duplique une ligne et je rentre la nouvelle string, si par malheur j'oublie de modifier la clé avec le dernier ID (clé numérique) utilisée, beh j'écrase les anciennes.

Je fais bien de faire un tableau pour pas aller chercher les données à chaque fois mais c'est peut être pas la meilleure façon de faire ?

$data = [
  1 => [
    "une valeur",
    "une valeur",
    "une valeur",
  ],
  2 => "une valeur",
  3 => "une valeur",
  4 => "une valeur",
  5 => "une valeur",
];

// création du tableau
$keysValues = [
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 2, 'value' => 'une valeur' ],
  [ 'key' => 3, 'value' => 'une valeur' ],
  [ 'key' => 4, 'value' => 'une valeur' ],
  [ 'key' => 5, 'value' => 'une valeur' ],
];
$data = [];
foreach ($keysValues as $keyValue) {
  if (!isset($data[$keyValue['key']]))
    $data[$keyValue['key']] = $keyValue['value'];
  elseif (!is_array($data[$keyValue['key']]))
    $data[$keyValue['key']] = [ $data[$keyValue['key']], $keyValue['value'] ];
  else
    $data[$keyValue['key']][] = $keyValue['value'];
}

$keysValues = [
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 1, 'value' => 'une valeur' ],
  [ 'key' => 2, 'value' => 'une valeur' ],
  [ 'key' => 3, 'value' => 'une valeur' ],
  [ 'key' => 4, 'value' => 'une valeur' ],
  [ 'key' => 5, 'value' => 'une valeur' ],
];

$data = [];
foreach ($keysValues as $keyValue) {
  //if (!isset($data[$keyValue['key']]))
  //  $data[$keyValue['key']] = [];
  $data[$keyValue['key']][] = $keyValue['value'];
}

foreach ($data as $key => $values)
  echo "La clé $key possède " . count($values). " valeur(s) : " . implode(',', $values) . "\n";

En fait un tableau avec plusieurs fois la même clé ça n'existe pas. Que la clé soit numérique ou alphanumérique. C'est comme si t'essayais de mettre plusieurs fois la même clé primaire dans une table sql, c'est pas possible. Si php pète pas une erreur quand il lit le code, au mieux il écrase la valeur par la dernière.

Le tableau il sort de où en fait ? si vraiment t'as besoin de stocker plusieurs valeurs sur un même index, dans ce cas tu peux stocker un tableau de valeurs.
[PHP]
$data = [
1 => [
"une valeur",
"une valeur",
"une valeur",
],
2 => "une valeur",
3 => "une valeur",
4 => "une valeur",
5 => "une valeur",
];

// création du tableau
$keysValues = [
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 2, 'value' => 'une valeur' ],
[ 'key' => 3, 'value' => 'une valeur' ],
[ 'key' => 4, 'value' => 'une valeur' ],
[ 'key' => 5, 'value' => 'une valeur' ],
];
$data = [];
foreach ($keysValues as $keyValue) {
if (!isset($data[$keyValue['key']]))
$data[$keyValue['key']] = $keyValue['value'];
elseif (!is_array($data[$keyValue['key']]))
$data[$keyValue['key']] = [ $data[$keyValue['key']], $keyValue['value'] ];
else
$data[$keyValue['key']][] = $keyValue['value'];
}
[/PHP]


Et c'est qu'un exemple, rien ne t'empêche de stocker un tableau de valeurs à chaque index même s'il n'y en a qu'une, ça peut même simplifier les traitements derrière.
[PHP]$keysValues = [
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 1, 'value' => 'une valeur' ],
[ 'key' => 2, 'value' => 'une valeur' ],
[ 'key' => 3, 'value' => 'une valeur' ],
[ 'key' => 4, 'value' => 'une valeur' ],
[ 'key' => 5, 'value' => 'une valeur' ],
];

$data = [];
foreach ($keysValues as $keyValue) {
//if (!isset($data[$keyValue['key']]))
// $data[$keyValue['key']] = [];
$data[$keyValue['key']][] = $keyValue['value'];
}

foreach ($data as $key => $values)
echo "La clé $key possède " . count($values). " valeur(s) : " . implode(',', $values) . "\n";
[/PHP]

Je peux pas, les clés identiques sont écrasées pendant la compilation à mon avis, pas moyen d'avoir juste les valeurs, sans les clés, sauf avec array_values mais les clés sont quand même écrasées.

Dommage, GO -> vérification visuelle :!:

Merci

Et oui, donc je suis bien embêté, soit je regarde manuellement mes 500 clés environ et voir si il y en a en double, soit je fais un foreach des valeurs, si je peux et en vérifier la clé, si elle existe pas déjà, en la stockant dans un tableau vide qui enregistre les clés passées dans le foreach.

Je vais essayer, je vous tiens au courant.

Salut two3d, c'est le principe du tableau associatif, une clé ne peut être présente qu'une fois, sinon tu ne pourrais pas retrouver l'élément correspondant.

Et il y a deux manières de savoir si la clé existe, c'est la fonction array_key_exists et le isset.

fonctionne pas, j'ai déjà essayé, le retour de mon foreach écrase les entrée en double si il y en a, donc elle trouve rien cette fonction

[quote=two3d post_id=466747 time=1616330349 user_id=18101]
Je ne parviens pas à trouver comment faire pour savoir si la clé 1 existe déjà.[/quote]

https://www.php.net/manual/fr/function.array-key-exists.php

$tableau=[
	1=>"une valeur",
	2=>"une valeur",
	3=>"une valeur",
	4=>"une valeur",
	5=>"une valeur",
];

$tableau=[
	1=>"une valeur",
	2=>"une valeur",
	3=>"une valeur",
	4=>"une valeur",
	5=>"une valeur",
	1=>"une valeur",
	1=>"une valeur",
	1=>"une valeur",
	1=>"une valeur",
];

Voilà mon problème, j'ai un tableau comme celui qui suit (un extrait):

[PHP]
$tableau=[
1=>"une valeur",
2=>"une valeur",
3=>"une valeur",
4=>"une valeur",
5=>"une valeur",
];[/PHP]

Le problème est que j'ai ajouté des clés sans savoir laquelle était la dernière, du coup je me retrouve avec:

[PHP]
$tableau=[
1=>"une valeur",
2=>"une valeur",
3=>"une valeur",
4=>"une valeur",
5=>"une valeur",
1=>"une valeur",
1=>"une valeur",
1=>"une valeur",
1=>"une valeur",
];[/PHP]

Je ne parviens pas à trouver comment faire pour savoir si la clé 1 existe déjà.

J'ai fais un foreach($tableau...) ensuite j'enregistre les clés dans un nouveau tableau pour voir si ensuite il existe déjà dans mon tableau temporaire, mais le problème c'est qu'il prend seulement 1 fois chaque clé (si ya 10 clé avec 1, il le sortira qu'une fois) #-o