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 non 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 provenant d'autres utilisateurs. Cela crée des vulnérabilités de sécurité où les données de session, les jetons d'authentification ou les informations personnelles de l'utilisateur A peuvent fuir vers l'utilisateur B.

Pourquoi c'est important

Implications 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 inter-requêtes. L'état d'authentification, les données de session ou les informations personnelles d'un utilisateur deviennent visibles pour d'autres utilisateurs, violant ainsi les limites de confidentialité et de sécurité.

Conditions de concurrence : Lorsque plusieurs requêtes concurrentes modifient la même variable globale, il y a de fortes chances de comportement imprévisible. Les données de l'utilisateur A peuvent être écrasées par la requête de l'utilisateur B en cours de traitement, entraînant des calculs incorrects, un état corrompu ou la visualisation des données d'autres utilisateurs.

Complexité du débogage : Les problèmes causés par la mise en cache de variables globales sont notoirement difficiles à reproduire car ils dépendent du timing des requêtes et de la concurrence. Les bugs apparaissent par intermittence en production sous charge mais se manifestent rarement lors des tests de développement en mode mono-thread.

Fuites de mémoire : Les variables globales qui accumulent des données sans nettoyage augmentent de manière illimitée au fil du temps. Chaque requête ajoute davantage de données aux caches ou tableaux globaux, épuisant finalement la mémoire du serveur et nécessitant des redémarrages de 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 c'est incorrect : Les variables globales currentUser et requestData persistent entre les requêtes. Lorsque plusieurs requêtes s'exécutent simultanément, la requête de l'utilisateur B peut écraser currentUser pendant que buildUserProfile() de l'utilisateur A est toujours en cours d'exécution, ce qui fait que l'utilisateur A voit 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 c'est important : Toutes les données spécifiques à la requête sont stockées dans des variables locales dont la portée est limitée au gestionnaire de requêtes. Chaque requête possède un état isolé qui ne peut pas fuir vers d'autres requêtes concurrentes. Les fonctions reçoivent les données via des paramètres plutôt que d'accéder à l'état global, éliminant ainsi les conditions de concurrence.

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 connexions ou les caches en lecture seule. Lorsque l'état global est nécessaire, utilisez des mécanismes de contrôle de concurrence appropriés et assurez-vous que les données ne sont jamais spécifiques à un utilisateur.