Update datatable-joins.Rmd #7220 aligned

based on :

$ git diff 2f49a0d HEAD ./vignettes/datatable-joins.Rmd
diff --git a/vignettes/datatable-joins.Rmd b/vignettes/datatable-joins.Rmd
index b3b3059..3d7cf8c 100644

Author: ChristianWia

vignettes/fr/datatable-joins.Rmd

@@ -65,7 +65,6 @@ NewTax = data.table(
 NewTax
 ```
 
-
 3. `ProductReceived`, une table dont les lignes simulent l'inventaire des ventes hebdomadaires.
 
 ```{r define_product_received}
@@ -95,7 +94,7 @@ possible_weekdays <- as.IDate(sapply(receipt_dates, `+`, 0:4))
 ProductSales = data.table(
   id = 1:10,
   date = sort(sample(possible_weekdays, 10L)),
-  product_id = sample(c(1:3, 7L), size = 10L, replace = TRUE), # NB: product '7' is in neither Products nor ProductReceived.
+  product_id = sample(c(1:3, 7L), size = 10L, replace = TRUE), # NB: product '7' n'est ni Products ni ProductReceived.
   count = sample(c(50L, 100L, 150L), size = 10L, replace = TRUE)
 )
 
@@ -146,8 +145,8 @@ Products[ProductReceived,
 Comme beaucoup de choses ont changé, nous allons expliquer les nouvelles caractéristiques dans les groupes suivants :
 
 - **Niveau colonne**
-   - Le *premier groupe* de colonnes dans le nouveau data.table vient de la table `x` .
-   - Le *second groupe* de colonnes de la nouvelle data.table vient de la table `i`.
+   - Le *premier groupe* de colonnes dans le nouveau `data.table` vient de la table `x` .
+   - Le *second groupe* de colonnes de la nouvelle `data.table` vient de la table `i`.
    - Si l'opération de jointure fait apparaître un **conflit de nom** (quand les deux tables ont un même nom de colonne) le ***prefixe*** `i.` est ajouté aux noms des colonnes de la **table de droite** (table en position `i`).
 
 - **Niveau ligne**
@@ -169,7 +168,7 @@ Products[ProductReceived,
          on = list(id = product_id)]
 ```
 
-- Inclure les colonnes associées dans l'alias `data.table` `list` : `.`.
+- Inclure les colonnes associées dans l'alias `.` de `data.table` `list`.
 
 ```{r, eval=FALSE}
 Products[ProductReceived,
@@ -203,7 +202,7 @@ ProductsKeyed[ProductReceivedKeyed]
 
 #### 3.1.3. Opérations après la jointure
 
-La plupart du temps après avoir terminé une jointure il faut faire des adaptations supplémentaires. Pour cela plusieurs alternatives vous sont proposées :
+La plupart du temps après une jointure il faut faire des adaptations supplémentaires. Pour cela plusieurs alternatives vous sont proposées :
 
 - Chaîner une nouvelle instruction en ajoutant une paire de crochets `[]`.
 - En passant comme argument `j` une liste des colonnes que l'on veut conserver ou créer.
@@ -233,12 +232,11 @@ Products[
 ]
 ```
 
-
-##### Résumer avec`on` dans `data.table`
+##### Résumer avec `on` dans `data.table`
 
 Nous pouvons aussi utiliser cette alternative pour renvoyer les résultats agrégés en fonction des colonnes présentes dans la table `x` .
 
-Par exemple on pourrait s'intéresser à la somme dépensée pour acheter chaque produit au fil des jours, quelque soient ces produits.
+Par exemple on pourrait s'intéresser à la somme dépensée pour acheter chaque produit au fil des jours.
 
 ```{r}
 dt1 = ProductReceived[
@@ -248,7 +246,7 @@ dt1 = ProductReceived[
   j = .(total_value_received  = sum(price * count))
 ]
 
-# alternative using multiple [] queries
+# alternative utilisant plusieurs requêtes [] 
 dt2 = ProductReceived[
   Products,
   on = c("product_id" = "id"),
@@ -261,7 +259,7 @@ identical(dt1, dt2)
 
 #### 3.1.4. Jointure basée sur plusieurs colonnes
 
-Jusqu'à présent, nous avons réalisé les jointures en se basant sur une colonne `data.table`, mais il est important de savoir que le package peut joindre des tables en prenant en compte plusieurs colonnes.
+Jusqu'à présent, nous avons réalisé des jointures basées sur une colonne `data.table`, mais il est important de savoir que le package peut joindre des tables en prenant en compte plusieurs colonnes.
 
 Pour illustrer cela supposons que nous voulions ajouter `tax_prop` de `NewTax` pour **mettre à jour** la table `Products`.
 
@@ -273,7 +271,7 @@ NewTax[Products, on = c("unit", "type")]
 
 Utilisez cette méthode pour combiner les colonnes de deux tables en se basant sur une ou plusieurs références mais ***en conservant seulement les lignes qui correspondent entre les deux tables***.
 
-Pour réaliser cette opération il suffit d'ajouter `nomatch = NULL` ou `nomatch = 0` à l'une quelconque des opérations de jointure précédentes pour renvoyer le même résultat.
+Pour réaliser cette opération il suffit d'ajouter `nomatch = NULL` à l'une quelconque des opérations de jointure précédentes pour renvoyer le même résultat.
 
 ```{r}
 # First Table
@@ -316,15 +314,14 @@ Dans ce cas l'opération renvoie la ligne de `product_id = 6,` car il ne figure
 
 ### 3.4. Semi jointure
 
-Cette méthode **ne garde que les lignes qui correspondent à une ligne de la seconde table** sans combiner les colonnes des tables.
+Cette méthode **n'extrait que les lignes qui correspondent à une ligne de la seconde table** sans combiner les colonnes des tables.
 
 En tant que jointure ceci est très similaire aux sous-ensembles, mais comme cette fois nous passons une table complète dans `i` nous devons vérifier que : 
 
 - Chaque ligne de la table `x` est dupliquée à cause de la duplication des lignes dans la table passée dans l'argument `i`.
 
 - Toutes les lignes renommées de `x` doivent conserver l'ordre originel des lignes.
 
-
 Pour faire ceci, suivez les étapes ci-après :
 
 1. Réaliser une **jointure interne** avec `which = TRUE` pour sauvegarder les numéros de ligne liés à chaque ligne sélectionnée de la table `x` .
@@ -348,14 +345,12 @@ SubSetRowsSorted = sort(unique(SubSetRows))
 SubSetRowsSorted
 ```
 
-
 3. Sélectionner les lignes `x` à garder.
 
 ```{r}
 Products[SubSetRowsSorted]
 ```
 
-
 ### 3.5. Jointure gauche
 
 Utiliser cette méthode pour combiner les colonnes de deux tables en se basant sur une ou plusieurs références mais ***en gardant toutes les lignes présentes dans la table située à gauche***.
@@ -378,7 +373,6 @@ Voici les éléments importants à prendre en compte :
    - Toutes les lignes de la table `i` ont été gardées : l'entrée soda de `Products` ne correspond à aucune ligne de `ProductReceived` et fait encore partie des résultats.
    - La ligne concernant `product_id = 6` ne fait plus partie des résultats car elle n'est pas présente dans la table `Products`.
 
-
 #### 3.5.1. Jointure après des opérations sur les chaînes
 
 Une des fonctionnalités clé de `data.table` est que l'on peut appliquer plusieurs opérations en chaînant les crochets, avant d'enregistrer le résultat final.
@@ -488,7 +482,6 @@ AllProductsMix[, temp_id := NULL]
 AllProductsMix[, !c("type", "i.type")]
 ```
 
-
 ### 3.7. Jointure complète
 
 Utilisez cette méthode pour combiner les colonnes de deux tables en se basant sur une ou plusieurs références mais ***sans supprimer aucune ligne***.
@@ -506,20 +499,19 @@ merge(x = Products,
       sort = FALSE)
 ```
 
-
 ## 4. Jointure de non équivalence
 
-Une jointure de non équivalence est un type de jointure où la condition pour sélectionner les lignes n'est pas basée sur une égalité mais sur d'autres opérateurs de comparaison tels que <, >, <=, ou >=. Ceci permet des **critères plus flexibles de jointure**. Dans `data.table`, le jointures non équivalentes sont particulièrement utiles pour les opérations telles que :
+Une jointure de non équivalence est un type de jointure où la condition pour sélectionner les lignes est basée sur des opérateurs de comparaison tels que <, >, <=, ou >= et qui sont autres que l'égalité. Ceci permet des **critères plus flexibles de jointure**. Dans `data.table`, les jointures non équivalentes sont particulièrement utiles pour les opérations telles que :
 
 - Rechercher la correspondance la plus proche
 - Comparer des intervalles de valeurs entre deux tables
 
-C'est une alternative intéressante si, après avoir fait une jointure droite ou interne : 
+C'est une alternative intéressante quand, après avoir fait une jointure droite ou interne : 
 
-- Vous souhaitez diminuer le nombre de lignes renvoyées en fonction du résultat de la comparaison des colonnes numériques de tables différentes.
-- Il n'est pas nécessaire de garder les colonnes de la table x *(data.table secondaire)* dans la table finale.
+- Vous souhaitez réduire le nombre de lignes renvoyées en fonction du résultat de la comparaison des colonnes numériques des tables.
+- Il n'est pas nécessaire de garder les colonnes de la table x *(`data.table` secondaire)* dans le résultat final.
 
-Pour illustrer le fonctionnement, concentrons-nous sur les promotions et les réceptions de product 2.
+Pour illustrer ce fonctionnement, concentrons-nous sur les promotions et les réceptions de product 2.
 
 ```{r}
 ProductSalesProd2 = ProductSales[product_id == 2L]
@@ -600,7 +592,6 @@ C'est utile lorsque vous avez besoin d'aligner des données de sources différen
 
 Par exemple, avec des données financières, vous pourriez utiliser une jointure glissante pour assigner la valeur la plus récente d'une action à chaque transaction, même si les mises à jour du prix et les transactions ne correspondent pas exactement aux mêmes instants.
 
-
 Dans notre exemple de supermarché nous pouvons utiliser une jointure glissante pour correspondre aux promotions avec les informations de produit les plus récentes.
 
 Supposons que le prix des bananes et des carottes change le premier jour de chaque mois.
@@ -635,13 +626,13 @@ ProductPriceHistory[ProductSales,
                     j = .(product_id, date, count, price)]
 ```
 
-## 7. Avantage de la vitesse de jointure
+## 6. Avantage de la vitesse de jointure
 
-### 7.1. Sous-ensembles en tant que jointures
+### 6.1. Sous-ensembles en tant que jointures
 
-Comme nous venons de le voir, dans la section précédente la table `x` est filtrée par les valeurs de la table `i` . Actuellement cette méthode est plus rapide que de passer une expression booléenne dans l'argument `i`.
+Comme nous venons de le voir, dans la section précédente la table `x` est filtrée par les valeurs de la table `i` . Cette méthode est plus rapide que de passer une expression booléenne dans l'argument `i`.
 
-Pour filtrer la table `x` rapidement nous ne passons pas la `data.table` entière, nous pouvons passer une `list()` de vecteurs avec les valeurs de la table originale que nous voulons garder ou omettre.
+Pour filtrer la table `x` rapidement nous n'avons pas besoin de passer une `data.table` entière, nous pouvons passer une `list()` de vecteurs avec les valeurs de la table originale que nous voulons garder ou omettre.
 
 Par exemple pour filtrer les dates auxquelles le marché a reçu 100 unités de bananes (`product_id = 1`) ou de popcorn (`product_id = 3`) nous pouvons utiliser ceci :
 
@@ -658,7 +649,6 @@ ProductReceived[list(c(1L, 3L), 100L),
                 nomatch = NULL]
 ```
 
-
 Nous pouvons aussi utiliser cette technique pour filtrer toute combinaison de valeurs en les préfixant avec `!` pour obtenir la négation de l'expression dans l'argument `i` et en gardant le `nomatch` à sa valeur par défaut. Par exemple nous pouvons filtrer les deux lignes filtrées précédemment.
 
 ```{r}
@@ -677,17 +667,17 @@ Products[!"popcorn",
          on = "name"]
 ```
 
-### 7.2. Mise à jour par référence
+### 6.2. Mise à jour par référence
 
 L'opérateur `:=` de data.table est utilisé pour modifier des colonnes par référence (c'est à dire sans recopie) lors de la jointure. Syntaxe générale : `x[i, on=, (cols) := val]`. 
 
-**Mise à jour Simple un à un**  
+**Mise à jour simple un à un**  
 
 Mise à jour de `Products` avec les prix de `ProductPriceHistory` :
 
 ```{r}
-Products[ProductPriceHistory, 
-         on = .(id = product_id), 
+Products[ProductPriceHistory,
+         on = .(id = product_id),
          price := i.price]
 
 Products