केवल 5 प्रतीकों के साथ JSF ** k?

Question

यह एक चुनौती नहीं है बल्कि एक सवाल है, मुझे लगा कि इसकी वजह से यह विषय पर है

गैर-चुनौती वाले प्रश्न जो प्रोग्रामिंग पहेली को सुलझाने से संबंधित हैं या एक विशेष प्रकार की चुनौती भी विषय पर हैं।

अब इस सवाल पर:

क्या केवल 5 अक्षरों के साथ किसी भी जावास्क्रिप्ट कोड को लिखना संभव है? JSFuck पहले से ही 6 प्रतीकों के साथ ऐसा करता है !+[]()लेकिन मुझे आश्चर्य है कि अगर !चरित्र की आवश्यकता है।

JSFuck स्ट्रिंग के लिए कास्टिंग के संयोजन के साथ काम करता है (एक खाली सरणी जोड़कर), संख्या के लिए कास्टिंग (एक + सामने लिखकर) और नकारात्मक द्वारा बूलियन को कास्टिंग। उदाहरण के लिए:

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

इस स्ट्रिंग से हम स्क्वायर ब्रैकेट का उपयोग करके सभी अक्षरों को अंदर की संख्या के साथ निकाल सकते हैं, और किसी भी संख्या को एक साथ सही जोड़कर कई बार बनाया जा सकता है।

इस तरह से बहुत सारे पत्र मिल सकते हैं और तार को समेटा जा सकता है। बनाने में सक्षम होने के लिए सबसे महत्वपूर्ण स्ट्रिंग है "constructor"क्योंकि इसका उपयोग Functionकिसी भी फ़ंक्शन से प्राप्त करने के लिए किया जा सकता है , और इस ऑब्जेक्ट का उपयोग स्ट्रिंग्स को जावास्क्रिप्ट के रूप में निष्पादित करने के लिए किया जा सकता है:

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

जैसा कि आप देख सकते हैं, !यहाँ 2 उपयोग हैं:

• तार से अक्षरों का चयन करने के लिए संख्याएँ बनाना।
• पाने के लिए बूलियन के लिए कास्टिंग "true"और "false"।

इन 2 में से पहला भी ++incrementor का उपयोग करके किया जा सकता है , सीधे पर नहीं 0, बल्कि इसे एक array के अंदर तत्वों पर इस्तेमाल किया जा सकता है:

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

तो सभी नंबरों के बिना बनाया जा सकता है !।

दूसरा मुश्किल ज्यादा है। अक्षरों में "true"और के महत्व और , जो दोनों में दिखाई देते हैं । मैं पहले से ही अन्य सभी पत्र मिल गया है के माध्यम से , , और तार करने के लिए कार्य करता है कास्टिंग द्वारा।"false""r""s""constructor""constructor""undefined""Infinity""NaN"

तो अंतिम सवाल: (कैसे) आप केवल उपयोग करके बूलियन, या पत्र "r"और "s"जावास्क्रिप्ट बना सकते हैं +[]()?

पत्र "l"भी मदद कर सकता है। इसे फॉर्म प्राप्त किया जा सकता है nullलेकिन मैं उन 5 प्रतीकों के साथ उस मूल्य को प्राप्त करने में सक्षम हूं। उदाहरण के लिए इसका उपयोग मलहम प्राप्त करने के लिए किया जा सकता है यदि हमारे पास पहले से ही है "s":

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

पत्र "l"और "k"साथ में पहुँच देगा "r":

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

बूलियन प्राप्त करने का कोई भी तरीका, nullया कोई भी पत्र r s l kबहुत उपयोगी होगा!

हमारे पास जो कुछ है उसका एक पुस्तकालय:

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

अनंत: + ((+ ([[]] [+]] + []] + ([[] [[]] + []] [(++ [[]] [+]] + (+) + [[]] [[]]) + (++ [[]] [[]])]) + (++ [[]] [[]] []) + (+ []) + (+ []) + (+ []))

NaN: + [] [[]]

