Javascript - Tome - VIII - Le Type Primitif Symbol

J AVA S C R I P T (Programmation Internet) V O L .
V I I I
Pour Débutants
J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818
CHAPITRE 14 : Le type primitif « Symbol () »
Une propriété (plutôt « type primitif ») particulière : Symbol().
Les « Symbol » sont de « type primitif » que des objets :

1. Ils ne peuvent pas être « prototype » d’objet.
2. Les « Symbol » ne sont pas « constructeur » : on ne peut pas uti-
liser la syntaxe « new Symbol() »".
3. Ils ne peuvent pas générer d’instances.
4. Ils ne peuvent pas être examinés avec instanceof,…
5. Ils ne peuvent pas être dénombrés avec la boucle « for... in … »
car non énumérables.
6. Ils n’apparaissent pas dans le tableau des résultats de « Ob-
ject.getOwnPropertyNames() » car la propriété créée est ano-
nyme.
Voici ce que dit « ECMA-262, 9th edition, June 2018 - ECMAScript®

2018 - Language Specication » sur le type « Symbol » :
6.1.5 The Symbol Type
The Symbol type is the set of all non-String values that may
be used as the key of an Object property (6.1.7).
Each possible Symbol value is unique and immutable.

J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VIII
Each Symbol value immutably holds an associated value
called [[Description]] that is either undefined or a String
value.
6.1.5.1 Well-Known Symbols
Well-known symbols are built-in Symbol values that are ex-

plicitly referenced by algorithms of this specification. They
are typically used as the keys of properties whose values
serve as extension points of a specification algorithm. Unless
otherwise specified, well-known symbols values are shared
by all realms (8.2).
Within this specification a well-known symbol is referred to

by using a notation of the form @@name, where “name” is
one of the values listed in Table 1.
Table 1: Well-known Symbols
@@Specification Name:
[[Description]]
* Value and Purpose
@@asyncIterator
[[Symbol.asyncIterator]]
* A method that returns the default AsyncIterator for an
object. Called by the semantic of the for-await-of statement.
Le type primitif Symbol() -2/31- dimanche, 24. mars 2019 (12:24 )
@@hasInstance
[[Symbol.hasInstance]]
* A method that determines if a constructor object recogniz-
es object as one of the constructor's instances. Called
by the semantics of the instanceof operator.
@@isConcatSpreadable
[[Symbol.isConcatSpreadable]]
* A Boolean valued property that if true indicates that an ob-
ject should be flattened to its array elements by Ar-
ray.prototype.concat method.
@@iterator
[[Symbol.iterator]]
* A method that returns the default Iterator for an object.
Called by the semantics of the for-of statement.
@@match
[[Symbol.match]]
* A regular expression method that matches the regular ex-
pression against a string.
Called by the String.prototype.match method.
@@replace
[[Symbol.replace]]
* A regular expression method that replaces matched sub-
strings of a string. Called by the String.prototype.replace
method.
@@search
[[Symbol.search]]
* A regular expression method that returns the index within
string that matches the regular expression.
Called by the String.prototype.search method.
@@species
[[Symbol.species]]
* A function valued property th is the constructor function
that is used to create derived object.
@@split
[[Symbol.split]]
* A regular expression method that splits a string at the indi-
cates that match the regular expression. Called by the
String.prototype.split method.
@@toPrimitive
[[Symbol.toPrimitive]]
* A method that converts an object to a corresponding primi-
tive value. Called by the ToPrimitive abstract operation.
@@toStringTag
[[Symbol.toStringTag]]
* A String valued property that used in the creation of the
default string description of a object. Accessed by the built-in
method Object.prototype.toString.
@@unscopables
[[Symbol.unscopables]]
* An object valued property whose own and inherited prop-
erty names are property names that are excluded from the
with environment binding of the associated object.
Un petit comparatif de « Symbol » avec « String »:
<script type="text/javascript">
let mySymb = Symbol("mySymb");
let ordStr = ("myStr");
console.log(mySymb);
// Symbol(mySymb)
console.log([mySymb]);
// Array [ Symbol(mySymb) ]
console.log(ordStr);
// myStr
console.log([ordStr]);
// Array [ "myStr" ]
console.log(String(mySymb));
// Symbol(mySymb)
console.log(String([mySymb]));
// TypeError: can't convert symbol to string
//
// Uncaught TypeError: Cannot convert a Symbol value to a
string
// at Array.join (<anonymous>)
// at Array.toString (<anonymous>)
// at String (<anonymous>)
console.log([String(mySymb)]);
// Array [ "Symbol(mySymb)" ]
console.log(String(ordStr));
// myStr
console.log(String([ordStr]));
// myStr
console.log([String(ordStr)]);
// Array [ "myStr" ]

