javascript tome ix - Format (Représentation) interne des objets JavaScript

Transcription

Formats / Représentation interne des Objets en
J AVA S C R I P T (Programmation Internet) V O L . I X
J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
La dernière révision de ce texte est disponible sur CD.
CHAPITRE 16 :
Format (Représentation) Interne des objets
en JavaScript, avec la commande
Object.getOwnPropertyDescriptors (object) :
Quand nous créons un objet, les propriétés de cet objet sont
en fait, à l’instar du prototype, des objets ayant leurs propres
propriétés appelées ici ATTRIBUTS, ses attributs comportant
chacune à leur tour ses propres propriétés suivantes et les
mêmes pour tous les attributs : value (en fait la valeur de la
propriété), writable, enumerable, configurable.
Rappelons que le prototype est une propriété particulière
(pas comme les autres) qui renferme les propriétés disponibles pour l’objet, mais aussi partageables avec et héritables
par ses fils, alors que les propriétés ordinaires (non contenues dans le prototype et définies directement dans le corps
de l’objet) ne sont pas héritables. Le prototype renferme
J.D.B. DIASOLUKA Nz. Luyalu
JavaScript Tome-IX
donc l’ensemble de propriétés intrinsèques communes à
l’objet en cours, et ses descendants.
Cependant, les propriétés propres du constructeur définies
lors de sa « définition » sont toutes héritables, mais ses variables locales ne le sont pas.
De même, si on redirige le prototype du constructeur vers un
autre objet (ou fonction), le prototype des instances de ce
constructeur créées sous l’ancien prototype continueront à
pointer le prototype du constructeur qui était en cours lors de
la construction/création de ces instances. Ces instances ne
reconnaîtront pas le nouveau prototype.
Tandis que les instances créées après redirection du prototype du constructeur pointeront ce nouveau prototype et ne
reconnaîtront pas l’ancien prototype.
On ne peut pas accéder aux propriétés propres d’un constructeur (dans le sens qu’elles n’appartiennent pas à son prototype) via le nom du constructeur
(nom_constructeur.property) quand ces propriétés ont été
définies dans le corps de définition du constructeur.
Format Interne des objets
- 2 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
Mais les propriétés propres d’un constructeur définies en
dehors de son corps de définition sont accessibles via le nom
de ce constructeur (nom_constructeur.property).
La commande Object.getOwnPropertyDescriptors (object)
liste les attributs [propres] ou descripteurs d’un objet.
Une instance n’hérite jamais d'une variable locale de son
constructeur.
Une instance n’hérite pas d'une propriété non ajoutée au
constructeur via le prototype en cours. Ce genre de propriétés sont des propriétés propres (non partageable ni héritable) du constructeur.
Le prototype étant un objet à part entière, la création/redirection d’un nouveau prototype DOIT se faire avec
l’opérateur « new ». (voyez l’exemple à la fin de cet exposé
chapitre XIII p. 24).
- 3 / 31 -
jeudi, 4. avril 2019 (10:49 )
I.
JavaScript Tome-IX
Format de stockage interne d’une String :
Nous scannerons d’abord la représentation interne d’un objet
String (chaîne [de caractères]). Un objet String (chaîne [de
caractères]) est représenté internement sous forme d’une
Array (tableau monodimensionnelle) dont les indices vont de
zéro à n-1, n étant la taille (length ou nombre de caractères)
de la chaîne.
<script type="text/javascript"> "use strict";
// Avec “ var ”
var stgv = "La filaire qui rend aveugle !";
console.log(stgv);
// La filaire qui rend aveugle !
console.log(Object.getOwnPropertyDescriptors(stgv));
// Object { 0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…},
5: {…}, 6: {…}, 7: {…}, 8: {…}, 9: {…}, … }
/*
0: {value: "L", writable: false, enumerable: true,
configurable: false}
1: {value: "a", writable: false, enumerable: true,
2: {value: " ", writable: false, enumerable: true,
3: {value: "f", writable: false, enumerable: true,
4: {value: "i", writable: false, enumerable: true,
5: {value: "l", writable: false, enumerable: true,
- 4 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
7: {value: "i", writable:
8: {value: "r", writable:
9: {value: "e", writable:
10: {value: " ", writable:
11: {value: "q", writable:
12: {value: "u", writable:
17: {value: "n", writable:
18: {value: "d", writable:
20: {value: "a", writable:
21: {value: "v", writable:
24: {value: "g", writable:
25: {value: "l", writable:
false, enumerable: true,
- 5 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
28: {value: "!", writable: false, enumerable: true,
length: {value: 29, writable: false, enumerable:
false, configurable: false}
__proto__: Object
*/
/////////////////////////////////////////////
// Avec “ let ”
let stgl = "La filaire qui rend aveugle !";
console.log(stgl);
console.log(Object.getOwnPropertyDescriptors(stgl));
// Object { 0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…},
5: {…}, 6: {…}, 7: {…}, 8: {…}, 9: {…}, … }
/*
- 6 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
- 7 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
28: {value: "!", writable: false, enumerable: true,
__proto__: Object
*/
/////////////////////////////////////////////
// Avec “ const ”
const stgc = "La filaire qui rend aveugle !";
console.log(stgc);
console.log(Object.getOwnPropertyDescriptors(stgc));
// Object { 0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…},
5: {…}, 6: {…}, 7: {…}, 8: {…}, 9: {…}, … }
/*
8: {value: "r", writable: false, enumerable: true,
- 8 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
28: {value: "!", writable:
- 9 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
length: {value: 29, writable:
__proto__: Object
*/
</script>
II.
false,
enumerable:
Format de stockage interne d’un littéral d’objet :
Un littéral d’objet est un moyen rapide de définir un nouvel
objet.
let obj = {article:"La", susbtantif:"filaire",
conjonctif:"qui", verbe:"rend",
cod:"aveugle", ponctuation:"!"};
console.log(obj);
// Object { article: "La", susbtantif:
conjonctif: "qui", verbe: "rend", cod:
ponctuation: "!" }
"filaire",
"aveugle",
/*
article: "La"
cod: "aveugle"
conjonctif: "qui"
ponctuation: "!"
susbtantif: "filaire"
verbe: "rend"
__proto__: Object
*/
console.log(Object.getOwnPropertyDescriptors(obj));
- 10 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
// Object { article: {…}, susbtantif: {…}, conjonctif: {…}, verbe: {…}, cod: {…}, ponctuation: {…} }
/*
// AVEC FIREFOX :
article: Object { value: "La", writable: true, enumerable: true, … }
cod: Object { value: "aveugle", writable: true,
enumerable: true, … }
conjonctif: Object { value: "qui", writable: true,
ponctuation: Object { value: "!", writable: true,
susbtantif: Object { value: "filaire", writable:
true, enumerable: true, … }
verbe: Object { value: "rend", writable: true, enumerable: true, … }
__proto__: Object { … }
// AVEC YANDEX :
article: {value: "La", writable: true, enumerable:
true, configurable: true}
cod: {value: "aveugle", writable: true, enumerable:
conjonctif: {value: "qui", writable: true, enumerable: true, configurable: true}
ponctuation: {value: "!", writable: true, enumerable: true, configurable: true}
susbtantif: {value: "filaire", writable: true, enumerable: true, configurable: true}
verbe: {value: "rend", writable: true, enumerable:
__proto__: Object
*/
</script>
- 11 / 31 -
jeudi, 4. avril 2019 (10:49 )
III.
JavaScript Tome-IX
Format de stockage interne d’une Array:
Une Array est une collection itérable indexée.
var arr = ["La", "filaire", "qui", "rend",
"aveugle", "!"];
console.log(arr);
//
Array
[
"La",
"aveugle", "!" ]
"filaire",
"qui",
"rend",
/*
(6) ["La", "filaire", "qui", "rend", "aveugle", "!"]
0: "La"
1: "filaire"
2: "qui"
3: "rend"
4: "aveugle"
5: "!"
length: 6
__proto__: Array(0)
*/
console.log(Object.getOwnPropertyDescriptors(arr));
/*
Object { 0: {…}, 1: {…}, 2: {…}, 3: {…}, 4: {…}, 5:
{…}, length: {…} }
0: {value: "La", writable: true, enumerable:
1: {value: "filaire", writable: true, enumerable: true, configurable: true}
2: {value: "qui", writable: true, enumerable:
- 12 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
3: {value: "rend", writable: true, enumerable:
4: {value: "aveugle", writable: true, enumerable: true, configurable: true}
5: {value: "!", writable: true, enumerable:
length: {value: 6, writable: true, enumerable:
__proto__: Object
*/
</script>
IV.
Format de stockage interne d’un objet Date via
l’opérateur « new » :
Un objet Date sert à afficher et à manipuler les dates.
var dat = new Date("Friday, 1953 8 11");
console.log(dat.toUTCString());
// Mon, 10 Aug 1953 22:00:00 GMT
console.log(Object.getOwnPropertyDescriptors(dat));
//
Object {
}
/*
{}
*/
</script>
- 13 / 31 -
jeudi, 4. avril 2019 (10:49 )
V.
JavaScript Tome-IX
Format de stockage interne d’un objet Date sans
l’opérateur « new » : ni plus ni moins une String.
var dat = Date("Friday, 1953 8 11");
console.log(dat.toLocaleString());
// Thu May 10 2018 08:43:29 GMT+0100 (Paris, Madrid)
console.log(Object.getOwnPropertyDescriptors(dat));
// Object {0: {…}, 1: {…}, 2: {…}, 3:
5: {…}, 6: {…}, 7: {…}, 8: {…}, 9: {…},
{…}, 12: {…}, 13: {…}, 14: {…}, 15: {…},
{…}, 18: {…}, 19: {…}, 20: {…}, 21: {…},
{…}, 24: {…}, 25: {…}, 26: {…}, 27: {…},
{…}, 30: {…}, 31: {…}, 32: {…}, 33: {…},
{…}, 36: {…}, 37: {…}, 38: {…}, 39: {…},
{…}, 42: {…}, 43: {…}, 44: {…}, 45: {…},
{…}, 48: {…}, length: {…}}
/*
0: {value: "T", writable:
1: {value: "h", writable:
4: {value: "M", writable:
{…}, 4: {…},
10: {…}, 11:
16: {…}, 17:
22: {…}, 23:
28: {…}, 29:
34: {…}, 35:
40: {…}, 41:
46: {…}, 47:
- 14 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
6: {value: "y", writable:
8: {value: "1", writable:
18: {value: ":", writable:
21: {value: ":", writable:
25: {value: "G", writable:
- 15 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
27: {value: "T", writable:
28: {value: "+", writable:
34: {value: "(", writable:
35: {value: "P", writable:
39: {value: "s", writable:
40: {value: ",", writable:
- 16 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
47: {value: "d", writable: false, enumerable: true,
48: {value: ")", writable: false, enumerable: true,
__proto__: Object
constructor: ƒ Object()
hasOwnProperty: ƒ hasOwnProperty()
isPrototypeOf: ƒ isPrototypeOf()
propertyIsEnumerable: ƒ propertyIsEnumerable()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
valueOf: ƒ valueOf()
__defineGetter__: ƒ __defineGetter__()
__defineSetter__: ƒ __defineSetter__()
__lookupGetter__: ƒ __lookupGetter__()
__lookupSetter__: ƒ __lookupSetter__()
get __proto__: ƒ __proto__()
set __proto__: ƒ __proto__()
*/
</script>
VI.
Format de stockage interne d’une « variable numérique » :
var numv = 2018;
console.log(numv);
// 2018
console.log(Object.getOwnPropertyDescriptors(numv));
- 17 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
/*
Object { }
{}
*/
</script>
VII.
Format de stockage interne d’un « objet Number »
avec l’opérateur « new » :
var numO = new Number( 2018 );
console.log(numO);
// Number { 2018 }
console.log(Object.getOwnPropertyDescriptors(numO));
/*
Number {2018}
__proto__: Number { 0 }
[[PrimitiveValue]]: 2018
*/
</script>
VIII.
Format de stockage interne d’un « objet Number »
sans l’opérateur « new » :
var numO = Number( 2018 );
- 18 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
console.log(numO);
// 2018
console.log(Object.getOwnPropertyDescriptors(numO));
/*
{}
*/
</script>
IX.
Format de stockage interne d’une variable « Boolean » :
var boolV = true;
console.log(boolV);
// true
console.log(Object.getOwnPropertyDescriptors(boolV));
/*
{}
*/
</script>
X.
Format de stockage interne d’une variable « Boolean » avec l’opérateur « new » :
- 19 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
var boolO = new Boolean(true);
console.log(boolO);
// Boolean { true }
/*
// AVEC FIREFOX
Boolean
__proto__: Boolean { false }
// AVEC YANDEX
Boolean {true}
__proto__: Boolean
[[PrimitiveValue]]: true
*/
console.log(Object.getOwnPropertyDescriptors(boolO));
// Object { }
/*
{}
*/
</script>
XI.
Format de stockage interne d’un « Boolean » sans
l’opérateur « new » :
var boolO = Boolean(true);
console.log(boolO);
- 20 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
// true
console.log(Object.getOwnPropertyDescriptors(boolO));
// Object { }
/*
{}
*/
</script>
XII.
Format de stockage interne d’un objet « Event » :
// Avec YANDEX :
console.log(Event);
// Event() { [native code] }
console.log(Object.getOwnPropertyDescriptors(Event));
// {length: {…}, name: {…}, arguments: {…}, caller:
{…}, prototype: {…}, …}
/*
AT_TARGET:{value: 2, writable:
true, configurable: false}
false,
enumerable:
BUBBLING_PHASE:{value: 3, writable: false, enumerable: true, configurable: false}
- 21 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
CAPTURING_PHASE:{value: 1, writable: false, enumerable: true, configurable: false}
NONE:{value: 0, writable: false, enumerable: true,
arguments:{value: null, writable: false, enumerable:
caller:{value: null, writable:
false,
enumerable:
length:{value: 1, writable: false, enumerable: false,
configurable: true}
name:{value: "Event", writable:
false, configurable: true}
false,
enumerable:
prototype:{value: Event, writable: false, enumerable:
__proto__:Object
*/
// Avec FIREFOX :
console.log(Event);
// function ()
/*
()
ALT_MASK: 1
AT_TARGET: 2
BUBBLING_PHASE: 3
CAPTURING_PHASE: 1
CONTROL_MASK: 2
META_MASK: 8
- 22 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
NONE: 0
SHIFT_MASK: 4
length: 1
name: "Event"
prototype: EventPrototype
{ composedPath: composedPath(), stopPropagation:
stopPropagation(), stopImmediatePropagation: stopImmediatePropagation(), … }
Symbol(Symbol.hasInstance): undefined
__proto__: function ()*/
console.log(Object.getOwnPropertyDescriptors(Event));
// Object { length: {…}, name: {…}, NONE: {…}, CAPTURING_PHASE: {…}, AT_TARGET: {…}, BUBBLING_PHASE:
{…}, ALT_MASK: {…}, CONTROL_MASK: {…}, SHIFT_MASK:
{…}, META_MASK: {…}, … }
/*
{…}
ALT_MASK: Object { value: 1, writable: false, enumerable: true, … }
AT_TARGET: Object {
value:
2,
writable:
false,
BUBBLING_PHASE: Object {
false, enumerable: true, … }
value:
3,
writable:
CAPTURING_PHASE: Object {
false, enumerable: true, … }
value:
1,
writable:
CONTROL_MASK: Object { value: 2, writable: false,
- 23 / 31 -
jeudi, 4. avril 2019 (10:49 )
META_MASK: Object {
JavaScript Tome-IX
value:
8,
writable:
false,
NONE: Object { value: 0, writable: false, enumerable: true, … }
SHIFT_MASK: Object { value: 4, writable: false,
length: Object { value: 1, writable: false, enumerable: false, … }
name: Object { value: "Event", writable: false,
enumerable: false, … }
prototype: Object { writable: false, enumerable:
false, configurable: false, … }
Symbol(Symbol.hasInstance): Object { writable:
false, enumerable: false, configurable: false, … }
*/
</script>
XIII. Les règles concernant l’héritage et les prototypes.
// Fonction = objet (« fnprot ») qui
// sera substituée au prototype natif.
function fnprot(){
this.propNProt = "Propriété N Protot"
}
- 24 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
// Constructeur (=objet) cObj
const cObj = function(){
this.nom = "ObjName";
this.date = new Date();
let vLocale = "« Var Locale de cObj »";
(function(){
console.log(vLocale) ;
// Affiche « Var Locale de cObj »
}());
}
// Instanciation de iObj de cObj
const iObj = new cObj();
// Les propriétés locales du constructeur
// sont accessibles depuis l’instance
// via l’identificateur « iObj » de l’instance.
console.log(iObj.nom) // ObjName
console.log(iObj.date)
// Date 2018-05-10T10:01:53.924Z
//
//
//
//
L’instance « iobj » a hérité des
propriétés propres (dans le sens de
« n’appartenant pas au prototype ») grâce
à l’opérateur « this » dans la définition.
// On ne peut pas accéder aux propriétés propres
// d’un constructeur via son nom, en dehors
// de son corps de description
console.log(cObj.nom) //undefined
console.log(cObj.date) //undefined
// Pourtant les deux ont donné, via l’instance,
// cfr plus haut.
- 25 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
// On n’hérite jamais d'une VARIABLE locale.
console.log(iObj.vLocale) // undefined
// Ajout d’une nouvelle propriété au constructeur
cObj.nvpropr="Nouvelle propriété";
// Affichons la nouvelle propriété du constructeur
// « cObj » avec son instance « iObj »
console.log(iObj.sage) // undefined
//
//
//
//
Vous voyez, on ne peut pas hériter d'une
propriété non ajoutée via le prototype en cours.
= Propriétés propres
(non partageables ni héritables)
// Ajout d'une nouvelle propriété via
// le PROTOTYPE par défaut
cObj.prototype.nprotprop = "nvpropviaPrototype"
// Enrichissement du prototype en cours.
console.log(iObj.nprotprop) // nvpropviaPrototype
// L’instance « iObj » a automatiquement
// hérité la nouvelle propriété
// "cObj.prototype.nprotprop" du prototype
// Changeons ("redirigeons") le prototype
// sur une autre fonction (objet).
cObj.prototype = new fnprot()
// Les propriétés de l’ancien prototype
// (le prototype par défaut lors de la création)
- 26 / 31 -
jeudi, 4. avril 2019 (10:49 )
//
//
//
//
JavaScript Tome-IX
resteront visibles aux instances déjà créées
et celles du nouveau prototype
ne seront visibles qu'aux instances qui seront
créées après la redirection.
console.log(iObj.nprotprop) // nvpropviaPrototype
//
//
//
//
//
Les propriétés du prototype par défaut
sont restées visibles car l'INSTANCE
continue de pointer LE MÊME PROTOTYPE
(ici le prototype par défaut) que
LORS DE SA CRÉATION.
//
//
//
//
//
L'instance créée avant la redirection de
prototype continuant de pointer l’ancien
prototype que lors de sa création, le nouveau
prototype du constructeur n'est pas reconnu
par l'instance pré-existante.
console.log(iObj.propNProt) // undefined
// Créons une nouvelle instance de cObj,
// le constructeur dont on a redirigé le
// prototype.
const iObj2 = new cObj();
// Les propriétés de l'ancien prototype
// (p.e. la « nprotprop ») ne sont pas visibles
// aux objets créés après redirection de prototype.
console.log(iObj2.nprotprop) // undefined
// Les propriétés du nouveau prototype
// sont visibles par les instances du constructeur
// créées après redirection de son prototype
- 27 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
// vers le nouveau.
console.log(iObj2.propNProt) // Propriété N Protot
</script>
Mots-clés :
format interne, représentation interne, objets, getOwnPropertyDescriptors, propri é t é s, prototype, attributs, descripteurs, string, chaîne de caractères, length, Array,
Tableau, unidimensionnel, monodimensionnel, Number, Boolean, Event
jeudi, 4. avril 2019 (10:49 ).
D’autres publications pouvant intéresser :
 https://www.scribd.com/document/37703625
