Show page

Differences

This shows you the differences between two versions of the page.

--- alf:laboratoare:02 [2019/02/03 11:19]
teodor.deaconu [Exercises]
+++ alf:laboratoare:02 [2022/03/14 16:14] (current)
diana.ghindaoanu [Exercises]
@@ Line 1: / Line 1: @@
-====== TP 2 - Structures de données ======
+====== TP 2 - Strings et Regex ======
-===== Tableaux =====
+===== Strings =====
+Soit une variable **str** qui est une chaîne de caractères;
-Un tableau (**array**) peut contenir plusieurs valeurs sous un seul nom, et vous pouvez accéder ses valeurs en faisant référence à un numéro d'index. Les index commencent par 0.
+===Fonctions prédéfinies pour le traitement des chaînes===
-<code javascript>
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length|str.length]]// - la longueur de la chaîne
-var a = [1, 2, 3, 4, "text", {}, ... ];
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring|str.substring (start, end)]]// - retourne un sous-string à partir de la position //start//
-var b = []; //tableau vide
+    * //start// - position de début de sous-string
-console.log(a[1]); //2
+    * //end// - position de fin de sous-string (optionnel)
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split|str.split (separator, limit)]]// - divise le string dans un array avec des éléments séparés par //separator//
-a.push(1); // on ajoute un élément à la fin du tableau
+    * //separator// - un string avec les caractères séparant les éléments du string original
-console.log(a.length); //le nombre des éléments qui se trouvent dans le tableau
-</code>
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length|list.length]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf|list.indexOf (search, index)]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf|list.lastIndexOf (search, index)]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push|list.push (element, ...)]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop|list.pop ()]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice|list.splice (start, deleteCount, pushElement, ...)]]// -
-  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map|list.map (functionToRun)]]// -
-<code javascript>
-var list = [5, 6, 3, 5, 2, 6];
-list.map (function (item, index, list)
-{
-  return item*3;
-});
-// [15, 18, 9, 15, 4, 18]
-</code>
-   * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex|list.findIndex (functionToSearch)]]// -
-<code javascript>
-var list = [5, 6, 3, 5, 2, 7, 4, 5, 4, 7, 3];
-list.findIndex (function (item, index, list)
-{
-  return item === 7;
-});
-// 5
-</code>
-   * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter|list.filter (functionToFilter)]]// -
-<code javascript>
-var list = [5, 6, 3, 5, 2, 6, 7];
-list.filter (function (item, index, list)
-{
-  return item>3;
-});
-// [5, 6, 5, 6, 7]
-</code>
-   * //list[index]// -
-===== String =====
-L'objet global **String** est un constructeur de chaînes de caractères.
-Les littéraux de chaînes de caractères peuvent avoir l'une des formes suivantes :
-<code javascript>
-"text"
-'text'
-"'text' in text"
-'It\'s a sunny day!' //character escaping
-</code>
-Nous avons une variable **str** qui est une chaîne de caractères. Les fonctions disponibles sont :
-  * //str.length//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/length|FR]]) - une propriété qui indique la longueur d'une chaîne
-  * //str.substring(start, end)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/substring|FR]]) - retourne le sous-string à partir de la position //start// jusqu'à la position //end// (le dernier paramètre est optionnel)
-  * //str.split(separator, limit)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/split|FR]]) - divise le string dans un array avec des éléments séparés par le //separator//
-    * //separator// - un string avec les caractères après lesquelles on veut séparer le string original
     * //limit// - le nombre maximum de divisions (optionnel)