console.log(ordStr.length);
// 5
console.log([ordStr].length);
// 1
console.log(Object.keys(mySymb));
// Array []
console.log(Object.keys(ordStr));
// Array(5) [ "0", "1", "2", "3", "4" ]
console.log(Object.values(mySymb));
// Array []
console.log(Object.values(ordStr));
// Array(5) [ "m", "y", "S", "t", "r" ]
console.log(Object.getOwnPropertyDescriptors(mySymb));
// Object { }
// __proto__: Object
console.log(Object.getOwnPropertyDescriptors(ordStr));
/*
{0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…}, length: {…}}
0: {value: "m", writable: false, enumerable: true, config-
urable: false}
1: {value: "y", writable: false, enumerable: true, config-
urable: false}
2: {value: "S", writable: false, enumerable: true, config-
urable: false}
3: {value: "t", writable: false, enumerable: true, config-
urable: false}
4: {value: "r", writable: false, enumerable: true, config-
urable: false}
length: {value: 5, writable: false, enumerable: false,
configurable: false}
__proto__: Object
*/
console.log(Object.getOwnPropertyNames(mySymb));
// Array []
console.log(Object.getOwnPropertyNames(ordStr));
// (6) ["0", "1", "2", "3", "4", "length"]
console.log(Object.getOwnPropertySymbols(mySymb));
// Array []
console.log(Object.getOwnPropertySymbols(ordStr));
// Array []
</script>
« Symbol » permet de créer des noms de variables spéciales (plutôt nom

unique de clé de propriétés) uniques ayant des valeurs littérales qu’on
peut utiliser comme ID (la valeur stockée dans le Symbole est utilisée
comme ID), et ces valeurs des Symboles ne peuvent pas se conflictuer
avec des noms de IDs préexistants/prédéfinis surtout en temps
d’exécution (prévient les erreurs de temps d’exécution). En fait c’est la
valeur de symbole qui est utilisée comme ID et non l’ID du symbole.
Cela permet de ne pas écraser des variables ou propriétés préexistantes
même quand on utilise leurs IDs.
Avec les symboles on a donc deux « valeurs » : celle de la propriété,

accessible via l’ID (clé) de celle-ci et qui est la valeur du Symbole qui
lui aussi a son ID. La valeur du symbole est donc l’ID de la propriété.
Bref, il faut considérer les symboles comme « noms d’ID unique générés
automatiquement ». « Symbol » est l’équivalent de « atome » dans
d’autres langages de programmation.
La description d’un symbole est facultative, utile uniquement à des fins

de débogage.
<script type="text/javascript"> "use strict";

let o = {
prop1 : "propriété prédéfinie"
// Prédéfinie par qq'1 d'autre;
};
console.log(o.prop1);
// propriété prédéfinie
// Notez le point.

o.prop1="modifiée par mégarde";
// modifiée par mégarde
// Notez le point.
// Solution = Symbole.
let prop1= Symbol("Descripteur");
o[prop1] = "Même ID Sans conflit";
// Notez les brackets.
let prop2= Symbol.for("2e Symbole");

// idem que « Symbol("2e Symbole"); », mais le
// crée sl* si le symbole n'existe pas encore.
o[prop2] = "On peut créer autant de symboles !";
let prop3= Symbol(2019);

