JSF ** k chỉ có 5 ký hiệu?

Đây không phải là một thách thức mà là một câu hỏi, tôi đoán nó thuộc chủ đề vì

Các câu hỏi không thử thách liên quan đến việc giải các câu đố lập trình hoặc một loại thử thách cụ thể cũng thuộc chủ đề.

Bây giờ đến câu hỏi:

Có thể viết bất kỳ mã JavaScript nào chỉ với 5 chữ cái không? JSFuck đã làm điều này với 6 biểu tượng !+[]()nhưng tôi tự hỏi liệu !nhân vật có cần thiết không.

JSFuck hoạt động với sự kết hợp giữa việc truyền vào chuỗi (bằng cách thêm một mảng trống), truyền vào số (bằng cách viết dấu + ở phía trước) và chuyển sang boolean bằng cách phủ định. Ví dụ:

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

Từ chuỗi này, chúng ta có thể trích xuất tất cả các chữ cái bằng cách sử dụng dấu ngoặc vuông có một số bên trong và bất kỳ số nào cũng có thể được tạo bằng cách thêm đúng với nhau nhiều lần.

Như thế này rất nhiều chữ cái có thể được tìm thấy và có thể được nối với các chuỗi. Chuỗi quan trọng nhất có thể tạo là "constructor"bởi vì nó có thể được sử dụng để lấy Functiontừ bất kỳ chức năng nào và đối tượng này có thể được sử dụng để thực thi các chuỗi dưới dạng JavaScript:

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

Như bạn có thể thấy, !có 2 cách sử dụng ở đây:

• Tạo số để chọn chữ cái từ chuỗi.
• Đúc để boolean để có được "true"và "false".

Cái đầu tiên trong số 2 cái này cũng có thể được thực hiện bằng cách sử dụng bộ ++tăng, không trực tiếp trên 0, nhưng nó có thể được sử dụng trên các phần tử bên trong một mảng:

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

Vì vậy, tất cả các số có thể được tạo ra mà không có !.

Cái thứ hai khó hơn. Tầm quan trọng của "true"và "false"nằm trong các chữ cái "r"và "s", cả hai đều xuất hiện trong "constructor". Tôi đã tìm thấy tất cả các chữ khác "constructor"bằng phương tiện "undefined", "Infinity", "NaN"và bằng cách đúc chức năng để chuỗi.

Vì vậy, câu hỏi cuối cùng: (Làm thế nào) bạn có thể tạo booleans, hoặc các chữ cái "r"và "s"bằng JavaScript chỉ bằng cách sử dụng +[]()?

Bức thư "l"cũng có thể giúp đỡ. Nó có thể được lấy mẫu nullnhưng tôi chưa thể có được giá trị đó với 5 biểu tượng đó. Ví dụ, nó có thể được sử dụng để lấy booleans nếu chúng ta đã có "s":

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

Bức thư "l"và "k"cùng nhau sẽ cung cấp quyền truy cập vào "r":

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

Bất kỳ cách nào để có được một boolean, nullhoặc bất kỳ chữ cái r s l knào sẽ rất hữu ích!

Một thư viện của những gì chúng ta có:

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

Vô cực: + ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (+ + [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ []))

NaN: + [] [[]]

chưa xác định: [][[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Tôi: (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []])]) + (++ [[]] [+ []] + []) + (+ [] + + (+ []) + (+ [])) + []) [+ []]

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

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

((([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] + []) [(++ [[]] [+ [ |]] + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []])]) + (([[] [[]] + []) [++ [[]] [+ []]])) + (([] [[]] + [] ) [(++ [[]] [+ []]) + (++ [[]] [+ []])])]] + []) [+ (++ [[]] [+ []] + [] + ((++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]))))]]]

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

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

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

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

