Règle
Éviter involontaire globale variable caching.In Node.js
et Python serveurs, variables variables persistent à travers
requêtes, ce qui fait que les données fuites et conditions de course.

Langages pris en charge : JavaScript, TypeScript, Python

Introduction

Les variables globales dans les serveurs Node.js persistent pendant toute la durée de vie du processus, et pas seulement pour une seule requête. Lorsque les gestionnaires de requêtes stockent des données utilisateur dans des variables globales, ces données restent accessibles aux requêtes ultérieures émanant d'utilisateurs différents. Cela crée des failles de sécurité lorsque les données de session, les jetons d'authentification ou les informations personnelles de l'utilisateur A sont divulguées à l'utilisateur B.

Pourquoi c'est important

Implications en matière de sécurité (fuites de données) : Les variables globales qui mettent en cache des données spécifiques à l'utilisateur créent des fuites de données entre les requêtes. L'état d'authentification, les données de session ou les informations personnelles d'un utilisateur deviennent visibles pour les autres utilisateurs, ce qui constitue une violation de la vie privée et des limites de sécurité.

Conditions de course : Lorsque plusieurs requêtes concurrentes modifient la même variable globale, le risque d'un comportement imprévisible est élevé. Les données de l'utilisateur A peuvent être écrasées par la requête de l'utilisateur B en cours de traitement, ce qui entraîne des calculs incorrects, un état corrompu ou des utilisateurs qui voient les données de l'autre.

Complexité du débogage : les problèmes causés par la mise en cache de variables globales sont notoirement difficiles à reproduire parce qu'ils dépendent de la synchronisation des requêtes et de la concurrence. Les bogues apparaissent par intermittence en production sous charge, mais se manifestent rarement dans les tests de développement à un seul fil.

Fuites de mémoire : Les variables globales qui accumulent des données sans être nettoyées croissent sans limite au fil du temps. Chaque requête ajoute davantage de données aux caches ou aux tableaux globaux, ce qui finit par épuiser la mémoire du serveur et nécessite le redémarrage du processus.

Exemples de code

❌ Non conforme :

let currentUser = null;
let requestData = {};

app.get('/profile', async (req, res) => {
    currentUser = await getUserById(req.userId);
    requestData = req.body;

    const profile = await buildUserProfile(currentUser);
    res.json(profile);
});

function buildUserProfile(user) {
    return {
        name: currentUser.name,
        data: requestData
    };
}

Pourquoi ce n'est pas correct : Les variables globales currentUser et requestData persistent à travers les requêtes. Lorsque plusieurs requêtes s'exécutent simultanément, la requête de l'utilisateur B peut écraser currentUser alors que la fonction buildUserProfile() de l'utilisateur A est toujours en cours d'exécution, ce qui permet à l'utilisateur A de voir les données de l'utilisateur B.

✅ Conforme :

app.get('/profile', async (req, res) => {
    const currentUser = await getUserById(req.userId);
    const requestData = req.body;

    const profile = buildUserProfile(currentUser, requestData);
    res.json(profile);
});

function buildUserProfile(user, data) {
    return {
        name: user.name,
        data: data
    };
}

Pourquoi cela est-il important ? Toutes les données spécifiques à une demande sont stockées dans des variables locales liées au gestionnaire de la demande. Chaque demande a un état isolé qui ne peut pas être divulgué à d'autres demandes concurrentes. Les fonctions reçoivent des données par le biais de paramètres plutôt que d'accéder à l'état global, ce qui élimine les conditions de course.

Conclusion

Conservez toutes les données spécifiques aux requêtes dans des variables locales ou des objets de requête fournis par votre framework. N'utilisez les variables globales que pour les états réellement partagés tels que la configuration, les pools de connexion ou les caches en lecture seule. Lorsque l'état global est nécessaire, utilisez des contrôles de concurrence appropriés et assurez-vous que les données ne sont jamais spécifiques à l'utilisateur.