OPÉRATEURS D’ÉGALITÉ - javascript tome xi

Téléchargement

O P É R AT E U R S D ’ É G A L I T É

JAVASCRIPT

(Programmation Internet)

VOL. VI

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818

CHAPITRE 10 : OPÉRATEURS D’ÉGALITÉ :

Faites attention à ceci :

* Avec l’opérateur « = = » JS fait le typecasting selon le contexte.

* Avec l’opérateur « = = = » JS ne fait pas de typecasting.

Si vous avez « true » avec « = = » et « true » avee « = = = » c’est

que ce true est vraiment

true

(même sans transtypage).

Si vous avez « true » avec « = = » et « false » avee « = = = » c’est

que ce true n’est en fait que

truthy

(forcé par transtypage)

truthy est un true par assimilation.

Si vous avez « false » avec « = = » et « false » avee « = = = » c’est

que ce false est vraiment

false

(même sans transtypage).

Si vous avez « false » avec « = = » et « true » avee « = = = » c’est

que ce false n’est en fait que

falsey

(forcé par transtypage).

falsey est un false par assimilation.

Dans les opérations logiques :

if(0) est évalué comme false (faux), mais pour tout autre nombre n;

if(n) est évalué comme true (vrai).

Mais le nombre 1 en base décimal est naturellement égal à 1 binaire

J.D.B. DIASOLUKA Nz. Luyalu

JavaScript Tome-VI

Opérateurs d’égalités

- 2 / 33 - vendredi, 31. mai 2019 (9:08 )

(boolean) du point de vue mathématique (quantité), mais pas identique

(pas représenté de la même façon) que true (boolean = binaire). true est

donc égal à 1 (binaire = à un seul bit).

De même., 0 égale à false, et false (boolean = à un seul bit) est assimi-

lable à 0 décimal pour les mêmes raisons que ci-dessus.

false en base binaire égale 0 avec un seul bit ;

true en base binaire égale 1 avec un seul bit :;

0 en base décimale = 0000 0000 en binaire 8 bits (byte) ;

1 en base décimale = 0000 0001 en binaire 8 bits (byte) ;

Rappel :

Un groupe de 4 bits est appelé QUARTET ou NYBBLE.

Un groupe de 8 bits est appelé BYTE ou OCTET.

Un groupe de 16 bits est appelé WORD ou MOT.

Un groupe de 32 bits est appelé DOUBLE-WORD = D-WORD.

Un groupe de 64 bits est appelé QUAD-WORD ou Q-WORD.

La taille de stockage dans les ordinateurs actuels est de 64 bits (qua-

druple-word), dans laquelle :

false (binaire) = 0 avec 1 seul bit (économie de 63 bits) ;

true (binaire) = 1 avec 1 seul bit (économie de 63 bits) ;

0 décimal = 00000000 00000000 00000000 00000000 binaire.

1 décimal = 00000000 00000000 00000000 00000001 binaire.

L’opérateur d’égalité « = = » fait une comparaison logique (après des

conversions implicites de type = typecasting nécessaires ou coercion de

types), tandis que l’opérateur d’égalité strict « = = = » travaille au ni-

veau du bit sans converson.

typeof true; => "boolean"

typeof false; => "boolean"

true; => true

J.D.B. DIASOLUKA Nz. Luyalu

JavaScript Tome-VI

Opérateurs d’égalités

- 3 / 33 - vendredi, 31. mai 2019 (9:08 )

false; => false

eval(true) => true

eval(false) => false

parseInt(true) => NaN

parseInt(false) => NaN

true*1 => 1

false*1; => 0

Les valeurs suivantes se résolvent en falsey (assimilées à faux) :

0, -0, null, NaN, undefined, chaîne vide ("").

false est vrai false,.

Leurs opposés « !val » se résolvent en « truthy (assimilées au vrai)».

L’opposé de false, reste un vrai true,

Les objets créés avec les valeurs de ce type en paramètres ont une valeur

initiale de false :

var BnP = new Boolean(); // Aucun paramètre

var BZ = new Boolean(0); // 0 en paramètre

var BN = new Boolean(null); // null en paramètre

var BEmptyS = new Boolean(''); // Chaîne vide

var BF = new Boolean(false); // false explicite.

Tout autre valeur y compris tout objet ou même la chaîne "false" crée

un objet ayant « true » comme valeur initiale.

Les objets créés avec des arguments se résolvant en true ont une valeur

initiale de true :

var BT = new Boolean(true); // true explicite.

var BTS = new Boolean('true'); // Chaîne non vide

var BFS = new Boolean('false'); // Chaîne non vide

J.D.B. DIASOLUKA Nz. Luyalu

JavaScript Tome-VI

Opérateurs d’égalités

- 4 / 33 - vendredi, 31. mai 2019 (9:08 )

var BOS = new Boolean('txt'); // Chaîne non vide

var BA = new Boolean([]); // Array

var BO = new Boolean({}); // Object

Ne confondez surtout pas les valeurs primitives bouléennes « true » et

« false » avec les valeurs « true » et « false » d’un objet Boolean.: un

objet booléen soit-il n’est jamais false (un objet est toujours true) même

quand il porte une valeur false ou qu’il est vide.

let v = true;

let vv = v.valueOf();

if (v === vv) console.log("same"); // same

else console.log("different");

let v1 = Boolean(true);

let vv1 = v1.valueOf();

if (v === vv) console.log("same"); // same

else console.log("different");

if (v === v1) console.log("same"); // same

else console.log("different");

if (vv === vv1) console.log("same"); // same

else console.log("different");

let v2 = new Boolean(true);

let vv2 = v2.valueOf();

if (v2 === vv2) console.log("same");