Les Nombres - javascript tome iv

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
JAVASC RI PT (Programmation Internet) VOL. III
+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818
La dernière révision de ce texte est disponible sur CD.
I. Le NaN (Not a Number) :
Quelques types de données sont très difficiles à se figurer :
1. null : valeur que souvent vous (rarement le système) affectez
explicitement à une variable pour l’initialiser à RIEN , juste pour
éviter qu’elle ait automatiquement la valeur undefined .
2. Undefined : Valeur que prend automatiquement une variable
quand elle n’est pas explicitement initialisée (même pas avec
null ) lors de sa déclaration.
3. NaN (number value that is a IEEE 754 “Not-a-Number” value) :
Il faut d’abord savoir qu’il n’y a pas un nombre particulier, précis
représentant le NaN . Dans IEEE 754 , NaN est défini comme tout
nombre à virgule flottante dont tous les bits d’exposant (expo-
nent bits) sont à 1 et la partie fractionnaire (fractional part) ayant
n’importe quelle valeur différente de zéro (any non-zero value).
Donc on peut bien avoir NaN !==NaN .
IV. Sur le mode strict « use strict; » il faut encore dire :
1. Le mode strict commence à l’endroit de sa déclaration sauf quand
il s’agit de paramètres ;
2.
Il ne peut être utilisé dans une fonction ayant un paramètre par
défaut (=initialisé).
3. Quand déclaré dans une fonction il a une portée fonction.

J.D.B. DIASOLUKA Nz. Luyalu 2 / 26 JavaScript Tome-III
4. Quand déclaré en dehors d’une fonction, il a une portée fichier,
c’est-à-dire seulement dans le fichier dans lequel il est déclaré,
pas dans les autres fichiers inclus.
Sans paramètres par défaut (initialisés) :
<script type="text/javascript">
E = Math.E; // Le mode strict déclaré plus loin
///////// function f(p=5) { "use strict";
// SyntaxError: "use strict" not allowed
// in function with default parameter
// test.html:3:20
"use strict"; // Activation mode strict, n’affecte pas E.
function f(p) { // paramètre simple.
const PI=Math.PI;
console.log(E+" & "+PI+" & "+p)
}
f(5); // Appel de la fonction avec argument.
</script>
// 2.718281828459045 & 3.141592653589793 & 5
Avec paramètre par défaut (initialisé), mais en mode standard !
N.B.: L’argument d’appel d’une fonction écrase la valeur par défaut du
paramètre formel de la fonction appelée.
<script type="text/javascript">
E = Math.E; // mode strict déclaré apré s
function f(p=(a)=>{with(i in a){
console.log(i+"VRAI DUMMY")}
}) {
const PI=Math.PI;
console.log(E+" & "+PI+" & **"+p+"**")
}
f(); // Argument écrase paramétre par dé faut.
f([5,[1,"txt",{}],"Bull"]);
</script>
// 2.718281828459045 & 3.141592653589793 & **(a)=>{with(i
in a){console.log(i+"VRAI DUMMY")}}**
// 2.718281828459045 & 3.141592653589793 &
**5,1,txt,[object Object],Bull**
Un paramètre par défaut est celui qui est TOUJOURS pris en considé-
ration avec la valeur lui définie quand la fonction appelante ne lui a