-  * //str.toUpperCase()//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/toUpperCase|FR]]) - retourne un nouveau string avec toutes les lettres majuscules
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase|str.toUpperCase ()]]// - retourne un nouveau string avec toutes les lettres majuscules
-  * //str.toLowerCase()//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/toLowerCase|FR]]) - retourne un nouveau string avec toutes les lettres minuscules
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase|str.toLowerCase ()]]// - retourne un nouveau string avec toutes les lettres minuscules
-  * //str.indexOf(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/indexOf|FR]]) - l'index auquel on trouve //search//
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf|str.indexOf (search, index)]]// - retourne la position de la première occurence de la valeur //search// dans un string;
-    * //search// - l'élément cherché
+    * //index// est optionnel, il représente la position de début
-    * //index// - l'index à partir duquel on commence à chercher
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf|str.lastIndexOf (search, index)]]// - retourne la position de la dernière occurence de la valeur //search// dans un string, ou -1;
-  * //str.lastIndexOf(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/lastIndexOf|FR]]) - la dernière apparition du //search//
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim|str.trim ()]]// - supprime les espaces du début et de la fin du string;
-  * //str.trim()//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/trim|FR]]) - on supprime tous les espaces du début et de la fin du string
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith|str.startsWith (search, position)]]// - retourne une valeur booléenne et vérifie si le string str commence par //search//
-  * //str.startsWith(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/startsWith|FR]]) - détermine si une chaîne commence par les caractères du //search//
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith|str.endsWith (search, positon)]]// - retourne une valeur booléenne et vérifie si le string str se termine par //search//
-  * //str.endsWith(search, index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/endsWith|FR]]) - détermine si une chaîne se termine par les caractères du //search//
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|str.replace (subStr, newSubStr)]]// - retourne un string ou //sucStr// est remplacé par //newSubStr//
-  * //str.replace(subStr, newSubStr)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|EN]], [[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|FR]]) - retourne un nouveau string avec //newSubStr// au lieu de //subStr//
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt|str.charAt (index)]]// - retourne le caractère de la position //index//
-  * //str.charAt(index)//([[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt|EN]], [[https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/String/charAt|FR]]) - retourne le caractère qui se trouve au //index//
+Pour en savoir plus, lisez la [[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String|documentation complète]].
-===== Objets =====
-Toutes les valeurs, à l'exception des primitives, sont des objets en JavaScript. Un objet est une collection des valeurs nommées (paires //nom: valeur//). Les noms des valeurs sont appellés //propriétés//.
+===== Expressions régulières =====
-<code javascript>
+==== Règles ====
-var personne = {
-    nom: "Pitt",
-    prenom: "Bradley",
-    age: 54,
-    greet: function () {
-        return "Hello!";
-    }
-};
-console.log(personne.nom); //Pitt
+^ Character ^ Description ^ Exemple ^
-console.log(personne['prenom']; //Bradley
+| * | Zéro ou plusieurs fois | a*, (ab)* |
-personne.greet(); //Hello!
+| + | Une ou plusieurs fois | a+, (ab)+ |
+| ? | Zéro ou une fois | a?, (ab)? |
+| %% ^ %% | début de string | %%^%%ab* |
+| %%$%% | fin de string | b*a$ |
+| . | tout symbole | . |
+| [  ] | Ensemble | [abc] |
+| \s | Espace blanc | a\sb |
+| [%%^%% ] | ensemble complémentaire | [%%^%%abc] |
+| ( ) | groupe | (abc)+ |
+| %% | %% | Ou | a %%|%% b, (ab) %%|%% (ba) |
-personne.date_de_naissance = "18/12/1963";
+==== JavaScript ====
-console.log(personne.date_de_naissance); //18/12/1963
+^ Character ^ Description ^ Exemple ^
-</code>
+| {n} | n fois | a{3} |
+| {n,m} | au moins n, au plus m | a{3,7} |
+| \w | alphanumérique et _ | \w |
+| \t | TAB | a\ta* |
+| \n | fin de linge | a\nb |
+| \r | retour chariot | a\rb |
+| a(?!b) | a seulement si non suivi par b | a(?!b) |
+| a(?=b) | a seulement si suivi par b | a(?=b) |
+| ( ) | group | a(ab)a |
-===== Operateur typeof =====
+Pour déclarer des expressions régulières, on peut écrire de deux façons:
-L'opérateur typeof est suivi de l'opérande dont le type doit être retourné.
 <code javascript>
-var x = 5;
-typeof x; //Number
-typeof "text"; //String
-typeof [1, 2, 3]; //Object
-</code>
-===== Valeur undefined =====
+// making a new RexEx object the standard way
+let regex: RegExp = new RegEx ("[0-9]+");
-Une variable qui n'a pas reçu une valeur est de type //undefined//. Une méthode ou une instruction renvoie également //undefined// si la variable en cours d'évaluation n'a pas de valeur. Une fonction renvoie //undefined// si aucune valeur n'a été retournée.
+// making a new RegEx object using a shortcut
+let regex: RegExp = /[0-9]+/;
-<code javascript>
-var x;
-typeof x; //undefined
 </code>
-===== Valeur null =====
+==== Fonctions supplémentaires ====
-La valeur //null// représente l'absence intentionnelle d'une valeur d'un objet. La variable avec cette valeur ne pointe vers aucun objet.
+=== String ===
+  * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/split|str.split(separatorRegex, limit)]]// - divise le string dans un array avec des éléments séparés //separatorRegex//
+  * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/match|str.match(regex)]]// - Recherche dans le string une sous-string qui suit l'expression régulière
+  * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/search|str.search(regex)]]// - Recherche une sous-string qui correspond à l'expression régulière et renvoie l'index de celle-ci ou -1 si elle ne la trouve pas.
-<code javascript>
+=== Fonctions pour les RegEx ===
-var personne = {nom: 'Pitt', prenom: 'Bradley', age: 54};
-personne = null;
-typeof personne; //Object
-console.log(personne) //{}
-</code>
-===== Fonctions =====
-Une fonction est un bloc de code conçu pour exécuter une tâche particulière. Les fonction sont exécutées lorsqu'elles sont appellées.
-Les définitions des fonctions en JavaScript ne spécifient pas les types de données pour les paramètres. Elles n'effectuent pas de vérification de type sur les arguments transmis et elles ne vérifient pas le nombre d'arguments reçus.
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec|regex.exec(str)]]// - Recherche dans un string une sous-string qui suit l'expression régulière
 <code javascript>
