Obfuscateur de nom de variable JavaScript

Renommez tous les noms de variables, de fonctions et de classes JavaScript en identifiants courts et dénués de sens pour protéger votre code source de l'ingénierie inverse occasionnelle. Choisissez entre des noms alphabétiques courts ou des noms de style hexadécimal, configurez l'exportation et la préservation globale et affichez le tableau complet de mappage de renommage - tous les traitements s'exécutent localement dans votre navigateur sans aucune inscription requise.

JavaScript Variable Name Obfuscator

Paste your JavaScript code below to rename all variables, functions, and classes to short, meaningless names. Choose between short alphabetic names or hex-style names. Configure whether to preserve global references and exported symbols. All processing runs locally in your browser - no signup required.

Name Style:

Preserve GlobalsPreserve Exports

JavaScript Input1,169 bytes

function formatOrderSummary(orderData, customerName) {
  const header = 'Order Summary for ' + customerName;
  const lines = [header, '---'];
  lines.push('Subtotal: $' + orderData.subtotal.toFixed(2));
  lines.push('Discount: $' + orderData.discount.toFixed(2));
  lines.push('Tax: $' + orderData.tax.toFixed(2));
  lines.push('Total: $' + orderData.total.toFixed(2));
  return lines.join('\n');
}

function getDiscountedPrice(originalPrice, discountPercent) {
  const discountValue = originalPrice * (discountPercent / 100);
  const finalPrice = originalPrice - discountValue;
  return Math.round(finalPrice * 100) / 100;
}

const DEFAULT_TAX_RATE = 0.08;
const MAX_ITEMS = 100;

Obfuscated Output

1,084 bytes(-85)

function calculateTotalPrice(items, discountRate) {
  let subtotal = 0;
  for (let i = 0; i < items.d; i++) {
    const item = items[i];
    subtotal += item.e * item.b;
  }
  const discountAmount = subtotal * discountRate;
  const totalPrice = subtotal - discountAmount;
  const taxAmount = totalPrice * 0.08;
  const finalPrice = totalPrice + taxAmount;
  return {
    subtotal: subtotal,
    a: discountAmount,
    j: taxAmount,
    g: finalPrice,
  };
}

function formatOrderSummary(orderData, customerName) {
  const header = 'Order Summary for ' + customerName;
  const lines = [header, '---'];
  lines.i('Subtotal: $' + orderData.subtotal.c(2));
  lines.i('Discount: $' + orderData.a.c(2));
  lines.i('Tax: $' + orderData.j.c(2));
  lines.i('Total: $' + orderData.g.c(2));
  return lines.h('\n');
}

function getDiscountedPrice(originalPrice, discountPercent) {
  const discountValue = originalPrice * (discountPercent / 100);
  const finalPrice = originalPrice - discountValue;
  return Math.f(finalPrice * 100) / 100;
}

const DEFAULT_TAX_RATE = 0.08;
const MAX_ITEMS = 100;

Variables Renamed

Names Preserved

Input Size

1,169 B

Output Size

1,084 B

Variable Name Mapping (10 entries)

Original Name	Obfuscated Name	Length Change
discount	a	-7
join	h	-3
length	d	-5
price	e	-4
push	i	-3
quantity	b	-7
round	f	-4
tax	j	-2
toFixed	c	-6
total	g	-4

Important: Variable name obfuscation is a basic form of code protection that makes your JS harder to read by humans and static analysis tools. It is not encryption and determined reverse engineers can still analyze your logic. For stronger protection, combine with string encoding, control flow obfuscation, and dead code injection. Always test obfuscated code thoroughly before deployment.

Pourquoi utiliser notre obfuscateur de noms de variables JavaScript ?

Changement de nom intelligent des variables : renommez instantanément toutes les variables JavaScript, les noms de fonctions, les noms de classe et les paramètres en identifiants courts et dénués de sens. L'obfuscateur détecte les déclarations locales, les paramètres de fonction, les clauses catch et les variables de boucle for - en renommant uniquement ce qui compte tout en préservant les mots réservés et les globaux intégrés.
Tableau complet de mappage de noms : affichez chaque décision de changement de nom dans un tableau de mappage clair affichant côte à côte les noms originaux et obscurcis. Triez par changement de longueur pour voir quels noms ont économisé le plus d'espace. Le mappage vous aide à vérifier que tous les identifiants ont été correctement transformés sans collisions.
Deux styles de dénomination : choisissez entre des noms alphabétiques courts (a, b, c, ..., aa, ab) pour une réduction maximale de la lisibilité, ou des noms de style hexadécimal (_0x1a, _0x2b, _0x3c) qui imitent les obfuscateurs commerciaux courants. Les deux styles produisent des identifiants JavaScript valides.
Traitement sécurisé et privé du navigateur : tous les renommages de variables s'exécutent entièrement dans votre navigateur à l'aide d'une analyse basée sur les expressions régulières JavaScript. Votre code source, votre propriété intellectuelle et vos algorithmes sensibles ne quittent jamais votre appareil. Pas d'inscription, pas de téléchargement de données, pas de suivi - confidentialité totale garantie.

