JSF ** k dengan hanya 5 simbol?

Ini bukan tantangan tetapi pertanyaan, saya pikir itu pada topik karena

Pertanyaan non-tantangan yang terkait dengan memecahkan teka-teki pemrograman atau jenis tantangan tertentu juga ada di topik.

Sekarang ke pertanyaan:

Mungkinkah menulis kode JavaScript hanya dengan 5 huruf? JSFuck sudah melakukan ini dengan 6 simbol !+[]()tapi saya ingin tahu apakah !karakter tersebut diperlukan.

JSFuck bekerja dengan kombinasi casting ke string (dengan menambahkan array kosong), casting ke angka (dengan menulis a + di depan) dan casting ke boolean dengan meniadakan. Sebagai contoh:

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

Dari string ini kita dapat mengekstrak semua hurufnya menggunakan tanda kurung siku dengan angka di dalamnya, dan angka apa pun dapat dibuat dengan menambahkan true bersama sebanyak itu.

Seperti ini banyak surat dapat ditemukan dan dapat digabungkan ke string. String yang paling penting untuk dapat dibuat adalah "constructor"karena dapat digunakan untuk mendapatkan Functiondari fungsi apa pun, dan objek ini dapat digunakan untuk mengeksekusi string sebagai JavaScript:

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

Seperti yang Anda lihat, !ada 2 kegunaan di sini:

• Membuat angka untuk memilih huruf dari string.
• Casting ke boolean untuk mendapatkan "true"dan "false".

Yang pertama dari 2 ini juga dapat dilakukan dengan menggunakan ++incrementor, tidak langsung aktif 0, tetapi dapat digunakan pada elemen-elemen di dalam array:

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

Jadi semua angka bisa dibuat tanpa !.

Yang kedua lebih sulit. Pentingnya "true"dan "false"terletak dalam surat-surat "r"dan "s", yang keduanya muncul di "constructor". Saya sudah menemukan semua huruf lain "constructor"dengan cara "undefined", "Infinity", "NaN"dan dengan casting fungsi untuk string.

Jadi pertanyaan terakhir: (Bagaimana) Anda bisa membuat boolean, atau huruf "r"dan "s"dalam JavaScript hanya dengan menggunakan +[]()?

Surat itu "l"mungkin juga membantu. Ini bisa didapat dari form nulltapi saya belum bisa mendapatkan nilai itu dengan 5 simbol tersebut. Misalnya dapat digunakan untuk mendapatkan boolean jika kita sudah memiliki "s":

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

Surat itu "l"dan "k"bersama - sama akan memberikan akses ke "r":

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

Cara apa pun untuk mendapatkan boolean, nullatau surat apa r s l kpun akan sangat berguna!

Perpustakaan yang kami miliki:

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

Infinity: + ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ []))

NaN: + [] [[]]