-function produit(p1, p2) {
+let regex: RegExp = /([0-9]+);([A-Za-z-\. ]+);([0-9]{3,4}[A-Za-z]+)/;
-    return p1 * p2; //la fonction retourne le produit des parametres
-}
-var x = produit(3, 4);
+let match: RegExpExecArray|null = regex.exec ('1;ANDRONIE S. Manuela - Bianca;1220F extra text');
-console.log(x); //12
-</code>
-===== For in =====
+/*
+match:
-L'instruction //for in// itère sur les propriétés énumérables d'un objet. Pour chaque propriété distincte, les instructions peuvent être exécutées.
+[ '1;ANDRONIE S. Manuela - Bianca;1220F', // the full match
+  '1', // the first group
-<code javascript>
+  'ANDRONIE S. Manuela - Bianca', // the second group
-var array = [5, 7, 2, 9, 3]
+  '1220F', // the third group
+  index: 0, // the position
-for(var i in array) {
+  input: '1;ANDRONIE S. Manuela - Bianca;1220F extra text' ] // the full string
-   console.log("Value " + array[i] + " at index " + i);
-}
-/* Output:
-Value 5 at index 0
-Value 7 at index 1
-Value 2 at index 2
-...
 */
-</code>
-===== For of =====
-L'instruction //for of// permet de créer une boucle Array qui parcourt un objet itérable et qui permet d'exécuter une ou plusieurs instructions pour la valeur de chaque propriété.
-<code javascript>
-var array = [5, 7, 2, 9, 3]
-for(var i of array) {
-   console.log("Value " + i);
-}
-/* Output:
-Value 5
-Value 7
-Value 2
-...
-*/
 </code>