अपरिभाषित: [] [[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

एन: (+ [] [[]] + []] [+ []]

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

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

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

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

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

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

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

Comments

यह codegolf.stackexchange.com/q/11690/194 से बहुत निकटता से संबंधित है , और यदि उस प्रश्न का JS उत्तर होता तो मैं बंद करने के लिए मतदान करता। जैसा कि यह है, इस सवाल का एक उत्तर पहले के प्रश्न के उत्तर में सीधे अनुवाद करने की संभावना है, लेकिन अंतर यह पर्याप्त रूप से सीमा रेखा बनाता है कि मैं एकतरफा बंद नहीं करना चाहता।

— पीटर टेलर

बहुत अच्छा सवाल है। मैं गूढ़ प्रोग्रामिंग और अपरंपरागत कम्प्यूटेशनल मॉडल के बारे में सवाल के बिल्कुल पक्ष में हूं , लेकिन कुछ लोगों को मतदान के लिए तैयार रहना चाहिए, क्योंकि वर्तमान में यह काफी हद तक फिट नहीं है जो लोग मेटा पर सहमत हैं। हालांकि मुझे इस तरह के सवालों के लिए एक मिसाल कायम करनी होगी। :)

— मार्टिन एंडर

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— एलेक्स ए।

इस तरह के सवाल मुझे इच्छा करते हैं कि एक प्रश्न के लिए एक इनाम देने की सुविधा थी।

— xnor

मुझे अनुमति के evalसाथ 2453 चर मिले window।

— कैलक्यूलेटरफिलीन

Answer 1

बुद्धिशीलता के बाद , परिणाम ऐसा लगता है कि, आधुनिक ब्राउज़र पर कम से कम, ऐसा करने का कोई तरीका नहीं है।

मैं पूरी प्रक्रिया को संक्षेप में बताने की कोशिश करूंगा, जिससे हम आगे बढ़ने से पहले किसी भी डोमेन में अपने विकल्पों को समाप्त करने के बारे में कुछ तर्क जोड़ सकते हैं। फिर, किसी प्रकार की अद्भुत नई अंतर्दृष्टि (जैसे, जावास्क्रिप्ट सिंटैक्स का एक कोना हर किसी के बारे में भूल रहा है) को छोड़कर, यह बहुत स्पष्ट होगा कि शेष पत्र प्राप्त करने का कोई तरीका नहीं है।

शाब्दिक

केवल तत्काल शाब्दिक आप के साथ कर सकते हैं +()[]नेस्टेड खाली सरणियों हैं [], [[]], [[[]]], आदि वहाँ से, हम कास्टिंग का उपयोग कर मूल्यों शुरू कर सकते हैं +:

• +[]शून्य हो जाता है, जो जेन्स की चाल का उपयोग करके मनमाने ढंग से सकारात्मक पूर्णांक तक फैलता है ++।

• []+[]है ""। वास्तव में, []+xहमें xसामान्य रूप से एक स्ट्रिंग प्रतिनिधित्व मिलता है ।

[]अगला उपयोग अनुक्रमण है। किसी वस्तु को अनुक्रमित करने के लिए ( [][[]]) आपको प्राप्त होता है undefined। कास्टिंग कि एक स्ट्रिंग और परिणाम अनुक्रमण करने के लिए आप पत्र प्राप्त करता है d e f i n u; इसका उपयोग करते हुए इसे एक पूर्णांक तक ले जाना सबसे पहले +आपको मिलता है NaN, जिसमें से अक्षर आते a Nहैं।

++अब तक पहुंची किसी भी गैर-पूर्णांक मूल्य पर चाल का उपयोग करना NaNया तो एक त्रुटि देता है । इसके अलावा, हमारे द्वारा बनाई गई कोई भी वस्तु कॉल करने योग्य (अभी तक) नहीं है, इसलिए ()मदद नहीं करता है (समूह को छोड़कर)।

हमारी आस्तीन में शेष चालें कास्टिंग और अनुक्रमण हैं। तो सवाल यह है 0123456789adefinuNकि हम किन वर्णों का उपयोग करके बना सकते हैं

• वे नंबर शाब्दिक हैं जिन्हें हम नए तार प्राप्त करने के लिए पूर्णांक में राउंड-ट्रिप कास्ट कर सकते हैं, या
• उन वस्तुओं के नाम हैं जिन्हें हम पहले ही प्राप्त कर सकते हैं?

नंबर शाब्दिक

दूसरा विकल्प का एक उदाहरण के रूप में, हम स्ट्रिंग कर सकते हैं "1e1000", और फिर पाने Infinityसे +"1e1000", और कास्टिंग कि वापस स्ट्रिंग के लिए हमें पत्र हो जाता है yऔर I।

इसके अलावा, हम कर सकते हैं "11e100", संख्या और वापस स्ट्रिंग के लिए "1.1e+101", पाने के लिए , जिसमें से हम निकालने .और +।

इसका उपयोग करते हुए ., बदले में, हम स्ट्रिंग बना सकते हैं ".0000001", इसे नंबर और बैक में डाल सकते हैं "1e-7", हमें जीतने के लिए -।

यह मूल रूप से सभी फ़्लोट्स आपको मिलेगा: इसके अलावा Infinityऔर कोई दिलचस्प मूल्य NaNनहीं हैं, और इसके अलावा उनके सामान्य स्ट्रिंग अभ्यावेदन में उपयोग किए जाने वाले कोई और वर्ण नहीं हैं -+.0123456789e।

गुण

इसलिए हमारे पास पत्र हैं -+.0123456789adefinuyIN। हम कौन से गुणों तक पहुँच सकते हैं? चलो जावास्क्रिप्ट पूछना।

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

केवल [].find, जो जेन्स ने पहले ही पाया था। आइए इसे एक तार में डालें, इसके सभी अक्षरों को काटें, और फिर से कोशिश करें। स्ट्रिंग प्रतिनिधित्व ब्राउज़र में थोड़ा अलग है। Chrome और Edge में, "function find() { [native code] }"सम्‍मिलित acdefinotuv()[]{}और एक स्थान है; हमारी पूरी वर्णमाला अब है +-.()[]{}0123456789INacdefinotuvy। फ़ायरफ़ॉक्स पर, अधिक स्थान और newlines हैं, लेकिन पत्र समान हैं।

हम अपनी खोज दोहराते हैं:

>>> 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.concatपदावनत किया जाता है: यह वास्तव में वही +करता है, जो हम पहले से ही कर सकते हैं। तो हमारे पास Array.prototype.concatऔर Array.prototype.find। हम उनके साथ क्या कर सकते हैं?

कार्य

concat()हमें पहली बार, अब सरणियाँ बनाने देता है। [[]].concat([[]])है [[], []], और एक स्ट्रिंग के लिए कास्टिंग हमें मिलता है ","। (यह हमें नए गुण खोजने में मदद नहीं करता है।) लेकिन .concatहमारे मूल्यों को संशोधित नहीं करता है, और यह कभी नहीं लौट सकता है nullया ऐसा कुछ भी नहीं कर सकता है।

कॉल find()करने से हमें मदद नहीं मिलती: MDN प्रलेखन कहता है

find()विधि, सरणी में एक मान देता है यदि सरणी संतुष्ट में एक तत्व प्रदान की परीक्षण कार्य करते हैं। अन्यथा undefinedवापस कर दिया जाता है।

उन दोनों को हम पहले से ही अनुक्रमण का उपयोग करके कर सकते हैं।

---

और यहाँ से, और कहीं नहीं जाना है। यदि आपको मेरे द्वारा लिखी गई किसी बात पर संदेह है, तो मुझे टिप्पणियों में बताएं।

Comments

मेरा व्यक्तिगत दृष्टिकोण मैं अकेला अतीत घंटे में साथ काम किया है सभी संभव मिले हैं nullलौटने कार्य: String.prototype.match, RegExp.exec, और Array.prototype.includes। इन सभी को बनाना असंभव है, जब तक कि एक regex बनाने का एक अजीब तरीका नहीं है, जिसके बारे में मुझे नहीं पता है, मैंने यह भी निष्कर्ष निकाला है कि ऐसा करने का कोई संभावित तरीका नहीं है।

— कॉनर ओ'ब्रायन

अच्छा विश्लेषण! यह शायद सही जवाब है, लेकिन मैं अभी भी कुछ चाल की उम्मीद कर रहा हूं ... शायद झूठी उम्मीद हालांकि :)

