JSF ** k avec seulement 5 symboles?

Ce n’est pas un défi mais une question, j’ai pensé que c’était sur le sujet à cause de

Les questions non liées à la résolution de problèmes de programmation ou à un type de défi particulier sont également abordées.

Passons maintenant à la question:

Est-il possible d'écrire du code JavaScript avec seulement 5 lettres? JSFuck le fait déjà avec 6 symboles, !+[]()mais je me demande si le !personnage est nécessaire.

JSFuck fonctionne avec une combinaison de transtypage en chaîne (en ajoutant un tableau vide), de transtypage en nombre (en écrivant un + devant) et de transtypage en boolean en négation. Par exemple:

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

De cette chaîne, nous pouvons extraire toutes ses lettres en utilisant les crochets avec un nombre à l'intérieur, et tout nombre peut être créé en ajoutant true ensemble autant de fois.

Comme cela, beaucoup de lettres peuvent être trouvées et peuvent être concaténées en chaînes. La chaîne la plus importante à pouvoir créer est "constructor"parce qu’elle peut être utilisée pour obtenir la Functionfonction de n’importe quelle fonction, et que cet objet peut être utilisé pour exécuter des chaînes en JavaScript:

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

Comme vous pouvez le voir, !a 2 utilisations ici:

• Création de nombres pour sélectionner des lettres parmi des chaînes.
• Casting au booléen pour obtenir "true"et "false".

Le premier de ces 2 peut également être fait en utilisant l' ++incrémenteur, pas directement sur 0, mais il peut être utilisé sur des éléments à l'intérieur d'un tableau:

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

Donc, tous les nombres peuvent être créés sans !.

Le second est plus difficile. L'importance de "true"et "false"réside dans les lettres "r"et "s", qui apparaissent tous les deux dans "constructor". Je l' ai déjà trouvé toutes les autres lettres "constructor"au moyen de "undefined", "Infinity", "NaN"et en lançant des fonctions à des chaînes.

Donc, la question ultime: (comment) pouvez-vous créer des booléens, ou les lettres "r"et "s"en JavaScript en utilisant seulement +[]()?

La lettre "l"pourrait aussi aider. Il peut être obtenu sous forme nullmais je n’ai pas pu obtenir cette valeur avec ces 5 symboles. Il peut par exemple être utilisé pour obtenir des booléens si on a déjà "s":

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

La lettre "l"et "k"ensemble donneraient accès à "r":

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

N'importe quel moyen d'obtenir un booléen nullou n'importe quelle lettre r s l kserait très utile!

Une bibliothèque de ce que nous avons:

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

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

NaN: + [] [[]]

indéfini: [][[]]

0: + []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Après réflexion , le résultat semble être que, du moins sur les navigateurs modernes, il n’ya aucun moyen de le faire.

Je vais essayer de résumer l’ensemble du processus en expliquant pourquoi nous avons épuisé nos options dans tous les domaines avant de poursuivre. Ensuite, à part une nouvelle idée étonnante (comme un cas de la syntaxe JavaScript que tout le monde oublie), il sera assez clair qu'il n'y a aucun moyen de récupérer les lettres restantes.

Littéraux

La seule immédiate littéraux que vous pouvez faire avec +()[]les tableaux vides imbriqués [], [[]], [[[]]], etc. A partir de là, nous pouvons commencer des valeurs de coulée en utilisant +:

• +[]obtient zéro, ce que l'astuce de Jens se développe à l'aide de nombres entiers positifs arbitraires ++.

• []+[]est "". En fait, []+xnous obtient une représentation de chaîne xen général.

[]La prochaine utilisation est l'indexation. L'indexation d'un objet en dehors des limites ( [][[]]) vous procure undefined. Le fait de lancer cela dans une chaîne et d'indexer le résultat vous donne les lettres d e f i n u; en la convertissant en un entier en utilisant d'abord +vous obtient NaN, à partir de laquelle les lettres a Nsuivent.

En utilisant l’ ++astuce sur toute valeur non entière atteinte jusqu’à présent, on obtient NaNou une erreur. De plus, aucun des objets que nous pouvons créer n'est appelable (pour le moment), donc cela ()n'aide pas (sauf pour le groupement).

Les astuces qui restent dans notre manche sont le casting et l'indexation. La question est donc: quelles chaînes pouvons-nous créer en utilisant les caractères 0123456789adefinuNqui

• sont des nombres littéraux que nous pouvons aller-retour pour convertir de nouvelles chaînes en entier, ou
• sont les noms de propriété des objets que nous pouvons déjà atteindre?

Littéraux numériques

Comme exemple de la deuxième option, nous pouvons créer la chaîne "1e1000", puis obtenir à Infinitypartir de +"1e1000", et relancer cette chaîne en chaîne nous donne les lettres yet I.

