Dyrk

 

Hey,
Salut à tous, une petite envie de vous partager un contenu sympa, pour les personnes un peu curieuses, qui souhaitent se plonger dans un sujet super intéressant pendant leurs vancances.

 

Je suis tombé il y a 2 ans sur ce super sujet là :

Developpez.com

Mais bon, à ce moment là, je n'étais pas spécialement dans l'état d'esprit que j'ai acquis aujourd'hui, et cette envie de toucher à tout !

Alors voilà, j'ai pas spécialement parcouru tous le sujet, je n'ai pas lu plus de 10 lignes du dossier, mais j'ai voulu m'inspirer de la technique qu’expérimente "Sylvain Pollet-Villard"

 

En vrai le JavaScript, même si il est parfois très sensible, il reste un langage très souple.

 

Et c'est sur cette souplesse que nous allons nous appuyer !

 

Par exemple nous allons essayer des combinaisons de tableau, d'objet pour obtenir soit des erreurs genre "Undefined" ou bien NaN (qui seront des sources de caractères)

Et essayer de réaliser des opérations qui nous retournerons des chiffres 0 ou 1 :)

Après c'est un jeu d'enfant ^^

 

Pour vous mettre un peu dans le bain, nous allons procéder à un enchaînement d'exemple :

Je précise que mes démonstrations s'enchainent, et qu'il est important de vous rappeler du nom des variables pour pouvoir comprendre les exemples.

 

Pour commencer nous allons essayer des additions de tableau pour obtenir des messages d'erreur :

//undefined
a=[]+[][0]

 

//NaN
b=+[a]

Voilà donc là on à obtenu 2 messages d'erreurs assez courant :
Undefined : qui indique que l'on manipule un élément qui n'existe pas.
NaN : Not a Number, qui lui, indique que l'on essaye de faire des calcules sur quelques choses qui n'est pas un chiffre ou un nombre.

Maintenant à quoi ces fameux message vont ils servirent ? Et bien tout simplement en tant que chaine de caractère, car on va ainsi pouvoir se servir des lettres dont ils sont constitué !

"U, N, D, E, F, I, N, E, D, N, A, N"

Genre dans l'exemple j'indique que :

a est égal à undefined

 

Pour écrire dude je pourrais maintenant écrire :

a[2]+a[0]+a[2]+a[3]

 

Mais là c'est encore trop simple :
Nous allons complexifier la chose, en offusquant également les chiffres :

 //1
c=++[+[]][0]

Voilà comment je suis parvenu à obtenir 1, en incrémentant une valeur nulle !

Ensuite, vous pouvez jongler facilement avec notre 1 :

 

//0
d=c-c

 

//2
e=c+c

 

En faisant 1+1 on obtient 2, 1-1 on obtient 0, .... bref là si vous arrivez à piger un peu la logique, vous allez pouvoir vous éclater !

Notre "dude" qui était précédemment ça :

a[2]+a[0]+a[2]+a[3]

Se transforme maintenant en ça :

a[e]+a[d]+a[e]+a[c+e]

 

On peut également agrémenter par la suite notre base de "lettre", et en ajouter quelques unes :

//false
f=(!c)+[]

 

//true
g=(!(!c))+[]

 

Pour ce qui est des booléens, là j'arrive à les obtenir en jouant avec les opérateurs logiques.

Quand on préfixe une variable d'un "!" on demande si elle existe et si elle n'est pas "false" (faux)

On peut également s'en servir pour obtenir des contraires :

(!true) ==> false   ==> (!1) ==> 0 = false

(!false) ==> true ==> !(!0)  ==> 1 = true

 

Sauf que dans mon exemple ci-dessous, je l'additionne à un tableau, pour indique que j'attends une chaîne et non pas un booléen.

 

Bref en pratique, nous allons pouvoir ainsi appeler des fonctions !

 

 

// d u d e
h=a[e]+a[d]+a[e]+a[c+e]

 

 

//alert
i=f[c]+f[e]+g[c+e]+g[c]+g[d]

 

 

//alert("dude");

eval(i+'("'+h+'")')

 

Voilà mon code pour ceux qui ça brancherais de continuer ce raisonnement !

 

//undefined
a = []+[][0]
//NaN
b=+[a]
//1
c=++[+[]][0]
//0
d=c-c
//2
e=c+c
//false
f=(!c)+[]
//true
g=(!(!c))+[]
// d u d e
h=a[e]+a[d]+a[e]+a[c+e]
//alert
i=f[c]+f[e]+g[c+e]+g[c]+g[d]
eval(i+'("'+h+'")')