J.D.B. DIASOLUKA Nz. Luyalu 3 / 26 JavaScript Tome-III
pas envoyé l’argument correspondant, mais prend éventuellement la
valeur de l’argument lui envoyé par la fonction appelante .
<script type="text/javascript"> "use strict";
function ard(n,p=2){
return Math.floor(((n*Math.pow(10,p+1))+5)/10)/Math.pow(10,p)
}
console.log(ard(Math.PI)) // 3.14
console.log(ard(Math.PI,2)) // 3.14
console.log(ard(Math.PI,0)) // 3
console.log(ard(Math.PI,-1)) // 0
console.log(ard(Math.PI,5)) // 3.14159
console.log((Math.PI).toFixed(5)) // 3.14159
console.log(ard(Math.PI,Math.E)) // 3.1411691558523307
console.log((Math.PI).toFixed(Math.E)) // 3.14
</script>
Paramètre par défaut : pas supporté par les anciens navigateurs :
Opera 12 :
[10/02/2018 09:44:14] JavaScript - file://localhost/K:/test.html
Inline script compilation
Syntax error at line 2 while loading: expected ')', got '='
function ard(n,p=2){
-----------------^
Acoo Browser Version 1.98 build 744 Unicode 2008 :
Ligne: 2
Car: 18
Erreur: ')' attendu
Code: 0
URL: file:///K:/test.html
Maelstrom Version 37.0.2.1 (5920655) 2018 :
Uncaught SyntaxError: Unexpected token = test.html:2
IV. La précédence (préséance) des opérateurs , exemple illustratif :
<script type="text/javascript"> "use strict";
var num = 10;
console.log(
5 == num / 2 && !(3 + 2 * num).toString() == false);
// Affiche true.

J.D.B. DIASOLUKA Nz. Luyalu 4 / 26 JavaScript Tome-III
console.log(
5 == num / 2 && !(3 + 2 * num).toString() === "");
// Affiche false.
console.log((3 + 2 * num).toString() == false) // false
console.log(!(3 + 2 * num).toString() == false) // true
console.log((3 + 2 * num).toString() === false) // false
console.log(!(3 + 2 * num).toString() === false) // true
console.log((3 + 2 * num).toString() == "") // false
console.log(!(3 + 2 * num).toString() == "") // true
console.log((3 + 2 * num).toString() === "") // false
console.log(!(3 + 2 * num).toString() === "") // false
console.log(!(3 + 2 * num)) // false
</script>
V. La méthode « filter() »
<script type="text/javascript">
"use strict";
var suppress = (from, tag) =>
from.filter(function(el){return el !== tag})
console.log(suppress(["Louis", "Morena", "Keriyza",
"Louis", "Keriyza", "Louis"], "Louis"));
var extract = (from, tag) =>
from.filter(function(el){return el === tag});
console.log(extract(["Louis", "Morena", "Keriyza",
"Louis", "Keriyza", "Louis"], "Louis")); </script>
// Array [ "Morena", "Keriyza", "Keriyza" ]
// Array [ "Louis", "Louis", "Louis" ]
VI. Le typecasting :
1 Dans les opérations arithmétiques (outre l’addition = concaténa-
tion) les chaînes sont converties ("implied typecasting) en
nombres :
25 - "10" = 15 ; 25 * "10" = 250 ; 25 / "10" = 2.5. ..
2 Dans les opérations de concaténation (toute addition impliquant
une chaîne de caractères) ce sont les autres types qui sont con-
vertis en chaîne de caractères.

J.D.B. DIASOLUKA Nz. Luyalu 5 / 26 JavaScript Tome-III
3 Dans l’addition d’un nombre et une string, le nombre est
coercé en string : 25 + "10" = "2510" .
4 Dans l’addittion d’un Boolean et une string, le Boolean
est coercé en string : true + "false" = "truefalse" .
5 Dans l’addition d’un nombre et un Boolean, le Boolean est coer-
cé en nombre : true + 10 = 11 ; false + 10 = 10 .
6 Dans les opérations de comparaison, les string (chaînes) sont
coercées en nombres : 10 < "050" = true .
Voyez donc ceci à la console :
"88"+77 -> "8877"
88+"77" -> "8877"
"88+77" -> "88+77"
88+77 -> 165
"Somme = " + 4 + 7 -> "Somme = 47"
"Somme = "+1*4+7 -> "Somme = 47"
"Somme = "+1*(4+7) -> "Somme = 11"
"Somme = "+(4+7) -> "Somme = 11"
"Somme = "+-(-4-7) -> "Somme = 11"
"Somme = "+eval(4+7) -> "Somme = 11"
"Somme = "+eval(4)+eval(7) -> "Somme = 47"
"Somme = "+parseInt(4)+parseInt(7) -> "Somme = 47"
Et dans un code :
<script type="text/javascript"> "use strict";
let n1=prompt("Donnez un nombre",
Math.floor(Math.random()*100));
const n2=prompt("Donnez un auttre nombre",
Math.floor(Math.random()*100));
console.log(n1+" + "+n2+" = ");
console.log(n1 + n2);
console.log(parseInt(n1) + parseInt(n2));
console.log(eval(n1) + eval(n2));
let n1e=eval(n1), n2e=eval(n2);
console.log(n1e + n2e);
let n1p=parseInt(n1), n2p=parseInt(n2);
console.log(n1p + n2p);
</script>
31 + 23 = test.html:6:4
3123 (test.html:7:4) 54 (test.html:8:4)
54 (test.html:9:4) 54 (test.html:11:4)
54 (test.html:13:4)