o[prop3] = "Description numérique !";
// modifiée par mégarde
// Notez le point.
console.log(o[prop1]);
// Même ID Sans conflit
// Notez les brackets.
console.log(o[prop2]);
// Notez aussi les brackets.
console.log(Symbol.keyFor(prop2));
// 2e Symbole
console.log(Symbol.keyFor(prop1));
// undefined
console.log(Object.getOwnPropertySymbols(o));
// Array(3) [ Symbol(Descripteur), Symbol(2e Symbole),
Symbol(2019) ]
// (3) […]
// 0: Symbol(Descripteur)
// 1: Symbol(2e Symbole)
// 2: Symbol(2019)
// length: 3
// <prototype>: Array []
</script>
Le drawback de cela est de rendre les propriétés d'objets anonymes.
Les valeurs des symboles sont stockées dans un registre appelé « table
globale de symboles ».
Exemple de génération de nom unique de clé de propriété :
1. « Symbol » comme propriété :
const KEY1 = Symbol();
const obj = {
KEY3:new Date().toLocaleDateString(),
[KEY4]:new Date().toLocaleTimeString()
};
console.log(obj[KEY4]); // 12:07:57
console.log(obj.KEY3); // 07/03/2019
/**/
obj[KEY1] = 123;
console.log(obj[KEY1]); // 123
obj.KEY2 = "abc";
console.log(obj.KEY2); // abc
</script>
2. « Symbol » comme méthode :
const FOO = Symbol();
const obj = {
[FOO](p) { // Notez les brakets

return Math.log(p);
}
};
console.log(
obj[FOO](new Date().getFullYear())
); // 7.610357618312838
</script>
3. « Symbol » comme « get » et comme « set » :
this. v;
const FOOs = Symbol();
let FOOg = Symbol();
const obj = {
set [FOOs](p) { // Avec ou sans brakets
console.log("Dans set" , FOOs, p);
this.v = p;
},
get FOOg() { // Avec ou sans brakets
console.log("Dans get", FOOg, this.v);
return "Date = "+this.v;
}
};
obj[FOOs] = new Date(); // Format ds description

console.log(obj.FOOg); // Format ds description
obj.FOOg; // Même format que dans la description
</script>
Ils sont générés par une « factory function » qui crée automatiquement
un nouveau et unique symbole. L’unique paramètre -optionnel- sert à
décrire le nom-unique de variable.
const varSymbol = Symbol('varSymbol');
console.log(varSymbol);
// Symbol(varSymbol)
console.log(varSymbol.toString() ,

String(varSymbol));
// Symbol(varSymbol) Symbol(varSymbol)
console.log(Symbol(),Symbol());
// Symbol() Symbol()
console.log(Symbol().toString(),
String(Symbol()));
// Symbol() Symbol()
console.log(Symbol('Red'),Symbol('Red'));
// Symbol(Red) Symbol(Red)
console.log(Symbol('Red').toString(),
String(Symbol('Red')));
// Symbol(Red) Symbol(Red)
console.log(Symbol()===Symbol());
// false
console.log(Symbol()==Symbol());
// false
console.log(Symbol('Green')===Symbol('Green'));
// false
console.log(Symbol('Blue')==Symbol('Blue'));
// false
const vSYMBOL1 = Symbol('DESCRIPTION');

const vSYMBOL2 = Symbol('DESCRIPTION');
console.log(vSYMBOL1,vSYMBOL2);
// Symbol(DESCRIPTION) Symbol(DESCRIPTION)
const v="DESCRIPTION";
const vSYMBOL3 = Symbol(v);
const vSYMBOL4 = Symbol(v);
console.log(vSYMBOL3,vSYMBOL4);
// Symbol(DESCRIPTION) Symbol(DESCRIPTION)
console.log(typeof Symbol); // function

console.log(typeof Symbol()); // symbol
console.log(Symbol('Yellow')=Symbol('Yellow'));
// YANDEX : test.html:50
// Uncaught ReferenceError:
// Invalid left-hand side in assignment
// at test.html:50
//
// FIRFOX :
// ReferenceError:
// invalid assignment left-hand side test.html:50:17
</script>
Exécution :
Les « Symbol » ne sont pas itérables, donc ne sont pas affichés par les
méthodes
 « Object.keys() »,
 « Object.getOwnPropertyNames() »,
 ni par la boucle « for-in ».
Par exemple, pour l’objet « File » dont propriétés sont :

ou avec
console.log(Object.getOwnPropertyDescriptors(File));
</script>
Avec Yandex :
test.html:2
1. {length: {…}, name: {…}, arguments: {…}, caller: {…}, prototype:

{…}}
1. arguments: {va-
lue: null, writable: false, enumerable: false, configurable:
false}
2. caller: {va-
lue: null, writable: false, enumerable: false, configurable:
false}
3. length: {val-
ue: 2, writable: false, enumerable: false, configurable: tru
e}
4. name: {val-
ue: "File", writable: false, enumerable: false, configurable
: true}

