[Ludique] Coder en Javascript avec seulement 3 caractères

Salut à tous,

En me renseignant sur les techniques d'obfuscation en Javascript j'ai appris que certains outils savaient remplacer les String en dur dans le code par des équivalents illisibles à bases de cast douteux entre Array, String et Number.
J'ai creusé un peu pour savoir jusqu'où on pouvait aller. Je me suis aperçu que simplement avec les caractères "[", "+" et "]", on pouvait déjà aller très loin !

+[] donne 0 par cast de l'opérateur +
Pour avoir 1, on pourrait essayer +[]++ mais on ne peut appliquer qu'un seul opérateur à la fois.
Cependant, si on place le tout dans une array dont on récupère le premier élément pour ensuite l'incrémenter, là ça fonctionne :
1: [+[]][0]++
Et comme on sait écrire 0, on arrive à :

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

qu'on peut écrire de manière plus courte par :

1: ++[[]][+[]] (merci Kaamo)

En suivant le même principe d'incrémentation à répétition, on arrive à récupérer tous les chiffres.

Maintenant les lettres !

"" : []+[]
"1" : []+1
"0" : []+0
undefined : [][+[]]
"undefined" : undefined + []

Génial, undefined en string, un tableau de caractères dont on va pouvoir récupérer certaines lettres via les index numériques (qu'on sait déjà coder)

On peut faire la même chose pour NaN : +[][+[]] pour récupérer le N majuscule et le a.

Dernière découverte de la soirée, on pourrait se servir de l'objet Infinity. Incrémenter de un à un jusqu'à l'infini est évidémment bien trop long, mais il existe une autre technique: caster le nombre en notation exponentielle. Comme on a le "e" grâce à "undefined", on peut écrire "1e1000" qui casté en nombre dépasse Number.MAX_VALUE, et donne Infinity. Bingo, des lettres en plus :P

Je n'ai pas d'autres idées pour le moment, mais j'ai déjà de quoi faire des trucs sympas. Par exemple lâchez ça en console Javascript :

Code:

---

[[]+[][+[]]][+[]][++[++[++[++[+[]][+[]]][+[]]][+[]]][+[]]]+[[]+[][+[]]][+[]][+[]]+[[]+[][+[]]][+[]][++[+[]][+[]]]+[[]+[][+[]]][+[]][++[+[]][+[]]]+[+[++[+[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[+[]][+[]]][+[]]][+[]]]+[++[+[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[++[+[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]

---

Voilà la liste des caractères que j'ai trouvé et leur traduction en [+] :

0: +[]
1: ++[[]][+[]]
2: ++[++[[]][+[]]][+[]]
3: ++[++[++[[]][+[]]][+[]]][+[]]
4: ++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]
5: ++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]
6: ++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
7: ++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
8: ++[++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]
9: ++[++[++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]

undefined : [][+[]]
NaN : +[][+[]]
Infinity : +[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]

"" : []+[]
[]+1 : "1"
[]+0 : "0"
undefined + []: "undefined"

a: [+[]+[][+[]]+[]][+[]][++[[]][+[]]]
d: [[]+[][+[]]][+[]][++[++[[]][+[]]][+[]]]
e: [[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]
f: [[]+[][+[]]][+[]][++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]]
i: [[]+[][+[]]][+[]][++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]]
n: [[]+[][+[]]][+[]][++[[]][+[]]]
t: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]
u: [[]+[][+[]]][+[]][+[]]
y: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][++[++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]

I: [+[++[[]][+[]]+[]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[++[[]][+[]]+[]][+[]]+[+[]]+[+[]]+[+[]]][+[]]+[]][+[]][+[]]
N: [+[][+[]]+[]][+[]][+[]]

Bon on est bien d'accord que tout cela ne sert strictement à rien, ce n'est absolument pas performant en termes d'obfuscation, mais je trouve ça assez fun :mrgreen:

Donc si vous avez d'autres idées pour aller trouver d'autres lettres, balancez !

Là j'ai peut-être une piste en cherchant avec les lettres dont je dispose une fonction dans le prototype de Array / String / Number / Object, puis caster cette fonction en String pour en récupérer une forme littérale. Quelque-chose comme ça :

[""][0]["big"]+[] --> "function big() { [native code] }"

Mais je ne trouve pas de fonction dont je dispose de toutes les lettres. Je pourrais aussi peut-être essayer de choper l'objet Date, mais il me manque le D majuscule...

Citation:

---

Envoyé par SylvainPV

Bon on est bien d'accord que tout cela ne sert strictement à rien, ce n'est absolument pas performant en termes d'obfuscation, mais je trouve ça assez fun :mrgreen:

---

:calim2: :scarymov:

Chacun trouve son petit plaisir comme il peut, mais il est clair que l'on ne pratique pas les mêmes méthodes. :mouarf:

Avec Infinity tu as le "i" en majuscule et minuscule. Peut-être peux-tu trouver une fonction qui te permettrait de réaliser des conversions majuscules / minuscules et inversement ?

Tu as aussi "d", "e", "f" il doit bien y avoir une relation logique entre ces lettres, non ? Et ainsi trouver les lettres manquantes ?

:mouarf: génial, tout simplement génial !

tu peux recup NaN plus simplement : {}+

avec ca tu peux avoir "[object Object]" : ({})+[]
--> tu peux ensuite récupérer les lettres : (({})+[])[1]
--> ca fait 6 lettres en + :mrgreen:

-----------
une piste possible avec les opérateurs binaires ?

@Auteur: j'aimerais bien pouvoir faire un toLowerCase ou toUpperCase, ou même juste un charcodeAt, mais c'est loin d'être facile avec les éléments à disposition. Si je pouvais j'aurais de quoi faire l'objet Date.

@Lorenzo: ha oui mais en utilisant les signes { } et ( ) c'est trop facile ;)

Salut Sylvain !
Haha je vois que je ne suis pas le seul fou à bord. J'avais commencé à m'amuser avec ça y'a quelques mois.

Le 1, tu peux l'avoir plus facilement :yaisse3: ++[[]][+[]].
Idem donc pour les autres chiffres, tu peux gagner un caractère (le +).

++[+[]][+[]] === ++[[]][+[]]

Merci Kaamo ;)
J'en suis pas encore à l'étape d'optimisation, j'aimerais vraiment débloquer d'autres lettres, après quoi ça laisserait porte ouverte à tout et n'importe quoi :)

Avec seulement le charset [+], je pense que tu as déjà fait le tour de ce qui est possible. Il va falloir que tu t'accordes un charset un peu plus large :mrgreen:

Après plusieurs heures de recherche je crois en effet que j'ai besoin d'étendre mon charset pour me débloquer. :cry:

Accéder aux booléens serait une aide appréciable, donc j'ai pensé inclure l'opérateur "!"

Cela me permet de faire :
false: ![]
true: !![]
et de récupérer les lettres t, r, a, l et s

Aussi cela réduit un peu la taille du code pour récupérer les chiffres.
Grâce à ces nouvelles lettres, je peux choper []["filter"] dans le prototype Array qui une fois casté en string me donne "function filter() { [native code] }"
A partir de là, le résultat varie un peu selon les navigateurs, donc je perds la portabilité du code. Mais cela me donne le c, le o, et le v, ainsi que les caractères ( ) { } [ ] et le whitespace.

Seulement, même si j'ai de quoi faire "eval", je suis de nouveau bloqué car je ne peux pas l'exécuter en tant que fonction. Pour cela j'ai besoin des caractères parenthèses ( ) ; donc je songe à les inclure aussi au charset, bien que six caractères c'est beaucoup moins impressionnant que trois...

Voilà où j'en suis avec le charset [+!]

0: +[]
1: +!+[]
2: +!+[]+!![]
3: +!+[]+!![]+!![]
4: +!+[]+!![]+!![]+!![]
5: +!+[]+!![]+!![]+!![]+!![]
6: +!+[]+!![]+!![]+!![]+!![]+!![]
7: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]
8: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]
9: +!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]
10: +[+!+[]+[]+[+[]]][+[]]