Cas d'utilisation courants de l'obfuscateur de nom de variable JavaScript

Protéger les bibliothèques JavaScript commerciales : les développeurs de bibliothèques JavaScript utilisent l'obscurcissement des noms de variables pour protéger leur code commercial contre l'ingénierie inverse occasionnelle. Renommer des noms de variables descriptifs comme calculateTotalPrice en noms dénués de sens comme a ou _0x1a rend beaucoup plus difficile pour les concurrents de comprendre votre logique de mise en œuvre.
Protection des scripts SaaS côté client : les fournisseurs SaaS avec JavaScript côté client utilisent l'obscurcissement des variables pour protéger la logique métier propriétaire, les modèles d'intégration d'API et les algorithmes de traitement des données visibles dans le navigateur. Combinés à la minification, les noms de variables obscurcis élèvent la barrière pour les concurrents analysant votre code front-end.
Distribution de plugins WordPress et CMS : les développeurs de plugins et de thèmes WordPress distribuent des ressources JavaScript obscurcies pour protéger leur travail contre la copie ou la modification facile. Le renommage des variables rend plus difficile pour les utilisateurs non autorisés de corriger les contrôles de licence ou d'extraire des fonctionnalités propriétaires de vos plugins.
Recherche sur la sécurité et défis CTF : les chercheurs en sécurité et les participants à Capture The Flag (CTF) utilisent l'obscurcissement des noms de variables pour créer des défis d'ingénierie inverse. Renommer des variables en noms obscurs est une technique fondamentale pour enseigner les compétences de désobfuscation JavaScript et d'analyse de code.
Masquage du code éducatif : les instructeurs et les créateurs de cours utilisent l'obfuscation variable pour distribuer des solutions d'exercices sans révéler de code lisible. Les étudiants peuvent tester les résultats par rapport aux résultats attendus tout en étant encouragés à développer leurs propres approches de mise en œuvre.
Pipeline de build pré-déploiement : intégrez l’obscurcissement des noms de variables dans votre pipeline de build comme première ligne de défense. Avant le déploiement en production, renommez automatiquement toutes les variables locales et les noms de fonctions internes pour réduire la lisibilité de vos bundles JavaScript livrés.

Qu’est-ce que l’obscurcissement des noms de variables ?

L'obscurcissement des noms de variables est une technique de protection du code qui remplace les noms d'identifiant significatifs dans le code JavaScript par des alternatives courtes et dénuées de sens. Par exemple, une variable descriptive telle que calculateTotalPrice devient a ou _0x1f . Cette transformation rend le code source beaucoup plus difficile à comprendre pour les humains et les outils d'analyse statique, tout en gardant le code entièrement exécutable. L'obscurcissement des noms de variables est l'une des techniques les plus fondamentales et les plus largement utilisées dans la protection du code JavaScript, utilisée par les obfuscateurs commerciaux comme UglifyJS, Terser et Jscrambler.

Comment fonctionne notre obfuscateur de noms de variables

Analyser et identifier : l'outil analyse votre code source JavaScript pour trouver tous les noms d'identifiant. Il détecte les variables déclarées avec var, let et const, les déclarations et expressions de fonctions, les noms de classes, les paramètres de fonction (y compris les fonctions fléchées), les variables de clause catch et les variables de contrôle de boucle for.
Filtrer et cartographier : les mots-clés JavaScript réservés, les éléments globaux intégrés (fenêtre, document, console, Math, etc.) et les noms configurés par l'utilisateur à conserver (exportations) sont exclus du changement de nom. Chaque identifiant restant reçoit un nom court unique généré à l'aide d'un schéma de dénomination en base 26 ou hexadécimal avec détection de collision.
Remplacement et sortie : grâce au remplacement d'expressions régulières tenant compte des limites de mots, chaque occurrence de chaque identifiant d'origine est remplacée par son homologue obscurcie. L'outil génère un tableau de mappage complet montrant la transformation de l'original à l'obfusqué pour chaque identifiant renommé.

