Les Nombres - javascript tome iv

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
J AVA S C R I P T (Programmation Internet) V O L . I I I
+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 (exponent 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.
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
&
**5,1,txt,[object Object],Bull**
3.141592653589793
&
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
2 / 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
3 / 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énation) 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 convertis en chaîne de caractères.
J.D.B. DIASOLUKA Nz. Luyalu
4 / 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 coercé 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)
J.D.B. DIASOLUKA Nz. Luyalu
5 / 26
JavaScript Tome-III
Vous pouvez forcer une coercion :
1 La fonction parseInt() covertit excplicitement un numérique littéral en entier,
2 La fonction parseFloat() covertit excplicitement un numérique littéral en nombre
Le numérique littéral doit être au début de la chaîne.
<script type="text/javascript"> "use strict";
var i = "1980 mille neuf cent quatre-vingt"
var f = "19.80 dix-neuf point quatre-vingt"
console.log(i) // 1980 mille neuf cent quatre-vingt
console.log(f) // 19.80 dix-neuf point quatre-vingt
console.log(parseInt(i))
// 1980
console.log(parseFloat(i))
// 1980
console.log(parseInt(f))
// 19
console.log(parseFloat(f))
// 19.8
</script>
VII. Vérifier si une chaîne contient une sous-chaîne donnée :
Quelques méthodes qui le permettent sont :
includes() :
<script type="text/javascript">
"use strict";
console.log("abcde".includes("cd"))
// true
console.log("abcde".includes("cd", 2)) // true
console.log("abcde".includes("CD"))
// false
console.log("abcde".includes("cd", 3)) // false
</script>
startsWith(), endsWith(), substr(d , L), substring(d , d+L) :
<script type="text/javascript">
"use strict";
console.log("abcde".startsWith("cd",2))
// true
console.log("abcde".endsWith("de"))
// true
console.log("abcdef".substr(2,3)=="cde") // true (d, L)
console.log("abcdefg".substring(2,5)=="cde")
//
false
(d, d+L) ou (d, F-1)
console.log("«"+"abcdefg".substr("b","d")+"»") // vide
console.log("«"+"abcdefg".substring("b","d")+"»") // vide
console.log("«"+"abcdefg".substr("c")+"»")
// Tout
J.D.B. DIASOLUKA Nz. Luyalu
6 / 26
JavaScript Tome-III
console.log("«"+"abcdefg".substring("c")+"»") // Tout
console.log("«"+"abcdefg".substr()+"»")
// Tout
console.log("«"+"abcdefg".substring()+"»")
// Tout
</script>
indexOf, lastIndeOf, match() :
<script type="text/javascript">
"use strict";
console.log("abcabc".indexOf("ca"))
// 2
console.log("abcde".indexOf("de")==3)
// true
console.log("abcabc".indexOf("x"))
// -1
console.log("abcab".indexOf("de")==3)
// false
console.log("a.b.c.d".lastIndexOf("."))
console.log("abcab".lastIndexOf("ab")==3)
console.log("abcabc".lastIndexOf("x"))
console.log("abcab".lastIndexOf("de")==-2)
</script>
//
//
//
//
5
true
-1
false
localeCompare , search :
<script type="text/javascript">
"use strict";
console.log("ddd".localeCompare("ddd")) // 0
console.log("ddd".localeCompare("ddc")) // 1
console.log("ddd".localeCompare("dde")) // -1
console.log("ddda".localeCompare("ddd")) // 1
console.log("ddd".localeCompare("ddda")) // -1
console.log("ddd".search("ddd"))
console.log("abcabc".search("ca"))
console.log("ddd".search("ddda"))
// 0
// 2
// -1
console.log("abcabcabc".match("bc")) // Array ["bca"]
console.log("abcabc".match("bcd"))
// null
</script>
VIII. Coder un texte avec « btoa(chaîne binaire) » et le décoder
avec « atob(chaîne base64String) ». Cette technique permet de
transmettre sans faille (interruption intempestive) un texte qui contient des caractères spéciaux entre ASCII 0 et ASCII 31.
<script type="text/javascript"> "use strict";
let stg="Ne confondez pas « types de "+
"donné es (minuscules) » et "+
"« objets standard » (Capitalisé s)";
J.D.B. DIASOLUKA Nz. Luyalu
7 / 26
JavaScript Tome-III
// Encoder le texte
let encodedData = btoa(stg);
console.log(encodedData);
// Dé coder le texte
let decodedData = atob(encodedData);
console.log(decodedData);
// Encoder texte contenant caracté res spé ciaux
encodedData = btoa(escape(stg));
console.log(encodedData);
// Dé coder le texte
decodedData = unescape(atob(encodedData));
console.log(decodedData);
</script>
IX. La fonction « String(obj) » ou la méthode « obj.toString() » : convertissent la valeur primitive d’un objet en une chaîne.
<script type="text/javascript"> "use strict";
var x = _ => ["A",1,{a:"a"},["y",{2:"deux"}]];
console.log(x().toString());
// A,1,[object Object],y,[object Object]
console.log(String(x()));
// A,1,[object Object],y,[object Object]
</script>
object.toString() s’applique aux objets suivants :
Boolean
Behavior
Elements of an Array are converted to strings. The resulting strings are
concatenated, separated by commas.
If the Boolean value is true, returns "true". Otherwise, returns "false".
Date
Returns the textual representation of the date.
Error
Returns a string containing the associated error message.
Function
Returns a string of the following form, where functionname is the
name of the function whose toString method was called:
Object
Array
Number
function functionname( ) { [native code] }
Returns the textual representation of the number.
J.D.B. DIASOLUKA Nz. Luyalu
8 / 26
JavaScript Tome-III
Object
String
Behavior
Returns the value of the String object.
Default
Returns "[object objectname]", where objectname is the name of the
object type.
La méthode « .toString » permet aussi de convertir un nombre d’une
base de numération vers une autre.
<script type="text/javascript"> "use strict";
function CreateRadixTable (){
// Create table heading.
console.log("Hex".padStart(3," ")+
"Dec".padStart(6,"
")+"Bin".padStart(9,"
")+"Oct".padStart(6," "))
for (var x = 0; x <= 32; x++) {
var s = "";
// Convert to hexadecimal.
s += (x.toString(16)).padStart(3," ");
// Convert to decimal.
s += (x.toString(10)).padStart(6," ")
// Convert to binary.
s += (x.toString(2)).padStart(9," ")
// Convert to octal.
s += (x.toString(8)).padStart(6," ")
console.log(s);
}
}
CreateRadixTable ();
</script>
Exécution :
J.D.B. DIASOLUKA Nz. Luyalu
9 / 26
JavaScript Tome-III
Hex
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
Dec
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Bin
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
Oct
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
1d
1e
1f
20
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111
100000
20
21
22
23
24
25
26
27
30
31
32
33
34
35
36
37
40
Affichage en nombre des chiffres significatifs (nnn.ddd...) :
<script type="text/javascript"> "use strict";
var num = new Number(1234);
console.log(num.toPrecision()); // 1234
console.log(num.toPrecision(2)); // 1.2e+3
num = new Number(1234.5678);
console.log(num);
// Number
console.log(num.valueOf());
//
console.log(num.toString());
//
console.log(String(num));
//
console.log(num.toPrecision());
//
console.log(num.toPrecision(2));
//
console.log(num.toPrecision(3));
//
console.log(num.toPrecision(4));
//
console.log(num.toPrecision(9));
//
</script>
{ 1234.5678 }
1234.5678
1234.5678
1234.5678
1234.5678
1.2e+3
1.23e+3
1235
1234.56780
Affichage en pas fixe des décimales (NNN... . ddd...) :
<script type="text/javascript">
var num = new Number(123);
console.log(num.toFixed());
console.log(num.toFixed(2));
"use strict";
// 123
// 123.00
num = new Number(123.4560);
J.D.B. DIASOLUKA Nz. Luyalu
10 / 26
JavaScript Tome-III
console.log(num);
//
console.log(num.valueOf());
console.log(num.toString());
console.log(String(num));
console.log(num.toFixed());
console.log(num.toFixed(2));
console.log(num.toFixed(3));
console.log(num.toFixed(4));
console.log(num.toFixed(8));
</script>
Number { 123.456 }
// 123.456
// 123.456
// 123.456
// 123
// 123.46
// 123.456
// 123.4560
// 123.45600000
Affichage Exponentiel (N.xx...Eee) :
<script type="text/javascript"> "use strict";
var num = new Number(1234);
console.log(num.toExponential()); // 1.234e+3
console.log(num.toExponential(2)); // 1.23e+3
num = new Number(123.4560);
console.log(num);
// Number { 123.456 }
console.log(num.valueOf()); // 123.456
console.log(num.toString()); // 123.456
console.log(String(num));
// 123.456
console.log(num.toExponential()); // 1.23456e+2
console.log(num.toExponential(2)); // 1.23e+2
console.log(num.toExponential(3)); // 1.235e+2
console.log(num.toExponential(4)); // 1.2346e+2
console.log(num.toExponential(8)); // 1.23456000e+2
</script>
IX. Les options d’affichage de la date :
<script>
var date = new Date(Date.UTC(+002018, 10, 24, 14, 5, 10, 250));
// identique é « var date = (new.Date()).getTime()); »
// console.log((new Date()).getTime());
// console.log((new Date()).getTime());
// console.log((new Date()).valueOf());
var options = {
weekday: "long", year: "numeric", month: "long",
day: "numeric", hour: "2-digit", minute: "2-digit",
second: "2-digit"};
var options2 = {
weekday: "short", year: "numeric", month: "short",
day: "numeric", hour: "2-digit", minute: "2-digit",
J.D.B. DIASOLUKA Nz. Luyalu
11 / 26
JavaScript Tome-III
second: "2-digit"};
console.log(date.valueOf());
// 1543068310250
console.log(date.valueOf().toLocaleString());
// 1,543,068,310,250
console.log(date.toLocaleString()); // 11/24/2018, 3:05:10 PM
console.log(date.toLocaleString().length);
// 22
console.log("*********");
console.log(date.toLocaleDateString("en-US")); // 11/24/2018
console.log(date.toLocaleDateString("fr-FR")); // 24/11/2018
console.log(date.toLocaleDateString("ja-JA")); // 2018/11/24
console.log(date.toLocaleDateString("en-US", options));
// Saturday, November 24, 2018, 3:05:10 PM
console.log(date.toLocaleDateString("fr-FR", options));
// samedi 24 novembre 2018 é 15:05:10
console.log(date.toLocaleDateString("en-US", options2));
// Sat, Nov 24, 2018, 3:05:10 PM
console.log(date.toLocaleDateString("fr-FR", options2));
// sam. 24 nov. 2018 é 15:05:10
console.log(date.toLocaleDateString("ja-JA", options));
// 2018?11?24???? 15:05:10
console.log(date.toLocaleDateString("ja-JA", options));
// 2018?11?24???? 15:05:10
console.log("*********");
console.log(date.toLocaleTimeString("en-us"));
// 3:05:10 PM
console.log(date.toLocaleTimeString("fr-FR"));
// 15:05:10
console.log(date.toISOString("fr-FR"));
// 2018-11-24T14:05:10.250Z
console.log(date.toLocaleTimeString("ja-JA"));
// 15:05:10
console.log(date.toLocaleTimeString("en-us", options));
// Saturday, November 24, 2018, 3:05:10 PM
console.log(date.toLocaleTimeString("fr-FR", options));
// samedi 24 novembre 2018 é 15:05:10
console.log(date.toISOString("fr-FR", options));
// 2018-11-24T14:05:10.250Z
console.log(date.toLocaleTimeString("en-us", options2));
// Sat, Nov 24, 2018, 3:05:10 PM
console.log(date.toLocaleTimeString("fr-FR", options2));
// sam. 24 nov. 2018 é 15:05:10
console.log(date.toLocaleTimeString("ja-JA", options2));
// 2018?11?24?(?) 15:05:10
console.log(date.toLocaleTimeString("ja-JA", options2));
// 2018?11?24?(?) 15:05:10
</script>
Manipulations des dates :
J.D.B. DIASOLUKA Nz. Luyalu
12 / 26
JavaScript Tome-III
<script>
// Dete et heure en cours.
var auj = new Date();
var mois = auj.getMonth()+1,
jour = auj.getDate(),
an = auj.getFullYear(),
hr = auj.getHours(),
min = auj.getMinutes(),
sec = auj.getSeconds(),
mil = auj.getMilliseconds();
// Manipulation directe de chaque élément de la date.
console.log(jour + '-' + mois + '-' + an+' T '+
hr + ':' + min + ':' + sec + ':' + mil);
console.log(auj.getTime());
// Ré GLER L'ANNéE.
auj.setFullYear(2920)
// Ré gler le mois.
auj.setMonth(6) // Les moins vont d'indice 0 (6=7)
// Ré gler le jour.
auj.setDate(15) // Les moins vont d'indice 0 (6=7)
console.log(auj.toLocaleDateString("fr-Fr")+ " T "+
auj.toLocaleTimeString("fr-Fr"));
console.log(auj.toISOString("fr-Fr"));
// Tous les get ont leurs équivalents set
auj.setFullYear(auj.getFullYear()+10) // AJOUTER 10 ANS.
auj.setMonth(auj.getMonth()-5) // SOUSTRAIRE 5 MOIS.
auj.setDate(auj.getDate()-14) // SOUSTRAIRE 2 SEMAINES.
console.log(auj.toLocaleDateString("fr-Fr"));
// Ré GLER LA DATE LORS DE LA CRé ATION
auj=new Date("1980 Feb 11 15 07:25:350Z")
console.log(auj.toLocaleDateString("fr-Fr")+ " T "+
auj.toLocaleTimeString("fr-Fr"));
auj=new Date("Feb 1980 11 15:07:25:350 -05:00")
console.log(auj.toLocaleDateString("fr-Fr")+ " T "+
auj.toLocaleTimeString("fr-Fr"));
</script>
Exécution avec YANDEX :
test.html:12
test.html:14
test.html:22
test.html:24
test.html:29
test.html:32
test.html:38
J.D.B. DIASOLUKA Nz. Luyalu
28-1-2018 T 22:32:13:316
1517175133316
15/07/2920 T 22:32:13
2920-07-15T21:32:13.316Z
11/08/1980 T 16:07:25
11/02/1980 T 21:07:25
1989-08-28T20:07:25.350Z
13 / 26
JavaScript Tome-III
Exécution avec FIREFOX :
28-1-2018 T 23:7:43:523
1517177263523
15/07/2920 T 23:07:43
2920-07-15T22:07:43.523Z
01/02/2930
Invalid Date T Invalid Date
Invalid Date T Invalid Date
test.html:12:1
test.html:14:1
test.html:22:1
test.html:24:1
test.html:30:1
test.html:34:1
test.html:37:1
X. Récursivité (récurrence - Factorielle d’un nombre) :
<script type="text/javascript">
var vin=170;
let fact = function ( n ) {
if ( n == 0) return 1;
else return fact ( n - 1) * n ;
}
console.log(vin+"! = "+fact(vin));
</script>
// 170! = 7.257415615307994e+306
Note :
Nous venons de voir là une méthode de l'objet Math. En voici d'autres
ainsi que les propriétés. Les Méthodes sont des fonctions intrinsèques,intégrées/incorporées, built-in dans l’objet. Elles ont des parenthèses (). Les Propriétés n’ont pas de parenthèses et représentent,ici
des constantes. Les Propriétés et Méthodes sont accessibles via l'objet
ici l’objet Math, et leur notation DOIT donc être précédée de « Math. »
(Math avec M majuscule et le reste en minuscules, suivi d’un point sans
espace devant et après le point) :
XI. Méthodes et propriétés standards de l’objet Math :
abs(N), ceil(N), floor(N), round(N), trunc(N), max(N1,N2),
min(N1,N2), pow(B,P), random(N), sqrt(N).
Logarithmes et exponentielle avec l’objet Math :
E, exp(N), LN2, LN10, log(N), LOG2E, SQRT1_2, SQRT2.
Trigonométrie avec l’objet Math :
J.D.B. DIASOLUKA Nz. Luyalu
14 / 26
JavaScript Tome-III
PI, sin(N), asin(N), cos(N), acos(N), tan(N), atan(N).
Notez la virgule de chaînage entre « k=0 » et « a.toLocaleSt... »
<script>
var a=new Date(9999,12,31).toLocaleString()
console.log(a.length);
for(k=0 , l=a.length ; k < 10 ; k++)
console.log(k*l)
</script>
// 23
// 0 23 46 69 92 115 138 161 184 207
Dans l’exemple qui suit, quand la condition « a<=5 ? » est remplie, le
chaînage « c = Math.pow(a,2) , d=b*b , e=2*a*b ; » ne se
passe pas comme on pourrait s’y attendre (seule la première expression
« c = Math.pow(a,2) » n’est pas exécutée , les deux autres
(« d=b*b » et « e=2*a*b » ;) sont exécutées :
<script>
var a=Math.round(Math.random()*10) ,
b=Math.ceil(Math.log(a)) ,
c=d=e=0 , v ;
v = a<=5 ?
a*a + b*b + 2*a*b
:
c = Math.pow(a,2) , d=b*b , e=2*a*b ;
console.log(v+" || "+a+"_"+b+" || "+c+"_"+d+"_"+e)
</script>
Exécution :
La condition « a<=5 ? » est remplie (a==4, inf ou == 5),
l’expression avant le double-point est exécutée, Aucune expression
dans le chaînage après ce double-point ne devrait être exécutée, mais
seule la première expression est ignorée (v a pris la valeur de
l’expression « a^2 + b^2 + 2*a*b » d’avant le double-point), « c =
Math.pow(a,2) » n’a pas été exécutée (c a gardé sa valeur initiale =
valeur d’initialisation), mais les deux autres « d=b*b » et
« e=2*a*b » ont été évaluées (exécutées).
J.D.B. DIASOLUKA Nz. Luyalu
15 / 26
JavaScript Tome-III
36 || 4_2 || 0_4_16
La condition « a<=5 ? » n’est pas remplie (a==7, > 5), l’expression
avant le double-point n’est pas exécutée, toute la chaîne d’expressions
après ce « : » est exécutée. v prend la valeur de la première expression
dans la chaîne d’instructions après le « : » .
49 || 7_2 || 49_4_28
XII.
Particularités de const, let et var :
Alors que JS en sloppy mode (mode standard) autorise d’utiliser une
variable sans la déclarer au préalable, JS en mode strict ("use strict" ;)
n’accepte pas d’utiliser une variable non, déclarée (avant ou après sa
première utilisation dans un scope donné).
En mode sloppy :
<script type="text/javascript">
d=Date(); console.log(d);
// Sat Feb 24 2018 22:21:20 GMT+0100 (Paris, Madrid)
</script>
En mode « use strict » :
<script type="text/javascript"> "use strict";
d=Date(); console.log(d);
// Uncaught ReferenceError: d is not defined [YANDEX]
// ReferenceError: assignment to undeclared variable d
[FIREFOX]
</script>
Variable déclarée avec « var » après sa première utilisation :
<script type="text/javascript"> "use strict";
d=Date(); console.log(d);
var d;
// Sat Feb 24 2018 22:34:35 GMT+0100 (Paris, Madrid)
</script>
Contraire à « var », « let » n’admet pas de déclaration différée de variable :
J.D.B. DIASOLUKA Nz. Luyalu
16 / 26
JavaScript Tome-III
<script type="text/javascript"> "use strict";
d=Date(); console.log(d);
let d;
// ReferenceError: can't access lexical
// declaration `d' before initialization [FIREFOX]
//
// Uncaught ReferenceError:
// d is not defined at test.html:2 [YANDEX]
// Uncaught ReferenceError: d is not defined [BAIDU]
</script>
De même contraire à « var », « let » n’admet pas de déclaration ni de
redéfinition de la même variable dans le même scope :
<script type="text/javascript"> "use strict";
var v;
var v;
let l;
let l;
/* FIERFOX : SyntaxError:
redeclaration of let l
test.html:6:5
note: Previously declared at line 5, column 5
YANDEX :
Uncaught SyntaxError:
Identifier 'l' has already been declared
</script>
*/
Tandis que « const » exige l’initialisation pendant l’unique déclaration
(n’accepte ni une réaffectation ni une redéclaration dans la même portée de bloc).
<script type="text/javascript"> "use strict";
d=Date(); console.log(d);
const d;
/* SyntaxError: missing = in const declaration [FIREFOX]
Uncaught SyntaxError:
Missing initializer in const declaration [YANDEX]
Uncaught SyntaxError: Unexpected token ; [BAIDU] */
</script>
Les valeurs des propriétés d’un objet const peuvent cependant être
modifiées :
J.D.B. DIASOLUKA Nz. Luyalu
17 / 26
JavaScript Tome-III
<script type="text/javascript"> "use strict";
const obj = {id: 'dias'};
////// obj = {id: 'wille'};
// TypeError:
//
invalid assignment to const `obj' [FIREFOX]
// Uncaught TypeError:
//
Assignment to constant variable.[YANDEX]
obj.id = 'wille';
console.log(obj); // Object { id: "wille" }
</script>
Dans les deux modes (sloppy et strict), une variable ou une expression
de fonction ne peuvent être déclarées qu’avec l’un des trois mots clés
suivants : const, let ou var, avec les spécificités suivantes :
1.
« const » (définit une entité constante, identificateur qui ne peut
être redéfini) et « let » (définit une variable ou une expression de
fonction) sont de portée (scope = domaine) bloc quel qu’il soit :
<script type="text/javascript"> "use strict";
{ let li=7 ; {console.log(li) /* 7 */} };
console.log(li)
// ReferenceError: li is not defined [FIREFOX]
// Uncaught ReferenceError: li is not defined [YANDEX]
</script>
<script type="text/javascript"> "use strict";
{ const ci=10 ; {console.log(ci) /* 10 */} };
console.log(ci)
// ReferenceError: ci is not defined [FIREFOX]
// Uncaught ReferenceError: ci is not defined [YANDEX]
</script>
2.
Une entité « const » ne peut être redéclarée, redéfinie ou réaffectée :
<script type="text/javascript"> "use strict";
const cf=function(){console.log(Date())};
cf();
cf=function(){console.log(Math.PI)};
// YANDEX :
// Sat Feb 24 2018 22:52:09 GMT+0100 (Paris, Madrid)
// Uncaught TypeError: Assignment to constant variable.
// FIREFOX :
// Sat Feb 24 2018 22:54:29 GMT+0100 (Paris, Madrid)
// TypeError: invalid assignment to const `cf'
J.D.B. DIASOLUKA Nz. Luyalu
18 / 26
JavaScript Tome-III
// BAIDU :
// Sat Feb 24 2018 22:55:33 GMT+0100 (Paris, Madrid)
// Uncaught TypeError: Assignment to constant variable.
</script>
3. « var » est de scope bloc de fonction ou fichier :
<script type="text/javascript"> "use strict";
let lg=5; const cg=20 ;
{ // Bloc vraiment ordinaire.
var vb=15;
console.log(cg) // 20. Visible ds bloc imbriqué .
}
console.log(lg, cg, vb) // 5 20 15
// vb est visible en dehors du bloc ordin,
// mais ne le serait pas hors un bloc de fct,
// cfr ci-dessous.
const cf=function(){var vf=10;}
console.log(vf);
// Uncaught ReferenceError: vf is not defined [BAIDU/YANDEX]
// ReferenceError: vf is not defined [FIREFOX]
</script>
4. const DOIT être initialisé au même moment que sa déclaration,
<script type="text/javascript"> "use strict";
const c2;
// SyntaxError: missing = in const declaration [FIREFOX]
// Uncaught SyntaxError: Missing initializer in const declaration [YANDEX]
// Uncaught SyntaxError: Unexpected token ; [BAIDU]
c2="const";
</script>
5. « var » et autres dans définition de fonction non expression :
En mode strict, une expression de fonction DOIT être précédée de var,
const ou let pour la définition / déclaration de fonction. Mais la définition simple de fonction ne doit jamais commencer par ces mots clés.
<script type="text/javascript"> "use strict";
function f(){console.log(Math.SQRT2)};
f(); // 1.4142135623730951
</script>
J.D.B. DIASOLUKA Nz. Luyalu
19 / 26
JavaScript Tome-III
<script type="text/javascript"> "use strict";
const function lf(){console.log(Math.SQRT2)};
// SyntaxError: missing variable name [FIREFOX]
// Uncaught SyntaxError: Unexpected token function [YANDEX]
</script>
<script type="text/javascript"> "use strict";
var function vf(){console.log(Math.SQRT2)};
// SyntaxError: missing variable name [FIREFOX]
// Uncaught SyntaxError: Unexpected token function [YANDEX]
</script>
<script type="text/javascript"> "use strict";
let function lf(){console.log(Math.SQRT2)};
// SyntaxError: let is a reserved identifier [FIREFOX]
// Uncaught SyntaxError: Unexpected strict mode reserved
word [YANDEX]
</script>
Si une const ne peut être ni redéclarée, ni redéfinie, ni réaffectée, la
valeur quelle renferme peut cependant être changée :
<script type="text/javascript"> "use strict";
const arr = ['A','B'];
const C = arr;
// arr et C ne peuvent étre
// redéclarés, redéfinis, ou réaffectés.
console.log(C);
// Array [ "A", "B" ]
// Mais la valeur de arr ou de C peuvent changer
// Méthode directe via les éléments.
[ arr[0],arr[1] ] = ['X' , 'Z'];
console.log(C);
// Array [ "X", "Z" ]
arr[0]= ["autre","array"] ;
arr[1] = {'X':'x' , 'Z':'z'};
console.dir(C);
console.dir(arr);
// […] , 0: "Zéro" , 1: "Un" , 2: "spl2" , 3: "PUSHé"
// length: 4
// Méthode directe via les méthodes...
J.D.B. DIASOLUKA Nz. Luyalu
20 / 26
JavaScript Tome-III
arr.push('PUSHé');
arr.splice(1,1,"spl1","spl2");
console.log(C);
// Array [ […], "spl1", "spl2", "PUSHé" ]
// […], 0: "Zéro", 1: "Un", 2: "spl2", 3: "PUSHé"
// length: 4
// La valeur de arr ou de C peuvent aussi changer
// par Méthode indirecte (p.e. du sein d'une fonction)
console.log("fct(C)= ",fct(C));
console.log("C=",C); // constante comme argument.
console.log("arr=",arr);
// Array [ "Zéro", "Un", "spl2", "PUSHé" ]
// […], 0: "Zéro", 1: "Un", 2: "spl2", 3: "PUSHé"
// length: 4
function fct(p){
p[0]="Zéro", p[1]="Un";
return p;
}
</script>
XIII.
A.
Techniques pour programmer le PGCD de deux entiers :
Par le biais des plus petits diviseurs communs :
1 Les deux entiers dans une array :
<script type="text/javascript"> "use strict";
var r,d,n1=2040,n2=39960
function pgcd(o){
o=o.sort().reverse() // n1 > n2
console.log(Object.values(o))
var pq=1;
for(var p=2 ; p<o[0]/2 ; p++){
for(var k=2 ; k<o[0]/2 ; k++){
if(!(o[0]%k) && !(o[1]%k)){
pq*=k; o=o.map(x=>x/k)
console.log(pq+" "+k+" "+o)
}
}
}
return pq
}
J.D.B. DIASOLUKA Nz. Luyalu
21 / 26
JavaScript Tome-III
r=pgcd([n1,n2]) // L’array
console.log("pgcd ("+n1+" &
r+" ("+n1/r+" &
</script>
// Array [ 39960, 2040 ]
// 2 2 19980,1020
// 6 3 6660,340
// 24 4 1665,85
// 120 5 333,17
// pgcd (2040 & 39960) = 120
des deux entiers.
"+n2+") = "+
"+n2/r+") ")
(17 & 333)
2 Les deux entiers dans un littéral d’objet :
<script type="text/javascript"> "use strict";
var r,d,n1=4020, n2=2040 // n1 >2
function pgcd(o){
console.log(Object.values(o))
var pq=1;
for(var p=2 ; p<o.n1/2 ; p++){
for(var k=2 ; k<o.n1/2 ; k++){
if(!(o.n1%k) && !(o.n2%k)){
pq*=k; o.n1/=k, o.n2/=k
console.log(pq+" "+k+" "+Object.values(o))
}
}
}
return pq
}
r=pgcd(d={n1:n1,n2:n2})
console.log("pgcd ("+n1+" & "+n2+") = "+
r+" ("+n1/r+" & "+n2/r+") ")
</script>
// Array [ 4020, 2040 ]
// 2 2 2010,1020
// 6 3 670,340
// 30 5 134,68
// 60 2 67,34
// pgcd (4020 & 2040) = 60 (67 & 34)
3 Plus simple (avec des primitives) :
<script type="text/javascript"> "use strict";
var r,d,n1,n2
function pgcd(n1,n2){
console.log(n1,n2)
var pq=1;
for(var p=2 ; p<n1/2 ; p++){
J.D.B. DIASOLUKA Nz. Luyalu
22 / 26
JavaScript Tome-III
for(var k=2 ; k<n1/2 ; k++){
if(!(n1%k) && !(n2%k)){
pq*=k; n1/=k, n2/=k
console.log(pq+" "+k+" "+n1+" "+n2)
}
}
}
return pq
}
r=pgcd(n1=Math.round(Math.random()*1e4),
n2=Math.round(Math.random()*1e5))
console.log("pgcd ("+n1+" & "+n2+") = "+
r+" ("+n1/r+" & "+n2/r+") ")
</script>
// 1792 33348
// 2 2 896 16674
// 14 7 128 2382
// 28 2 64 1191
// pgcd (1792 & 33348) = 28 (64 & 1191)
B. Selon les deux principes :
PGCD ( a , b ) = PGCD ( b , a mod b ) et PGCD ( a , 0 ) = a. :
1 Les deux entiers dans une array :
<script type="text/javascript"> "use strict";
// PGCD(a,b) = PGCD (b,a mod b) et PGCD(a,0) = a.
var r,d,
n1=2040,n2=39972 // Les deux entiers
function pgcd(a){
a=asort(a) // n1 > n2
console.log(Object.values(a),+" "+n1+" "+n2)
var pq=1;
while(a[1]) a=[a[1], a[0]%a[1]] , console.log(a)
return a[0]
}
r=pgcd([n1,n2]) // L’array des deux entiers.
console.log("pgcd ("+n1+" & "+n2+") = "+
r+" ("+n1/r+" & "+n2/r+") ")
function asort(a){
return a.sort().reverse() // n1 > n2
}
</script>
// Array [ 39972, 2040 ]
2040 39972
J.D.B. DIASOLUKA Nz. Luyalu
23 / 26
test.html:7:4
JavaScript Tome-III
//
//
//
//
//
//
//
//
Array [ 2040, 1212 ]
Array [ 1212, 828 ]
Array [ 828, 384 ]
Array [ 384, 60 ]
Array [ 60, 24 ]
Array [ 24, 12 ]
Array [ 12, 0 ]
pgcd (2040 & 39972) = 12 (170 & 3331)
XIV.
test.html:11:10
test.html:11:10
test.html:11:10
test.html:11:10
test.html:11:10
test.html:11:10
test.html:11:10
test.html:17:2
Définition de méthode en JavaScript :
On peut définit une méthode en « inline » ou en différé.
En différé :
<script model="text/javascript"> "use strict";
function Specs (model) {
this.model = model;
this.color = "bleu";
this.dispInfo = dispSpecsInfo;
// Méthode déclarée ici, mais
// définie en différé (ailleurs).
// Notez l'absence de parenthése.
}
function dispSpecsInfo() {
return 'Fusée '+this.model+" "+this.color;
}
// Définition "externe" de la méthode
// Specs.dispSpecsInfo().
// Inconvénients :
// 1. Peut étre appelé de n'importe oé,
//
éventuellement générant des erreurs.
// 2. Risque de conflicts avec des fonctions
//
de librairies ou de redéfinition.
// 3. Bouffe de l'espace.
var specs = new Specs('Soyouz'); // Instanciation
specs.color = "grisétre"; // On redéfinit color
console.log(specs.dispInfo());
// Fusée Soyouz grisétre
</script>
En ligne (inline) :
J.D.B. DIASOLUKA Nz. Luyalu
24 / 26
JavaScript Tome-III
<script model="text/javascript"> "use strict";
function Specs (model) {
this.model = model;
this.color = "bleu";
this.dispInfo = dispSpecsInfo_=>
'Fusé e '+this.model+" "+this.color;
// Mé thode dé finie en inline :
// moins de codes.
}
var specs = new Specs('Soyouz'); // Instanciation
specs.color = "roussé tre"; // On redé finit color
console.log(specs.dispInfo());
// Fusé e Soyouz grisé tre
</script>
Mots-clés :
Itération, ITERATEUR, object retourné, Symbol.iterator, itérable,
next, listage, propriété, enumerable, for...in, itérable, Itération Synchrone
mardi, 2. octobre 2018 (11:59 ).
J.D.B. DIASOLUKA Nz. Luyalu
25 / 26
JavaScript Tome-III
DIASOLUKA Nz. Luyalu
Docteur en Médecine, Chirurgie & Accouchements (1977),
CNOM : 0866 - Spécialiste en ophtalmologie (1980)
Informaticien-amateur, Programmeur et WebMaster.
Chercheur indépendant, autonome et autofinancé, bénévole,
sans aucun conflit d’intérêt ou liens d'intérêts ou contrainte
promotionnelle avec qui qu’il soit ou quelqu’organisme ou
institution / organisation que ce soit, étatique, paraétatique ou
privé.
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
[email protected]
J.D.B. DIASOLUKA Nz. Luyalu
26 / 26
JavaScript Tome-III