Sadece 5 sembollü JSF ** k?

Bu bir meydan okuma değil, bir soru, çünkü konuyla ilgili olduğunu düşündüm.

Programlama bulmacalarının çözülmesiyle ilgili sorun olmayan sorular veya belirli bir meydan okuma türü de konuyla ilgili.

Şimdi soruya:

Sadece 5 harfli bir JavaScript kodu yazmak mümkün müdür? JSFuck bunu zaten 6 sembolle yapıyor !+[]()ama !karakterin gerekli olup olmadığını merak ediyorum .

JSFuck, dizeye döküm (boş bir dizi ekleyerek), sayıya döküm (önüne + yazarak) ve olumsuzlayarak boolene döküm kombinasyonuyla çalışır. Örneğin:

[]        \\ Empty array
+[]       \\ Cast to number -> 0
!+[]      \\ Negate -> true
!+[]+[]   \\ Cast to string -> "true"

Bu dizgeden tüm harfleri köşeli parantez içinde bir sayı ile çekip çıkarabiliriz ve bu sayıyı bir araya toplayarak herhangi bir sayı girebiliriz.

Bunun gibi birçok harf bulunabilir ve karakter dizileri ile birleştirilebilir. Oluşturabilecek en önemli dize , herhangi bir işlevden "constructor"almak için kullanılabileceği Functionve bu nesneyi JavaScript olarak dizeleri çalıştırmak için kullanılabileceği içindir:

[]["find"]                          \\ the function Array.prototype.find
[]["find"]["constructor"]           \\ the Function object
[]["find"]["constructor"](string)() \\ same as eval(string)

Gördüğünüz gibi !, burada 2 kullanım var:

• Dizelerden harfleri seçmek için sayılar oluşturma.
• Boolean için Döküm almak "true"ve "false".

Bu 2'den ilki ++, doğrudan değil , artırıcı kullanılarak da yapılabilir 0, ancak bir dizinin içindeki öğeler üzerinde de kullanılabilir:

+[]          \\ 0
[+[]]        \\ [0]
[+[]][+[]]   \\ [0][0] -> 0
++[+[]][+[]] \\ ++[0][0]-> 1
++[[]][+[]]  \\ also works because ++ casts to number

Böylece tüm sayılar olmadan oluşturulabilir !.

İkincisi daha zor. Önemi "true"ve "false"harflerle bırakır "r"ve "s"hem görünür, "constructor". Zaten diğer bütün harfleri bulduk "constructor"vasıtasıyla "undefined", "Infinity", "NaN"ve dizeleri işlevleri döküm yoluyla.

Öyleyse nihai soru: (Nasıl) kullanarak sadece boolean veya harfleri "r"ve "s"JavaScript'i oluşturabilirsiniz +[]()?

Mektup "l"da yardımcı olabilir. Bu şekilde elde edilebilir, nullancak bu 5 sembolle bu değeri elde edemedim. Örneğin, eğer varsa, boolean almak için kullanılabilir "s":

[]["includes"]()       \\ false
[+[]]["includes"](+[]) \\ true

Mektup "l"ve "k"birlikte, aşağıdakilere erişimi sağlayacaktır "r":

([]+[])["link"]() \\ "<a href="undefined"></a>"

Bir boolean almak için herhangi bir yol, nullya da herhangi bir harf r s l kçok yararlı olacaktır!

Elimizde bir kütüphane var:

Dizi.prototype.find: [] [((([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])]

Sonsuzluk: + ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ []))

NaN: + [] [[]]

Tanımsız: [][[]]

0: + []

1: ++ [[]] [+ []]

2: (++ [[]] [+ []]) + (++ [[]] [+ []])

3: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

4: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []])

5: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []])

6: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

7: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

8: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

9: (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])

a: (+ [] [[]] + []) [++ [[]] [+ []]]

c: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

d: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])]

e: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []])]

f: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []]) + (++ [[]] [+ []])]

i: ([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

n: ([] [[]] + []) [++ [[]] [+ []]]

o: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]

t: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ [] ])]

u: ([] [[]] + []) [+ []]

v: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]))]

y: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ [] ]) + (++ [[]] [+ []])]

I: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] ) + (+ []) + (+ [])) + []) [+ []]

N: (+ [] [[]] + []) [+ []]

"": ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [ ]) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [+ (++ [[]] [+ [] ] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])))]

(: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

): ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