a: [![]+[]][+[]][+!+[]]
c: [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+!+[]+!![]+!![]]
d: [[]+[][+[]]][+[]][++[++[[]][+[]]][+[]]]
e: [[][+[]]+[]][+[]][+!+[]+!![]+!![]]
f: [![]+[]][+[]][+[]]
i: [[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]
l: [![]+[]][+[]][++[++[[]][+[]]][+[]]]
n: [[][+[]]+[]][+[]][+!+[]]
o: [[][[![]+[]][+[]][+[]]+[[]+[][+[]]][+[]][++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[]+[][+[]]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]+[!![]+[]][+[]][++[[]][+[]]]]+[]][+[]][++[++[++[++[++[++[[]][+[]]][+[]]][+[]]][+[]]][+[]]][+[]]]
r: [!![]+[]][+[]][++[[]][+[]]]
s: [![]+[]][+[]][++[++[++[[]][+[]]][+[]]][+[]]]
t: [!![]+[]][+[]][+[]]
u: [[]+[][+[]]][+[]][+[]]
v: [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+[+!+[]+!![]+[]+[+!+[]+!![]+!![]+!![]+!![]][+[]]][+[]]]
y: [+[+!+[]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[+!+[]][+[]]+[+[]][+[]]+[+[]][+[]]+[+[]][+[]]][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]+!![]+!![]]

I: [+[+!+[]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[+!+[]][+[]]+[+[]][+[]]+[+[]][+[]]+[+[]][+[]]][+[]]+[]][+[]][+[]]
N: [+[][+[]]+[]][+[]][+[]]

" ": [[]+[][[![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]+!![]+!![]]+[![]+[]][+[]][++[++[[]][+[]]][+[]]]+[!![]+[]][+[]][+[]]+[[][+[]]+[]][+[]][+!+[]+!![]+!![]]+[!![]+[]][+[]][++[[]][+[]]]]][+[]][+!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![]]

J'ai également de quoi faire "constructor", et donc []["constructor"]["constructor"] pour avoir le constructeur de Function 8-) Seulement pour pouvoir m'en servir il me faut les parenthèses, arf

:bravo:

Pour avoir le constructeur de Function, je passais par filter (ça fait moins de code :mrgreen:) : []["filter"]["constructor"] === []["constructor"]["constructor"].
Je m'étais arrêté à ce niveau. Sans les (), on ne peut pas faire grand chose comme tu le fais remarquer. Il nous manque de quoi parser + exécuter le code : []["filter"]["constructor"](/* code */)(). Mais avec (), t'es le roi du pétrole :mrgreen:

J'avais creusé aussi pour utiliser btoa / atob (base-64 encodage/décodage) pour choper des caractères en plus et en convertissant des nombres unicode en caractères (fromCharCode), mais je ne retrouve pas mes tests.

En gros il faut le charset ()![]+ pour tout faire.
Si tu veux, j'avais trouvé 1 outil fonctionnel avec le charset ()![]+ et un autre avec {} en plus.

Je suis arrivé aux mêmes conclusions que toi Kaamo :) Il faut absolument les parenthèses pour pouvoir évaluer les fonctions (et donc à terme utiliser un appel eval pour traduire n'importe quel script dans ces six caractères).

Je passe par []["sort"]["constructor"] pour avoir le constructeur Fonction (à voir lequel est plus court) et suis remonté jusqu'à fromCharCode également. Le plus dur a été de récupérer le C majuscule ! J'y suis parvenu comme ceci :
([]["sort"]["constructor"]("return document")()["forms"]["constructor"]+[])[13]

Non je n'ai pas trouvé plus simple :mrgreen:

Enfin, avec tout ça je peux commencer à bosser sur un convertisseur automatique. dès que je suis sur le bon PC , j'envoie les sources.

Au final 6 caractères c'est pas si mal :P

bande de tarés :aie:

Ça me refait penser à un prof qui nous avait fait coder en brainfuck... pour le fun

+1 pour le brainfuck, c'est le même genre de danse cérébrale :D

Citation:

---

Je passe par []["sort"]["constructor"] pour avoir le constructeur Fonction (à voir lequel est plus court)

---

Vu qu'il faut passer par filter pour récupérer le "o" de sort. Je pense qu'il est plus simple de passer par filter. Toutes ses lettres sont récupérables par des "opérations de base". Quoique ça se tient, vu que filter a deux lettres de plus ... Hum, à tester :D

Joli pour le "C" ! Beaucoup moins galère que le mien. Je n'avais pas pensé à document. (attention spoiler) J'étais passé par []["filter"]["constructor"]("return this")()["atob"]("20N")[1] (ou j'avais vu une technique pour passer par unescape("%43")). Galère comme tu le vois car fallait débloquer d'autres moyens :

[]["filter"]["constructor"]("return this")() qui retourne donc l'objet global window. Le h étant 17 en base 18 (+("17"))["toString"](18) et le b de "[object Window]" : ([]["filter"]["constructor"]("return this")()+[])[2] ou alors en passant par 11 en base 12 (+("11"))["toString"](12) :mur:

Ou je viens de penser à ... ([]["filter"]["constructor"]("return console")()["constructor"]+[])[9]

Pas mal le atob et le changement de base !
Le changement de base peut être utilisé à la place de String.fromCharCode dans de nombreux cas. Toutes les lettres minuscules peuvent être récupérées comme ceci:
de a : (+("10"))["to"+(("")["constructor"]+[]).slice(9,15)](36)
à z: (+("35"))["to"+(("")["constructor"]+[]).slice(9,15)](36)

Pour récupérer window, il y a plus simple :
[]["filter"]["constructor"]("return self")():ccool:

Le self !!! :oops: Je n'y pense jamais en effet !


Oui, potentiellement avec le changement de base il y a moyen de tout récupérer en base 36. (au moins les minuscules)
(+("10"))["toString"](36) === "a" jusqu'à (+("35"))["toString"](36) === "z".
Il faut avoir débloqué les chiffres et toString. Mieux vaut passer par ce moyen qu'en dernier recours. Par exemple le 'a' se récupère mieux avec un (![]+[])[1] qu'avec un (+("10"))["toString"](36) converti

EDIT : oui voilà :)

En combinant nos optimisations respectives, je suis arrivé à la fonction String.fromCharCode en 8370 caractères au lieu de 13069 :ccool:

Pour info :
b via (0).constructor === Number : 832 chars
b via 11.toString(20) : 1410 chars

h via window.location.href[0] : 1969 chars
h via +("17"))["to"+(("")["constructor"]+[]).slice(9,15)](20) : 1440 chars