5. prototype: {va-
lue: File, writable: false, enumerable: false, configurable:
false}
6. __proto__: Object
Avec Firefox :
console.log(Object.keys(File));
</script>
console.log(Object.values(File));
</script>
console.log(Object.getOwnPropertyNames(File));
</script>

Attention :
« Object.getOwnPropertyNames(File) »
ne donne pas le même résultat que
« Reflect.ownKeys(File) » :
console.log(Reflect.ownKeys(File));
</script>
console.log(Object.getOwnPropertySymbols(File));
</script>
La propriété « Symbol . iterator » :
Une propriété intéressante de « Symbol » c’est le « Symbol . iterator »

qui comme son nom l’indique, permet de générer des « itérables » via
une fonction génératrice « function* () » :

const iterable = new Object();
iterable[Symbol.iterator] = function* () {
for(let k=5;k<10;k++)yield {a:k , b:k*k};
};

console.log([...iterable]);
// Array(5) [ {…}, {…}, {…}, {…}, {…} ]
// (5) […]
// 0: Object { a: 5, b: 25 }
// 1: Object { a: 6, b: 36 }
// 2: Object { a: 7, b: 49 }
// 3: Object { a: 8, b: 64 }
// 4: Object { a: 9, b: 81 }
// length: 5
// <prototype>: Array []
</script>
Ci-dessous, quelques types natifs (=incorporées, " built-in types") ayant

par défaut le comportement d’itération :
 Array . prototype [@@iterator]()

 TypedArray . prototype [@@iterator]()
 String . prototype [@@iterator]()
 Map . prototype [@@iterator]()
 Set . prototype [@@iterator]()
Structure interne de Symbol :

Exemples d’utilisation de « Symbol » :
Exemple1 :
const RED = Symbol('red');
const ORANGE = Symbol('Orange');
const YELLOW = Symbol('Yellow');
const GREEN = Symbol('Green');
const BLUE = Symbol('Blue');
const VIOLET = Symbol('Violet');
const a=[
RED,ORANGE,YELLOW,GREEN,BLUE,VIOLET,
Symbol("GARBAGE")
];
function coulComplement(color) {
switch (color) {
case RED: fgo(color, GREEN);break;
case ORANGE: fgo(color, BLUE);break;
case YELLOW: fgo(color, VIOLET);break;
case GREEN: fgo(color, RED);break;
case BLUE: fgo(color, ORANGE);break;
case VIOLET: fgo(color, YELLOW);break;
default: console.log(color,
' - Unknown color Symbol');
}
}
function fgo(cl,cp){
console.log(
`Complément de ${String(cl)} = ${cp.toString()}`
);
}
for(i in a)coulComplement(a[i]);
</script>
Exemple2 :

var idxv = Symbol('qcmV');
console.log(idxv); // Symbol(qcmV)
const idxc = Symbol('qcmC');

console.log(idxc); // Symbol(qcmC)
const a = [68, 80, 55];

console.log(a, ` , a.length = ${a.length}`);
// Array(3) [ 68, 80, 55 ] , a.length = 3
a[idxv]= 71;

// Array(3) [ 68, 80, 55 ] , a.length = 3
console.log(à[idxv] = `, a[idxv]);
// a[idxv] = 71
a[idxv]= 42; // Ã‰crasement de a[idxv]

// Array(3) [ 68, 80, 55 ] , a.length = 3
// a[idxv] = 42
a[idxc]= 29;
// Array(3) [ 68, 80, 55 ] , a.length = 3
console.log(à[idxc] = `, a[idxc]);
// a[idxc] = 29
a[idxc]= 46; // Ã‰crasement de a[idxc]

