Zum Inhalt springen
Aback Tools Logo

JavaScript-Variablennamen-Deobfuscator

Analysieren Sie verschleierte Variablen-, Funktions- und Klassennamen in JavaScript-Code und erhalten Sie aussagekräftige Namensvorschläge auf Basis des Verwendungskontexts. Fügen Sie Ihren Code ein, prüfen Sie die Vorschläge mit Konfidenzbewertung, bearbeiten oder akzeptieren Sie sie, erstellen Sie eine Umbenennungszuordnung und sehen Sie den deobfuskierten Code vorab — alles kostenlos, privat und ohne Registrierung.

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.

Funktionen

  • Automatische Erkennung verschleierter Namen: durchsucht Ihren Code nach kurzen Namen (a, b, i, j), Bezeichnern mit Hex-Präfix (_0x...), Variablen nur aus Unterstrichen und anderen Mustern, die in minifiziertem und verschleiertem JavaScript üblich sind.
  • Kontextbezogene Namensvorschläge: jede erkannte Variable wird in ihrem Verwendungskontext analysiert — nahe Schlüsselwörter wie count, user, id, error und result bestimmen den vorgeschlagenen aussagekräftigen Namen samt Konfidenzbewertung.
  • Interaktiver Umbenennungsablauf: Vorschläge je Bezeichner akzeptieren, bearbeiten oder überschreiben. Erstellen Sie eine vollständige Umbenennungstabelle mit den Namen Original → deobfuskiert — ohne manuelle Suche.
  • Vorschau des deobfuskierten Codes: Nach der Zuordnung der Variablen sehen Sie den Code mit allen ersetzten Originalnamen vorab. Kopieren Sie den umgewandelten Code oder laden Sie die Zuordnung als JSON herunter.

Was ist die Deobfuskierung von Variablennamen?

Bei der Deobfuskierung von Variablennamen werden kurze, bedeutungslose oder kodierte Bezeichnernamen in JavaScript-Code durch aussagekräftige, beschreibende Namen ersetzt, die ihren Zweck vermitteln. Verschleierte Namen wie a, _0x42 oder ____ werden je nach Verwendung durch Vorschläge wie userCount, apiToken oder resultData ersetzt.

So funktioniert der Deobfuscator

Das Tool parst Ihren JavaScript-Code, um alle bezeichnerähnlichen Tokens zu extrahieren. JavaScript-Schlüsselwörter, Namen der Standardbibliothek und Eigenschaftszugriffsketten werden herausgefiltert. Jeder verbleibende Bezeichner wird nach seiner Wahrscheinlichkeit bewertet, verschleiert zu sein — kurze Länge, Hex-Präfixe, Muster nur aus Unterstrichen und nicht beschreibende Namen erhalten die höchsten Werte. Ein Kontextfenster um jede Verwendung wird analysiert: nahe Schlüsselwörter (z. B. deutet „count“ auf einen Zähler, „user“ auf ein Benutzerobjekt) bestimmen den vorgeschlagenen Ersatz.

Konfidenzstufen

Jeder Vorschlag enthält eine Konfidenzbewertung: hoch, mittel oder niedrig. Hohe Konfidenz bedeutet, dass der umgebende Kontext eine starke, eindeutige Schlüsselwortübereinstimmung enthält. Mittel bedeutet eine teilweise oder indirekte Übereinstimmung. Niedrig bedeutet, dass der Name verschleiert wirkt, der Kontext aber nur wenige Hinweise liefert — diese Vorschläge sind fundierte Vermutungen auf Basis gängiger Konventionen.

Datenschutz und Einschränkungen