C via document.forms.constructor === HTMLCollection : 4498 chars
C via []["filter"]["constructor"]("return self")()["atob"]("00N")[1] : 2411 chars

Maintenant le compilateur :)

SylvainPV, Kaamo, je ne sais pas comment vous faites, mais moi j'ai décroché :hola:







PS :

Citation:

---

Toi nouveau lecteur, oui toi, si tu arrives jusqu'à ce message sans migraine, sache que tu ne rêves pas... tu es bien dans le forum Javascript :aie:

---

Citation:

---

Envoyé par Enerian

bande de tarés :aie:

---

On peut pas mieux dire :aie:

Et j'avoue que là où j'ai vraiment commencé à rigoler, c'est là :mouarf:

Citation:

---

Envoyé par SylvainPV

... ha oui mais en utilisant les signes { } et ( ) c'est trop facile ;)

---

:scarymov:

Et voilà le compilateur : http://syllab.fr/projets/experiments/sixcharsjs/

Il ne fonctionne que sur Chrome, en raison de quelques astuces et bidouillages évoqués plus haut.

Chaque conversion prend 20k caractères juste pour mettre en place l'évaluation, après cela dépend de la longueur du script. Donc ne soyez pas gourmands pour vos conversions.

Pour que ce soit plus drôle, j'ai encodé la fonction d'encodage dans le code de l'encodeur :mrgreen:

edit: je viens de voir que quelques virgules se balladent dans le code généré. Il n'y a pas de place pour un septième caractère, il va falloir que je corrige ça !

8O
Pour ma défense, Sylvain semble bien plus "taré" que moi :mrgreen:. Je n'ai jamais eu l'ambition d'aller jusqu'au compilateur ... fonctionnel de surcroît
Bien joué Sylvain, c'est classe :ccool:

Citation:

---

Chaque conversion prend 20k caractères juste pour mettre en place l'évaluation

---

Ça me parait énorme 20K caractères. Tu ne passes par cette forme pour évaluer le code ?

Code:

---

"[][" + compile("filter") + "][" + compile("constructor") + "](" + compile(code) + ")()"

---

Si, je passe bien par là pour faire un eval, mais c'est derrière le compile(code) que j'ai ajouté une (grosse) optimisation. Regarde la différence de taille entre alert("Hello World") compilé par rapport à alert("test"), c'est très minime par rapport aux autres façons de récupérer les lettres "H", "W" etc...

Je ne lâche pas la solution tout de suite, il faut que je corrige ce problème de virgules ; et je vais peut-être rédiger un article pour tout expliquer depuis le début.

Malin !! Si j'ai bien capté, tu récupères l'Unicode de chaque caractère saisi, tu le passes à la moulinette pour récupérer le nombre (traduit en String) en ([]!+). Mais du coup .. tu passes par là pour chaque caractère plutôt que de checker avant s'il se trouve parmi les caractères "simples" à traduire ?