,:[[]] [([] [(([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([[] [[]] + []) [(++ [[]] [[[]]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []])]) + (([[[[]] + []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ [ Hoặc] (++ [[]] [+ []]) + (++ [[]] [+ []])] + ([] [(([] [[]] + []) [ (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [ + []])]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + ( ++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])]) + (([] [[]] +] []) [++ [[]] [+ []]]) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []])])] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [ []] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])) + (++ [[]] [+ []] ;] + ([] [[]] + []) [++ [[]] [+ []]] + ([] [(([] [[]] + []) [(++ [[ [] [+ []]) + (++ [[]] [+ []])) + (++ [[]] [+ []]) + (++ [[]] [+ []]) ") + (([[] [[]] + []) [(++ [[]] [+ []]) + + [] [] [)] + (++ [[]] [+ []]) + + [++ [[]] [+ []]]) + (([[[[]] + []) [(++ [[]] [+ []]) + (++ [[]] [ + []])])] + [[) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + + (++ [[]] [+ []])] + (+ []] [[]] + []) [++ [[]] [+ []]] + (+ ((++ [[]] [+ []] + []) + (([] [[]] + []) [(++ [[]] [+ []]) + (++ [[]] [+ []]) + (++ [[]] [+ []])])) + ( ++ [[]] [+ []] + []) + (+ []) + (+ []) + (+ [])) + []) [(++ [[]] [+ [] |) + (++ [[]] [+ []]) + (++ [[]] [+ []]) + + (++ [[]] [+ []]) + (++ [[ [] [+ []]) + (++ [[]] [+ []])]] [([[]]) + []

Sau khi động não , kết quả dường như là, trên các trình duyệt hiện đại ít nhất, không có cách nào để làm điều này.

Tôi sẽ cố gắng tóm tắt toàn bộ quá trình, thêm một số lý do về lý do tại sao chúng tôi sử dụng hết các tùy chọn của mình trong bất kỳ miền nào trước khi tiếp tục. Sau đó, loại bỏ một số loại hiểu biết mới tuyệt vời (như, một trường hợp cú pháp JavaScript mà mọi người đều quên), sẽ khá rõ ràng rằng không có cách nào để có được các chữ cái còn lại.

Văn học

Các chỉ ngay lập tức literals bạn có thể thực hiện với +()[]những mảng trống lồng nhau [], [[]], [[[]]]vv Từ đó, chúng ta có thể bắt đầu đúc giá trị sử dụng +:

• +[]bằng không, mà mánh khóe của Jens mở rộng sang các số nguyên dương tùy ý sử dụng ++.

• []+[]là "". Trong thực tế, []+xchúng ta có một đại diện chuỗi xnói chung.

[]Sử dụng tiếp theo là lập chỉ mục. Lập chỉ mục một đối tượng nằm ngoài giới hạn ( [][[]]) giúp bạn undefined. Truyền chuỗi đó thành một chuỗi và lập chỉ mục kết quả sẽ đưa bạn các chữ cái d e f i n u; đúc nó thành một số nguyên đầu tiên bằng cách sử dụng +giúp bạn NaN, từ đó các chữ cái a Ntheo sau.

Sử dụng ++thủ thuật trên bất kỳ giá trị không nguyên nào đạt được cho đến nay đều cho NaNhoặc lỗi. Ngoài ra, không có đối tượng nào chúng tôi có thể tạo là có thể gọi được (chưa), vì vậy ()không giúp ích gì (ngoại trừ việc nhóm).

Các thủ thuật còn lại lên tay áo của chúng tôi là đúc và lập chỉ mục. Vì vậy, câu hỏi là: trong đó chuỗi chúng ta có thể tạo ra bằng cách sử dụng ký tự 0123456789adefinuNmà một trong hai

• là những chữ số chúng ta có thể truyền khứ hồi thành số nguyên để có chuỗi mới hoặc
• tên tài sản của các đối tượng chúng ta đã có thể tiếp cận?

Số chữ

Như một ví dụ về tùy chọn thứ hai, chúng ta có thể tạo chuỗi "1e1000", sau đó lấy Infinitytừ +"1e1000"và chuyển chuỗi đó trở lại chuỗi cho chúng ta các chữ cái yvà I.

Ngoài ra, chúng ta có thể thực hiện "11e100", chuyển thành số và quay lại chuỗi, để lấy "1.1e+101", từ đó chúng ta trích xuất .và +.

Sử dụng điều đó ., đến lượt chúng ta có thể tạo chuỗi ".0000001", chuyển nó thành số và quay lại, để có được "1e-7", chiến thắng chúng ta -.

Về cơ bản, tất cả các số float sẽ giúp bạn: không có bất kỳ giá trị thú vị nào khác ngoài Infinityvà NaN, và không có thêm ký tự nào được sử dụng trong các biểu diễn chuỗi thông thường của chúng ngoài -+.0123456789e.

Tính chất

Vì vậy, chúng tôi có các chữ cái -+.0123456789adefinuyIN. Những tính chất nào chúng ta có thể đạt được? Hãy hỏi 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: [] }

Chỉ [].find, mà Jens đã tìm thấy. Hãy tạo chuỗi đó thành chuỗi, gặt tất cả các chữ cái của nó và thử lại. Đại diện chuỗi là một chút khác nhau trên các trình duyệt. Trên Chrome và Edge, "function find() { [native code] }"chứa acdefinotuv()[]{}và một khoảng trắng; bảng chữ cái đầy đủ của chúng tôi bây giờ +-.()[]{}0123456789INacdefinotuvy. Trên Firefox, có nhiều khoảng trắng và dòng mới hơn, nhưng các chữ cái đều giống nhau.

Chúng tôi lặp lại tìm kiếm của chúng tôi:

>>> 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.concatkhông được dùng nữa: nó thực hiện chính xác những gì +chúng ta có thể làm. Vì vậy, chúng tôi đã nhận Array.prototype.concatvà Array.prototype.find. Chúng ta có thể làm gì với họ?

Chức năng

concat()cho phép chúng ta tạo lần đầu tiên các mảng dài hơn. [[]].concat([[]])là [[], []], và truyền nó đến một chuỗi được chúng ta ",". (Điều này không giúp chúng tôi tìm các thuộc tính mới.) Nhưng .concatkhông sửa đổi các giá trị của chúng tôi và nó không bao giờ có thể trả lại nullhoặc bất cứ điều gì tương tự.

Gọi find()cũng không giúp chúng tôi: tài liệu MDN nói

Các find()phương thức trả về một giá trị trong mảng, nếu một phần tử trong mảng thoả mãn được cung cấp chức năng kiểm tra. Nếu không thì undefinedđược trả lại.

Cả hai chúng ta đều có thể sử dụng lập chỉ mục.

Và từ đây, không còn nơi nào để đi. Nếu bạn nghi ngờ bất cứ điều gì tôi đã viết, hãy cho tôi biết trong các ý kiến.

3 chức năng trong câu trả lời của Lynn không phải là vô dụng. Nhưng chế độ nghiêm ngặt trong ECMAScript 5 đã phá vỡ kế hoạch của tôi.

Có một sự giải quyết trong các phiên bản cũ hơn của JavaScript / ECMAScript. Nếu một phương thức được gọi mà không có đối tượng, thì đối tượng toàn cục windowđược giả sử. Vì vậy, chúng ta có thể làm điều này:

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

Điều này vẫn đúng với các trình duyệt hiện đại, nhưng chỉ khi chức năng không được xác định trong chế độ nghiêm ngặt. Và tất cả các hàm dựng sẵn (với mã gốc) dường như ở chế độ nghiêm ngặt. Trong các trình duyệt cũ hơn khi chưa có chế độ nghiêm ngặt, điều này cũng hoạt động cho các chức năng tích hợp.

Giả sử chúng ta đang sử dụng các trình duyệt cũ hơn. Sau đó, nếu chúng ta muốn window, chúng ta phải tìm một hàm dựng sẵn trả về một cái gì đó có chứa this. Trong các lựa chọn duy nhất chúng tôi có, có chức năng Array.prototype.concatthực hiện chính xác điều đó. Chúng ta có thể kiểm tra nó như thế này:

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.

Vì vậy, về cơ bản, nó không quan tâm đến việc đối tượng mà nó được gọi là một mảng (nhưng ít nhất nó phải là một đối tượng). Nó chỉ bọc nó trong một mảng nếu không.

Nếu chúng ta có window, trước tiên chúng ta có thể lấy chuỗi [object Window]bằng cách chuyển chuỗi thành chuỗi. Với nhân vật mới b, chúng ta có thể nhận rvà ssử dụng hai dòng sau và mỗi nhân vật chúng ta không có constructor:

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

Nhưng vấn đề khác là loại bỏ tham chiếu đối tượng từ [].concat. Gói nó trong một mảng và trích xuất không hoạt động, bởi vì [].concatđã có nghĩa []["concat"]. Cách duy nhất tôi biết có thể được xây dựng bằng cách sử dụng +[]()là trả về nó từ một hàm. Array.prototype.finddường như có thể làm điều đó:

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

Chúng tôi đã luôn luôn có chức năng trung thực. Array.prototype.concatvà String.prototype.concatcả hai trả lại sự thật nếu đối tượng là window. Nếu chúng ta sử dụng cái sau, chúng ta đã sử dụng tất cả ba chức năng có sẵn.

Nhưng, thật không may, Array.prototype.findkhông tồn tại trong trình duyệt cũ mà chúng ta đang sử dụng. Ít nhất tôi đã không tìm thấy một hoạt động. Và tôi đã không tìm thấy một cách khác để loại bỏ các tham chiếu đối tượng.

Mã hoàn chỉnh có thể kiểm tra được trong các trình duyệt hiện đại trả về rvà s, với .bind(window)cách giải quyết:

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