— जेन्स रेंडर्स

यदि हम पकड़ने और फेंकने के लिए पत्र प्राप्त कर सकते हैं, तो क्या हम त्रुटि के पत्र प्राप्त कर सकते हैं? वह 'हिर ’है।

— R

यहां तक ​​कि अगर हम स्ट्रिंग्स का निर्माण करते हैं , "catch"और "throw"जो हम वर्तमान में नहीं कर सकते हैं, तो हमें evalउन कीवर्ड के रूप में उपयोग करने के लिए कुछ - कुछ चाहिए , जो कि हमारा लक्ष्य है।

— लिन

ऋणात्मक संख्याओं का उपयोग -और संख्या कास्टिंग संभव है , लेकिन यह बहुत उपयोगी नहीं है।

— कैलक्यूलेटरफलाइन

Answer 2

लिन के जवाब में 3 कार्य बेकार नहीं थे। लेकिन ECMAScript 5 में सख्त मोड ने मेरी योजना को विफल कर दिया।

जावास्क्रिप्ट / ECMAScript के पुराने संस्करणों में एक विचित्रता है। यदि किसी विधि को बिना वस्तु के कहा जाता है, तो वैश्विक वस्तु windowमान ली जाती है। तो हम यह कर सकते हैं:

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

यह आधुनिक ब्राउज़रों के लिए अभी भी सही है, लेकिन केवल अगर फ़ंक्शन को सख्त मोड में परिभाषित नहीं किया गया है। और सभी अंतर्निहित फ़ंक्शन (मूल कोड के साथ) सख्त मोड में लग रहे थे। पुराने ब्राउज़रों में जब अभी तक सख्त मोड नहीं है, तो यह अंतर्निहित कार्यों के लिए भी काम करता है।

