javascript - 这些 javascript 混淆器如何生成实际的工作代码？

Question

有this one和 this one而且它们都生成完全不可读的代码，其中一个比另一个更可爱。

现在，我不是 Javascript 方面的专家，但我看不到如何

ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');

和

$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$_$_+(![]+"")[$._$_]+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.__+"(\\\"\\"+$.__$+$._$_+$._$$+$.__+$.$_$_+$.$$__+"\\"+$.__$+$.$_$+$._$$+"\\"+$.__$+$.__$+$.$$$+"\\"+$.__$+$.$$_+$.$$_+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.$$$$+(![]+"")[$._$_]+$._$+"\\"+$.__$+$.$$_+$.$$$+"\\\")"+"\"")())();

是按预期执行的实际有效 javascript。说真的，运行它们。他们都是 alert("StackOverflow") .我可以理解混淆一些逻辑或字符串混淆，但没有可见的控制语句。这个混淆器是否以 The Language Which Shall Not Be Named 的风格发挥作用？ ?我对我的代码看起来也很满意，但我完全不理解它背后的魔力。

我已经尝试通过两个页面的源代码进行挑选，它们对我来说就像它们生成的代码一样令人困惑。

这是如何运作的？

Answer 1

多么有趣!这是我的尝试。基本上这里发生的是一堆数字和字符串被分配给变量。这些变量被连接起来形成一个编码字符串。该编码字符串被解码以形成一串 JavaScript 代码。该代码被设置为函数的主体，然后执行。

让我们逐行来看:

第 1 行:

ﾟωﾟﾉ = /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/['_'];

ﾟωﾟﾉ - 一个全局变量 /｀ｍ´）ﾉ ~┻━┻ / - 一个正则表达式 /*´∇｀*/ - 多行注释 ['_'] - 获取属性 _的正则表达式。

由于 RegExp 没有 _属性，变量 ﾟωﾟﾉ包含值 undefined .

第 2 行:

o = (ﾟｰﾟ) = _ = 3;

定义变量 o , ﾟｰﾟ , 和 _ , 并将它们的每个值设置为 3 .

第 3 行:

c = (ﾟΘﾟ) = (ﾟｰﾟ) - (ﾟｰﾟ);

定义变量 c和 ﾟΘﾟ并将它们的值设置为 0 . ( ﾟｰﾟ 是 3 ，所以 (ﾟｰﾟ) - (ﾟｰﾟ) 与 ﾟｰﾟ - ﾟｰﾟ 相同 3 - 3 。现在 c 和 ﾟΘﾟ 都包含 1 ；

第 4 行:

(ﾟДﾟ) = (ﾟΘﾟ) = (o ^ _ ^ o) / (o ^ _ ^ o);

定义变量 ﾟДﾟ并重新定义变量 ﾟΘﾟ . ^是 bitwise XOR operator和 o和 _都是 3 . o ^ _ ^ o与 3 ^ 3 ^ 3 相同. 3 ^ 3是 0 , 3 ^ 0是 3 .
然后 3 / 3是 1 . ﾟДﾟ和 ﾟΘﾟ现在两者都包含 1 .

5号线:

(ﾟДﾟ) = { ﾟΘﾟ: '_', ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ], ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)], ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ] };

带有换行符和缩进:

(ﾟДﾟ) = {
    ﾟΘﾟ: '_',
    ﾟωﾟﾉ: ((ﾟωﾟﾉ == 3) + '_')[ﾟΘﾟ],
    ﾟｰﾟﾉ: (ﾟωﾟﾉ + '_')[o ^ _ ^ o - (ﾟΘﾟ)],
    ﾟДﾟﾉ: ((ﾟｰﾟ == 3) + '_')[ﾟｰﾟ]
};

重新定义 ﾟДﾟ作为对象字面量，具有属性 ﾟΘﾟ , ﾟωﾟﾉ , ﾟｰﾟﾉ , 和 ﾟДﾟﾉ . ﾟДﾟ.ﾟΘﾟ是 ”_”。 ﾟДﾟ.ﾟωﾟﾉ是 ((undefined == 3) + "_")[1]这是 "false_"[1]这是 "a" . ﾟДﾟ.ﾟｰﾟﾉ是 (undefined + "_")[3 ^ 3 ^ 3 - 1]这是 "undefined_"[2]这是 "d" . ﾟДﾟ.ﾟДﾟﾉ是 ((3 == 3) + "_")[3]这是 "true_"[3]这是 "u" .