Okay j'ai résolu mon problème de virgules, ça venait de ["to"+(("")["constructor"]+[]).slice(9,15)] ; je n'ai pas pensé à convertir la virgule entre les deux arguments de slice :oops: ; du coup j'ai remplacé par [""]["constructor"]["name"]. Plus long mais tant pis !

Donc maintenant, le code de l'encodeur !
Préchauffez vos neurones et réapprovisionnez-vous en café :mrgreen:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

app.encode = function(input){ var charcodes = []; for(var c=0; c<input.length; c++){ charcodes.push( app.convertInt( input.charCodeAt(c) ) ); }   var out = "[]+" + charcodes.join("+"+app.convertTable["f"]+"+"); out = "[]+(" + out + ")["+_("split")+"]("+app.convertTable["f"]+")"; out = _("return ") + "+" + app.convertTable["String"] + "+" + _(".fromCharCode(") + "+(" + out +")+" + _(')'); out = app.eval(out); out = app.eval(out); return out; };

---

Avant tout je parcours le code et pour chaque caractère, récupère le charCode associé. Les charcodes sont des petits nombres, ils prennent en moyenne moins de place que les conversions de lettres exposées auparavant. De plus, String.fromCharCode() prend une infinité d'arguments et nous permettra de convertir tous les charcode en un seul appel.

Pour générer une array de charcodes numériques, ce serait très lourd de la constituer en String en encodant les virgules, puis de faire un eval. A la place je constitue une string avec les charcode séparés par un caractère séparateur. Il faut qu'il soit le plus court possible sans être un nombre, j'ai donc choisi le "f" : (![]+[])[+[]] ; Puis il suffit d'appeler split sur ce même code séparateur pour reconstituer l'array.

Seulement avec cette méthode, les éléments de l'array (les charcodes) ne sont plus des nombres mais des String. Donc au lieu d'un appel direct de la fonction String.fromCharCode, je constitue une string "String.fromCharCode(" + (array castée en string) +")" que je retourne évaluée ensuite.

