Un tableau (array) est utilisé pour tocker plusieurs valuers dans une seule variable. En Javascript, on n'impose ni la dimenstion du tableau, ni le type de ses éléments. Cela veut dire qu'un seul tableau peut inclure aussi des nombres, que des chaîne de caractères ou même des objets. On peut accéder aux valeurs d'un array en faisant référence à un numéro d'index. Les indices commencent par 0.

var a = [1, 2, 3, 4, "text", {}, ... ];
var b = []; //tableau vide
console.log(a[1]); //2

• list.length - numéro d'éléments du tableau
• list.indexOf (search, index) - numéro de l'indice correspondant à la variable “search”
• list.lastIndexOf (search, index) - indice pour la derniere occurence de la variable “search”
• list.push (element, ...) - ajouter un element au tableau
• list.pop () - supprime et retourne la valeur du dernier élément de la liste
• list.splice (start, deleteCount, pushElement, ...) - changer le contenu du tableau, en supprimant ou en remplaçant certains éléments
• list.map (functionToRun) - créer un nouveau tableau contenant des éléments générés par la fonction appelée

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) - retourne l'indice du premier élément qui satisfait la fonction appelée

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) - nouveau tableau avec les éléments qui passent la fonction fourniw

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

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

• str.length(EN, FR) - 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 clé: valeur). Les noms des valeurs sont appellés propriétés.

var personne = {
    nom: "Pitt",
    prenom: "Bradley",
    age: 54,
    greet: function () {
        return "Hello!";
    }
};
 
// afficher des propriétés de l'objet
 
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 de la 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 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 réel.

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 [10, 20, 30] nommé “number_array”. (1p)
   1. Affichez le tableau avec console.log
   2. Affichez avec un for
   3. Affichez avec un for of
   4. Affichez avec un for in
2. Créez un programme et exécutez-le avec des paramètres dans la ligne de commande. Affichez : (1p)
   1. la liste des 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 multiply qui reçoit deux nombres comme paramètres et qui : (1p)
   1. affiche le résultat
   2. retourne le résultat
   3. stocke le résultat dans une variable et l'affiche
4. Écrivez un programme qui reçoit un paramètre (diamètre d'un cercle). (1p)
   1. Implémentez des fonctions qui calculent et retournent la circonférence et la surface d'un cercle.
   2. Modifiez les fonctions tel qu'elles affichent le résultat du calcul. Utilisez parseInt.
5. 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)
6. Faites un objet étudiant du type: {nom: NomDeFamille, prénom: Prénom, points_credit: NrPointsCrédit}, en utilisant les paramètres de la ligne de commande. (ex: node main.js Radulescu Radu 100) (1p)
   1. Affichez l'objet
   2. Affichez chaque attribut de l'objet
   3. Faites un array avec 5 objets de type étudiant
   4. Affichez l'étudiant avec le plus points credit
   5. Affichez la moyenne géométrique de points
   6. Affichez la personne avec le prénom le plus longue
   7. Affichez tous les objets en ordre alphabétique apres le nom
7. Ajoutez aux objets de l'exercise précédent un nouvel 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)
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: ['c', 'co', 'cod', 'o', 'od', 'd'] pour le string cod) (1p)
10. É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)
11. Bonus: Faites une fonction qui trie le tableau d'objets de l'exercice 6 après l'un de ses attributs (donné comme paramètre). Hint: Appellez la fonction sort avec la fonction créée par vous comme paramètre. (1p)