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.

var a = [1, 2, 3, 4, "text", {}, ... ];
var b = []; //tableau vide
console.log(a[1]); //2
 
a.push(1); // on ajoute un élément à la fin du tableau
console.log(a.length); //le nombre des éléments qui se trouvent dans le tableau

* list.length -

• list.indexOf (search, index) -
• list.lastIndexOf (search, index) -
• list.push (element, ...) -
• list.pop () -
• list.splice (start, deleteCount, pushElement, ...) -
• list.map (functionToRun) -

var list = [5, 6, 3, 5, 2, 6];
 
list.map (function (item, index, list)
{
  return item*3;
});
 
// [15, 18, 9, 15, 4, 18]

• list.findIndex (functionToSearch) -

var list = [5, 6, 3, 5, 2, 7, 4, 5, 4, 7, 3];
 
list.findIndex (function (item, index, list)
{
  return item === 7;
});
 
// 5

• list.filter (functionToFilter) -

var list = [5, 6, 3, 5, 2, 6, 7];
 
list.filter (function (item, index, list)
{
  return item>3;
});
 
// [5, 6, 5, 6, 7]

• list[index] -

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 :

"text"
'text'
"'text' in text"
'It\'s a sunny day!' //character escaping

Nous avons une variable str qui est une chaîne de caractères. Les fonctions disponibles sont :

• str.length(EN, FR) - une propriété qui indique la longueur d'une chaîne
• str.substring(start, end)(EN, FR) - retourne le sous-string à partir de la position start jusqu'à la position end (le dernier paramètre est optionnel)
• str.split(separator, limit)(EN, 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()(EN, FR) - retourne un nouveau string avec toutes les lettres majuscules
• str.toLowerCase()(EN, FR) - retourne un nouveau string avec toutes les lettres minuscules
• str.indexOf(search, index)(EN, FR) - l'index auquel on trouve search
  • search - l'élément cherché
  • index - l'index à partir duquel on commence à chercher
• str.lastIndexOf(search, index)(EN, FR) - la dernière apparition du search
• str.trim()(EN, FR) - on supprime tous les espaces du début et de la fin du string
• str.startsWith(search, index)(EN, FR) - détermine si une chaîne commence par les caractères du search
• str.endsWith(search, index)(EN, FR) - détermine si une chaîne se termine par les caractères du search
• str.replace(subStr, newSubStr)(EN, FR) - retourne un nouveau string avec newSubStr au lieu de subStr
• str.charAt(index)(EN, FR) - retourne le caractère qui se trouve au index

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.

var personne = {
    nom: "Pitt",
    prenom: "Bradley",
    age: 54,
    greet: function () {
        return "Hello!";
    }
};
 
console.log(personne.nom); //Pitt
console.log(personne['prenom']; //Bradley
personne.greet(); //Hello!
 
personne.date_de_naissance = "18/12/1963";
console.log(personne.date_de_naissance); //18/12/1963

L'opérateur typeof est suivi de l'opérande dont le type doit être retourné.

var x = 5;
typeof x; //Number
typeof "text"; //String
typeof [1, 2, 3]; //Object

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.

var x;
typeof x; //undefined

La valeur null représente l'absence intentionnelle d'une valeur d'un objet. La variable avec cette valeur ne pointe vers aucun objet.

var personne = {nom: 'Pitt', prenom: 'Bradley', age: 54};
personne = null;
 
typeof personne; //Object
console.log(personne) //{}

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.

function produit(p1, p2) {
    return p1 * p2; //la fonction retourne le produit des parametres
}
 
var x = produit(3, 4);
console.log(x); //12

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.

var array = [5, 7, 2, 9, 3]
 
for(var i in array) {
   console.log("Value " + array[i] + " at index " + i);
}
 
/* Output:
Value 5 at index 0
Value 7 at index 1
Value 2 at index 2
...
*/

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é.

var array = [5, 7, 2, 9, 3]
 
for(var i of array) {
   console.log("Value " + i);
}
 
/* Output:
Value 5
Value 7
Value 2
...
*/

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.

Lancement du processus Node.js pour le fichier process.js :

$ node process.js one 2 three

//process.js
 
for(var argumentIndex in process.argv) {
   console.log(argumentIndex + ": " + process.argv[argumentIndex]);
}
 
/* Output:
0: C:\Program Files\nodejs\node.exe
1: C:\Users\student\Desktop\process.js
2: one
3: 2
4: three
*/

La fonction parseInt() analyse une chaîne de caractère fournie en argument et renvoie un entier exprimé dans une base donnée.

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

• 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).

La fonction parseFloat() permet de transformer une chaîne de caractères en un nombre flottant.

var string = "15.35";
var number = parseFloat(string);
 
console.log(number); //15.35
console.log(typeof number); //Number
console.log(typeof string); //Object

• string - Une chaîne de caractères qui contient la valeur qu'on souhaite analyser et transformer dans un nombre flottant.

1. Faites un projet de NodeJS. Créez un tableau de nombres [1, 2, 3]. (1p)
   1. Affichez le tableau avec console.log
   2. Affichez avec un for
   3. Affichez avec un for in
   4. Affichez avec un for of
2. Créez un programme et exécutez-le avec des paramètres. Affichez : (1p)
   1. les paramètres avec console.log
   2. le nombre de paramètres
   3. les paramètres avec un for(à votre choix)
3. Faites un programme qui contient une fonction sum qui reçoit deux nombres comme paramètres et qui : (1p)
   1. affiche le resultat
   2. retourne le resultat
   3. stocke le resultat dans une variable et affiche-la
4. Écrivez un programme qui reçoit un paramètre (rayon d'un cercle). (1p)
   1. Implémentez des fonction qui calculent la circonférence et la surface d'un cercle.
   2. La fonction doit afficher le resutat du calcul. Utilisez parseInt.
5. Faites un tableau avec 10 nombres aléatoires avec des valeurs entre 1-100 (Math.random()). Affichez la somme des éléments du tableau. (1p)
6. Faites un objet personne du type: {nom: Andrei, prenom: Popescu, age: 20}, en utilisant les paramètres de la ligne de commande. (ex: node main.js Andrei Popescu 20) (1p)
   1. Affichez l'objet
   2. Affichez chaque attribut de l'objet
   3. Faites un array avec 5 objets de type personne
   4. Affichez la plus jeune personne
   5. Affichez la moyenne d'age
   6. Affichez la personne avec le nom le plus longue
   7. Affichez tous les objets en ordre alphabetique du nom
7. Ajoutez aux objets de l'exercise précédent un nouveau attribut addresse, qui a le format: {ville: 'Bucarest', rue: 'Splaiul Independentei', numero: 313}. 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'addresse. (1p)
8. Faites une fonction pour vérifier si un objet contient une propriété donnée. (1p)
9. Écrivez un programme qui retourne un tableaux avec les sous-strings d'un string donnée. (ex: ['a', 'al', 'alf', 'l', 'lf', 'f'] pour le string alf) (1p)
10. Écrivez une fonction pour convertir un objet dans une liste de paires [key, value]. (ex: {nom: 'Andrei', age: 20} resulte en [ ['nom', 'Andrei'], ['age', 20] ]) (1p)
11. 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 sort avec la fonction créée par vous comme paramètre. (1p)

Solutions