{: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])))]

}: ([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(+ (++ [[]] [+ [] ]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + [] + ((++ [[]] [+ []]) + ( ++ [[]] [+ []])))]

.: (+ (++ [[]] [+ []] + [] + (++ [[]] [+ []]) + ([] [[]] + []) [(++ [ []] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + (++ [[]] [+ [] ] + [] + (+ []) + (+ []))) + []) [++ [[]] [+ []]]

,:[[]] [([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(++ [[]] [+ [ ]]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + ([] [(([] [[]] + []) [ (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[] ] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + '[]) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []] )] + ([] [[]] + []) [++ [[]] [+ []]] + ([] [(([] [[]] + []) [(++ [[ ]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) ]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[] ] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [ + []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])] + (+ [] [[]] + []) [++ [[]] [+ []]] + (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + ( ++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ [])) + []) [(++ [[]] [+ [] ]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[ ]] [+ []]) + (++ [[]] [+ []])]] ([[]]) + []

Beyin fırtınasından sonra sonuç, en azından modern tarayıcılarda, bunu yapmanın bir yolu olmadığı görülüyor.

Devam etmeden önce, seçeneklerimizi neden herhangi bir alanda tükettiğimize dair bazı akıl yürütmeler ekleyerek, tüm süreci özetlemeye çalışacağım. Ardından, bazı şaşırtıcı yeni fikirlerin engellenmesi (örneğin, herkesin unuttuğu bir JavaScript sözdiziminin küçük bir örneği), kalan harfleri elde etmenin bir yolu olmadığı açıkça anlaşılacaktır.

Değişmez

Sadece acil Birlikte yapabilirsiniz değişmezleri +()[]iç içe boş dizilerdir [], [[]], [[[]]]vb Oradan kullandığımız değerleri döküm başlayabilirsiniz +:

• +[]Jens'in hilesi, keyfi pozitif tamsayıları kullanarak genişleten sıfırı alır ++.

• []+[]olduğunu "". Aslında, []+xbize xgenel olarak bir dize gösterimi alır .

[]sonraki kullanım endeksleme. Bir nesneyi sınırların dışında ( [][[]]) dizine almak sizi alır undefined. Bunu bir dizgeye çevirip sonucu indekslemek size harfleri getirir d e f i n u; ilk önce bir tamsayıya +çevirmek NaN, harflerin geldiği yerden sizi alır a N.

Bu ++numarayı şimdiye kadar ulaşılan tam sayı olmayan bir değer üzerinde kullanmak NaNya bir hata verir ya da verir . Ayrıca, oluşturabileceğimiz nesnelerin hiçbiri çağrılabilir değildir (henüz), bu nedenle ()yardımcı olmaz (gruplama hariç).

Kolumuzda kalan diğer numaralar döküm ve indekslemedir. Öyleyse soru şudur: 0123456789adefinuNya karakterleri kullanarak hangi karakterleri oluşturabiliriz

• yeni karakter dizileri elde etmek için tamsayıya geçebileceğimiz sayı değişmezleri veya
• ulaşabileceğimiz nesnelerin mülkiyet adları nedir?

Sayı değişmezleri

İkinci seçeneğin Bir örnek olarak, biz dize yapabilir "1e1000"ve sonra olsun Infinitygelen +"1e1000"ve bu döküm geri dizeye bize mektup alır yve I.

Ayrıca, yapabilir "11e100"almak için, sayı ve dize arkasına döküm "1.1e+101"hangi biz özü, .ve +.

Bunu kullanarak ., sırayla dizgeyi yapabilir, ".0000001"sayı ve geri çevirebilir, elde etmek için "1e-7", bizi kazanabiliriz -.

Bu temelde tüm yüzdürmeler sizi alacaktır: Infinityve dışında hiçbir ilginç değer yoktur ve NaNnormal dize temsillerinde kullanılan karakterlerden başka karakter yoktur -+.0123456789e.

Özellikleri

Demek mektuplarımız var -+.0123456789adefinuyIN. Hangi özelliklere ulaşabiliriz? JavaScript'i soralım.

>>> R = /^[-+.0123456789adefinuyIN]+$/
>>> [Array, Object, String, Number].reduce((h, f) => {
        h[f.name] = Object.getOwnPropertyNames(f.prototype).filter(x => x.match(R));
        return h }, {})

{ Array: [ 'find' ], Object: [], String: [], Number: [] }

Sadece [].find, Jens'in zaten bulduğu şey. Bunu bir dizeye atalım, tüm harflerini toplayalım ve tekrar deneyelim. Dize gösterimi tarayıcılar arasında biraz farklıdır. Chrome ve Kenardan, "function find() { [native code] }"içerdiği acdefinotuv()[]{}ve bir boşluk; tam alfabemiz şimdi +-.()[]{}0123456789INacdefinotuvy. Firefox'ta daha çok boşluk ve yeni satır var, ancak harfler aynı.

Aramamızı tekrar ediyoruz:

>>> R = /^[+-.()\[\]{}0123456789INacdefinotuvy]+$/
>>> [Array, Object, String, Number, Function].reduce((h, f) => {
        h[f.name] = Object.getOwnPropertyNames(f.prototype).filter(x => x.match(R));
        return h }, {})

{ Array: [ 'concat', 'find' ],
  Object: [],
  String: [ 'concat' ],
  Number: [],
  Function: [] }

String.prototype.concatkullanımdan kaldırıldı: tam olarak ne yaptığını +, şimdiden yapabileceğimiz şeyi yapar. Yani elimizdeki Array.prototype.concatve Array.prototype.find. Onlarla ne yapabiliriz?

Fonksiyonlar

concat()ilk kez daha uzun diziler oluşturmamıza izin veriyor. [[]].concat([[]])olduğu [[], []]ve bir dizeye o döküm bizi alır ",". (Bu yeni özellikleri bulmamıza yardımcı olmaz.) Fakat .concatdeğerlerimizi değiştirmez ve asla geri dönüş yapamaz null.

Arama find()da bize yardımcı olmuyor: MDN belgelerine göre

find()Yöntem olup, dizideki bir değer verir dizi tatmin bir eleman temin test fonksiyonu ise. Aksi takdirde undefinediade edilir.

İkisini de zaten indeksleme kullanarak yapabiliriz.

Ve buradan, gidecek başka bir yer yok. Yazdığım bir şeyden şüpheleniyorsanız, yorumlarda bana bildirin.

Lynn'in cevabındaki 3 fonksiyon o kadar da işe yaramaz değildi. Ancak ECMAScript 5'teki katı mod planımı bozdu.

JavaScript / ECMAScript'in eski sürümlerinde bir tuhaflık var. Bir nesne nesne olmadan çağrılırsa, küresel nesne windowkabul edilir. Yani bunu yapabiliriz:

a = {f:function(){return this}};
a.f();                            // Returns a.
g = a.f;
g();                              // Returns window.
window.g();                       // Also returns window.

Bu, modern tarayıcılar için hala geçerlidir, ancak yalnızca işlev katı modda tanımlanmadıysa. Ve tüm yerleşik işlevler (yerel kodla birlikte) katı modda görünüyordu. Daha önceki tarayıcılarda henüz katı mod bulunmadığında, bu yerleşik işlevler için de geçerlidir.

Eski tarayıcıları kullandığımızı varsayalım. O zaman istersen window, içerdiği bir şey döndüren yerleşik bir işlev bulmalıyız this. Sahip olduğumuz tek seçenek içinde, Array.prototype.concattam olarak bunu yapan fonksiyon var. Bunu böyle test edebiliriz:

Number.prototype.concat = Array.prototype.concat;
1..concat(2);                     // Returns [1, 2]
concat = Array.prototype.concat;
window.concat(2);                 // Returns [window, 2]
concat(2)                         // TypeError in modern browsers while
                                  //   returning the same thing in older ones.
concat.bind(window)(2)            // A workaround in modern browsers.

Bu yüzden temelde çağrıldığı nesnenin bir dizi olup olmadığı umrunda değil (ama en azından bir nesne olmalı). Değilse sadece bir dizi içinde sarar.

Olursa window, öncelikle [object Window]bir dizgiye çevirerek dizgiyi alabiliriz. Yeni karakterle b, sırasıyla aşağıdaki iki satırı ve sahip olmadığımız her karakteri alabilir rve kullanabiliriz :sconstructor

window["atob"]("cuaa")[0]
window["atob"]("cyaa")[0]

Ancak diğer sorun nesne referansını kaldırmaktır [].concat. Bir diziye sarmak ve ayıklamak işe yaramıyor çünkü [].concatzaten []["concat"]. Muhtemelen kullanılarak inşa edilebilecek tek yol +[](), onu bir işlevden döndürmektir. Array.prototype.findBunu yapabilmek gibiydi:

[[]["concat"]]["find"](x=>1)      // Returns Array.prototype.concat, where x=>1 can
                                  //   be replaced with any always truthy function.

Her zaman truthy fonksiyonlarımız vardı. Array.prototype.concatve String.prototype.concateğer nesne ise her ikisi de gerçeği döndürür window. Sonuncusunu kullanırsak, mevcut üç işlevi de kullandık.

Ancak ne yazık ki, Array.prototype.findkullandığımız eski tarayıcıda mevcut değil. En azından işe yarayan bir tane bulamadım. Ve nesne referansını kaldırmanın başka bir yolunu bulamadım.

Modern döndürdüğü tarayıcılarda test edilebilir tam kod rve sbirlikte .bind(window)çözüm:

[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0]["ato"+([]+[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0])[2]]("cuaa")[0];
[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0]["ato"+([]+[[]["concat"]]["find"](""["concat"].bind(window)).bind(window)()[0])[2]]("cyaa")[0]