// Array(3) [ 68, 80, 55 ] , a.length = 3
console.log(à[idxc] = `, a[idxc]);
// a[idxc] = 46
a[a.length]= 95;

// Array(4) [ 68, 80, 55, 95 ] , a.length = 4
console.log(à[a.length] = `, a[a.length]);
// a[a.length] = undefined
console.log(à[a.length] = , ${a[a.length]}`);
console.log(à[a.length] = , a${[a.length]}`);
console.log(à[4] = `, a[4]);
// a[4] = undefined

// a[idxv] = 42
console.log(à[Symbol('1')] = `, a[Symbol('1')]);
// a[Symbol('1')] = undefined
console.log(à["Symbol('1')"] = `, a["Symbol('1')"]);
// a["Symbol('1')"] = undefined
console.log(à[Symbol(1)] = `, a[Symbol(1)]);
// a[Symbol(1)] = undefined
console.log(à["Symbol(1)"] = `, a["Symbol(1)"]);
// a["Symbol(1)"] = undefined
console.log(`(a[eval(Symbol('1'))]) = `,
(a[eval(Symbol('1'))]));
// => (a[eval(Symbol('1'))]) = undefined
console.log(èval(a[(Symbol('1'))]) = `,
eval(a[(Symbol('1'))]));
// => eval(a[(Symbol('1'))]) = undefined
console.log(`Symbol.keyFor(idxv) = `,
Symbol.keyFor(idxv));
// => Symbol.keyFor(idxv) = undefined
console.log(à[(Symbol.keyFor(idxv))] = `,
a[(Symbol.keyFor(idxv))]);
// => a[(Symbol.keyFor(idxv))] = undefined
console.log(Òbject.keys(a) = ${Object.keys(a)}`);
// => Object.keys(a) = 0,1,2,3
console.log(Òbject.getOwnPropertyNames(a) = `,
Object.getOwnPropertyNames(a));
// => Array(5) [ "0", "1", "2", "3", "length"
]
console.log(Òbject.getOwnPropertySymbols(a) = `,
Object.getOwnPropertySymbols(a));
// => Array [ Symbol(qcmV), Symbol(qcmC) ]
console.log(`Reflect.ownKeys(a) = `,
Reflect.ownKeys(a));
// Array(7) [ "0", "1", "2", "3", "length", Sym-
bol(qcmV), Symbol(qcmC) ]
console.log(Object.entries(a));
// Array(4) [ (2) […], (2) […], (2) […], (2) […] ]
</script>
Exemple dans une fonction :

Création, utilisation, contraintes et restrictions.

var Elenge = (function () {
var KOMBO = Symbol('kombo');
var MBOKA = Symbol('mboka');
function Elenge(kombo, pName) {

this[KOMBO] = kombo;
this[MBOKA] = pName;
}
Elenge.prototype.dispKombo = function () {
console.log(

"=> Dans Elenge.prototype.dispKombo");
return this[KOMBO]; // Lors de l'appel
};
Elenge.prototype.dispMboka = function () {
console.log(
"=> Dans Elenge.prototype.dispMboka");
return this[MBOKA]; // Lors de l'appel
};
return Elenge; // Lors de l'instanciation

})();
console.log("Départ");
var motu = new Elenge('Kele', 'Lobiko');
console.log(motu.dispKombo(), motu.dispMboka());
// => Kele Lobiko
let t = "";
for (var key in motu) t += key + ` | `
console.log(t); // => dispKombo | dispMboka |
// Les Symbols ne sont pas énumerables
console.log(motu["kombo"]); // => undefined

console.log(motu["KOMBO"]); // => undefined
// Les symboles sont uniques

console.log(motu[Symbol('kombo')]); // => undefined
console.log(motu[Symbol('KOMBO')]); // => undefined
console.log(Object.getOwnPropertySymbols(Elenge));
// => Array []
</script>

Dommage, l’Array des « Symbol » est vide.

Exemple dans un object :