第 6 行:

(ﾟДﾟ)[ﾟΘﾟ] = ((ﾟωﾟﾉ == 3) + '_')[c ^ _ ^ o];

是相同的:

ﾟДﾟ.ﾟΘﾟ = ((undefined == 3) + "_")[1 ^ 3 ^ 3];

这与以下内容相同:

ﾟДﾟ.ﾟΘﾟ = "false_"[1];

所以 ﾟДﾟ.ﾟΘﾟ是 "a" .

第 7 - 16 行:

因此它继续，将字符串和数字分配给变量和对象属性。直到最后一行:

第 17 行:

(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ + (ﾟДﾟ)[ﾟoﾟ] + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + ((ﾟｰﾟ) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + (ﾟｰﾟ) + (o ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (c ^ _ ^ o) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟΘﾟ) + ((o ^ _ ^ o) + (o ^ _ ^ o)) + (ﾟｰﾟ) + (ﾟДﾟ)[ﾟεﾟ] + (ﾟｰﾟ) + ((o ^ _ ^ o) - (ﾟΘﾟ)) + (ﾟДﾟ)[ﾟεﾟ] + ((ﾟｰﾟ) + (ﾟΘﾟ)) + (ﾟΘﾟ) + (ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

此时，我们有以下变量:

ﾟωﾟﾉ    // undefined
o       // 3
ﾟｰﾟ     // 4
_       // 3
c       // 0
ﾟΘﾟ     // 1
ﾟДﾟ     /* {
            "1": "f",
            ﾟΘﾟ: "_",
            ﾟωﾟﾉ: "a",
            ﾟｰﾟﾉ: "d",
            ﾟДﾟﾉ: "e",
            c: "c",
            o: "o",
            return: "\\",
            ﾟΘﾟﾉ: "b",
            constructor: "\"",
            _: Function
        } */
ﾟoﾟ     // "constructor"
ﾟεﾟ     // "return"
oﾟｰﾟo   // "u"

该行主要是一个大字符串连接。我们可以通过删除不必要的括号并添加换行符使其更具可读性:

ﾟДﾟ['_'](
    ﾟДﾟ['_'](
        ﾟεﾟ + 
        ﾟДﾟ[ﾟoﾟ] + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟΘﾟ + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        (ﾟｰﾟ + (o ^ _ ^ o)) + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        (o ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ﾟｰﾟ + 
        (o ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        (c ^ _ ^ o) + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟΘﾟ + 
        ((o ^ _ ^ o) + (o ^ _ ^ o)) + 
        ﾟｰﾟ + 
        ﾟДﾟ[ﾟεﾟ] + 
        ﾟｰﾟ + 
        ((o ^ _ ^ o) - ﾟΘﾟ) + 
        ﾟДﾟ[ﾟεﾟ] + 
        (ﾟｰﾟ + ﾟΘﾟ) + 
        ﾟΘﾟ + 
        ﾟДﾟ[ﾟoﾟ]
    )(ﾟΘﾟ)
)("_");

该连接字符串的值为:

return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51"

因此，用文字替换所有变量，我们最终得到以下 JavaScript，它在最后一行执行:

Function(Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"")(1))("_")

打破那条线，在中间我们看到连接的字符串被传递给 Function构造函数，使字符串成为函数体:

Function("return\"\\141\\154\\145\\162\\164\\50\\42\\110\\145\\154\\154\\157\\54\\40\\112\\141\\166\\141\\123\\143\\162\\151\\160\\164\\42\\51\"")

因此，该字符串被评估为 JavaScript，而 Function构造函数返回这个函数:

function () {
    return"\141\154\145\162\164\50\42\110\145\154\154\157\54\40\112\141\166\141\123\143\162\151\160\164\42\51";
}

该函数立即执行:

Function("return\"\\141\\154\\145\\...\\51\"")(1)

并返回字符串:

alert("Hello, JavaScript")

嘿，这看起来像 JavaScript!但现在还没有。这只是一个字符串。但是该字符串被传递给另一个 Function构造函数，为我们提供了一个将字符串作为 JavaScript 执行的函数:

Function("alert(\"Hello, JavaScript\")")

这与以下内容相同:

function () {
    alert("Hello, JavaScript");
}

该函数立即执行:

Function("alert(\"Hello, JavaScript\")")("_")

最后调用我们未混淆的代码。