Comment utiliser array_fill_keys pour gérer les tableaux vides

Pourquoi le tableau vide cause-t-il des problèmes?

Supposons que nous écrivons une fonction qui prévoit de générer un tableau de valeurs par défaut pour une utilisation ultérieure en fonction de la liste des clés fournies par l'utilisateur:

 function initDefaults(array $keys, $defaultValue) {
    return array_fill_keys($keys, $defaultValue);
}

Lorsque $ touches est vide, la fonction renvoie un tableau vide. Si la logique suivante du code ne gère pas spécifiquement les tableaux vides, les problèmes suivants peuvent être causés:

• Traversal a échoué : le corps de la boucle n'est pas exécuté, affectant la logique métier;

• Données manquantes : les paires de valeurs de clé par défaut attendues ne sont pas générées;

• Exception du programme : par exemple, une erreur d'index non définie s'est produite lors de l'accès aux éléments du tableau.

Comment éviter efficacement les problèmes causés par des tableaux vides?

1. Répanes vides prédéaccorales

Avant d'appeler Array_Fill_keys , déterminez d'abord si le tableau des clés est vide:

 $keys = getKeysFromUser(); // Peut renvoyer un tableau vide

if (empty($keys)) {
    // Selon les besoins de l'entreprise，Sélectionnez un plan de traitement：
    // 1) Renvoie un tableau de clés par défaut
    // 2) Lancer une invite d'exception
    // 3) Renvoie un tableau vide directement et est compatible dans la logique de traitement ultérieure

    $keys = ['defaultKey']; // Utilisez une clé par défaut ici
}

$array = array_fill_keys($keys, 0);

Cette méthode peut garantir que $ array contient au moins un élément, en évitant les erreurs pendant l'accès ultérieur.

2. Définissez la liste des clés par défaut

Si l'entreprise le permet, un ensemble fixe de clés par défaut peut être défini comme une alternative:

 function safeFillKeys(array $keys, $defaultValue, array $defaultKeys = ['default']) {
    if (empty($keys)) {
        $keys = $defaultKeys;
    }
    return array_fill_keys($keys, $defaultValue);
}

Lorsqu'on appelle:

 $result = safeFillKeys([], 0, ['key1', 'key2']);
print_r($result);

De cette façon, même si un tableau vide est passé, une structure par défaut raisonnable peut être renvoyée.

3. Utiliser la stratégie de fusion

La combinaison du tableau de clés passé et du tableau de clés par défaut garantit que le tableau final n'est pas vide:

 $keys = array_unique(array_merge($keys, ['fallbackKey']));
$array = array_fill_keys($keys, null);

Array_Unique garantit que la clé ne sera pas répétée, Array_merge ajoute la clé par défaut. Cela évite la situation vide du tableau.

4. Compatible avec les tableaux vides dans la logique des affaires

Si vous ne pouvez pas contrôler le synchronisation des appels de Array_Fill_Keys , vous pouvez ajouter un jugement lorsque vous utilisez le résultat:

 $array = array_fill_keys($keys, 0);

if (empty($array)) {
    // Traitement spécial，Par exemple, initialisez la valeur par défaut
    $array = ['default' => 0];
}

// Continuez à un traitement de suivi

Résumer

array_fill_keys est une fonction concise et efficace, mais lorsque le tableau de clé d'entrée est vide, le comportement de renvoi d'un tableau vide peut entraîner des dangers cachés pour le programme. Les précautions raisonnables comprennent:

• Déterminer si le tableau d'entrée est vide à l'avance;

• Définir la valeur de clé par défaut définie;

• Fusionner le tableau des clés passés avec le tableau de clé par défaut;

• Compatible avec les situations de tableau vides dans la logique des affaires.

Cela peut garantir la robustesse et la stabilité du programme et éviter les vulnérabilités logiques ou les erreurs causées par des tableaux vides.

 // Exemple de code：Usage sûr array_fill_keys
function safeArrayFillKeys(array $keys, $value, array $defaultKeys = ['default']) {
    if (empty($keys)) {
        $keys = $defaultKeys;
    }
    return array_fill_keys($keys, $value);
}

$keys = []; // Probablement vide
$result = safeArrayFillKeys($keys, 0);
print_r($result);