var O = {annee: 2018};
Object.defineProperty(O, 'mois', {value: 12});
O[Symbol('jour')] = 8;
O[Symbol('heure')] = Date.now;
console.log(Òbject.keys(O) = ${Object.keys(O)}`);
// => annee
console.log(Òbject.getOwnPropertyNames(O) = `,
Object.getOwnPropertyNames(O));
// => Array [ "annee", "mois" ]
console.log(Òbject.getOwnPropertySymbols(O) = `,
Object.getOwnPropertySymbols(O));
// => Array [ Symbol(jour) ]
console.log(`Reflect.ownKeys(O) = `,
Reflect.ownKeys(O));
// => Array(3) [ "annee", "mois", Symbol(jour)
]
</script>

Quelques méthodes de « Symbol » :

var Elenge = (function () {
var KOMBO = Symbol('kombo');
var MBOKA = Symbol('mboka');
function Elenge(kombo, pName) {

this[KOMBO] = kombo;
this[MBOKA] = pName;
}
Elenge.prototype.dispKombo = function () {
console.log(
"=> Dans Elenge.prototype.dispKombo");
return this[KOMBO]; // Lors de l'appel

};
Elenge.prototype.dispMboka = function () {
console.log(
"=> Dans Elenge.prototype.dispMboka");
return this[MBOKA]; // Lors de l'appel
};
return Elenge; // Lors de l'instanciation

})();
console.log("Départ");
var motu = new Elenge('Kele', 'Lobiko');
console.log(motu.dispKombo(), motu.dispMboka());
// => Kele Lobiko
console.log(motu["kombo"]); // => undefined

console.log(motu["KOMBO"]); // => undefined
// Les symboles sont uniques

console.log(motu[Symbol('kombo')]); // => undefined
console.log(motu[Symbol('KOMBO')]); // => undefined
console.log(Object.getOwnPropertySymbols(Elenge));
// => Array []
var t = "";
for (var key in motu) t += key + ` | `;
console.log(t); // => dispKombo | dispMboka |
// Les Symbols ne sont pas énumerables
var keysymb = Symbol.for("motu");
console.log(`« keysymb === Symbol.for("motu") » = ` ,

keysymb === Symbol.for("motu")); // true
console.log(`keysymb = ` , keysymb); // Symbol(motu)
console.log(`Symbol.for("motu") = `,
Symbol.for("motu")); // Symbol(motu)
console.log(`Symbol.keyFor(keysymb) = `,
Symbol.keyFor(keysymb)); // motu
var t="";
for (var y in Symbol.keyFor(keysymb))
t += y + ` | `;
console.log(t); // => 0 | 1 | 2 | 3 |
var t="";
for (var i in Symbol.keyFor(keysymb))
t += Symbol.keyFor(keysymb)[i] + ` | `;
console.log(t); // => m | o | t | u |
</script>

Kinshasa, le dimanche 24 mars 2019 - 12:24:33 PM
Mots-clés :
Reflect,Symbol,key,keyFor,iterator,generator,function*,toString,prototype,
type primitif,built-in,incorporé
DIASOLUKA Nz. Luyalu

Docteur en Médecine, Chirurgie & Accouchements (1977),
CNOM : 0866 - Spécialiste en ophtalmologie (1980)
Études humanités : Scientifique - Mathématiques & Physique.
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é, industriel ou commercial en relation avec le sujet
présenté.
+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818
diasfb@mail2world.com
Autre Lecture :
https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-de-La-
Creation

D’autres publications pouvant aussi intéresser :
• https://www.scribd.com/document/377036251/Le-
Dosage-Des-Medicaments-en-Cac-Cas
• https://www.scribd.com/document/377035454/Le-
Hasard-Des-Thermometres-Non-contact-a-Infrarouge
• https://www.scribd.com/document/376222482/Petite-
Introduction-Aux-Fonctions-JavaScript
• https://www.scribd.com/document/376221919/La-Foi-
en-Jesus-Christ-Pour-Quoi-Faire
• https://www.scribd.com/document/375689778/Lacuite-
visuelle-angulaire
• https://www.scribd.com/document/375349851/La-
variable-This
•
https://www.scribd.com/document/375024162/Fonctions-
Imbriquees-en-JS
• https://www.scribd.com/document/374789297/Format-
Interne-Des-Objets-JavaScript
•
https://www.scribd.com/document/374788758/Iterations-
en-JavaScript
• https://www.scribd.com/document/374738470/Le-Plus-
Grand-Secret-de-La-Creation
• https://www.scribd.com/document/374597969/Nouvelle-
Formule-d-IMC-indice-de-doduite-Selon-Dr-Diasoluka
• https://www.scribd.com/document/373847209/Property-
Descriptors
• https://www.scribd.com/document/373833282/l-Objet-
Global-Window
•
https://www.scribd.com/document/372665249/Javascript-
Tome-II
• https://www.scribd.com/document/355291488/motilite-
oculaire-2
• https://www.scribd.com/document/355291239/motilite-
oculaire-I
• https://www.scribd.com/document/355290248/Script-d-
Analyses-Des-Reflexes-Pupillomoteurs
•
https://www.scribd.com/document/321168468/Renseigne
ments-Id-et-Anthropometriques
•
https://www.scribd.com/document/320856721/Emission-
31-Jul-2016
•
https://www.scribd.com/document/318182982/Complicati
on-Visuelle-du-Traitement-de-La-Malaria
• https://www.scribd.com/document/318180637/Rapport-
Entre-Oxymetrie-Et-Type-Respiration
•
https://www.scribd.com/document/315746265/Classificati
on-Des-Medicaments
•
https://www.scribd.com/document/315745909/Incongruen
ces-Heresies-et-Heterodoxies-de-la-Notion-de-
Laboratoire
• https://www.scribd.com/document/315745725/Rapport-
Entre-Oxymetrie-Et-Type-Respiration

Javascript - Tome - VIII - Le Type Primitif Symbol

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Javascript - Tome - VIII - Le Type Primitif Symbol

Diunggah oleh

Hak Cipta:

J AVA S C R I P T (Programmation Internet) V O L .

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

CHAPITRE 14 : Le type primitif « Symbol () »

Une propriété (plutôt « type primitif ») particulière : Symbol().

Les « Symbol » sont de « type primitif » que des objets :

Voici ce que dit « ECMA-262, 9th edition, June 2018 - ECMAScript®

6.1.5 The Symbol Type

Each possible Symbol value is unique and immutable.

6.1.5.1 Well-Known Symbols

Well-known symbols are built-in Symbol values that are ex-

Within this specification a well-known symbol is referred to

Table 1: Well-known Symbols

Un petit comparatif de « Symbol » avec « String »:

Le type primitif Symbol() -5/31- dimanche, 24. mars 2019 (12:24 )

« Symbol » permet de créer des noms de variables spéciales (plutôt nom

Avec les symboles on a donc deux « valeurs » : celle de la propriété,

La description d’un symbole est facultative, utile uniquement à des fins

<script type="text/javascript"> "use strict";

Le type primitif Symbol() -7/31- dimanche, 24. mars 2019 (12:24 )

let prop2= Symbol.for("2e Symbole");

let prop3= Symbol(2019);

Le drawback de cela est de rendre les propriétés d'objets anonymes.

Exemple de génération de nom unique de clé de propriété :

1. « Symbol » comme propriété :

2. « Symbol » comme méthode :

Le type primitif Symbol() -9/31- dimanche, 24. mars 2019 (12:24 )

3. « Symbol » comme « get » et comme « set » :

obj[FOOs] = new Date(); // Format ds description

Le type primitif Symbol() -10/31- dimanche, 24. mars 2019 (12:24 )

const vSYMBOL1 = Symbol('DESCRIPTION');

console.log(typeof Symbol); // function

Par exemple, pour l’objet « File » dont propriétés sont :

Le type primitif Symbol() -12/31- dimanche, 24. mars 2019 (12:24 )

1. {length: {…}, name: {…}, arguments: {…}, caller: {…}, prototype:

Le type primitif Symbol() -13/31- dimanche, 24. mars 2019 (12:24 )

Le type primitif Symbol() -14/31- dimanche, 24. mars 2019 (12:24 )

La propriété « Symbol . iterator » :

Une propriété intéressante de « Symbol » c’est le « Symbol . iterator »

<script type="text/javascript"> "use strict";

Le type primitif Symbol() -15/31- dimanche, 24. mars 2019 (12:24 )

Ci-dessous, quelques types natifs (=incorporées, " built-in types") ayant

 Array . prototype [@@iterator]()

Structure interne de Symbol :

Le type primitif Symbol() -16/31- dimanche, 24. mars 2019 (12:24 )

Exemples d’utilisation de « Symbol » :

<script type="text/javascript"> "use strict";

const idxc = Symbol('qcmC');

const a = [68, 80, 55];

Le type primitif Symbol() -18/31- dimanche, 24. mars 2019 (12:24 )

a[idxv]= 42; // Ã‰crasement de a[idxv]

a[idxc]= 46; // Ã‰crasement de a[idxc]

console.log(a, ` , a.length = ${a.length}`);

Le type primitif Symbol() -19/31- dimanche, 24. mars 2019 (12:24 )

Exemple dans une fonction :

<script type="text/javascript"> "use strict";

function Elenge(kombo, pName) {

Le type primitif Symbol() -21/31- dimanche, 24. mars 2019 (12:24 )

return Elenge; // Lors de l'instanciation

console.log(motu["kombo"]); // => undefined

// Les symboles sont uniques

Le type primitif Symbol() -22/31- dimanche, 24. mars 2019 (12:24 )

Dommage, l’Array des « Symbol » est vide.

Le type primitif Symbol() -23/31- dimanche, 24. mars 2019 (12:24 )

Exemple dans un object :

<script type="text/javascript"> "use strict";

Le type primitif Symbol() -24/31- dimanche, 24. mars 2019 (12:24 )