+  * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test|regex.test(str)]]// - Recherche dans une chaîne une sous-chaîne qui suit l'expression régulière et renvoie true de celle-ci trouve un ou false sinon
+Pour plus de fonctions, lisez la [[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp|documentation RegEx complète]].
-===== Arguments de la ligne de commande =====
-La propriété **process.argv** renvoie un tableau contenant les arguments de la ligne de commande transmis lors du lancement du processus Node.js. Le premier élément sera process.execPath (le chemin d'executable //node//). Le deuxième élément sera le chemin vers le fichier JavaScript en cours d'exécution. Les autres éléments seront des arguments de ligne de commande supplémentaires.
+===== Exercises =====
+Fichiers de groups:
-Lancement du processus Node.js pour le fichier //process.js// :
+  - Téléchargez depuis le github le fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP2/BusinessFinancialData.csv|BusinessFinancialData.csv]] qui contient des données financières d'entreprise. Dans ce document on a stocké le code de l'entreprise, la période de temps, la valeur totale, le sujet, la catégorie et le domaine d'activité (dans cette ordre précisément). Créez un projet nodejs et copiez dans une chaîne seulement la ligne numéro 3. Sans utiliser des expressions régulières, résolvez les demandes suivantes (seulement a l'aide des **fonctions pour les strings**):
-<code bash>
+    - Affichez la position (index) du sujet dans le string. (**0.2p**)
-$ node process.js one 2 three
+    - Affichez la dernière position de " " (\s) dans la chaîne. (**0.4p**)
+    - Traitez le string pour afficher sur des lignes différentes" le code, la valeur totale et la catégorie.  (**0.4p**)
+  - Lisez tout le contenu du fichier dans un string (indice: voir TP 0). Sans utiliser des expressions régulières, résolvez les demandes suivantes:
+    - Divisez la chaîne dans un tableau en utilisant le caractère de nouvelle ligne (\n) comme séparateur (//\r\n// pour Windows). (**0.4p**)
+    - Traitez chaque string du tableau et affichez sur des lignes différentes le code, la valeur totale et la catégorie de chaque entreprise qui est dans le fichier. (**0.6p**)
+  - Pour chaque ligne de l'exercice 2, créez un objet de type Entreprise avec les détails de celle-ci. La méthode reste a votre choix. Ajoutez les objects dans un tableau. (**1p**)
+  - Téléchargez le fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP2/passwd|passwd]] et lisez-le dans un string. Créez un tableau avec des objets contenant les informations comprises dans le fichier, pour chaque ligne. Vous pouvez trouver des détails sur le format du fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP2/passwd|passwd]] ici. (**1p**)
+  - Utilisez des expressions régulières pour résoudre l'exercice 2. Vous pouvez utiliser [[https://regex101.com|RegEx101]] pour écrire l'expression régulière et tester sa validité. (**1p**)
+  - Utilisez des expressions régulières pour résoudre l'exercice 3. (**1.5p**)
+  - Utilisez des expressions régulières pour résoudre l'exercice 4. (**1.5p**)
+  - Lisez le fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP2/typescript_errors.txt|typescript_errors]] et affichez:
+    - combien d'erreurs y a-t-il (**0.5p**)
+    - le liste de codes d'erreur (**0.5p**)
+    - Stockez les informations dans un tableau ayant le format suivant: (**0.5p**)<code json>
+[
+   {
+      "type":"error",
+      "code":<erorr_code if it exists>,
+      "type_error":<true/false>, //s'il s'agit d'une erreur de type
+      "description":<the error description>
+   },
+   ...
+]
 </code>
