Comprendre les types de données et les opérateurs

Les différents types de données

Comme nous l’avons vu, les fonctions Lodash s’appliquent à différents types de données, que l’on peut regrouper en deux grandes familles :
→ les types primitifs et les types objets.

Types de données primitifs

• Number
  Représente des nombres, entiers (integer) ou à virgule flottante (floating).
  Exemple : age = 42
• String
  Chaîne de caractères, représente une séquence de caractères délimitée par des guillemets (" ").
  Exemples : "John" ou "42" (⚠ ici, "42" est une chaîne, pas un nombre)
• Boolean
  Représente une valeur booléenne, vraie ou fausse (true ou false).
  Exemple : is_OA = false
• Null
  Représente une valeur nulle ou l’absence de valeur. En général null est utilisé pour indiquer de façon intentionnelle et explicite que la variable n’a pas de valeur.
  Exemple : abstract = null (la notice n’a pas de résumé)
• Undefined
  Indique une valeur non définie.
  En pratique, il est déconseillé d’assigner soi-même undefined en raison de sa proximité conceptuelle avec null.

JavaScript renvoi aussi « undefined » si l’on essaye d’accéder a une propriété qui n’existe pas. Si par exemple on veut extraire les valeurs associées à une clé, mais que cette dernière n’existe pas dans toutes les notices alors le résultat sera « undefined » pour les objets n’ayant pas cette clé.

Types de données objets

Les types objets sont des structures de données plus complexes.
Ils permettent de regrouper des valeurs et des fonctionnalités liées dans une seule entité.

• Object
  En JavaScript, un objet est une collection non ordonnée de paires clé-valeur.
  Chaque paire est appelée une propriété de l’objet.
  • Les clés (ou noms de propriétés) sont des chaînes de caractères (ou des symboles).
  • Les valeurs peuvent être de n’importe quel type de données : primitives ou objets.

Exemple :

L’objet ci-dessous a pour valeurs des chaînes de caractères, des nombres, un booléen,un objet (address) ainsi qu’un tableau (children).

{
  "name": "John",
  "age": 42,
  "address": {
    "number": 1,
    "street": "Main Street",
    "city": "Nowhere"
  },
  "married": true,
  "children": ["Bob", "Alice"]
}

• Array
  Un tableau représente une collection ordonnée d’éléments indexés numériquement.
  Chaque élément est accessible via son indice (ex: array[0], array[1], etc.).

  Dans l’exemple ci-dessus :

  • "Bob" est à l’index [0]
  • "Alice" est à l’index [1]

🔀 Ces types peuvent s’imbriquer :

• Des tableaux dans des objets
• Des objets dans des tableaux
• Des objets dans des objets dans des objets…
• Ou encore des tableaux de tableaux (matrices)

Les opérateurs JavaScript

Il existe une multitude d’opérateurs en Javascript très bien détaillés ici.
Ceux-ci permettent d’exprimer des conditions, de comparer ou évaluer des données, nous ne verrons ici que les opérateurs indispensables dans Lodex.

Affectation (=)

Permet d’assigner une valeur à une variable.
Ex. : value = 3 affecte la valeur 3 à la variable value.
💡 Dans un loader par exemple, on affecte un nom à une nouvelle colonne par path = maNouvelleColonne

Égalité (==) vs Égalité stricte (===)

• == compare la valeur, en faisant des conversions automatiques si nécessaire (3 == "3" renvoie true).
• === compare la valeur et le type : (3 === "3" renvoie false car l’un est un nombre, l’autre une chaîne).

Négation (!) et inégalités

• ! inverse une valeur booléenne : !true → false
• != vérifie que deux valeurs sont différentes (tolère la conversion)
• !== vérifie qu’elles sont différentes et de types différents

Logique booléenne : && et ||

• && (ET logique) retourne true si les deux conditions sont vraies
• || (OU logique) retourne true si au moins une condition est vraie

Ternaire (condition ? valeurSiVrai : valeurSiFaux)

Une façon compacte d’écrire un if/else :

thru(age => age >= 18 ? "majeur" : "mineur");

Au lieu de :

thru(function(age) {
  if (age >= 18) {
    return "majeur";
  } else {
    return "mineur";
  }
});

Comparateurs numériques

• > : supérieur à
• >= : supérieur ou égal à
• < : inférieur à
• <= : inférieur ou égal à

Les fonctions fléchées =>ou anonymes

Une expression de fonction fléchée est une syntaxe plus compacte pour écrire des fonctions classiques, peut être plus claires pour des débutants, mais beaucoup plus verbeuses.
Cette syntaxe est omniprésente dans Lodex quand on utilise des fonctions comme map, thru, filter etc.

.thru(function(number) {
  return number + 1;
})

Cette fonction qui permet d’ajouter 1 au nombre reçu s’écrit de façon plus courte par :

.thru(number => number + 1)

Par exemple :

✅ Il est tout à fait possible d’écrire : .map(item => item.trim())

Ici, .trim() est une méthode native de JavaScript sur les chaînes de caractères, on peut l’appeler de la façon habituelle dans Lodex.
La fonction applique .trim() à chaque élément du tableau (via .map()) pour retirer les espaces et caractères invisibles en début et fin de chaîne.

❌ En revanche, si on tente : .map(item => item.startCase())

Cela échoue, car startCase() n’existe pas en JavaScript (fonction qui met en majuscule la première lettre de chaque mot d’une chaîne). Étant une fonction propre à Lodash, elle doit être appelée avec le préfixe _ pour que Lodex sache qu’il faut utiliser Lodash.

✅ Il faut écrire : .map(item => _.startCase(item))

👉 Chapitre suivant