From bf332fa8f987ad890ef23ae999c346819608ca87 Mon Sep 17 00:00:00 2001 From: mk360 Date: Thu, 21 Apr 2022 01:56:25 +0200 Subject: [PATCH 1/3] create file --- .../get-started/TS for the New Programmer.md | 194 ++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 docs/documentation/fr/get-started/TS for the New Programmer.md diff --git a/docs/documentation/fr/get-started/TS for the New Programmer.md b/docs/documentation/fr/get-started/TS for the New Programmer.md new file mode 100644 index 00000000..052ce4e0 --- /dev/null +++ b/docs/documentation/fr/get-started/TS for the New Programmer.md @@ -0,0 +1,194 @@ +--- +title: TypeScript for the New Programmer +short: TS for the New Programmer +layout: docs +permalink: /fr/docs/handbook/typescript-from-scratch.html +oneline: Learn TypeScript from scratch +--- + +Congratulations on choosing TypeScript as one of your first languages — you're already making good decisions! + +You've probably already heard that TypeScript is a "flavor" or "variant" of JavaScript. +The relationship between TypeScript (TS) and JavaScript (JS) is rather unique among modern programming languages, so learning more about this relationship will help you understand how TypeScript adds to JavaScript. + +## What is JavaScript? A Brief History + +JavaScript (also known as ECMAScript) started its life as a simple scripting language for browsers. +At the time it was invented, it was expected to be used for short snippets of code embedded in a web page — writing more than a few dozen lines of code would have been somewhat unusual. +Due to this, early web browsers executed such code pretty slowly. +Over time, though, JS became more and more popular, and web developers started using it to create interactive experiences. + +Web browser developers responded to this increased JS usage by optimizing their execution engines (dynamic compilation) and extending what could be done with it (adding APIs), which in turn made web developers use it even more. +On modern websites, your browser is frequently running applications that span hundreds of thousands of lines of code. +This is long and gradual growth of "the web", starting as a simple network of static pages, and evolving into a platform for rich _applications_ of all kinds. + +More than this, JS has become popular enough to be used outside the context of browsers, such as implementing JS servers using node.js. +The "run anywhere" nature of JS makes it an attractive choice for cross-platform development. +There are many developers these days that use _only_ JavaScript to program their entire stack! + +To summarize, we have a language that was designed for quick uses, and then grew to a full-fledged tool to write applications with millions of lines. +Every language has its own _quirks_ — oddities and surprises, and JavaScript's humble beginning makes it have _many_ of these. Some examples: + +- JavaScript's equality operator (`==`) _coerces_ its arguments, leading to unexpected behavior: + + ```js + if ("" == 0) { + // It is! But why?? + } + if (1 < x < 3) { + // True for *any* value of x! + } + ``` + +- JavaScript also allows accessing properties which aren't present: + + ```js + const obj = { width: 10, height: 15 }; + // Why is this NaN? Spelling is hard! + const area = obj.width * obj.heigth; + ``` + +Most programming languages would throw an error when these sorts of errors occur, some would do so during compilation — before any code is running. +When writing small programs, such quirks are annoying but manageable; when writing applications with hundreds or thousands of lines of code, these constant surprises are a serious problem. + +## TypeScript: A Static Type Checker + +We said earlier that some languages wouldn't allow those buggy programs to run at all. +Detecting errors in code without running it is referred to as _static checking_. +Determining what's an error and what's not based on the kinds of values being operated on is known as static _type_ checking. + +TypeScript checks a program for errors before execution, and does so based on the _kinds of values_, it's a _static type checker_. +For example, the last example above has an error because of the _type_ of `obj`. +Here's the error TypeScript found: + +```ts twoslash +// @errors: 2551 +const obj = { width: 10, height: 15 }; +const area = obj.width * obj.heigth; +``` + +### A Typed Superset of JavaScript + +How does TypeScript relate to JavaScript, though? + +#### Syntax + +TypeScript is a language that is a _superset_ of JavaScript: JS syntax is therefore legal TS. +Syntax refers to the way we write text to form a program. +For example, this code has a _syntax_ error because it's missing a `)`: + +```ts twoslash +// @errors: 1005 +let a = (4 +``` + +TypeScript doesn't consider any JavaScript code to be an error because of its syntax. +This means you can take any working JavaScript code and put it in a TypeScript file without worrying about exactly how it is written. + +#### Types + +However, TypeScript is a _typed_ superset, meaning that it adds rules about how different kinds of values can be used. +The earlier error about `obj.heigth` was not a _syntax_ error: it is an error of using some kind of value (a _type_) in an incorrect way. + +As another example, this is JavaScript code that you can run in your browser, and it _will_ log a value: + +```js +console.log(4 / []); +``` + +This syntactically-legal program logs `Infinity`. +TypeScript, though, considers division of number by an array to be a nonsensical operation, and will issue an error: + +```ts twoslash +// @errors: 2363 +console.log(4 / []); +``` + +It's possible you really _did_ intend to divide a number by an array, perhaps just to see what happens, but most of the time, though, this is a programming mistake. +TypeScript's type checker is designed to allow correct programs through while still catching as many common errors as possible. +(Later, we'll learn about settings you can use to configure how strictly TypeScript checks your code.) + +If you move some code from a JavaScript file to a TypeScript file, you might see _type errors_ depending on how the code is written. +These may be legitimate problems with the code, or TypeScript being overly conservative. +Throughout this guide we'll demonstrate how to add various TypeScript syntax to eliminate such errors. + +#### Runtime Behavior + +TypeScript is also a programming language that preserves the _runtime behavior_ of JavaScript. +For example, dividing by zero in JavaScript produces `Infinity` instead of throwing a runtime exception. +As a principle, TypeScript **never** changes the runtime behavior of JavaScript code. + +This means that if you move code from JavaScript to TypeScript, it is **guaranteed** to run the same way, even if TypeScript thinks that the code has type errors. + +Keeping the same runtime behavior as JavaScript is a foundational promise of TypeScript because it means you can easily transition between the two languages without worrying about subtle differences that might make your program stop working. + + + +#### Erased Types + +Roughly speaking, once TypeScript's compiler is done with checking your code, it _erases_ the types to produce the resulting "compiled" code. +This means that once your code is compiled, the resulting plain JS code has no type information. + +This also means that TypeScript never changes the _behavior_ of your program based on the types it inferred. +The bottom line is that while you might see type errors during compilation, the type system itself has no bearing on how your program works when it runs. + +Finally, TypeScript doesn't provide any additional runtime libraries. +Your programs will use the same standard library (or external libraries) as JavaScript programs, so there's no additional TypeScript-specific framework to learn. + + + +## Learning JavaScript and TypeScript + +We frequently see the question "Should I learn JavaScript or TypeScript?". + +The answer is that you can't learn TypeScript without learning JavaScript! +TypeScript shares syntax and runtime behavior with JavaScript, so anything you learn about JavaScript is helping you learn TypeScript at the same time. + +There are many, many resources available for programmers to learn JavaScript; you should _not_ ignore these resources if you're writing TypeScript. +For example, there are about 20 times more StackOverflow questions tagged `javascript` than `typescript`, but _all_ of the `javascript` questions also apply to TypeScript. + +If you find yourself searching for something like "how to sort a list in TypeScript", remember: **TypeScript is JavaScript's runtime with a compile-time type checker**. +The way you sort a list in TypeScript is the same way you do so in JavaScript. +If you find a resource that uses TypeScript directly, that's great too, but don't limit yourself to thinking you need TypeScript-specific answers for everyday questions about how to accomplish runtime tasks. + +## Next Steps + +This was a brief overview of the syntax and tools used in everyday TypeScript. From here, you can: + +- Learn some of the JavaScript fundamentals, we recommend either: + + - [Microsoft's JavaScript Resources](https://docs.microsoft.com/javascript/) or + - [JavaScript guide at the Mozilla Web Docs](https://developer.mozilla.org/docs/Web/JavaScript/Guide) + +- Continue to [TypeScript for JavaScript Programmers](/docs/handbook/typescript-in-5-minutes.html) +- Read the full Handbook [from start to finish](/docs/handbook/intro.html) (30m) +- Explore the [Playground examples](/play#show-examples) + + + From f270ea16c8b76cfab5d3507d859e8f9fc9df7ff9 Mon Sep 17 00:00:00 2001 From: mk360 Date: Sun, 24 Apr 2022 22:33:27 +0200 Subject: [PATCH 2/3] translate ts for new programmers --- .../get-started/TS for the New Programmer.md | 160 +++++++++--------- 1 file changed, 79 insertions(+), 81 deletions(-) diff --git a/docs/documentation/fr/get-started/TS for the New Programmer.md b/docs/documentation/fr/get-started/TS for the New Programmer.md index 052ce4e0..6a390c8b 100644 --- a/docs/documentation/fr/get-started/TS for the New Programmer.md +++ b/docs/documentation/fr/get-started/TS for the New Programmer.md @@ -1,65 +1,63 @@ --- -title: TypeScript for the New Programmer -short: TS for the New Programmer +title: TypeScript pour les nouveaux programmeurs +short: TS pour les nouveaux programmeurs layout: docs permalink: /fr/docs/handbook/typescript-from-scratch.html oneline: Learn TypeScript from scratch --- -Congratulations on choosing TypeScript as one of your first languages — you're already making good decisions! +Félicitations, vous avez choisi TypeScript comme premier langage — déjà une bonne décision ! -You've probably already heard that TypeScript is a "flavor" or "variant" of JavaScript. -The relationship between TypeScript (TS) and JavaScript (JS) is rather unique among modern programming languages, so learning more about this relationship will help you understand how TypeScript adds to JavaScript. +Vous avez peut-être déjà entendu dire que TypeScript est une "variante" de JavaScript. +La relation entre les deux est unique parmi les langages de programmation existants, et étudier cette relation vous permettra de comprendre ce qu'ajoute TypeScript à JavaScript. -## What is JavaScript? A Brief History +## Bref historique de JavaScript -JavaScript (also known as ECMAScript) started its life as a simple scripting language for browsers. -At the time it was invented, it was expected to be used for short snippets of code embedded in a web page — writing more than a few dozen lines of code would have been somewhat unusual. -Due to this, early web browsers executed such code pretty slowly. -Over time, though, JS became more and more popular, and web developers started using it to create interactive experiences. +JavaScript (aussi connu sous le nom ECMAScript) était à l'origine un simple langage de scripting pour navigateurs. +Quand il fut inventé, il était utilisé pour de petits extraits de code dans une page web — aller au-delà d'une douzaine de ligne était inhabituel. +De ce fait, les navigateurs exécutaient du code JS assez lentement. +Cependant, la popularité de JavaScript grandira avec le temps, et les développeurs web ont commencé à s'en servir pour créer des expériences interactives. -Web browser developers responded to this increased JS usage by optimizing their execution engines (dynamic compilation) and extending what could be done with it (adding APIs), which in turn made web developers use it even more. -On modern websites, your browser is frequently running applications that span hundreds of thousands of lines of code. -This is long and gradual growth of "the web", starting as a simple network of static pages, and evolving into a platform for rich _applications_ of all kinds. +Les développeurs de navigateurs Web répondirent à cette croissance de fréquence d'usage en optimisant les environnements d'exécution (compilation dynamique) et en élargissant le champ du possible avec JS (en ajoutant des APIs). Cela contribua à un usage encore plus répandu parmi les développeurs web. +Un site web moderne, de nos jours, contient des centaines de milliers de lignes de code. Ceci est en phase avec la façon dont le web a grandi, partant d'un simple ensemble de pages statiques, pour devenir une plateforme d'applications riches pour tout et sur tout. -More than this, JS has become popular enough to be used outside the context of browsers, such as implementing JS servers using node.js. -The "run anywhere" nature of JS makes it an attractive choice for cross-platform development. -There are many developers these days that use _only_ JavaScript to program their entire stack! +De plus, le JS est devenu assez populaire pour être utilisé en dehors de navigateurs, Node.js ayant marqué l'implémentation de JS dans un environnement côté serveur. +Cette capacité à s'exécuter partout a rendu du langage un choix populaire pour le développement d'applications cross-platform. +Il y a beaucoup de développeurs dont le stack technique n'est constitué que de JavaScript ! -To summarize, we have a language that was designed for quick uses, and then grew to a full-fledged tool to write applications with millions of lines. -Every language has its own _quirks_ — oddities and surprises, and JavaScript's humble beginning makes it have _many_ of these. Some examples: +Pour résumer, ce langage a été créé à l'origine pour répondre à des besoins simples, puis a évolué pour supporter l'exécution de millions de lignes. +Chaque langage a ses propres points bizarres et surprises, le JS ne faisant pas exception dû à ses débuts : -- JavaScript's equality operator (`==`) _coerces_ its arguments, leading to unexpected behavior: +- L'opérateur d'égalité (`==`) _convertit_ ses arguments, conduisant à un comportement bizarre : ```js if ("" == 0) { - // It is! But why?? + // C'est vrai, mais pourquoi ? } if (1 < x < 3) { - // True for *any* value of x! + // C'est vrai peu importe la valeur de x ! } ``` -- JavaScript also allows accessing properties which aren't present: +- JavaScript permet l'accès à des propriétés inexistantes : ```js const obj = { width: 10, height: 15 }; - // Why is this NaN? Spelling is hard! const area = obj.width * obj.heigth; + // Bonne chance pour savoir pourquoi "area" est égale à NaN ``` -Most programming languages would throw an error when these sorts of errors occur, some would do so during compilation — before any code is running. -When writing small programs, such quirks are annoying but manageable; when writing applications with hundreds or thousands of lines of code, these constant surprises are a serious problem. +La plupart des langages lanceraient une erreur lors de ces situations. Certains le font à la compilation — avant l'exécution de quoi que ce soit. +Cette absence d'erreurs et ses mauvaises surprises sont gérables pour de petits programmes, mais beaucoup moins à l'échelle d'une grande application. -## TypeScript: A Static Type Checker +## TypeScript : un vérificateur statique de types -We said earlier that some languages wouldn't allow those buggy programs to run at all. -Detecting errors in code without running it is referred to as _static checking_. -Determining what's an error and what's not based on the kinds of values being operated on is known as static _type_ checking. +Nous disions que certains langages interdiraient l'exécution de code erroné. +La détection d'erreurs dans le code sans le lancer s'appelle la _vérification statique_. +La distinction entre ce qui est une erreur de ce qui ne l'est pas, en partant des valeurs avec lesquelles on travaille, s'appelle la vérification statique de types. -TypeScript checks a program for errors before execution, and does so based on the _kinds of values_, it's a _static type checker_. -For example, the last example above has an error because of the _type_ of `obj`. -Here's the error TypeScript found: +TypeScript vérifie les erreurs d'un programme avant l'exécution, et fait cela en se basant sur les _types de valeurs_, c'est un _vérificateur statique_. +Par exemple, l'exemple ci-dessus avait une erreur à cause du _type_ d'`obj` : ```ts twoslash // @errors: 2551 @@ -67,60 +65,60 @@ const obj = { width: 10, height: 15 }; const area = obj.width * obj.heigth; ``` -### A Typed Superset of JavaScript +### Une surcouche typée de JavaScript -How does TypeScript relate to JavaScript, though? +Quel est le rapport entre JavaScript et TypeScript ? -#### Syntax +#### Syntaxe -TypeScript is a language that is a _superset_ of JavaScript: JS syntax is therefore legal TS. -Syntax refers to the way we write text to form a program. -For example, this code has a _syntax_ error because it's missing a `)`: +TypeScript est une _surcouche_ de JavaScript : une syntaxe JS légale est donc une syntaxe TS légale. +La syntaxe définit la façon dont on écrit un programme. +Par exemple, ce code has une erreur de _syntaxe_ parce qu'il manque un `)` : ```ts twoslash // @errors: 1005 let a = (4 ``` -TypeScript doesn't consider any JavaScript code to be an error because of its syntax. -This means you can take any working JavaScript code and put it in a TypeScript file without worrying about exactly how it is written. +TypeScript ne considère pas forcément du code JavaScript comme du code invalide. +Cela signifie que vous pouvez prendre du code JavaScript fonctionnel et le mettre dans un fichier TypeScript sans vous inquiéter de comment il est écrit exactement. #### Types -However, TypeScript is a _typed_ superset, meaning that it adds rules about how different kinds of values can be used. -The earlier error about `obj.heigth` was not a _syntax_ error: it is an error of using some kind of value (a _type_) in an incorrect way. +Cependant, TypeScript est une surcouche _typée_. Cela veut dire que TS ajoute des règles régissant comment différents types de valeurs peuvent être utilisés. +L'erreur à propos de `obj.heigth` n'est pas une erreur de _syntaxe_ : c'est une erreur où l'on a utilisé une sorte de valeur (un _type_) de façon incorrecte. -As another example, this is JavaScript code that you can run in your browser, and it _will_ log a value: +Autre exemple, ce code JavaScript que vous pouvez lancez dans votre navigateur. Il _va_ afficher une valeur : ```js console.log(4 / []); ``` -This syntactically-legal program logs `Infinity`. -TypeScript, though, considers division of number by an array to be a nonsensical operation, and will issue an error: +Ce programme - dont la syntaxe est correcte - affiche `Infinity`. +Mais TypeScript considère que la division d'un nombre par un tableau ne fait pas sens, et va lancer une erreur : ```ts twoslash // @errors: 2363 console.log(4 / []); ``` -It's possible you really _did_ intend to divide a number by an array, perhaps just to see what happens, but most of the time, though, this is a programming mistake. -TypeScript's type checker is designed to allow correct programs through while still catching as many common errors as possible. -(Later, we'll learn about settings you can use to configure how strictly TypeScript checks your code.) +Il se peut que vous vouliez _vraiment_ diviser un nombre par un tableau, peut-être juste pour voir le résultat, mais la plupart du temps, vous avez fait une erreur. +Le vérificateur de types de TS est conçu pour accepter les programmes valides, tout en signalant le plus d'erreurs communes possibles. +(Nous apprendrons plus tard divers paramètres pour contrôler à quel point vous voulez que TS soit strict avec votre code.) -If you move some code from a JavaScript file to a TypeScript file, you might see _type errors_ depending on how the code is written. -These may be legitimate problems with the code, or TypeScript being overly conservative. -Throughout this guide we'll demonstrate how to add various TypeScript syntax to eliminate such errors. +En migrant du code JavaScript vers un fichier TypeScript, il se peut que vous voyiez des _erreurs de type_ en fonction de la façon avec laquelle il a été écrit. +Il se peut qu'il y ait de vrais problèmes avec votre code, tout comme il se peut que TypeScript soit trop strict. +À travers ce guide, nous montrerons comment ajouter de la syntaxe TypeScript pour éliminer ces erreurs. -#### Runtime Behavior +#### Comportement à l'exécution -TypeScript is also a programming language that preserves the _runtime behavior_ of JavaScript. -For example, dividing by zero in JavaScript produces `Infinity` instead of throwing a runtime exception. -As a principle, TypeScript **never** changes the runtime behavior of JavaScript code. +TypeScript est aussi un langage qui préserve le _comportement à l'exécution_ de JavaScript. +Par exemple, la division par 0 produit `Infinity` au lieu de lancer une erreur. +TypeScript, par principe, ne change **jamais** le comportement de code JS. -This means that if you move code from JavaScript to TypeScript, it is **guaranteed** to run the same way, even if TypeScript thinks that the code has type errors. +Cela veut dire que si vous déplacez du code de JavaScript à TypeScript, il est **garanti** de s'exécuter de la même façon, même si TS pense qu'il comporte des erreurs liées aux types. -Keeping the same runtime behavior as JavaScript is a foundational promise of TypeScript because it means you can easily transition between the two languages without worrying about subtle differences that might make your program stop working. +La conservation du comportement à l'exécution est l'un des principes fondamentaux de TypeScript parce que cela signifie que vous pouvez facilement alterner entre les deux langages sans vous inquiéter de différences subtiles qui empêcheraient votre programme de se lancer. -#### Erased Types +#### Effacement de types -Roughly speaking, once TypeScript's compiler is done with checking your code, it _erases_ the types to produce the resulting "compiled" code. -This means that once your code is compiled, the resulting plain JS code has no type information. +Grossièrement, une fois que le compilateur de TypeScript a fini de vérifier le code, il _efface_ les types pour laisser le code résultant. +Cela signifie qu'à la fin du processus de compilation, le code JS ne conserve aucune information de types. -This also means that TypeScript never changes the _behavior_ of your program based on the types it inferred. -The bottom line is that while you might see type errors during compilation, the type system itself has no bearing on how your program works when it runs. +Cela signifie aussi que TypeScript, en se basant sur les types présents dans le code, n'altère jamais le _comportement_ du programme. -Finally, TypeScript doesn't provide any additional runtime libraries. -Your programs will use the same standard library (or external libraries) as JavaScript programs, so there's no additional TypeScript-specific framework to learn. +Pour résumer, même si vous pouvez avoir des erreurs de type lors de la compilation, le système de types n'affecte aucunement la façon dont votre programme s'exécute. + +Enfin, TypeScript ne fournit aucune librairie supplémentaire. +Vos programmes utiliseront les mêmes librairies standard ou externes que vos programmes JS, il n'y a donc aucun framework additionnel à apprendre au niveau de TS. + +Il est intéressant de noter qu'il est possible de préciser la version de JavaScript que TypeScript doit cibler lors de la compilation. Cela affecte le code final, qui contiendra ou non des _polyfills_ (du code qui redéfinit des fonctionnalités existantes dans une version de JavaScript mais absentes dans une autre). -## Learning JavaScript and TypeScript +## Apprendre JavaScript et TypeScript -We frequently see the question "Should I learn JavaScript or TypeScript?". +Une question souvent posée est "Est-ce que je dois apprendre TypeScript ou JavaScript", à laquelle on répond qu'il n'est pas possible d'apprendre le TS sans apprendre le JS. -The answer is that you can't learn TypeScript without learning JavaScript! -TypeScript shares syntax and runtime behavior with JavaScript, so anything you learn about JavaScript is helping you learn TypeScript at the same time. +TypeScript possède la même syntaxe, et se comporte de la même façon que JavaScript, donc vous pourrez utiliser tout ce que vous apprenez avec JavaScript, dans TypeScript. -There are many, many resources available for programmers to learn JavaScript; you should _not_ ignore these resources if you're writing TypeScript. -For example, there are about 20 times more StackOverflow questions tagged `javascript` than `typescript`, but _all_ of the `javascript` questions also apply to TypeScript. +Il y a beaucoup, _beaucoup_ de ressources disponibles pour apprendre le JavaScript. Ces ressources ne doivent pas être ignorées si vous voulez apprendre TypeScript. Par exemple, il y a à peu près 20 fois plus de questions StackOverflow taggées `javascript` que `typescript`, mais toutes les questions `javascript` s'appliquent aussi à TypeScript. -If you find yourself searching for something like "how to sort a list in TypeScript", remember: **TypeScript is JavaScript's runtime with a compile-time type checker**. -The way you sort a list in TypeScript is the same way you do so in JavaScript. -If you find a resource that uses TypeScript directly, that's great too, but don't limit yourself to thinking you need TypeScript-specific answers for everyday questions about how to accomplish runtime tasks. +Si vous recherchez quelque chose comme "comment trier un tableau en TypeScript", souvenez-vous : **TypeScript est du JavaScript avec un vérificateur de types à la compilation**. La façon dont vous triez un tableau en JavaScript est la même qu'en TypeScript. +Si vous trouvez une ressource qui utilise TypeScript, ce n'est pas plus mal, mais ne croyez pas que vous avez besoin de réponses spécifiques à TS pour des tâches JS de tous les jours. -## Next Steps +## Prochaines étapes -This was a brief overview of the syntax and tools used in everyday TypeScript. From here, you can: +C'était un bref résumé des syntaxes et outils utilisés dans le TypeScript de tous les jours. À partir de là, vous pourrez : -- Learn some of the JavaScript fundamentals, we recommend either: +- Apprendre des fondamentaux de TypeScript. Nous recommandons : - - [Microsoft's JavaScript Resources](https://docs.microsoft.com/javascript/) or - - [JavaScript guide at the Mozilla Web Docs](https://developer.mozilla.org/docs/Web/JavaScript/Guide) + - [Les ressources JavaScript de Microsoft](https://docs.microsoft.com/javascript/) or + - [Le guide JavaScript dans les Mozilla Web Docs](https://developer.mozilla.org/docs/Web/JavaScript/Guide) -- Continue to [TypeScript for JavaScript Programmers](/docs/handbook/typescript-in-5-minutes.html) -- Read the full Handbook [from start to finish](/docs/handbook/intro.html) (30m) -- Explore the [Playground examples](/play#show-examples) +- Continuer vers la page [TypeScript pour les développeurs JavaScript](/docs/handbook/typescript-in-5-minutes.html) +- Lire le Manuel [du début à la fin](/docs/handbook/intro.html) (30m) +- Explorer les [exemples du bac à sable](/play#show-examples)