En outre, nous pouvons créer "11e100", lancer vers le nombre et revenir à la chaîne, pour obtenir "1.1e+101", à partir de laquelle nous extrayons .et +.

À l'aide de cela ., nous pouvons créer la chaîne ".0000001", la lancer en nombre et en revenir, pour nous "1e-7"gagner -.

C'est essentiellement ce que tous les flottants auront pour vous: il n'y a pas d'autres valeurs intéressantes que Infinityet NaN, et il n'y a pas plus de caractères utilisés dans leurs représentations de chaîne habituelles que -+.0123456789e.

Propriétés

Nous avons donc les lettres -+.0123456789adefinuyIN. Quelles propriétés pouvons-nous atteindre? Demandons à 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: [] }

Seulement [].find, ce que Jens a déjà trouvé. Jetons cela dans une chaîne, récoltons toutes ses lettres et réessayons. La représentation des chaînes est un peu différente selon les navigateurs. Sur Chrome et Edge, "function find() { [native code] }"contient acdefinotuv()[]{}et un espace; notre alphabet complet est maintenant +-.()[]{}0123456789INacdefinotuvy. Sur Firefox, il y a plus d'espaces et de nouvelles lignes, mais les lettres sont les mêmes.

Nous répétons notre recherche:

>>> 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.concatest obsolète: il fait exactement ce que +fait, ce que nous pouvons déjà faire. Alors nous avons Array.prototype.concatet Array.prototype.find. Que pouvons-nous faire avec eux?

Les fonctions

concat()nous permet de créer, pour la première fois, des tableaux plus longs. [[]].concat([[]])est [[], []], et jetter cela à une chaîne nous obtient ",". (Cela ne nous aide pas à trouver de nouvelles propriétés.) Mais .concatne modifie pas nos valeurs et ne peut jamais revenir nullou quelque chose comme ça.

L'appel find()ne nous aide pas non plus: la documentation de MDN indique

La find()méthode retourne une valeur dans le tableau, si un élément du tableau satisfait à la fonction de test fournie. Sinon undefinedest retourné.

Tous les deux que nous pouvons déjà faire en utilisant l'indexation.

Et à partir de là, il n’ya nulle part où aller. Si vous doutez de quelque chose que j'ai écrit, faites-le-moi savoir dans les commentaires.

Les 3 fonctions de la réponse de Lynn n'étaient pas inutiles. Mais le mode strict dans ECMAScript 5 a déjoué mon plan.

Il y a une bizarrerie dans les anciennes versions de JavaScript / ECMAScript. Si une méthode est appelée sans objet, l'objet global windowest utilisé. Donc on peut faire ça:

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

Ceci est toujours valable pour les navigateurs modernes, mais uniquement si la fonction n'est pas définie en mode strict. Et toutes les fonctions intégrées (avec du code natif) semblaient être en mode strict. Dans les navigateurs plus anciens, lorsqu'il n'y a pas encore de mode strict, cela fonctionne également pour les fonctions intégrées.

Supposons que nous utilisions des navigateurs plus anciens. Ensuite, si nous voulons window, nous devons trouver une fonction intégrée qui retourne quelque chose contenant this. Parmi les seuls choix que nous avions, il y a la fonction qui Array.prototype.concatfait exactement cela. Nous pouvons le tester comme ceci:

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.

Donc, fondamentalement, il importe peu que l'objet sur lequel il est appelé soit un tableau (mais ce doit être un objet pour le moins). Cela l'enveloppe simplement dans un tableau sinon.

Si nous en avions un window, nous pouvons d’abord obtenir la chaîne [object Window]en la transformant en chaîne. Avec le nouveau personnage b, nous pouvons obtenir ret sutiliser les deux lignes suivantes, ainsi que tous les personnages que nous n'avions pas constructor:

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

Mais l’autre problème est de supprimer la référence à l’objet [].concat. Envelopper dans un tableau et extraire ne fonctionne pas, parce que [].concatsignifie déjà []["concat"]. Le seul moyen que je connaisse qui puisse éventuellement être construit +[]()est de le renvoyer à partir d'une fonction. Array.prototype.findsemblait pouvoir le faire:

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

Nous avons toujours eu des fonctions de vérité. Array.prototype.concatet les String.prototype.concatdeux retournent la vérité si l'objet est window. Si nous utilisons la dernière, nous avons utilisé les trois fonctions disponibles.

Mais, malheureusement, Array.prototype.findn'existe pas dans l'ancien navigateur que nous utilisons. Au moins, je n'en ai pas trouvé un qui fonctionne. Et je n'ai pas trouvé d'autre moyen de supprimer la référence à l'objet.

Le code complet qui peut être testé dans les navigateurs modernes est renvoyé ret s, avec la .bind(window)solution de contournement:

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