Dieser Deobfuscator läuft vollständig in Ihrem Browser. Ihr Code verlässt Ihr Gerät nie. Er ist für die Analyse einzelner Dateien ausgelegt und funktioniert am besten mit eigenständigem JavaScript. Für professionelle Deobfuskierung über mehrere Dateien hinweg sollten Sie ein dediziertes Desktop-Werkzeug wie de4js oder die Rekonstruktion von Source Maps in Betracht ziehen. Das Tool analysiert ausschließlich Bezeichnernamen und Verwendungsmuster — es verfolgt weder Laufzeitzustand noch Datenfluss.

Häufig gestellte Fragen

Die Deobfuskierung von JavaScript-Variablennamen ersetzt kurze, bedeutungslose oder kodierte Bezeichnernamen (wie a, b, _0x42f3) durch beschreibende Namen (wie userName, totalCount, apiResponse), die auf der Verwendung dieser Variablen im Code basieren. Dadurch wird verschleierter Code viel leichter lesbar und verständlich, ohne sein Verhalten zu ändern.

Das Tool durchsucht Ihren Code nach bezeichnerähnlichen Tokens und filtert JavaScript-Schlüsselwörter sowie Namen der Standardbibliothek heraus. Es markiert Namen, die sehr kurz sind (1-2 Zeichen), hexähnliche Muster verwenden (_0x...), nur aus Unterstrichen bestehen oder Dollarzeichen enthalten — all das ist in minifiziertem und verschleiertem JavaScript üblich. Jeder Treffer wird anschließend in seinem umgebenden Kontext analysiert, um einen aussagekräftigen Vorschlag zu erzeugen.

Die Genauigkeit hängt davon ab, wie aussagekräftig der umgebende Codekontext ist. Wird eine Variable neben eindeutigen Schlüsselwörtern wie „count“, „user“ oder „error“ verwendet, wird der Vorschlag als hohe Konfidenz eingestuft. Bei weniger offensichtlichen Kontexten werden Vorschläge als mittel oder niedrig bewertet. Prüfen Sie Vorschläge immer, bevor Sie sie verwenden — das Tool liefert einen Ausgangspunkt, keine Garantie für Richtigkeit.

Ja. Bei jedem erkannten Bezeichner erscheint neben dem vorgeschlagenen Namen eine Schaltfläche „Bearbeiten“. Klicken Sie darauf, um Ihren eigenen Namen einzugeben, und dann auf „Speichern“, um ihn der Umbenennungszuordnung hinzuzufügen. So behalten Sie die volle Kontrolle über die deobfuskierte Ausgabe und profitieren zugleich von der automatischen Analyse des Tools.

Ja. Nach dem Umbenennen zeigt die Zuordnungstabelle alle Paare Original → deobfuskiert. Klicken Sie auf „JSON herunterladen“, um die Zuordnung als .json-Datei zu speichern. Das ist nützlich für Dokumentation, Code-Reviews oder um dieselbe Umbenennung auf mehrere Dateien anzuwenden.

Nein. Analyse und Umbenennung erfolgen ausschließlich in Ihrer Browsersitzung. Die Vorschau des deobfuskierten Codes zeigt, wie der Code mit Ihren Zuordnungen aussehen würde, aber nichts wird auf die Festplatte geschrieben oder irgendwohin übertragen. Kopieren Sie den umgewandelten Code manuell, wenn Sie ihn speichern möchten.

Absolut. Der JavaScript-Variablennamen-Deobfuscator läuft zu 100 % in Ihrem Browser. Ihr Code wird nie auf einen Server hochgeladen, in keiner Datenbank gespeichert oder über das Netzwerk übertragen. Alle Parsing-, Analyse- und Vorschlagslogik läuft lokal auf Ihrem Gerät — für vollständige Privatsphäre und Sicherheit.

Ja — 100 % kostenlos, ohne Registrierung, ohne Konto und ohne Nutzungslimits. Analysieren Sie so viele Codeausschnitte, wie Sie brauchen, benennen Sie so viele Variablen um, wie Sie möchten, und laden Sie Ihre Zuordnungen herunter — dauerhaft kostenlos, ohne versteckte Kosten oder Premium-Stufen.