,— écrivez simplement du Markdown." +- icon: 👁 + title: Meilleur dans les éditeurs + desc: Le Markdown se rendu parfaitement dans les IDEs et éditeurs de texte modernes. +support: + description: Disponible depuis JDK 23 (sept. 2024) diff --git a/translations/content/fr/language/module-import-declarations.yaml b/translations/content/fr/language/module-import-declarations.yaml new file mode 100644 index 0000000..6081d99 --- /dev/null +++ b/translations/content/fr/language/module-import-declarations.yaml @@ -0,0 +1,18 @@ +--- +title: Déclarations d'import de modules +oldApproach: Nombreux imports +modernApproach: import module +summary: Importez tous les packages exportés d'un module avec une seule déclaration. +explanation: "Les déclarations d'import de modules permettent d'importer tout ce qu'un module exporte avec une seule ligne. C'est particulièrement utile pour java.base, qui couvre les collections, l'E/S, les streams et plus encore." +whyModernWins: +- icon: 🧹 + title: Une seule ligne + desc: Remplace une longue liste d'imports par un seul import de module. +- icon: 📦 + title: Compatible avec les modules + desc: Tire parti du système de modules pour importer des ensembles cohérents de packages. +- icon: 🚀 + title: Démarrage rapide + desc: Parfait pour les scripts et prototypes où les listes d'imports sont fastidieuses. +support: + description: Finalisé dans JDK 25 LTS (JEP 511, sept. 2025). diff --git a/translations/content/fr/language/pattern-matching-instanceof.yaml b/translations/content/fr/language/pattern-matching-instanceof.yaml new file mode 100644 index 0000000..9729a0d --- /dev/null +++ b/translations/content/fr/language/pattern-matching-instanceof.yaml @@ -0,0 +1,18 @@ +--- +title: Pattern matching pour instanceof +oldApproach: instanceof + casting +modernApproach: Variable de pattern +summary: "Combine la vérification de type et le casting en une seule étape avec le pattern matching." +explanation: "Le pattern matching pour instanceof élimine le casting redondant après une vérification de type. La variable est automatiquement limitée à la portée où le pattern correspond, rendant le code plus sûr et concis." +whyModernWins: +- icon: 🔄 + title: Sans casting redondant + desc: "La vérification de type et la liaison de variable se font en une seule expression." +- icon: 📏 + title: Moins de lignes + desc: Une ligne au lieu de deux — la ligne de casting disparaît complètement. +- icon: 🛡️ + title: Portée sûre + desc: La variable de pattern n'est dans la portée que là où le type est garanti. +support: + description: Disponible depuis JDK 16 (mars 2021) diff --git a/translations/content/fr/language/pattern-matching-switch.yaml b/translations/content/fr/language/pattern-matching-switch.yaml new file mode 100644 index 0000000..48e6203 --- /dev/null +++ b/translations/content/fr/language/pattern-matching-switch.yaml @@ -0,0 +1,18 @@ +--- +title: Pattern matching dans switch +oldApproach: Chaîne if-else +modernApproach: Patterns de types +summary: Remplace les chaînes if-else avec instanceof par des patterns de types propres dans switch. +explanation: "Le pattern matching dans switch permet de faire correspondre des types directement, combinant la vérification de type, le casting et la liaison en une seule étiquette de cas concise. Le compilateur vérifie l'exhaustivité." +whyModernWins: +- icon: 📐 + title: Dispatch structuré + desc: Le switch rend la structure de branchement explicite et lisible d'un coup d'œil. +- icon: 🎯 + title: Forme d'expression + desc: Retourne une valeur directement — sans variable mutable nécessaire. +- icon: ✅ + title: Exhaustivité + desc: Le compilateur s'assure que tous les types sont couverts. +support: + description: Disponible depuis JDK 21 LTS (sept. 2023) diff --git a/translations/content/fr/language/primitive-types-in-patterns.yaml b/translations/content/fr/language/primitive-types-in-patterns.yaml new file mode 100644 index 0000000..e8992c2 --- /dev/null +++ b/translations/content/fr/language/primitive-types-in-patterns.yaml @@ -0,0 +1,18 @@ +--- +title: Types primitifs dans les patterns +oldApproach: Vérifications de plages manuelles +modernApproach: Patterns primitifs +summary: "Le pattern matching fonctionne maintenant avec les types primitifs, pas seulement avec les objets." +explanation: "Java 25 étend le pattern matching aux types primitifs. Vous pouvez utiliser int, long, double, etc. dans des patterns switch avec des gardes when, éliminant le besoin de boxing ou de vérifications de plages manuelles." +whyModernWins: +- icon: 📦 + title: Sans boxing + desc: Correspond à des primitifs directement — sans besoin du wrapper Integer. +- icon: 🎯 + title: Cohérence des patterns + desc: La même syntaxe de patterns pour les objets et les primitifs. +- icon: ⚡ + title: Meilleures performances + desc: Évite la surcharge de l'autoboxing dans le pattern matching. +support: + description: "Aperçu dans JDK 25 (troisième aperçu, JEP 507). Nécessite --enable-preview." diff --git a/translations/content/fr/language/private-interface-methods.yaml b/translations/content/fr/language/private-interface-methods.yaml new file mode 100644 index 0000000..8c4a328 --- /dev/null +++ b/translations/content/fr/language/private-interface-methods.yaml @@ -0,0 +1,18 @@ +--- +title: Méthodes privées dans les interfaces +oldApproach: Logique dupliquée +modernApproach: Méthodes privées +summary: Extrayez la logique partagée dans les interfaces en utilisant des méthodes privées. +explanation: "Java 9 permet les méthodes privées dans les interfaces, ce qui permet de partager du code entre les méthodes default sans exposer les détails d'implémentation aux classes qui les implémentent." +whyModernWins: +- icon: 🧩 + title: Réutilisation du code + desc: Partagez la logique entre les méthodes default sans duplication. +- icon: 🔐 + title: Encapsulation + desc: Les détails d'implémentation restent cachés aux classes implémentantes. +- icon: 🧹 + title: Interfaces DRY + desc: Fini le copier-coller entre les méthodes default. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/language/record-patterns.yaml b/translations/content/fr/language/record-patterns.yaml new file mode 100644 index 0000000..740536f --- /dev/null +++ b/translations/content/fr/language/record-patterns.yaml @@ -0,0 +1,18 @@ +--- +title: Patterns de record (déstructuration) +oldApproach: Accès manuel +modernApproach: Déstructuration +summary: Déstructurez des records directement dans les patterns — extrayez les champs en une seule étape. +explanation: "Les patterns de record permettent de décomposer les composants d'un record directement dans instanceof et switch. Les patterns imbriqués sont également supportés, permettant des correspondances profondes sans variables intermédiaires." +whyModernWins: +- icon: 🎯 + title: Extraction directe + desc: Accédez aux composants du record sans appeler les accesseurs manuellement. +- icon: 🪆 + title: Imbriquable + desc: "Les patterns peuvent être imbriqués — correspondez aux records internes en une seule expression." +- icon: 📏 + title: Code compact + desc: "Cinq lignes deviennent deux — moins de cérémonie, la même clarté." +support: + description: Disponible depuis JDK 21 LTS (sept. 2023) diff --git a/translations/content/fr/language/records-for-data-classes.yaml b/translations/content/fr/language/records-for-data-classes.yaml new file mode 100644 index 0000000..62f1cff --- /dev/null +++ b/translations/content/fr/language/records-for-data-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Records pour les classes de données +oldApproach: POJO verbeux +modernApproach: record +summary: "Une ligne remplace plus de 30 lignes de code répétitif pour les porteurs de données immutables." +explanation: "Les records génèrent automatiquement le constructeur, les accesseurs (x(), y()), equals(), hashCode() et toString(). Ils sont immutables par conception et idéaux pour les DTOs, objets de valeur et le pattern matching." +whyModernWins: +- icon: ⚡ + title: Définition en une ligne + desc: "Une seule ligne remplace constructeur, getters, equals, hashCode et toString." +- icon: 🔒 + title: Immutable par défaut + desc: Tous les champs sont final — sans risque de setters. +- icon: 🧩 + title: Compatible avec les patterns + desc: Les records fonctionnent avec les patterns de déstructuration dans switch et instanceof. +support: + description: Disponible depuis JDK 16 (mars 2021) diff --git a/translations/content/fr/language/sealed-classes.yaml b/translations/content/fr/language/sealed-classes.yaml new file mode 100644 index 0000000..b8a4de9 --- /dev/null +++ b/translations/content/fr/language/sealed-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Classes sealed pour les hiérarchies de types +oldApproach: Hiérarchie ouverte +modernApproach: sealed permits +summary: Restreignez quelles classes peuvent étendre un type — permettant des switchs exhaustifs. +explanation: "Les classes sealed définissent un ensemble fermé de sous-types. Le compilateur connaît tous les cas possibles, ce qui permet le pattern matching exhaustif sans branche default. Combinées avec les records, elles modélisent des types de données algébriques." +whyModernWins: +- icon: 🔐 + title: Hiérarchie contrôlée + desc: Seuls les sous-types autorisés peuvent étendre — sans sous-classes surprises. +- icon: ✅ + title: Correspondance exhaustive + desc: "Le compilateur vérifie que le switch couvre tous les cas, sans default nécessaire." +- icon: 📐 + title: Types de données algébriques + desc: Modélisez naturellement les types somme — sealed + records = ADTs en Java. +support: + description: Disponible depuis JDK 17 LTS (sept. 2021) diff --git a/translations/content/fr/language/static-members-in-inner-classes.yaml b/translations/content/fr/language/static-members-in-inner-classes.yaml new file mode 100644 index 0000000..e13e11c --- /dev/null +++ b/translations/content/fr/language/static-members-in-inner-classes.yaml @@ -0,0 +1,18 @@ +--- +title: Membres statiques dans les classes internes +oldApproach: Classe statique imbriquée requise +modernApproach: Membres statiques dans les classes internes +summary: "Définissez des membres statiques dans les classes internes sans avoir besoin de classes statiques imbriquées." +explanation: "Avant Java 16, seules les classes statiques imbriquées pouvaient contenir des membres statiques. Les classes internes (non statiques) ne pouvaient pas avoir de statiques car elles nécessitaient une instance englobante. Java 16 assouplit cette restriction, permettant des champs statiques, méthodes et même des types imbriqués dans les classes internes." +whyModernWins: +- icon: 🔓 + title: Plus de flexibilité + desc: Les classes internes peuvent maintenant avoir des membres statiques quand c'est nécessaire. +- icon: 🧩 + title: État partagé + desc: Suivez l'état partagé entre les instances d'une classe interne. +- icon: 🎨 + title: Liberté de conception + desc: Pas besoin de promouvoir en classe statique imbriquée juste pour un champ statique. +support: + description: Disponible depuis JDK 16 (mars 2021) diff --git a/translations/content/fr/language/static-methods-in-interfaces.yaml b/translations/content/fr/language/static-methods-in-interfaces.yaml new file mode 100644 index 0000000..740ddac --- /dev/null +++ b/translations/content/fr/language/static-methods-in-interfaces.yaml @@ -0,0 +1,18 @@ +--- +title: Méthodes statiques dans les interfaces +oldApproach: Classes utilitaires +modernApproach: Méthodes statiques dans les interfaces +summary: "Ajoutez des méthodes utilitaires statiques directement aux interfaces au lieu de classes utilitaires séparées." +explanation: "Avant Java 8, les méthodes utilitaires liées à une interface devaient résider dans une classe séparée (ex. Collections pour Collection). Les méthodes statiques dans les interfaces permettent de garder les utilitaires liés ensemble. C'est courant dans les APIs modernes comme Comparator.comparing(), Stream.of() et List.of()." +whyModernWins: +- icon: 📦 + title: Meilleure organisation + desc: "Gardez les utilitaires liés à l'interface, pas dans une classe séparée." +- icon: 🔍 + title: Découvrabilité + desc: Les méthodes factory et auxiliaires se trouvent là où vous les attendez. +- icon: 🧩 + title: Cohésion d'API + desc: Pas besoin de classes *Utils ou *Helper séparées. +support: + description: Disponible depuis JDK 8 (mars 2014) diff --git a/translations/content/fr/language/switch-expressions.yaml b/translations/content/fr/language/switch-expressions.yaml new file mode 100644 index 0000000..caca892 --- /dev/null +++ b/translations/content/fr/language/switch-expressions.yaml @@ -0,0 +1,18 @@ +--- +title: Expressions switch +oldApproach: Instruction switch +modernApproach: Expression switch +summary: "switch comme expression qui retourne une valeur — sans break, sans fall-through." +explanation: "Les expressions switch retournent une valeur directement, utilisent la syntaxe flèche pour éviter les erreurs de fall-through, et le compilateur vérifie l'exhaustivité. Cela remplace la forme d'instruction sujette aux erreurs." +whyModernWins: +- icon: 🎯 + title: Retourne une valeur + desc: Affectez le résultat du switch directement — sans variable temporaire. +- icon: 🛡️ + title: Sans fall-through + desc: "La syntaxe flèche élimine les erreurs accidentelles de fall-through par break manquant." +- icon: ✅ + title: Vérification d'exhaustivité + desc: Le compilateur s'assure que tous les cas sont couverts. +support: + description: Disponible depuis JDK 14 (mars 2020) diff --git a/translations/content/fr/language/text-blocks-for-multiline-strings.yaml b/translations/content/fr/language/text-blocks-for-multiline-strings.yaml new file mode 100644 index 0000000..c82e0f8 --- /dev/null +++ b/translations/content/fr/language/text-blocks-for-multiline-strings.yaml @@ -0,0 +1,18 @@ +--- +title: Blocs de texte pour les chaînes multiligne +oldApproach: Concaténation de chaînes +modernApproach: Blocs de texte +summary: "Écrivez des chaînes multiligne de façon naturelle avec des blocs de texte à triple guillemets." +explanation: "Les blocs de texte permettent d'écrire des chaînes multiligne exactement comme elles apparaissent. Fini d'échapper les guillemets ou d'ajouter \n. Le compilateur supprime automatiquement l'indentation accidentelle." +whyModernWins: +- icon: 📖 + title: Lisible tel quel + desc: "JSON, SQL et HTML ressemblent à de vrais JSON, SQL et HTML dans votre code source." +- icon: 🚫 + title: Sans enfer des échappements + desc: Les guillemets intégrés n'ont pas besoin d'antislash d'échappement. +- icon: 📐 + title: Indentation intelligente + desc: "Les espaces blancs initiaux sont rognés automatiquement selon la position du délimiteur de fermeture." +support: + description: Disponible depuis JDK 15 (sept. 2020) diff --git a/translations/content/fr/language/type-inference-with-var.yaml b/translations/content/fr/language/type-inference-with-var.yaml new file mode 100644 index 0000000..95c754a --- /dev/null +++ b/translations/content/fr/language/type-inference-with-var.yaml @@ -0,0 +1,18 @@ +--- +title: Inférence de type avec var +oldApproach: Types explicites +modernApproach: Mot-clé var +summary: "Utilisez var pour l'inférence de type dans les variables locales — moins de bruit, la même sécurité." +explanation: "Depuis Java 10, le compilateur infère les types des variables locales à partir du côté droit. Cela réduit le bruit visuel sans sacrifier la sécurité des types. Utilisez var quand le type est évident par le contexte." +whyModernWins: +- icon: ⚡ + title: Moins de code répétitif + desc: "Pas besoin de répéter les types génériques complexes des deux côtés de l'affectation." +- icon: 👁 + title: Meilleure lisibilité + desc: "Concentrez-vous sur les noms de variables et les valeurs, pas sur les déclarations de types." +- icon: 🔒 + title: Toujours sûr en termes de types + desc: Le compilateur infère et applique le type exact à la compilation. +support: + description: Disponible depuis JDK 10 (mars 2018) diff --git a/translations/content/fr/language/unnamed-variables.yaml b/translations/content/fr/language/unnamed-variables.yaml new file mode 100644 index 0000000..41d7fc8 --- /dev/null +++ b/translations/content/fr/language/unnamed-variables.yaml @@ -0,0 +1,18 @@ +--- +title: Variables sans nom avec _ +oldApproach: Variable inutilisée +modernApproach: Marqueur de position _ +summary: "Utilisez _ pour indiquer l'intention quand une variable est délibérément laissée inutilisée." +explanation: "Les variables sans nom communiquent aux lecteurs et aux outils qu'une valeur est délibérément ignorée. Fini les conventions de nommage comme 'ignored' ou 'unused', ni les avertissements de l'IDE." +whyModernWins: +- icon: 📢 + title: Intention claire + desc: _ dit explicitement 'cette valeur n'est pas nécessaire ici'. +- icon: 🔇 + title: Sans avertissements + desc: Les IDEs et linters ne signaleront pas les variables intentionnellement inutilisées. +- icon: 🧹 + title: Lambdas plus propres + desc: "Les lambdas avec plusieurs paramètres sont plus propres quand vous n'en avez besoin que de certains." +support: + description: Finalisé dans JDK 22 (JEP 456, mars 2024). diff --git a/translations/content/fr/security/key-derivation-functions.yaml b/translations/content/fr/security/key-derivation-functions.yaml new file mode 100644 index 0000000..950f1e7 --- /dev/null +++ b/translations/content/fr/security/key-derivation-functions.yaml @@ -0,0 +1,18 @@ +--- +title: Fonctions de dérivation de clés +oldApproach: PBKDF2 manuel +modernApproach: API KDF +summary: Dérivez des clés cryptographiques en utilisant l'API KDF standard. +explanation: "L'API KDF fournit une interface standard pour les fonctions de dérivation de clés, y compris HKDF. Elle remplace l'encombrant pattern SecretKeyFactory + PBEKeySpec par une API propre basée sur un builder." +whyModernWins: +- icon: 📐 + title: API propre + desc: Pattern builder au lieu de constructeurs encombrants de KeySpec. +- icon: 🔧 + title: Support HKDF + desc: Algorithme HKDF moderne aux côtés de PBKDF2. +- icon: 🛡️ + title: Standard + desc: API unifiée pour tous les algorithmes de dérivation de clés. +support: + description: Finalisé dans JDK 25 LTS (JEP 510, sept. 2025). diff --git a/translations/content/fr/security/pem-encoding.yaml b/translations/content/fr/security/pem-encoding.yaml new file mode 100644 index 0000000..daee2cb --- /dev/null +++ b/translations/content/fr/security/pem-encoding.yaml @@ -0,0 +1,18 @@ +--- +title: Encodage/décodage PEM +oldApproach: Base64 manuel + en-têtes +modernApproach: API PEM +summary: Encodez et décodez des objets cryptographiques au format PEM nativement. +explanation: "L'API PEM fournit un encodage/décodage standard pour les certificats, clés et autres objets cryptographiques au format PEM. Fini l'enveloppement manuel de Base64 avec des en-têtes BEGIN/END." +whyModernWins: +- icon: 🧹 + title: Sans Base64 manuel + desc: Les en-têtes PEM, le retour à la ligne et Base64 sont gérés automatiquement. +- icon: 🔄 + title: Bidirectionnel + desc: Encodez vers PEM et décodez depuis PEM avec une seule API. +- icon: 🛡️ + title: Format standard + desc: Produit une sortie PEM compatible RFC 7468. +support: + description: Aperçu dans JDK 25 (JEP 470). Nécessite --enable-preview. diff --git a/translations/content/fr/security/random-generator.yaml b/translations/content/fr/security/random-generator.yaml new file mode 100644 index 0000000..ce1b1c3 --- /dev/null +++ b/translations/content/fr/security/random-generator.yaml @@ -0,0 +1,18 @@ +--- +title: Interface RandomGenerator +oldApproach: new Random() / ThreadLocalRandom +modernApproach: Factory RandomGenerator +summary: Utilisez l'interface RandomGenerator pour choisir des algorithmes de nombres aléatoires par nom sans se coupler à une classe spécifique. +explanation: "JDK 17 a introduit RandomGenerator comme interface commune pour toutes les implémentations de générateurs de nombres aléatoires. Au lieu de coder en dur new Random() ou ThreadLocalRandom, vous pouvez sélectionner des algorithmes par nom via une factory, facilitant le changement entre des algorithmes optimisés pour différents cas d'utilisation (vitesse, qualité statistique, divisibilité)." +whyModernWins: +- icon: 🔧 + title: Agnostique à l'algorithme + desc: Choisissez le meilleur algorithme de génération aléatoire par nom sans changer la structure du code. +- icon: ⚡ + title: Meilleurs algorithmes + desc: Accès aux générateurs LXM modernes avec des propriétés statistiques supérieures. +- icon: 🔗 + title: API unifiée + desc: Une interface couvre Random, ThreadLocalRandom, SplittableRandom et plus. +support: + description: Disponible depuis JDK 17 (septembre 2021, JEP 356). diff --git a/translations/content/fr/security/strong-random.yaml b/translations/content/fr/security/strong-random.yaml new file mode 100644 index 0000000..f084543 --- /dev/null +++ b/translations/content/fr/security/strong-random.yaml @@ -0,0 +1,18 @@ +--- +title: Génération de nombres aléatoires forts +oldApproach: new SecureRandom() +modernApproach: getInstanceStrong() +summary: Obtient l'implémentation la plus forte de SecureRandom de la plateforme. +explanation: "getInstanceStrong() retourne l'implémentation de SecureRandom configurée comme la plus forte sur la plateforme. Cela est contrôlé par la propriété de sécurité securerandom.strongAlgorithms." +whyModernWins: +- icon: 🛡️ + title: La plus forte disponible + desc: Sélectionne automatiquement le meilleur algorithme pour la plateforme. +- icon: 📖 + title: Intention explicite + desc: Communique clairement qu'une aléatoire forte est requise. +- icon: 🔧 + title: Configurable + desc: Les administrateurs peuvent changer l'algorithme fort via les propriétés de sécurité. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/security/tls-default.yaml b/translations/content/fr/security/tls-default.yaml new file mode 100644 index 0000000..10c08c2 --- /dev/null +++ b/translations/content/fr/security/tls-default.yaml @@ -0,0 +1,18 @@ +--- +title: TLS 1.3 par défaut +oldApproach: Configuration manuelle de TLS +modernApproach: TLS 1.3 par défaut +summary: TLS 1.3 est activé par défaut — aucune configuration explicite du protocole n'est nécessaire. +explanation: "Java 11 a ajouté le support de TLS 1.3 et en a fait le protocole préféré. HttpClient l'utilise automatiquement. Fini de spécifier manuellement les versions de protocole pour les connexions sécurisées." +whyModernWins: +- icon: 🛡️ + title: Plus sécurisé + desc: TLS 1.3 élimine les suites de chiffrement obsolètes et les patterns de handshake. +- icon: ⚡ + title: Handshake plus rapide + desc: TLS 1.3 se complète en un aller-retour au lieu de deux. +- icon: 🆓 + title: Sans configuration + desc: Sécurisé par défaut — aucune sélection explicite de protocole nécessaire. +support: + description: Disponible depuis JDK 11 (sept. 2018) diff --git a/translations/content/fr/streams/collectors-flatmapping.yaml b/translations/content/fr/streams/collectors-flatmapping.yaml new file mode 100644 index 0000000..d65a9fb --- /dev/null +++ b/translations/content/fr/streams/collectors-flatmapping.yaml @@ -0,0 +1,18 @@ +--- +title: Collectors.flatMapping() +oldApproach: flatMap imbriqué +modernApproach: flatMapping() +summary: Utilisez flatMapping() pour aplatir à l'intérieur d'un collector de regroupement. +explanation: "Collectors.flatMapping() applique un mapping un-à-plusieurs comme un collector descendant. C'est l'équivalent dans les collectors de Stream.flatMap() — utile à l'intérieur de groupingBy ou partitioningBy." +whyModernWins: +- icon: 🧩 + title: Composable + desc: Fonctionne comme collector descendant à l'intérieur de groupingBy. +- icon: 📐 + title: Un seul passage + desc: Aplatit et regroupe en un seul parcours du stream. +- icon: 🔗 + title: Imbriquable + desc: Se combine avec d'autres collectors descendants. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/optional-ifpresentorelse.yaml b/translations/content/fr/streams/optional-ifpresentorelse.yaml new file mode 100644 index 0000000..51c6837 --- /dev/null +++ b/translations/content/fr/streams/optional-ifpresentorelse.yaml @@ -0,0 +1,18 @@ +--- +title: Optional.ifPresentOrElse() +oldApproach: if/else sur Optional +modernApproach: ifPresentOrElse() +summary: Gérez les deux cas d'Optional, présent et vide, en un seul appel. +explanation: "ifPresentOrElse() reçoit un Consumer pour le cas présent et un Runnable pour le cas vide. Évite l'anti-pattern isPresent/get." +whyModernWins: +- icon: 📏 + title: Expression unique + desc: Les deux cas sont gérés en un seul appel de méthode. +- icon: 🚫 + title: Sans get() + desc: Élimine le dangereux pattern isPresent() + get(). +- icon: 🔗 + title: Fluide + desc: S'enchaîne naturellement après findUser() ou toute méthode qui retourne Optional. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/optional-or.yaml b/translations/content/fr/streams/optional-or.yaml new file mode 100644 index 0000000..359507c --- /dev/null +++ b/translations/content/fr/streams/optional-or.yaml @@ -0,0 +1,18 @@ +--- +title: Optional.or() comme alternative +oldApproach: Alternative imbriquée +modernApproach: Chaîne .or() +summary: Enchaînez des alternatives d'Optional sans vérifications imbriquées. +explanation: "Optional.or() retourne l'Optional original s'il a une valeur, sinon évalue le supplier pour obtenir un Optional alternatif. Les suppliers sont paresseux — ils ne sont invoqués que si nécessaire." +whyModernWins: +- icon: 🔗 + title: Enchaînable + desc: Empilez des alternatives dans un pipeline lisible. +- icon: ⚡ + title: Évaluation paresseuse + desc: Les suppliers alternatifs ne s'exécutent que si nécessaire. +- icon: 📖 + title: Déclaratif + desc: "Se lit comme 'essayez le primaire, ou le secondaire, ou les valeurs par défaut'." +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/predicate-not.yaml b/translations/content/fr/streams/predicate-not.yaml new file mode 100644 index 0000000..3535742 --- /dev/null +++ b/translations/content/fr/streams/predicate-not.yaml @@ -0,0 +1,18 @@ +--- +title: Predicate.not() pour la négation +oldApproach: Négation avec lambda +modernApproach: Predicate.not() +summary: Utilisez Predicate.not() pour nier des références de méthodes proprement au lieu d'écrire des lambdas enveloppants. +explanation: "Avant Java 11, nier une référence de méthode nécessitait de l'envelopper dans une lambda. Predicate.not() permet de nier n'importe quel prédicat directement, gardant le code lisible et cohérent avec le style de références de méthodes dans tout le pipeline de stream." +whyModernWins: +- icon: 👁 + title: Négation plus propre + desc: Pas besoin d'envelopper les références de méthodes dans des lambdas juste pour les nier. +- icon: 🔗 + title: Composable + desc: Fonctionne avec n'importe quel Predicate, permettant des chaînes de prédicats propres. +- icon: 📖 + title: Se lit naturellement + desc: Predicate.not(String::isBlank) se lit comme un langage naturel. +support: + description: Disponible depuis JDK 11 (septembre 2018). diff --git a/translations/content/fr/streams/stream-gatherers.yaml b/translations/content/fr/streams/stream-gatherers.yaml new file mode 100644 index 0000000..b223932 --- /dev/null +++ b/translations/content/fr/streams/stream-gatherers.yaml @@ -0,0 +1,18 @@ +--- +title: Stream gatherers +oldApproach: Collector personnalisé +modernApproach: gather() +summary: Utilisez des gatherers pour des opérations intermédiaires personnalisées dans les streams. +explanation: "Les gatherers sont une nouvelle opération intermédiaire de stream qui permet d'exprimer des transformations complexes comme des fenêtres glissantes, des groupes de taille fixe et des opérations de scan qui étaient impossibles avec les opérations standard de stream." +whyModernWins: +- icon: 🧩 + title: Composable + desc: Les gatherers se composent avec d'autres opérations de stream. +- icon: 📦 + title: Opérations intégrées + desc: windowFixed, windowSliding, fold, scan disponibles nativement. +- icon: 🔧 + title: Extensible + desc: Écrivez des gatherers personnalisés pour n'importe quelle transformation intermédiaire. +support: + description: Finalisé dans JDK 24 (JEP 485, mars 2025). diff --git a/translations/content/fr/streams/stream-iterate-predicate.yaml b/translations/content/fr/streams/stream-iterate-predicate.yaml new file mode 100644 index 0000000..2ed9a3a --- /dev/null +++ b/translations/content/fr/streams/stream-iterate-predicate.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.iterate() avec prédicat +oldApproach: iterate + limit +modernApproach: iterate(seed, pred, op) +summary: "Utilisez un prédicat pour arrêter l'itération — comme une boucle for sous forme de stream." +explanation: "Stream.iterate(seed, hasNext, next) à trois arguments fonctionne comme une boucle for : seed est le début, hasNext détermine quand s'arrêter et next produit la valeur suivante." +whyModernWins: +- icon: 🎯 + title: Terminaison naturelle + desc: S'arrête selon une condition, pas une limite arbitraire. +- icon: 📐 + title: Équivalent à for + desc: Même sémantique que for(seed; hasNext; next). +- icon: 🛡️ + title: Sans risque de stream infini + desc: Le prédicat garantit la terminaison. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/stream-mapmulti.yaml b/translations/content/fr/streams/stream-mapmulti.yaml new file mode 100644 index 0000000..0d5f28e --- /dev/null +++ b/translations/content/fr/streams/stream-mapmulti.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.mapMulti() +oldApproach: flatMap + List +modernApproach: mapMulti() +summary: Émet zéro ou plusieurs éléments par entrée sans créer de streams intermédiaires. +explanation: "mapMulti() est une alternative impérative à flatMap qui évite de créer des objets Stream intermédiaires pour chaque élément. C'est plus efficace quand le mapping produit un petit nombre d'éléments." +whyModernWins: +- icon: ⚡ + title: Moins d'allocations + desc: Aucun Stream intermédiaire créé par élément. +- icon: 🎯 + title: Style impératif + desc: Utilisez des boucles et des conditionnels directement. +- icon: 📐 + title: Flexible + desc: Émettez zéro, un ou plusieurs éléments avec un contrôle total. +support: + description: Disponible depuis JDK 16 (mars 2021) diff --git a/translations/content/fr/streams/stream-of-nullable.yaml b/translations/content/fr/streams/stream-of-nullable.yaml new file mode 100644 index 0000000..80fe489 --- /dev/null +++ b/translations/content/fr/streams/stream-of-nullable.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.ofNullable() +oldApproach: Vérification de null +modernApproach: ofNullable() +summary: Crée un stream de zéro ou un élément à partir d'une valeur qui peut être null. +explanation: "Stream.ofNullable() retourne un stream d'un seul élément si la valeur n'est pas null, ou un stream vide si elle est null. Élimine le pattern de vérification ternaire de null." +whyModernWins: +- icon: 📏 + title: Concis + desc: Un seul appel remplace le conditionnel ternaire. +- icon: 🔗 + title: Compatible avec flatMap + desc: Parfait à l'intérieur de flatMap pour ignorer les valeurs null. +- icon: 🛡️ + title: Sûr contre null + desc: Sans risque de NPE — null est converti en stream vide. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/stream-takewhile-dropwhile.yaml b/translations/content/fr/streams/stream-takewhile-dropwhile.yaml new file mode 100644 index 0000000..5276571 --- /dev/null +++ b/translations/content/fr/streams/stream-takewhile-dropwhile.yaml @@ -0,0 +1,18 @@ +--- +title: Stream takeWhile / dropWhile +oldApproach: Boucle manuelle +modernApproach: takeWhile/dropWhile +summary: Prenez ou abandonnez des éléments d'un stream selon un prédicat. +explanation: "takeWhile() retourne des éléments tant que le prédicat est vrai et s'arrête au premier faux. dropWhile() ignore les éléments tant que c'est vrai et retourne le reste. Les deux fonctionnent mieux sur les streams ordonnés." +whyModernWins: +- icon: 🎯 + title: Court-circuit + desc: Arrête le traitement dès que le prédicat échoue. +- icon: 🔗 + title: Compatible avec les pipelines + desc: S'enchaîne avec d'autres opérations de stream naturellement. +- icon: 📖 + title: Déclaratif + desc: "takeWhile se lit comme de l'anglais : 'prend tant que inférieur à 100'." +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/streams/stream-tolist.yaml b/translations/content/fr/streams/stream-tolist.yaml new file mode 100644 index 0000000..f084dbc --- /dev/null +++ b/translations/content/fr/streams/stream-tolist.yaml @@ -0,0 +1,18 @@ +--- +title: Stream.toList() +oldApproach: Collectors.toList() +modernApproach: .toList() +summary: Le terminal toList() remplace le verbose collect(Collectors.toList()). +explanation: "Stream.toList() retourne une liste non modifiable. C'est équivalent à .collect(Collectors.toUnmodifiableList()) mais beaucoup plus court. Note : le résultat est immutable, contrairement à Collectors.toList()." +whyModernWins: +- icon: 📏 + title: 7 caractères vs 24 + desc: .toList() remplace .collect(Collectors.toList()). +- icon: 🔒 + title: Immutable + desc: La liste résultante ne peut pas être modifiée. +- icon: 📖 + title: Fluide + desc: Se lit naturellement à la fin d'un pipeline. +support: + description: Disponible depuis JDK 16 (mars 2021) diff --git a/translations/content/fr/streams/virtual-thread-executor.yaml b/translations/content/fr/streams/virtual-thread-executor.yaml new file mode 100644 index 0000000..347a8eb --- /dev/null +++ b/translations/content/fr/streams/virtual-thread-executor.yaml @@ -0,0 +1,18 @@ +--- +title: Executor avec threads virtuels +oldApproach: Pool de threads fixe +modernApproach: Executor de threads virtuels +summary: Utilisez des executors de threads virtuels pour une concurrence légère illimitée. +explanation: "L'executor de threads virtuels crée un nouveau thread virtuel pour chaque tâche. Pas besoin de dimensionner le pool — les threads virtuels sont suffisamment économiques pour en créer des millions." +whyModernWins: +- icon: ♾️ + title: Sans dimensionnement + desc: Sans taille de pool à ajuster — créez autant de threads que nécessaire. +- icon: ⚡ + title: Léger + desc: Les threads virtuels utilisent des Ko de mémoire, pas des Mo. +- icon: 🧹 + title: Auto-closeable + desc: try-with-resources gère la fermeture automatiquement. +support: + description: Disponible depuis JDK 21 LTS (sept. 2023) diff --git a/translations/content/fr/strings/string-chars-stream.yaml b/translations/content/fr/strings/string-chars-stream.yaml new file mode 100644 index 0000000..7ec5b2f --- /dev/null +++ b/translations/content/fr/strings/string-chars-stream.yaml @@ -0,0 +1,18 @@ +--- +title: Caractères de String comme stream +oldApproach: Boucle manuelle +modernApproach: Stream de chars() +summary: Traitez les caractères d'une chaîne comme un pipeline de stream. +explanation: "String.chars() retourne un IntStream de valeurs de caractères, permettant un traitement fonctionnel. Pour le support Unicode, codePoints() gère correctement les caractères supplémentaires." +whyModernWins: +- icon: 🔗 + title: Enchaînable + desc: Utilisez filter, map, collect sur des streams de caractères. +- icon: 📐 + title: Déclaratif + desc: Décrivez ce qu'il faut faire, pas comment itérer. +- icon: 🌐 + title: Prêt pour Unicode + desc: codePoints() gère correctement les emojis et les caractères supplémentaires. +support: + description: Disponible depuis JDK 8+ (amélioré en 9+) diff --git a/translations/content/fr/strings/string-formatted.yaml b/translations/content/fr/strings/string-formatted.yaml new file mode 100644 index 0000000..b5c07c6 --- /dev/null +++ b/translations/content/fr/strings/string-formatted.yaml @@ -0,0 +1,18 @@ +--- +title: String.formatted() +oldApproach: String.format() +modernApproach: formatted() +summary: Appelez formatted() directement sur la chaîne de modèle. +explanation: "String.formatted() est une méthode d'instance équivalente à String.format() mais invoquée sur la chaîne de format. Elle se lit plus naturellement dans un flux de gauche à droite." +whyModernWins: +- icon: 📖 + title: Se lit naturellement + desc: Template.formatted(args) se déroule mieux que String.format(template, args). +- icon: 🔗 + title: Enchaînable + desc: Peut être enchaîné avec d'autres méthodes de String. +- icon: 📏 + title: Moins verbeux + desc: Élimine l'appel statique redondant à String.format(). +support: + description: Disponible depuis JDK 15 (sept. 2020) diff --git a/translations/content/fr/strings/string-indent-transform.yaml b/translations/content/fr/strings/string-indent-transform.yaml new file mode 100644 index 0000000..61c7420 --- /dev/null +++ b/translations/content/fr/strings/string-indent-transform.yaml @@ -0,0 +1,18 @@ +--- +title: String.indent() et transform() +oldApproach: Indentation manuelle +modernApproach: indent() / transform() +summary: Indentez du texte et enchaînez des transformations de chaînes de façon fluide. +explanation: "indent(n) ajoute n espaces à chaque ligne. transform(fn) applique n'importe quelle fonction et retourne le résultat, permettant un enchaînement fluide d'opérations sur les chaînes." +whyModernWins: +- icon: 📏 + title: Intégré + desc: L'indentation est une opération courante — maintenant c'est un seul appel. +- icon: 🔗 + title: Enchaînable + desc: transform() permet des pipelines fluides sur les chaînes. +- icon: 🧹 + title: Code propre + desc: Sans séparation manuelle de lignes ni boucles avec StringBuilder. +support: + description: Disponible depuis JDK 12 (mars 2019) diff --git a/translations/content/fr/strings/string-isblank.yaml b/translations/content/fr/strings/string-isblank.yaml new file mode 100644 index 0000000..f19f42e --- /dev/null +++ b/translations/content/fr/strings/string-isblank.yaml @@ -0,0 +1,18 @@ +--- +title: String.isBlank() +oldApproach: trim().isEmpty() +modernApproach: isBlank() +summary: Vérifiez si une chaîne est vide avec un seul appel de méthode. +explanation: "isBlank() retourne true si la chaîne est vide ou ne contient que des espaces blancs, y compris les caractères d'espace Unicode que trim() ne détecte pas." +whyModernWins: +- icon: 📖 + title: Auto-documenté + desc: isBlank() dit exactement ce qu'il vérifie. +- icon: 🌐 + title: Compatible Unicode + desc: Gère tous les espaces blancs Unicode, pas seulement ASCII. +- icon: ⚡ + title: Sans allocation + desc: Aucune chaîne intermédiaire rognée n'est créée. +support: + description: Disponible depuis JDK 11 (sept. 2018) diff --git a/translations/content/fr/strings/string-lines.yaml b/translations/content/fr/strings/string-lines.yaml new file mode 100644 index 0000000..8653028 --- /dev/null +++ b/translations/content/fr/strings/string-lines.yaml @@ -0,0 +1,18 @@ +--- +title: String.lines() pour diviser les lignes +oldApproach: split("\\n") +modernApproach: lines() +summary: Utilisez String.lines() pour diviser du texte en un stream de lignes sans la surcharge des expressions régulières. +explanation: "String.lines() retourne un Stream
de lignes divisées par \n, \r ou \r\n. C'est plus paresseux et efficace que split(), évite la compilation de regex et s'intègre naturellement avec l'API Stream pour le traitement ultérieur." +whyModernWins: +- icon: ⚡ + title: Streaming paresseux + desc: Les lignes sont produites à la demande, pas toutes à la fois comme split(). +- icon: 🔧 + title: Fins de ligne universelles + desc: "Gère \n, \r et \r\n automatiquement sans regex." +- icon: 🔗 + title: Intégration avec Stream + desc: Retourne un Stream pour utilisation directe avec filter, map, collect. +support: + description: Disponible depuis JDK 11 (septembre 2018). diff --git a/translations/content/fr/strings/string-repeat.yaml b/translations/content/fr/strings/string-repeat.yaml new file mode 100644 index 0000000..991abe0 --- /dev/null +++ b/translations/content/fr/strings/string-repeat.yaml @@ -0,0 +1,18 @@ +--- +title: String.repeat() +oldApproach: Boucle avec StringBuilder +modernApproach: repeat() +summary: Répète une chaîne n fois sans boucle. +explanation: "String.repeat(int) retourne la chaîne concaténée avec elle-même n fois. Gère les cas limites : repeat(0) retourne une chaîne vide, repeat(1) retourne la même chaîne." +whyModernWins: +- icon: 📏 + title: Une seule ligne + desc: Remplace 5 lignes de code avec StringBuilder par un seul appel. +- icon: ⚡ + title: Optimisé + desc: L'implémentation interne est optimisée pour les grandes répétitions. +- icon: 📖 + title: Intention claire + desc: repeat(3) transmet immédiatement l'objectif. +support: + description: Disponible depuis JDK 11 (sept. 2018) diff --git a/translations/content/fr/strings/string-strip.yaml b/translations/content/fr/strings/string-strip.yaml new file mode 100644 index 0000000..7678de6 --- /dev/null +++ b/translations/content/fr/strings/string-strip.yaml @@ -0,0 +1,18 @@ +--- +title: String.strip() vs trim() +oldApproach: trim() +modernApproach: strip() +summary: "Utilisez la suppression d'espaces compatible Unicode avec strip(), stripLeading(), stripTrailing()." +explanation: "trim() ne supprime que les caractères ≤ U+0020 (caractères de contrôle ASCII et espace). strip() utilise Character.isWhitespace() qui gère les espaces Unicode comme l'espace insécable, l'espace idéographique, etc." +whyModernWins: +- icon: 🌐 + title: Correct pour Unicode + desc: Gère tous les caractères d'espace de tous les scripts. +- icon: 🎯 + title: Directionnel + desc: stripLeading() et stripTrailing() pour le rognage d'un seul côté. +- icon: 🛡️ + title: Moins d'erreurs + desc: Sans espaces blancs inattendus dans le texte international. +support: + description: Disponible depuis JDK 11 (sept. 2018) diff --git a/translations/content/fr/tooling/aot-class-preloading.yaml b/translations/content/fr/tooling/aot-class-preloading.yaml new file mode 100644 index 0000000..0bcbea5 --- /dev/null +++ b/translations/content/fr/tooling/aot-class-preloading.yaml @@ -0,0 +1,18 @@ +--- +title: Préchargement de classes AOT +oldApproach: Démarrage à froid à chaque fois +modernApproach: Cache AOT +summary: Mettez en cache le chargement et la compilation des classes pour un démarrage instantané. +explanation: "Le préchargement de classes AOT met en cache les classes chargées et liées d'une exécution d'entraînement. Lors des démarrages suivants, les classes sont chargées depuis le cache, sautant la vérification et la liaison. Combiné avec la compilation AOT, cela réduit drastiquement le temps de démarrage." +whyModernWins: +- icon: ⚡ + title: Démarrage plus rapide + desc: Saute le chargement, la vérification et la liaison des classes. +- icon: 📦 + title: État en cache + desc: L'exécution d'entraînement capture l'état idéal des classes. +- icon: 🔧 + title: Sans changements de code + desc: Fonctionne avec les applications existantes — ajoutez simplement des flags JVM. +support: + description: Disponible comme fonctionnalité standard dans JDK 25 LTS (JEPs 514/515, sept. 2025). diff --git a/translations/content/fr/tooling/built-in-http-server.yaml b/translations/content/fr/tooling/built-in-http-server.yaml new file mode 100644 index 0000000..e2c9d73 --- /dev/null +++ b/translations/content/fr/tooling/built-in-http-server.yaml @@ -0,0 +1,18 @@ +--- +title: Serveur HTTP intégré +oldApproach: Serveur externe / framework +modernApproach: CLI jwebserver +summary: Java 18 inclut un serveur HTTP minimal intégré pour le prototypage et le service de fichiers. +explanation: "JDK 18 a ajouté un serveur HTTP de fichiers simple et sans dépendances, accessible via l'outil de ligne de commande jwebserver ou l'API SimpleFileServer. Il sert des fichiers statiques depuis un répertoire donné sans configuration. L'outil CLI est idéal pour le prototypage rapide, les tests et le partage de fichiers ad-hoc — sans dépendances externes ni frameworks nécessaires. L'API permet une utilisation programmatique avec des gestionnaires personnalisables et des niveaux de sortie." +whyModernWins: +- icon: 🚀 + title: Sans configuration + desc: Exécutez jwebserver dans n'importe quel répertoire — sans installation, configuration ni dépendances nécessaires. +- icon: 📦 + title: Intégré dans le JDK + desc: Distribué avec chaque installation de JDK 18+, toujours disponible sur n'importe quelle machine avec Java. +- icon: 🧪 + title: Idéal pour le prototypage + desc: Sert des fichiers statiques instantanément pour tester du HTML, des APIs ou le développement front-end. +support: + description: Disponible depuis JDK 18 (mars 2022) diff --git a/translations/content/fr/tooling/compact-object-headers.yaml b/translations/content/fr/tooling/compact-object-headers.yaml new file mode 100644 index 0000000..2d749b5 --- /dev/null +++ b/translations/content/fr/tooling/compact-object-headers.yaml @@ -0,0 +1,18 @@ +--- +title: En-têtes d'objets compacts +oldApproach: En-têtes de 128 bits +modernApproach: En-têtes de 64 bits +summary: Réduit de moitié la taille des en-têtes d'objets pour une meilleure densité mémoire et utilisation du cache. +explanation: "Les en-têtes d'objets compacts réduisent la surcharge par objet de 128 bits à 64 bits sur les plateformes 64 bits. Cela économise de la mémoire et améliore l'utilisation du cache, surtout pour les applications avec de nombreux petits objets." +whyModernWins: +- icon: 📦 + title: En-têtes 50% plus petits + desc: 8 octets au lieu de 16 par objet. +- icon: ⚡ + title: Meilleure utilisation du cache + desc: Plus d'objets tiennent dans les lignes de cache du CPU. +- icon: 📊 + title: Densité accrue + desc: Plus d'objets tiennent dans la même taille de heap. +support: + description: Finalisé dans JDK 25 LTS (JEP 519, sept. 2025). diff --git a/translations/content/fr/tooling/jfr-profiling.yaml b/translations/content/fr/tooling/jfr-profiling.yaml new file mode 100644 index 0000000..d2d0024 --- /dev/null +++ b/translations/content/fr/tooling/jfr-profiling.yaml @@ -0,0 +1,18 @@ +--- +title: JFR pour le profilage +oldApproach: Profileur externe +modernApproach: Java Flight Recorder +summary: "Profilez n'importe quelle application Java avec le Flight Recorder intégré — sans outils externes." +explanation: "Java Flight Recorder (JFR) est un outil de profilage à faible surcharge intégré dans la JVM. Il capture les événements CPU, mémoire, GC, E/S, threads et événements personnalisés avec un impact minimal sur les performances (~1%)." +whyModernWins: +- icon: 🆓 + title: Intégré + desc: Sans profileur externe à installer ou licencier. +- icon: ⚡ + title: Faible surcharge + desc: ~1% d'impact sur les performances — sûr pour la production. +- icon: 📊 + title: Événements riches + desc: CPU, mémoire, GC, threads, E/S, verrous et événements personnalisés. +support: + description: Disponible depuis JDK 9/11 (open source en 11) diff --git a/translations/content/fr/tooling/jshell-prototyping.yaml b/translations/content/fr/tooling/jshell-prototyping.yaml new file mode 100644 index 0000000..21c61aa --- /dev/null +++ b/translations/content/fr/tooling/jshell-prototyping.yaml @@ -0,0 +1,18 @@ +--- +title: JShell pour le prototypage +oldApproach: Créer un fichier + compiler + exécuter +modernApproach: REPL JShell +summary: Testez des expressions Java de façon interactive sans créer de fichiers. +explanation: "JShell est une boucle lecture-évaluation-impression pour Java. Testez des expressions, expérimentez avec des APIs et prototypez du code sans créer de fichiers, compiler ni écrire de méthode main. Inclut la complétion automatique par tabulation et la documentation en ligne." +whyModernWins: +- icon: ⚡ + title: Retour instantané + desc: Écrivez une expression et voyez le résultat immédiatement. +- icon: 📝 + title: Sans fichiers nécessaires + desc: Sans fichiers .java, sans étape de compilation. +- icon: 🔍 + title: Exploration d'APIs + desc: La complétion par tabulation aide à découvrir les méthodes et paramètres. +support: + description: Disponible depuis JDK 9 (sept. 2017) diff --git a/translations/content/fr/tooling/junit6-with-jspecify.yaml b/translations/content/fr/tooling/junit6-with-jspecify.yaml new file mode 100644 index 0000000..9decc7f --- /dev/null +++ b/translations/content/fr/tooling/junit6-with-jspecify.yaml @@ -0,0 +1,18 @@ +--- +title: JUnit 6 avec sécurité de nuls JSpecify +oldApproach: API sans annotations +modernApproach: API @NullMarked +summary: JUnit 6 adopte @NullMarked de JSpecify, rendant explicites les contrats de nuls dans toute son API d'assertions. +explanation: "JUnit 5 a été distribué sans annotations de nullabilité standardisées, laissant les développeurs deviner si les paramètres d'assertion ou les valeurs de retour pouvaient être null. JUnit 6 adopte JSpecify dans tout son module : l'annotation @NullMarked rend tous les types non annotés non-nuls par défaut, et @Nullable marque les exceptions. La classe Assertions annote explicitement les paramètres comme assertNull(@Nullable Object actual) et fail(@Nullable String message), pour que les IDEs et analyseurs statiques comme NullAway et Error Prone puissent détecter le mauvais usage de null à la compilation plutôt qu'à l'exécution." +whyModernWins: +- icon: 📜 + title: Contrats explicites + desc: "@NullMarked dans le module de JUnit 6 documente la sémantique des nuls directement dans l'API — sans besoin de lire le code source." +- icon: 🛡️ + title: Sécurité à la compilation + desc: Les IDEs et analyseurs alertent quand null est passé là où non-null est attendu, détectant les erreurs avant l'exécution des tests. +- icon: 🌐 + title: Standard de l'écosystème + desc: JSpecify est adopté par Spring, Guava et d'autres — sémantique de nuls cohérente dans toute votre pile. +support: + description: Disponible depuis JUnit 6.0 (octobre 2025, nécessite Java 17+) diff --git a/translations/content/fr/tooling/multi-file-source.yaml b/translations/content/fr/tooling/multi-file-source.yaml new file mode 100644 index 0000000..682a8fb --- /dev/null +++ b/translations/content/fr/tooling/multi-file-source.yaml @@ -0,0 +1,18 @@ +--- +title: Lanceur de code source multi-fichiers +oldApproach: Tout compiler d'abord +modernApproach: Lanceur de code source +summary: Lancez des programmes multi-fichiers sans étape de compilation explicite. +explanation: "Java 22+ peut compiler automatiquement les fichiers source référencés lors du lancement depuis un fichier .java. Cela rend les petits programmes multi-fichiers aussi faciles à exécuter que des scripts, sans besoin de Maven ou Gradle." +whyModernWins: +- icon: 🚀 + title: Sans configuration + desc: Aucun outil de build nécessaire pour les petits programmes multi-fichiers. +- icon: 🔗 + title: Résolution automatique + desc: Les classes référencées sont trouvées et compilées automatiquement. +- icon: 📝 + title: Comme un script + desc: Exécutez des programmes multi-fichiers comme des scripts. +support: + description: Disponible depuis JDK 22 (mars 2024) diff --git a/translations/content/fr/tooling/single-file-execution.yaml b/translations/content/fr/tooling/single-file-execution.yaml new file mode 100644 index 0000000..a332620 --- /dev/null +++ b/translations/content/fr/tooling/single-file-execution.yaml @@ -0,0 +1,18 @@ +--- +title: Exécution d'un fichier unique +oldApproach: Compilation en deux étapes +modernApproach: Lancement direct +summary: Exécutez des programmes Java à fichier unique directement sans javac. +explanation: "Le lanceur Java peut compiler et exécuter un fichier source unique en une seule commande. Combiné avec le support shebang sous Unix, les fichiers Java peuvent fonctionner comme des scripts. Aucune étape de compilation séparée n'est nécessaire." +whyModernWins: +- icon: ⚡ + title: Une seule commande + desc: java Fichier.java compile et exécute en une seule étape. +- icon: 📝 + title: Comme un script + desc: Ajoutez une ligne shebang pour rendre les fichiers .java exécutables comme des scripts. +- icon: 🎓 + title: Convivial pour l'apprentissage + desc: Les débutants exécutent du code immédiatement sans apprendre les outils de build. +support: + description: Disponible depuis JDK 11 (sept. 2018) diff --git a/translations/strings/fr.yaml b/translations/strings/fr.yaml new file mode 100644 index 0000000..e664bc7 --- /dev/null +++ b/translations/strings/fr.yaml @@ -0,0 +1,83 @@ +site: + title: java.evolved + tagline: Java a évolué. Votre code aussi peut. + tagline_line1: Java a évolué. + tagline_line2: Votre code aussi peut. + description: Une collection de snippets Java modernes. Chaque ancien pattern Java + à côté de son remplacement moderne et propre — côte à côte. + heroSnippetCount: ✦ {{snippetCount}} patterns modernes · Java 8 → Java 25 + heroOld: Ancien + heroModern: Moderne + allComparisons: Toutes les comparaisons + snippetsBadge: '{{snippetCount}} snippets' +nav: + allPatterns: ← Tous les patterns + toggleTheme: Changer le thème + viewOnGitHub: Voir sur GitHub + selectLanguage: Sélectionner la langue +breadcrumb: + home: Accueil +sections: + codeComparison: Comparaison de Code + whyModernWins: Pourquoi la méthode moderne gagne + oldApproach: Ancienne Approche + modernApproach: Approche Moderne + sinceJdk: Depuis JDK + difficulty: Difficulté + jdkSupport: Support JDK + howItWorks: Comment ça fonctionne + relatedDocs: Documentation Associée + relatedPatterns: Patterns associés +filters: + show: 'Afficher :' + all: Tous +difficulty: + beginner: Débutant + intermediate: Intermédiaire + advanced: Avancé +search: + placeholder: Rechercher des snippets… + noResults: Aucun résultat trouvé. + esc: ESC + searchTrigger: Rechercher… + navigate: naviguer + open: ouvrir + close: fermer +cards: + old: Ancien + modern: Moderne + hoverHint: survolez pour voir le moderne → + hoverHintRelated: Survolez pour voir le moderne ➜ + touchHint: 👆 appuyez ou glissez → +copy: + copy: Copier + copied: Copié ! +share: + label: Partager +view: + expandAll: Tout développer + collapseAll: Tout réduire +stats: + modernPatterns: Patterns Modernes + jdkVersions: Versions JDK Couvertes + categories: Catégories + linesOfPython: Lignes de Python Requises +footer: + tagline: Java a évolué. Votre code aussi peut. + madeWith: Fait avec ❤️ par + and: et + inspiredBy: Inspiré par + viewOnGitHub: Voir sur GitHub +copilot: + headline: Modernisez votre code Java avec GitHub Copilot. + description: Laissez Copilot vous aider à migrer les patterns legacy vers Java moderne + — automatiquement. + appModernization: Modernisation d'App → + javaGuide: Guide Java → +support: + available: Disponible + preview: Aperçu + experimental: Expérimental +untranslated: + notice: Cette page n'a pas encore été traduite en {{localeName}}. + viewInEnglish: Voir en Anglais