Aller au contenu
Aback Tools Logo

Désobfuscateur de noms de variables JavaScript

Analysez les noms obfusqués de variables, fonctions et classes dans du code JavaScript et obtenez des suggestions de noms pertinentes fondées sur le contexte d'usage. Collez votre code, examinez les suggestions avec leur indice de confiance, modifiez-les ou acceptez-les, créez une table de renommage et prévisualisez le code désobfusqué — le tout gratuitement, en privé et sans inscription.

JavaScript Variable Name Deobfuscator

Paste JavaScript code with obfuscated variable names (a, b, _0x, etc.) and get meaningful name suggestions based on usage context. Edit suggestions, build a rename mapping, and preview the deobfuscated code.

Live analysis — results update as you type

Detected Obfuscated Identifiers (15)

e×4High confidence
length
c) { var d = []; for (var e = 0; e < b.length; e++) { ... var d = []; for (var e = 0; e < b.length; e++) { var f ... for (var e = 0; e < b.length; e++) { var f = b[e]; if
i×4High confidence
length
a) { let r = []; for (let i = 0; i < data.length; i++) { ... let r = []; for (let i = 0; i < data.length; i++) { let ... (let i = 0; i < data.length; i++) { let v = data[i];
v×4High confidence
length
< data.length; i++) { let v = data[i]; if (v.status = ... let v = data[i]; if (v.status === 'active') { ... active') { r.push({ id: v.id, val: v.amount * 1.1 });
b×3High confidence
length
function a(b, c) { var d = []; for (va ... d = []; for (var e = 0; e < b.length; e++) { var f = b[ ... b.length; e++) { var f = b[e]; if (f > 10) { d
d×3Medium confidence
first
function a(b, c) { var d = []; for (var e = 0; e < b ... b[e]; if (f > 10) { d.push(f * 2); } } retu ... sh(f * 2); } } return d; } function _0x42(x, y) {
f×3High confidence
length
e < b.length; e++) { var f = b[e]; if (f > 10) { ... ) { var f = b[e]; if (f > 10) { d.push(f * 2); ... if (f > 10) { d.push(f * 2); } } return d; }
data×3Medium confidence
length
urn z * 1.5; } function proc(data) { let r = []; for (let i ... r = []; for (let i = 0; i < data.length; i++) { let v = da ... ta.length; i++) { let v = data[i]; if (v.status === 'act
r×3High confidence
id
function proc(data) { let r = []; for (let i = 0; i < d ... .status === 'active') { r.push({ id: v.id, val: v.amoun ... * 1.1 }); } } return r; }
x×2Medium confidence
first
return d; } function _0x42(x, y) { const z = x + y; re ... ion _0x42(x, y) { const z = x + y; return z * 1.5; } fun
y×2Medium confidence
first
eturn d; } function _0x42(x, y) { const z = x + y; retur ... _0x42(x, y) { const z = x + y; return z * 1.5; } functio
z×2Medium confidence
data
unction _0x42(x, y) { const z = x + y; return z * 1.5; } ... { const z = x + y; return z * 1.5; } function proc(data)
a×1Medium confidence
accumulator
function a(b, c) { var d = []; for (
c×1Medium confidence
config
function a(b, c) { var d = []; for (var e
_0x42×1Low confidence
hexString__0x
} } return d; } function _0x42(x, y) { const z = x + y;
id×1High confidence
id
== 'active') { r.push({ id: v.id, val: v.amount * 1.1 })

Manual Rename

→

Add custom mappings for variables the detector may have missed.

Privacy Guarantee

All analysis runs entirely in your browser. Your code never leaves your device — no uploads, no API calls, no tracking.

Fonctionnalités

  • Détection automatique des noms obfusqués : analyse votre code pour repérer les noms courts (a, b, i, j), les identifiants à préfixe hexadécimal (_0x...), les variables à base de traits de soulignement et d'autres motifs courants dans le JavaScript minifié et obfusqué.
  • Suggestions de noms contextuelles : chaque variable détectée est analysée dans son contexte d'usage — les mots-clés proches comme count, user, id, error et result déterminent le nom pertinent suggéré et son indice de confiance.
  • Flux de renommage interactif : acceptez, modifiez ou remplacez les suggestions de chaque identifiant. Construisez une table complète de renommage avec les noms original → désobfusqué, sans aucune recherche manuelle.
  • Aperçu du code désobfusqué : après avoir mappé les variables, prévisualisez le code avec tous les noms d'origine remplacés par vos noms désobfusqués. Copiez le code transformé ou téléchargez la table au format JSON.

Qu'est-ce que la désobfuscation des noms de variables ?

La désobfuscation des noms de variables consiste à remplacer les noms d'identifiants courts, vides de sens ou encodés dans du code JavaScript par des noms significatifs et descriptifs qui traduisent leur rôle. Les noms obfusqués comme a, _0x42 ou ____ sont remplacés par des suggestions comme userCount, apiToken ou resultData selon leur usage.

Comment fonctionne le désobfuscateur

L'outil analyse votre code JavaScript pour en extraire tous les jetons ressemblant à des identifiants. Il écarte les mots-clés JavaScript, les noms de la bibliothèque standard et les chaînes d'accès aux propriétés. Chaque identifiant restant est noté selon sa probabilité d'être obfusqué : longueur courte, préfixes hexadécimaux, motifs uniquement en traits de soulignement et noms non descriptifs obtiennent les scores les plus élevés. Une fenêtre de contexte autour de chaque usage est analysée : les mots-clés proches (par exemple « count » évoque un compteur, « user » un objet utilisateur) déterminent le remplacement suggéré.

Niveaux de confiance

Chaque suggestion comporte un indice de confiance élevé, moyen ou faible. Une confiance élevée signifie que le contexte proche contient une correspondance de mot-clé forte et sans ambiguïté. Moyenne correspond à une correspondance partielle ou indirecte. Faible signifie que le nom semble obfusqué mais que le contexte offre peu d'indices — ces suggestions sont des estimations fondées sur les conventions courantes.

Confidentialité et limites

Ce désobfuscateur fonctionne entièrement dans votre navigateur. Votre code ne quitte jamais votre appareil. Il est conçu pour l'analyse d'un seul fichier et fonctionne au mieux avec du JavaScript autonome. Pour une désobfuscation de niveau professionnel sur plusieurs fichiers, envisagez un outil de bureau dédié comme de4js ou la reconstruction des source maps. L'outil analyse uniquement les noms d'identifiants et les motifs d'usage — il ne suit ni l'état d'exécution ni les flux de données.

Foire aux questions

La désobfuscation des noms de variables JavaScript remplace des noms d'identifiants courts, vides de sens ou encodés (comme a, b, _0x42f3) par des noms descriptifs (comme userName, totalCount, apiResponse) selon l'usage de ces variables dans le code. Le code obfusqué devient ainsi beaucoup plus lisible et compréhensible, sans changer son comportement.

L'outil parcourt votre code à la recherche de jetons ressemblant à des identifiants et écarte les mots-clés JavaScript ainsi que les noms de la bibliothèque standard. Il signale les noms très courts (1-2 caractères), ceux qui utilisent des motifs hexadécimaux (_0x...), ceux composés uniquement de traits de soulignement et ceux contenant des signes dollar — tous courants dans le JavaScript minifié et obfusqué. Chaque occurrence est ensuite analysée dans son contexte pour générer une suggestion pertinente.

La précision dépend de la richesse du contexte entourant le code. Lorsqu'une variable est utilisée près de mots-clés clairs comme « count », « user » ou « error », la suggestion est marquée d'une confiance élevée. Pour des contextes moins évidents, les suggestions sont notées moyenne ou faible. Vérifiez toujours les suggestions avant de les utiliser — l'outil fournit un point de départ, pas une garantie d'exactitude.

Oui. Chaque identifiant détecté affiche un bouton « Modifier » à côté de son nom suggéré. Cliquez dessus pour saisir votre propre nom, puis sur « Enregistrer » pour l'ajouter à la table de renommage. Vous gardez ainsi le contrôle total du résultat désobfusqué tout en profitant de l'analyse automatique de l'outil.

Oui. Après avoir renommé des variables, la table affiche toutes les paires original → désobfusqué. Cliquez sur « Télécharger JSON » pour enregistrer la table dans un fichier .json. C'est utile pour la documentation, la revue de code ou pour appliquer le même renommage à plusieurs fichiers.

Non. Toute l'analyse et le renommage se font uniquement dans votre session de navigateur. L'aperçu du code désobfusqué montre à quoi ressemblerait le code avec vos tables appliquées, mais rien n'est écrit sur le disque ni transmis où que ce soit. Copiez manuellement le code transformé si vous voulez le conserver.

Absolument. Le désobfuscateur de noms de variables JavaScript fonctionne à 100 % dans votre navigateur. Votre code n'est jamais envoyé à un serveur, stocké dans une base de données ni transmis par le réseau. Toute l'analyse syntaxique, le traitement et la logique de suggestion s'exécutent localement sur votre appareil, pour une confidentialité et une sécurité totales.

Oui — 100 % gratuit, sans inscription, sans compte et sans limite d'utilisation. Analysez autant d'extraits de code que nécessaire, renommez autant de variables que vous voulez et téléchargez vos tables — gratuit pour toujours, sans frais cachés ni offre premium.