Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

French translation of chapter 7 and 8 of lesson 1 #69

Closed
wants to merge 3 commits into from
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 30 additions & 0 deletions fr/1/external_internal_functions.md
Original file line number Diff line number Diff line change
@@ -1,5 +1,35 @@
<!-- Add translation for the following page: https://vyper.fun/#/1/external_internal_functions
Do NOT change the code below. The below code runs the code editor -->
# Chapitre 8: Fonctions Interne / Externe

Comme nous avons vu dans le dernier chapitre, toutes les fonctions doivent inclure un décorateur de visibilité (`@external` ou `@internal`).

| Décorateur | Description |
| ----------- | --------------------------------------------------------- |
| `@external` | Fonction qui peut être appelée qu'à l'extérieur |
| `@internal` | Fonction qui peut être appelée que dans le contrat actuel |

Nous voudrions créer certaines fonctions qui ne devraient pas être appelées extérieurement. Pour ces fonctions, nous utiliserions le décorateur de visibilité `@internal`.

Voyons comment déclarer une fonction interne :

```vyper
peopleToAge: HashMap[String[64], uint256]

@internal
def _addPerson(_name: String[64], _age: uint256):
self.peopleToAge[_name] = [_age]
```

Ceci signifie que seules les fonctions qui sont dans notre contrat actuel pourront appeler la fonction `_addPerson` et l'ajouter au mappage `peopleToAge`.

Notez que le tiret bas (`_`) au début du nom de la fonction et des paramètres. Il s'agit d'une convention de dénomination d'ajouter un tiret bas (`_`) devant le nom d'une fonction interne et leurs paramètres.

## Faisons le test

Notre fonction `createPokemon` dans notre contrat est actuellement externe — ça signifie que tout le monde peut l'appeler et créer un nouveau Pokémon dans notre contrat! rendons la interne.

1. Modifiez `createPokemon` pour qu'elle devienne une fonction interne. N'oubliez pas la convention de dénomination!

<!-- tabs:start -->

Expand Down
70 changes: 70 additions & 0 deletions fr/1/working_with_structs.md
Original file line number Diff line number Diff line change
@@ -1,5 +1,75 @@
<!-- Add translation for the following page: https://vyper.fun/#/1/working_with_structs
Do NOT change the code below. The below code runs the code editor -->
# Chapitre 7: Travailler avec les Structures et les Mappages.

Vous souvenez vous de la structure `Person` de l'exemple précédent ?
```vyper
struct Person:
age: uint256
name: String[64]

people: HashMap[uint256, Person]
```

Maintenant nous allons apprendre comment créer un nouveau `Persons` et l'ajouter au mappage `people`.

```vyper
// create a New Person:
Person vasa = Person({ name: "vasa", age: 22 })

// Add that person to the mapping with key `0`:
self.people[0] = vasa
```

Nous pouvons aussi les combiner ensemble et les faire en une seule ligne de code pour garder les choses propres :

```vyper
self.people[0] = Person({ name: "vasa", age: 22 })
```

## La variable `self`

Notez que nous avons utilisé le mot-clé `self` pour accéder à la variable (d'état) `people`.

La variable `self` est une variable d'environnement utilisé pour référencer un contrat de l'intérieur. `self` nous permet de **lire et écrire une variable d'état** et **appeler la fonction privée (interne) de notre contrat**. Nous allons apprendre les fonctions externes/internes dans le chapitre suivant.

`self` est utilisé pour accéder les variables d'état d'un contrat, comme dans l'exemple suivant :

```vyper
message: String[10]

@external
def setMessage(msg: String[10]):
self.message = msg
```

`self` est aussi utilisé pour appeler une fonction interne dans un contrat.

```vyper
@internal
def multiplyByTwo(amount: uint256):
amount * 2

@external
def calculate(amount: uint256):
self.multiplyByTwo(amount)
```

## Faisons le test

Faisons en sorte que notre fonction `createPokemon` fasse quelque chose !

1. Supprime le mot-clé `pass`. Remplis le corps de la fonction pour qu'elle crée un nouveau `Pokemon`, et l'ajoute au mappage `pokemonList`. Utilisez les valeurs suivantes pour notre nouveau `Pokemon`.

- `name`: nom (depuis les arguments de la fonction),
- `dna`: ADN (depuis les arguments de la fonction),
- `HP`: PV (depuis les arguments de la fonction),
- `matches`: 0,
- `wins`: 0

2. Ne pas oublier d'utiliser la variable d'environnement `self` pour accéder au mappage `pokemonList`.

3. Faisons le en une seule ligne de code pour garder les choses propres.

<!-- tabs:start -->

Expand Down