+     - Ecrivez le tableau dans un fichier (indice: utilisez JSON.stringify) (**0.5p**)
-<code javascript>
+   - **Bonus**: Ecrivez un programme qui reçoit comme paramètre le fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP2/typescript_class.ts|typescript_class.ts]]. Lisez le fichier et résolvez les demandes suivantes:
-//process.js
+     - affichez les bibliothèques importées (**0.3p**)
+     - affichez toutes les classes déclarées (**0.3p**)
-for(var argumentIndex in process.argv) {
+     - affichez toutes les classes enfant déclarées (nom de la classe enfant et la classe parent) (**0.1p**)
-   console.log(argumentIndex + ": " + process.argv[argumentIndex]);
+     - affichez toutes les fonctions déclarées (nom et type de retour) (**0.3p**)
-}
-/* Output:
-: C:\Program Files\nodejs\node.exe
-: C:\Users\student\Desktop\process.js
-: one
-: 2
-: three
-*/
-</code>
-===== parseInt et parseFloat =====
-=== parseInt ===
-La fonction //parseInt()// analyse une chaîne de caractère fournie en argument et renvoie un entier exprimé dans une base donnée.
-<code javascript>
-var string = "12";
-var base = 10;
-var number = parseInt(string, base);
-console.log(number); //12
-console.log(typeof number); //Number
-console.log(typeof string); //Object
-</code>
-  * string - La valeur qu'on souhaite analyser et convertir. Si l'argument string n'est pas une chaîne de caractères, elle sera convertie en une chaîne. Les blancs contenus au début de l'argument sont ignorés.
-  * base - Un entier compris entre 2 et 36 qui représente la base utilisée pour la valeur représentée dans la chaîne. La base utilisée en général est la base décimale (valeur 10 pour ce paramètre).
-=== parseFloat ===
-La fonction //parseFloat()// permet de transformer une chaîne de caractères en un nombre flottant.
-<code javascript>
-var string = "15.35";
-var number = parseFloat(string);
-console.log(number); //15.35
-console.log(typeof number); //Number
-console.log(typeof string); //Object
-</code>
-  * string - Une chaîne de caractères qui contient la valeur qu'on souhaite analyser et transformer dans un nombre flottant.
-===== Exercises =====
-  - Faites un projet de NodeJS. Créez un tableau de nombres [10, 20, 30] nommé "number_array". (**1p**)
-    - Affichez le tableau avec //console.log//
-    - Affichez avec un //for//
-    - Affichez avec un //for of//
-    - Affichez avec un //for in//
-  - Créez un programme et exécutez-le avec des paramètres. Affichez : (**1p**)
-    - les paramètres avec //console.log//
-    - le nombre de paramètres
-    - les paramètres avec un //for//(à votre choix)
-  - Faites un programme qui contient une fonction //multiply// qui reçoit deux nombres comme paramètres et qui : (**1p**)
-    - affiche le résultat
-    - retourne le résultat
-    - stocke le résultat dans une variable et affiche-la
-  - Écrivez un programme qui reçoit un paramètre (diamètre d'un cercle). (**1p**)
-    - Implémentez des fonction qui calculent la circonférence et la surface d'un cercle.
-    - La fonction doit afficher le résultat du calcul. Utilisez //parseInt//.
-  - Faites un tableau avec 10 nombres aléatoires avec des valeurs entre 1-50 (//Math.random()//). Affichez la différence des éléments du tableau. (**1p**)
-  - Faites un objet //étudiant// du type: {nom: Radulescu, prénom: Radu, points_credit: 100}, en utilisant les paramètres de la ligne de commande. (ex: node main.js Radulescu Radu 100) (**1p**)
-    - Affichez l'objet
-    - Affichez chaque attribut de l'objet
-    - Faites un array avec 5 objets de type //étudiant//
-    - Affichez l'étudiant avec le plus points credit
-    - Affichez la moyenne géométrique de points
-    - Affichez la personne avec le prénom le plus longue
-    - Affichez tous les objets en ordre alphabétique du nom
-  - Ajoutez aux objets de l'exercise précédent un nouveau attribut //adresse//, qui a le format: {ville: 'Bucarest', rue: 'Bulevardul Timisoara', numéro: 200}. Les informations seront données comme paramètres de la ligne de commande. Le premier paramètre doit être le nom de la personne à laquelle on ajoute l’adresse. (**1p**)
-  - Faites une fonction pour vérifier si un objet contient une propriété donnée. (**1p**)
-  - Écrivez un programme qui retourne un tableaux avec les sous-strings d'un string donnée. (ex: ['c', 'co', 'cod', 'o', 'od', 'd'] pour le string //cod//) (**1p**)
-  - Écrivez une fonction pour convertir un objet dans une liste de paires [key, value]. (ex: {prénom: 'Radu', points_credit: 100} résulte en [ ['prénom', 'Radu'], ['points_credit', 100] ]) (**1p**)
-  - **Bonus**: Faites une fonction qui trie le tableau d'objets de l'exercice 6 après un de ses attributs (donné comme paramètre). **Hint**: Appellez la fonction [[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort|sort]] avec la fonction créée par vous comme paramètre. (**1p**)
-==== Solutions ====
-<hidden>
-[[https://github.com/alexandruradovici/alf2018/tree/master/TP/TP2|Solutions]]
-</hidden>

Cours

TP

Simplifiee

Seminaires

Devoir

Ressources

alf/laboratoare/02.1549185550.txt.gz · Last modified: 2019/02/03 11:19 by teodor.deaconu

Show page Old revisions

Media Manager Back to top