Ce qui est renommé lors d'un obscurcissement

Déclarations de variables locales : les variables créées avec let, const et var à l'intérieur des fonctions, blocs ou modules sont renommées en identifiants courts. Seules les variables dont le nom comporte plus d'un caractère sont prises en compte pour le renommage.
Noms de fonctions et de méthodes : les déclarations de fonctions nommées, les expressions de fonctions et les définitions de méthodes au sein des classes sont renommées - à moins qu'elles ne soient exportées ou marquées pour être conservées.
Paramètres de fonction : tous les paramètres formels des fonctions régulières, des fonctions fléchées et des fonctions asynchrones sont renommés. Cela inclut les paramètres par défaut et les paramètres de repos.
Liaisons de classe et de capture : les noms de déclaration de classe et les noms de variables d'exception dans les clauses catch sont renommés. Gère également les variables d'itération de la boucle for (for let i...) et les liaisons de modèles de déstructuration.

Confidentialité et limites

Notre obfuscateur de noms de variables JavaScript traite tout localement dans votre navigateur. Votre code source ne quitte jamais votre appareil : pas de téléchargement, pas de traitement par le serveur, pas de stockage de données. Cependant, l'obscurcissement des noms de variables présente à lui seul des limites importantes : il ne protège pas les littéraux de chaîne (qui révèlent toujours les points de terminaison et les messages de l'API), n'empêche pas l'analyse du flux de contrôle et n'arrête pas les rétro-ingénieurs déterminés qui peuvent utiliser des débogueurs et des outils d'analyse AST. Pour une protection complète, combinez cela avec le codage de chaînes, l’obscurcissement du flux de contrôle et d’autres techniques. Testez toujours minutieusement votre code obscurci avant de le déployer en production.

Foire aux questions

Un obfuscateur de noms de variables JavaScript est un outil qui renomme tous les noms de variables, de fonctions et de classes significatifs dans votre code JS en identifiants courts et dénués de sens. Par exemple, calculateTotalPrice devient simplement a ou _0x1f. Cela rend votre code source beaucoup plus difficile à lire et à comprendre tout en le gardant pleinement fonctionnel.

Non. Notre obfuscateur de noms de variables transforme uniquement les noms d’identifiants tout en préservant toutes les autres structures de code. Les mots-clés JavaScript réservés, les variables globales intégrées et les noms préservés configurés par l'utilisateur restent inchangés. La sortie obscurcie s’exécute de manière identique à l’original.

L'obfuscateur préserve tous les mots et mots-clés réservés JavaScript, les objets et fonctions globaux intégrés (fenêtre, document, console, Math, JSON, Tableau, Objet, etc.) et les noms que vous choisissez de conserver via l'option « Préserver les exportations ». Lorsqu'ils sont activés, les noms exportés restent inchangés pour maintenir la compatibilité des modules.

Les noms courts utilisent un schéma alphabétique en base 26 (a, b, c, ..., z, aa, ab, ...) produisant le résultat le plus compact. Les noms hexadécimaux utilisent _0x suivi d'un nombre hexadécimal (_0x1a, _0x2b, _0x3c), imitant les obfuscateurs commerciaux populaires. Les deux produisent des identifiants JavaScript valides.

Absolument. Notre obfuscateur de noms de variables s'exécute entièrement dans votre navigateur en utilisant JavaScript : aucune donnée n'est jamais téléchargée sur un serveur. Votre code source, votre propriété intellectuelle et vos algorithmes propriétaires ne quittent jamais votre appareil. Aucune inscription requise, confidentialité totale.

Non. L’obscurcissement des noms de variables rend le code plus difficile à lire en renommant les identifiants, mais il ne crypte pas le code. Le code crypté ne peut pas s'exécuter sans déchiffrement, tandis que le code obscurci s'exécute normalement. L'obscurcissement est un moyen de dissuasion qui augmente les efforts requis pour l'ingénierie inverse.

Oui. L'outil peut être intégré à votre flux de travail de développement en tant qu'étape préalable au déploiement. Prenez simplement la sortie obscurcie et incluez-la dans vos artefacts de construction. La sortie de la table de mappage vous aide à déboguer les problèmes en montrant exactement comment chaque nom a été transformé.

Oui, notre obfuscateur de noms de variables JavaScript est 100 % gratuit, sans inscription requise, sans niveau premium, sans limites d'utilisation, sans restrictions de taille de fichier et sans publicité. Utilisez-le un nombre illimité de fois pour tout projet personnel ou commercial.