1/Le-Dosage-Des-Medicaments-en-CacCas
4/Le-Hasard-Des-Thermometres-Noncontact-a-Infrarouge
2/Petite-Introduction-Aux-FonctionsJavaScript
- 28 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
9/La-Foi-en-Jesus-Christ-Pour-Quoi-Faire
8/Lacuite-visuelle-angulaire
1/La-variable-This
2/Fonctions-Imbriquees-en-JS
7/Format-Interne-Des-Objets-JavaScript
8/Iterations-en-JavaScript
0/Le-Plus-Grand-Secret-de-La-Creation
9/Nouvelle-Formule-d-IMC-indice-dedoduite-Selon-Dr-Diasoluka
9/Property-Descriptors
2/l-Objet-Global-Window
9/Javascript-Tome-II
8/motilite-oculaire-2
9/motilite-oculaire-I
- 29 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
8/Script-d-Analyses-Des-ReflexesPupillomoteurs
8/Renseignements-Id-et-Anthropometriques
1/Emission-31-Jul-2016
2/Complication-Visuelle-du-Traitement-deLa-Malaria
7/Rapport-Entre-Oxymetrie-Et-TypeRespiration
5/Classification-Des-Medicaments
9/Incongruences-Heresies-et-Heterodoxiesde-la-Notion-de-Laboratoire
5/Rapport-Entre-Oxymetrie-Et-TypeRespiration
- 30 / 31 -
jeudi, 4. avril 2019 (10:49 )
JavaScript Tome-IX
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 uelqu’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
[email protected]
- 31 / 31 -
jeudi, 4. avril 2019 (10:49 )

javascript tome ix - Format (Représentation) interne des objets JavaScript

Transcription

Documents pareils

J`ai (très) mal au travail

Plugins Firefox - Direction Informatique - Université Paris-Sud

TD4 - Promela

Lycée « Emulation Dieppoise » et CFA des métiers de l`automobile

KEY You drive me mad but I love you

Un joueur de football traque le racisme dans les

Fête familiale les Petits Trésors 2012

Quiz name: Connais-tu bien Harry Potter?

Test 1 - CIAQES

TP 1 Python : une grosse calculette…