Le premier eval remplace le code ([+!]) par la string "String.fromCharCode(123,145,167,...)", le second exécute la fonction String.fromCharCode pour récupérer le code "décompilé". Et voilà le travail :)

Héhé excellent ! :applo:
Sympa les petites astuces et l'emploie de fromCharCode qui prend tout son sens du coup.

Donc tu pourrais faire de même pour convertir les données "en dur" que tu dois utiliser pour encoder, non ? app.convertTable["String"], _("split") etc car celles-ci, si j'ai bien compris, sont traduites en utilisant la table de correspondance des lettres pré-calculées ?

D'ailleurs, j'ai trouvé un compilateur fonctionnel hier en cherchant un peu : JSF*ck ! Le même charset est employé et il utilise la même table de correspondance à quelques broutilles près. Pour alert(1), il le fait en 1669 car. Mais j'ai testé

Code:

---

1 2	var name = prompt("What is your name ?"); alert("Hello "+name);

---

et là, les perfs sont désastreuses.

A priori, il utilise d'abord les caractères connus, il construit les digits à la volée et il remplace les caractères inconnus par la même technique que toi fromCharCode(CharCodeAt()). Une fois tous les caractères matchés, il traduit le tout en soupe ([!+]) à coup de regex.

Citation:

---

Envoyé par Kaamo

Donc tu pourrais faire de même pour convertir les données "en dur" que tu dois utiliser pour encoder, non ? app.convertTable["String"], _("split") etc car celles-ci, si j'ai bien compris, sont traduites en utilisant la table de correspondance des lettres pré-calculées ?

---

Je ne comprends pas trop, ces données en dur sont justement celles qui me permettent de faire le String.fromCharcode, autrement le double eval. C'est le serpent qui se mord la queue si on fait ça.

Je ne connaissais pas JSFuck, on dirait que je ne suis pas le seul à avoir eu cette idée farfelue :P Mais c'est intéressant de comparer les implémentations, par exemple il économise un caractère pour undefined, il a pensé utiliser sort comme moi et il a utilisé return this comme toi pour récupérer Window.

Au niveau du compilateur, il ne passe pas par String.fromCharCode comme wrapper total du code, donc autant il gagne en place pour les petits scripts, autant la taille explose avec les scripts plus gros.

En effet :aie:

Il y a Hieroglyphy, mais qui utilise {} en plus !
Lui n'utilises pas du tout fromCharCode mais il utilise la technique charCodeAt pour chaque lettre de l'input qui n'est pas dans la table des lettres pré-calculées. Ensuite, il emploie plusieurs techniques (unescape, hexa) et prend celle qui fournit la séquence la plus courte et la stocke dans une table pour ne pas recalculer ensuite si le caractère revient ! C'est malin aussi.

Mais ta solution semble la plus optimale. A titre d'exemple, ton

Code:

---

1 2	var name = prompt("What is your name ?"); alert("Hello "+name);

---

donne 55287 caractères chez lui. Par contre, contrairement à JSFuck, il est ultra rapide pour la conversion.

Si j'ai bien compris, le jour où je veux balancer les 241k caractères constituant le fatras de mon générateur de phrases dans ton compilateur... >>> :aie:

La question "pour quoi faire ça ?" renvoyant dos à dos nos deux projets :mouarf: qui ont tous deux un petit problème pour répondre à cette question ^^ (quoi que je n'aie pas la moindre prétention de comparer mon jouet avec tes prouesses :ave: )

J'ai regardé ton générateur Romain, ça donne des résultats plutôt amusants ! Il y a quelques temps j'avais vu un outil similaire qui générait des "phrases bidons qui font bien sur les powerpoint d'entreprise" en anglais. C'était à pisser de rire :mouarf:

J'ai pris contact avec l'auteur de JSFuck pour comparer nos implémentations. Il doit y avoir moyen de grapiller quelques centaines de caractères encore, juste pour le plaisir de bien faire ;)