मान लें कि हम पुराने ब्राउज़र का उपयोग कर रहे हैं। फिर अगर हम चाहते हैं window, तो हमें एक अंतर्निहित फ़ंक्शन ढूंढना होगा, जिसमें कुछ शामिल है this। केवल हमारे पास विकल्प थे, वहाँ Array.prototype.concatठीक वही कर रहा है। हम इसे इस तरह से परख सकते हैं:

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.

इसलिए मूल रूप से यह परवाह नहीं करता है कि जिस वस्तु को कहा जाता है वह एक सरणी है (लेकिन यह कम से कम एक वस्तु होनी चाहिए)। यह सिर्फ एक सरणी में लपेटता है अगर नहीं।

अगर हमारे पास था window, तो सबसे पहले हम स्ट्रिंग [object Window]को एक स्ट्रिंग के द्वारा प्राप्त कर सकते हैं । नए वर्ण के साथ b, हम क्रमशः निम्नलिखित दो पंक्तियों को प्राप्त कर सकते हैं rऔर sउनका उपयोग कर सकते हैं, और प्रत्येक वर्ण जो हमारे पास नहीं था constructor:

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

लेकिन दूसरी समस्या वस्तु संदर्भ को हटाने की है [].concat। इसे एक सरणी में लपेटना और निकालना काम नहीं करता है, क्योंकि [].concatपहले से ही इसका मतलब है []["concat"]। एकमात्र तरीका जो मुझे पता है कि संभवतः इसका उपयोग करके निर्माण किया जा सकता है +[]()इसे एक फ़ंक्शन से वापस करना है। Array.prototype.findऐसा करने में सक्षम होना चाहिए:

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

हमारे पास हमेशा सत्य कार्य थे। Array.prototype.concatऔर String.prototype.concatयदि वस्तु है तो दोनों सत्य लौटाते हैं window। यदि हम बाद के एक का उपयोग करते हैं, तो हमने तीन उपलब्ध कार्यों में से सभी का उपयोग किया।

लेकिन, दुर्भाग्यवश, Array.prototype.findहमारे द्वारा उपयोग किए जा रहे पुराने ब्राउज़र में मौजूद नहीं है। कम से कम मुझे एक काम नहीं मिला। और मुझे ऑब्जेक्ट रेफरेंस को हटाने का दूसरा तरीका नहीं मिला।

पूर्ण कोड जो आधुनिक ब्राउज़रों में परीक्षण योग्य है , जो रिटर्न rऔर वर्कअराउंड के sसाथ .bind(window):

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

Comments

कूल जानकारी। आपने कौन से ब्राउज़र आज़माए हैं?

— लिन

@ लियन कई नहीं। ज्यादातर फ़ायरफ़ॉक्स 3.6.0 और 25.0। मैं यहाँ और यहाँ से पढ़ता हूँ जो findसख्त मोड की तुलना में बहुत बाद में आया है इसलिए कुछ काम करना संभव नहीं है। मैंने एज के बारे में पूछा क्योंकि मुझे लगा कि यह मानक का पालन करने के लिए पिछड़ी संगतता को प्राथमिकता देने का मौका हो सकता है। मैंने भी इसी कारण कोंकणोर की कोशिश की। और कुछ कमांड लाइन ब्राउज़र, लेकिन उनमें से कोई भी जावास्क्रिप्ट का समर्थन नहीं करता है।

— jimmy23013

मैंने सफारी 7.1 और 8 की कोशिश की, और ब्राउज़र स्क्रीनशॉट वेबसाइट पर फोन पर कुछ यादृच्छिक माना जाने वाला डिफ़ॉल्ट ब्राउज़र। अब तक कोई काम नहीं करता।

— jimmy23013

@ jimmy23013 सफारी 5.0 या 5.1 आज़माएं। कैन आई यूज़ के अनुसार , पुरानी सफारी में आंशिक समर्थन सख्त मोड को संदर्भित करता है जो अभी भी बहुत सारे जेएस को स्वीकार करता है जिसे अमान्य माना जाना चाहिए। हालांकि findअभी तक लागू नहीं किया गया था, शायद यह आंशिक रूप से था! ... यदि केवल उनकी सूची में था ...

— mbomb007