tidak terdefinisi: [][[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Setelah melakukan brainstorming , hasilnya tampaknya, setidaknya pada browser modern, tidak ada cara untuk melakukan ini.

Saya akan mencoba merangkum seluruh proses, menambahkan beberapa alasan tentang mengapa kami telah kehabisan opsi kami di domain tertentu sebelum melanjutkan. Kemudian, kecuali beberapa jenis wawasan baru yang menakjubkan (seperti, kasus sudut sintaksis JavaScript yang dilupakan oleh semua orang), akan sangat jelas bahwa tidak ada cara untuk mendapatkan surat-surat yang tersisa.

Literal

Satu-satunya langsung literal Anda dapat membuat dengan +()[]adalah array kosong bersarang [], [[]], [[[]]], dll Dari sana, kita bisa mulai casting nilai-nilai menggunakan +:

• +[]mendapat nol, yang trik Jens meluas ke bilangan bulat positif sewenang-wenang menggunakan ++.

• []+[]adalah "". Bahkan, []+xmembuat kita representasi string xsecara umum.

[]Penggunaan selanjutnya adalah pengindeksan. Pengindeksan objek di luar batas ( [][[]]) membuat Anda undefined. Melemparkannya ke string dan mengindeks hasilnya membuat Anda mendapatkan surat d e f i n u; melemparkannya ke integer terlebih dahulu menggunakan +membuat Anda NaN, dari mana huruf-huruf a Nmengikuti.

Menggunakan ++trik pada nilai non-integer yang dicapai sejauh ini baik memberi NaNatau kesalahan. Selain itu, tidak ada objek yang dapat kita buat yang dapat dipanggil (belum), jadi ()tidak membantu (kecuali untuk pengelompokan).

Trik yang tersisa di lengan kami adalah casting dan indexing. Jadi pertanyaannya adalah: string mana yang bisa kita buat menggunakan karakter 0123456789adefinuNyang baik

• adalah jumlah literal yang dapat kita putar untuk integer untuk mendapatkan string baru, atau
• Apakah nama properti dari objek yang sudah dapat kita jangkau?

Jumlah literal

Sebagai contoh dari opsi kedua, kita dapat membuat string "1e1000", lalu mendapatkan Infinitydari +"1e1000", dan melemparkannya kembali ke string memberi kita surat ydan I.

Juga, kita dapat membuat "11e100", melemparkan ke nomor dan kembali ke string, untuk mendapatkan "1.1e+101", dari mana kita mengekstrak .dan +.

Dengan menggunakan itu ., pada gilirannya, kita dapat membuat string ".0000001", melemparkannya ke nomor dan kembali, untuk mendapatkan "1e-7", memenangkan kita -.

Pada dasarnya itu semua float akan memberi Anda: tidak ada nilai lebih menarik selain Infinitydan NaN, dan tidak ada lagi karakter yang digunakan dalam representasi string mereka yang biasa selain -+.0123456789e.

Properti

Jadi kami punya surat-suratnya -+.0123456789adefinuyIN. Properti mana yang bisa kita jangkau? Mari kita bertanya JavaScript.

>>> 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: [] }

Hanya [].find, yang sudah ditemukan Jens. Mari kita melemparkannya ke sebuah string, menuai semua suratnya, dan coba lagi. Representasi string sedikit berbeda di seluruh browser. Di Chrome dan Edge, "function find() { [native code] }"berisi acdefinotuv()[]{}dan spasi; alfabet lengkap kami adalah sekarang +-.()[]{}0123456789INacdefinotuvy. Di Firefox, ada lebih banyak ruang dan baris baru, tetapi hurufnya sama.

Kami ulangi pencarian kami:

>>> 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.concatsudah usang: ia melakukan apa yang +dilakukannya, yang sudah bisa kita lakukan. Jadi kami punya Array.prototype.concatdan Array.prototype.find. Apa yang bisa kita lakukan dengan mereka?

Fungsi

concat()mari kita buat, untuk pertama kalinya, array yang lebih panjang. [[]].concat([[]])adalah [[], []], dan casting itu ke string membuat kita ",". (Ini tidak membantu kami menemukan properti baru.) Tetapi .concattidak mengubah nilai-nilai kami, dan itu tidak pernah dapat kembali nullatau yang seperti itu.

Menelepon find()juga tidak membantu: dokumentasi MDN mengatakan

The find()Metode mengembalikan nilai dalam array, jika elemen dalam memenuhi berbagai fungsi pengujian yang disediakan. Kalau undefinedtidak dikembalikan.

Kedua hal itu sudah bisa kita lakukan menggunakan pengindeksan.

Dan dari sini, tidak ada tempat lain untuk pergi. Jika Anda meragukan sesuatu yang saya tulis, beri tahu saya di komentar.

3 fungsi dalam jawaban Lynn tidaklah sia-sia. Tetapi mode ketat dalam ECMAScript 5 menggagalkan rencana saya.

Ada kekhasan dalam versi JavaScript / ECMAScript yang lebih lama. Jika suatu metode disebut tanpa objek, objek global windowdiasumsikan. Jadi kita bisa melakukan ini:

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

Ini masih berlaku untuk peramban modern, tetapi hanya jika fungsinya tidak ditentukan dalam mode ketat. Dan semua fungsi bawaan (dengan kode asli) tampaknya berada dalam mode ketat. Di peramban lama saat belum ada mode ketat, ini juga berfungsi untuk fungsi bawaan.

Asumsikan kita menggunakan browser lama. Maka jika kita mau window, kita harus menemukan fungsi bawaan yang mengembalikan sesuatu yang berisi this. Dalam satu-satunya pilihan yang kami miliki, ada fungsi yang Array.prototype.concatmelakukan hal itu. Kita bisa mengujinya seperti ini:

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.

Jadi pada dasarnya itu tidak peduli apakah objek yang dipanggil adalah array (tetapi setidaknya harus menjadi objek). Itu hanya membungkusnya dalam array jika tidak.

Jika sudah window, pertama-tama kita bisa mendapatkan string [object Window]dengan melemparkannya ke string. Dengan karakter baru b, kita dapat memperoleh rdan smenggunakan dua baris berikut masing-masing, dan setiap karakter yang tidak kita miliki constructor:

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

Tetapi masalah lainnya adalah menghapus referensi objek [].concat. Membungkusnya dalam sebuah array dan mengekstraksi tidak berfungsi, karena [].concatsudah berarti []["concat"]. Satu-satunya cara saya tahu yang mungkin bisa dibangun menggunakan +[]()adalah mengembalikannya dari suatu fungsi. Array.prototype.findsepertinya bisa melakukan itu:

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

Kami selalu memiliki fungsi kebenaran. Array.prototype.concatdan String.prototype.concatkeduanya mengembalikan kebenaran jika objeknya window. Jika kami menggunakan yang terakhir, kami menggunakan ketiga fungsi yang tersedia.

Namun, sayangnya, Array.prototype.findtidak ada di browser lama yang kami gunakan. Setidaknya saya tidak menemukan satu yang berfungsi. Dan saya tidak menemukan cara lain untuk menghapus referensi objek.

Kode lengkap yang dapat diuji di browser modern yang mengembalikan rdan s, dengan .bind(window)solusinya:

[[]["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]