added French concept-aliases.md, concept-autoloading.md and concept-c…

…onfigurations.md [skip ci]

docs/guide-fr/concept-aliases.md

@@ -1,14 +1,14 @@
-Les Alias
-=========
-Les alias sont utilisés pour représenter des chemins de fichier ou des URLs de sorte que vous n'ayez pas à spécifier des chemins ou des URLs explicitement dans votre projet. Un alias doit commencer par le caractère `@` de façon à le différencier des chemins de fichiers habituels et des URLs. Les alias définis sans le caractère de tête `@` seront préfixés avec ce caractère `@`. 
-Yii dispose déjà d'un nombre important d'alias prédéfinis. Par exemple, l'alias `@yii` représente le chemin d'installation du *framework* Yii; `@web` représente l'URL de base pour l'application web courante. 
+Alias
+=====
 
+Les alias sont utilisés  pour représenter des chemins de fichier ou des URL de façon à ce que vous n'ayez pas besoin d'écrire ces chemins ou ces URL en entier dans votre code. Un alias doit commencer par le caractère arobase `@` pour être différentié des chemins de fichier et des URL normaux. Les alias définis sans ce caractère de tête `@` sont automatiquement préfixé avec ce dernier.
 
+Yii possèdent de nombreux alias pré-définis déjà disponibles. Par exemple, l'alias `@yii` représente le chemin d'installation de la base structurée de développement PHP (*framework*), Yii ; L'alias `@web` représente l'URL de base de l'application Web en cours d'exécution.
 
-Définir des alias <span id="defining-aliases"></span>
------------------
+Définition des alias <span id="defining-aliases"></span>
+--------------------
 
-Vous pouvez définir un alias soit pour un chemin de fichier ou pour une URL en appelant [[Yii::setAlias()]]:
+Vous pouvez définir un alias pour un chemin de fichier ou pour une URL en appelant [[Yii::setAlias()]]:
 
 ```php
 // un alias pour un chemin de fichier
@@ -17,58 +17,62 @@ Yii::setAlias('@foo', '/path/to/foo');
 // un alias pour une URL
 Yii::setAlias('@bar', 'http://www.example.com');
 ```
-> Note: le chemin de fichier ou l'URL cible de l'alias *ne* doit *pas* nécessairement référencer un fichier ou une ressource existante.
 
-Étant donné un alias défini, il est possible de faire dériver un nouvel alias (sans appeler la commande [[Yii::setAlias()]]) en ajoutant une barre oblique `/` suivi d'un ou de plusieurs segments de chemin de fichier. Les alias définis via la commande [[Yii::setAlias()]] sont des *alias racines*, les alias qui en dérivent sont des *alias dérivés*. Par exemple, `@foo` est un alias racine, tandis que `@foo/bar/file.php` est un alias dérivé.
+> Note: le chemin de fichier ou l'URL pour qui un alias est créé peut *ne pas* nécessairement faire référence à un fichier ou une ressource existante.
+
+Étant donné un alias, vous pouvez dériver un autre alias – sans faire appel à [[Yii::setAlias()]]) – en y ajoutant une barre oblique de division `/` suivi d'un ou plusieurs segments de chemin. Les alias définis via [[Yii::setAlias()]] sont des *alias racines*, tandis que les alias qui en dérivent sont des *alias dérivés*. Par exemple, `@foo` est un alias racine, alors que `@foo/bar/file.php` est un alias dérivé.
 
-Il est possible de définir un alias en utilisant un autre alias (qu'il soit racine ou dérivé): 
+Vous pouvez définir un alias en utilisant un autre alias (qu'il soit racine ou dérivé) :
 
 ```php
 Yii::setAlias('@foobar', '@foo/bar');
 ```
 
-Les alias racines sont habituellement définis pendant l'étape d'[amorçage](runtime-bootstrapping.md). Vous pouvez par exemple appeler la commande [[Yii::setAlias()]] dans le [script d'entrée](structure-entry-scripts.md). Pour plus de commodité, l'objet [Application](structure-applications.md) propose une propriété modifiable appelée `aliases` que vous pouvez définir dans la [configuration](concept-configurations.md) de l'application:
+Les alias racines sont ordinairement définis pendant l'étape d'[amorçage](runtime-bootstrapping.md). Par exemple, vous pouvez appeler [[Yii::setAlias()]] dans le [script d'entrée](structure-entry-scripts.md). Pour commodité, la classe [Application](structure-applications.md) fournit une propriété nommée `aliases` que vous pouvez configurer dans la [configuration](concept-configurations.md) de l'application :
 
 ```php
 return [
     // ...
     'aliases' => [
-        '@foo' => '/chemin/vers/foo',
+        '@foo' => '/path/to/foo',
         '@bar' => 'http://www.example.com',
     ],
 ];
 ```
 
+
 Résolution des alias <span id="resolving-aliases"></span>
 --------------------
 
-Vous pouvez appeler la méthode [[Yii::getAlias()]] pour obtenir le chemin de fichier ou l'URL qu'un alias représente. La même méthode peut aussi convertir des alias dérivés dans leur chemin de fichier ou URL correspondants: 
+Vous pouvez appeler [[Yii::getAlias()]] pour résoudre un alias racine en le chemin de fichier ou l'URL qu'il représente. La même méthode peut aussi résoudre un alias dérivé en le chemin de fichier ou l'URL correspondant :
 
 ```php
-echo Yii::getAlias('@foo');               // displays: /path/to/foo
-echo Yii::getAlias('@bar');               // displays: http://www.example.com
-echo Yii::getAlias('@foo/bar/file.php');  // displays: /path/to/foo/bar/file.php
+echo Yii::getAlias('@foo');               // affiche : /path/to/foo
+echo Yii::getAlias('@bar');               // affiche : http://www.example.com
+echo Yii::getAlias('@foo/bar/file.php');  // affiche : /path/to/foo/bar/file.php
 ```
 
-Le chemin/URL représenté par un alias dérivé est déterminé en remplaçant la partie alias racine avec son chemin/URL correspondant dans l'alias dérivé.
-> Note: la méthode [[Yii::getAlias()]] ne vérifie pas si le chemin/URL obtenu représente un fichier ou une ressource existante.
+Le chemin ou l'URL que représente un alias dérivé est déterminé en remplaçant l'alias racine par le chemin ou l'URL qui lui correspond dans l'alias dérivé.
+
+> Note: la méthode [[Yii::getAlias()]] ne vérifie pas que le chemin ou l'URL qui en résulte fait référence à un fichier existant ou à une ressource existante.
 
-Un alias racine peut également contenir des barres obliques `/`. La méthode [[Yii::getAlias()]] est suffisamment intelligente pour déterminer quelle partie de l'alias est un alias racine et donc déterminer correctement le chemin de fichier ou l'url correspondant:
+
+Un alias racine peut également contenir des barres obliques de division `/`. La méthode [[Yii::getAlias()]] est suffisamment intelligente pour dire quelle partie d'un alias est un alias racine et, par conséquent, déterminer correctement le chemin de fichier ou l'URL qui correspond : 
 
 ```php
-Yii::setAlias('@foo', '/chemin/vers/foo');
-Yii::setAlias('@foo/bar', '/chemin2/bar');
-Yii::getAlias('@foo/test/file.php');  // affiche /chemin/vers/foo/test/file.php
-Yii::getAlias('@foo/bar/file.php');   // affiche /chemin2/bar/file.php
+Yii::setAlias('@foo', '/path/to/foo');
+Yii::setAlias('@foo/bar', '/path2/bar');
+Yii::getAlias('@foo/test/file.php');  // affiche : /path/to/foo/test/file.php
+Yii::getAlias('@foo/bar/file.php');   // affiche : /path2/bar/file.php
 ```
 
-Si `@foo/bar` n'était pas défini comme un alias racine, le dernier exemple afficherait  `/chemin/vers/foo/bar/file.php`.
+Si `@foo/bar` n'est pas défini en tant qu'alias racine, la dernière instruction affiche `/path/to/foo/bar/file.php`.
 
 
-Utilisation des  alias <span id="using-aliases"></span>
-----------------------
+Utilisation des alias <span id="using-aliases"></span>
+---------------------
 
-Les alias sont reconnus en de nombreux endroits de Yii sans avoir besoin d'appeler la méthode [[Yii::getAlias()]] pour les convertir en chemin ou URLs. A titre d'exemple, la méthode [[yii\caching\FileCache::cachePath]] accepte aussi bien un chemin de fichier et un alias représentant un chemin de fichier, grâce au préfixe `@` qui permet de différencier le chemin de fichier d'un alias. 
+Les alias sont reconnus en différents endroits dans Yii sans avoir besoin d'appeler [[Yii::getAlias()]] pour les convertir en chemin ou URL. Par exemple, [[yii\caching\FileCache::cachePath]] accepte soit un chemin de fichier, soit un alias représentant un chemin de fichier, grâce au préfixe `@` qui permet de différentier un chemin de fichier d'un alias.
 
 ```php
 use yii\caching\FileCache;
@@ -77,29 +81,32 @@ $cache = new FileCache([
     'cachePath' => '@runtime/cache',
 ]);
 ```
-Reportez-vous à la documentation de l'API pour vérifier si une propriété ou un paramètre d'une méthode accepte les alias.
+
+Reportez-vous à la documentation de l'API pour savoir si une propriété ou une méthode prend en charge les alias.
 
 
-Alias prédéfinis <span id="predefined-aliases"></span>
+Alias prédéfinis  <span id="predefined-aliases"></span>
 ----------------
-Yii définit une série d'alias pour faciliter le référencement des chemins de fichier et URLs souvent utilisés: 
 
-- `@yii`, le répertoire où se situe le fichier `BaseYii.php` (aussi appelé le répertoire framework).
-- `@app`, le [[yii\base\Application::basePath|chemin de base]] de l'application courante.
-- `@runtime`, le [[yii\base\Application::runtimePath|le chemin d'exécution]] de l'application courante. Valeur par défaut: `@app/runtime`.
-- `@webroot`, La répertoire web racine de l'application web courante.  Il est déterminé en se basant sur le répertoire contenant le [script d'entrée](structure-entry-scripts.md).
-- `@web`, l'url de base de l'application courante. Cet alias a la même valeur que la propriété [[yii\web\Request::baseUrl]].
-- `@vendor`, le [[yii\base\Application::vendorPath|Le répertoire vendor de Composer]]. Valeur par défaut: `@app/vendor`.
-- `@bower`, le répertoire racine qui contient [les paquets bower](http://bower.io/). Valeur par  défaut: `@vendor/bower`.
-- `@npm`, le répertoire racine qui contient [les paquets npm](https://www.npmjs.org/). Valeur par défaut: `@vendor/npm`.
+Yii prédéfinit un jeu d'alias pour faire référence à des chemin de fichier ou à des URL d'utilisation courante :
+
+- `@yii`, le dossier où le fichier `BaseYii.php` se trouve – aussi appelé dossier de la base structurée de développement PHP .
+- `@app`, le  [[yii\base\Application::basePath|chemin de base]] de l'application en cours d'exécution. 
+- `@runtime`, le [[yii\base\Application::runtimePath|chemin du dossier runtime]] de l'application en cours d'exécution. Valeur par défaut `@app/runtime`.
+- `@webroot`, le dossier Web racine de l'application en cours d'exécution. Il est déterminé en se basant sur le dossier qui contient le [script d'entrée](structure-entry-scripts.md).
+- `@web`, l'URL de base de l'application en cours d'exécution. Cet alias a la même valeur que  [[yii\web\Request::baseUrl]].
+- `@vendor`, le [[yii\base\Application::vendorPath|dossier vendor de Composer]]. Valeur par défaut `@app/vendor`.
+- `@bower`, le dossier racine des [paquets bower](http://bower.io/). Valeur par défaut `@vendor/bower`.
+- `@npm`, le dossier racine des [paquets npm](https://www.npmjs.org/). Valeur par défaut `@vendor/npm`.
+
+L'alias `@yii` est défini lorsque vous incluez le fichier `Yii.php` dans votre [script d'entrée](structure-entry-scripts.md). Les alias restants sont définis dans le constructeur de l'application au moment où la [configuration](concept-configurations.md) de l'application est appliquée.
+ .
 
-L'alias `@yii` est défini quand le fichier `Yii.php`est inclus dans votre [script d'entrée](structure-entry-scripts.md). Le reste des alias est défini dans le constructeur de l'application au moment ou la [configuration](concept-configurations.md) de cette dernière est appliquée.
 
 Alias d'extension <span id="extension-aliases"></span>
 -----------------
 
-Un alias est automatiquement défini pour chaque [extension](structure-extensions.md) installée via Composer.
-Chacun de ces alias est nommé par l'espace de noms (namespace) racine de l'extension tel que déclaré dans son fichier `composer.json`, et chacun pointe sur le répertoire racine du paquet. Par exemple, si vous installez l'extension `yiisoft/yii2-jui`, vous obtenez automatiquement un alias `@yii/jui` défini pendant la [phase d'amorçage](runtime-bootstrapping.md), équivalent à 
+Un alias est automatiquement défini par chacune des [extensions](structure-extensions.md) qui sont installées par Composer. Chaque alias est nommé d'après le nom de l'extension déclaré dans le fichier `composer.json`. Chaque alias représente le dossier racine du paquet. Par exemple, si vous installez l'extension `yiisoft/yii2-jui`, vous obtiendrez automatiquement l'alias `@yii/jui` défini durant l'étape d'[amorçage](runtime-bootstrapping.md), et équivalent à :
 
 ```php
 Yii::setAlias('@yii/jui', 'VendorPath/yiisoft/yii2-jui');

docs/guide-fr/concept-autoloading.md

@@ -0,0 +1,64 @@
+Chargement automatique des classes
+==================================
+
+Yii compte sur le [mécanisme de chargement automatique des classes](http://www.php.net/manual/en/language.oop5.autoload.php) pour localiser et inclure tous les fichiers de classes requis. Il fournit un chargeur automatique de classe de haute performance qui est conforme à la [norme PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md). Le chargeur automatique est installé lorsque vous incluez le fichier `Yii.php`.
+
+> Note: pour simplifier la description, dans cette section, nous ne parlerons que du chargement automatique des classes. Néanmoins, gardez présent à l'esprit que le contenu que nous décrivons ici s'applique aussi au chargement automatique des interfaces et des traits. 
+
+
+Utilisation du chargeur automatique de Yii <span id="using-yii-autoloader"></span>
+------------------------------------------
+
+Pour utiliser le chargeur automatique de classes de Yii, vous devez suivre deux règles simples lorsque vous créez et nommez vos classes :
+
+* Chaque classe doit être placée sous un [espace de noms](http://php.net/manual/en/language.namespaces.php) (p. ex. `foo\bar\MyClass`)
+* Chaque classe doit être sauvegardée sous forme d'un fichier individuel dont le chemin est déterminé par l'algorithme suivant : 
+
+```php
+// $className est un nom de classe pleinement qualifié sans la barre oblique inversée de tête
+$classFile = Yii::getAlias('@' . str_replace('\\', '/', $className) . '.php');
+```
+
+For exemple, si le nom de classe et l'espace de noms sont `foo\bar\MyClass`, l'[alias](concept-aliases.md) pour le chemin du fichier de classe correspondant est `@foo/bar/MyClass.php`. Pour que cet alias puisse être résolu en un chemin de fichier, soit `@foo`, soit `@foo/bar` doit être un [alias racine](concept-aliases.md#defining-aliases).
+
+Lorsque vous utilisez le [modèle de projet *Basic*](start-installation.md), vous pouvez placer vos classes sous l'espace de nom de niveau le plus haut `app` afin qu'elles puissent être chargées automatiquement par Yii sans avoir besoin de définir un nouvel alias. Cela est dû au fait que `@app` est un [alias prédéfini](concept-aliases.md#predefined-aliases), et qu'un nom de classe comme `app\components\MyClass` peut être résolu en le fichier de classe `AppBasePath/components/MyClass.php`, en appliquant l'algorithme précédemment décrit. 
+
+Dans le [modèle de projet avancé](https://github.com/yiisoft/yii2-app-advanced/blob/master/docs/guide/README.md), chaque niveau possède son propre alias. Par exemple, le niveau « interface utilisateur » a l'alias `@frontend`, tandis que le niveau « interface d'administration » a l'alias `@backend`. En conséquence, vous pouvez mettre les classes de l'interface utilisateur sous l'espace de noms `frontend`, tandis que les classes de l'interface d'administration sont sous l'espace de noms `backend`. Cela permet à ces classes d'être chargées automatiquement par le chargeur automatique de Yii. 
+
+Table de mise en correspondance des classes <span id="class-map"></span>
+-------------------------------------------
+
+Le chargeur automatique de classes de Yii prend en charge la fonctionnalité *table de mise en correspondance des classes*, qui met en correspondance les noms de classe avec les chemins de classe de fichiers. Lorsque le chargeur automatique charge une classe, il commence par chercher si la classe existe dans la table de mise en correspondance. Si c'est le cas, le chemin de fichier correspondant est inclus directement sans plus de recherche. Cela rend le chargement des classes très rapide. En fait, toutes les classes du noyau de Yii sont chargées de cette manière. 
+
+Vous pouvez ajouter une classe à la table de mise en correspondance des classes, stockée dans `Yii::$classMap`, avec l'instruction :
+
+```php
+Yii::$classMap['foo\bar\MyClass'] = 'path/to/MyClass.php';
+```
+
+Les [alias](concept-aliases.md) peuvent être utilisés pour spécifier des chemins de fichier de classe. Vous devez définir la table de mise en correspondance dans le processus d'[amorçage](runtime-bootstrapping.md) afin qu'elle soit prête avant l'utilisation de vos classes. 
+
+
+Utilisation d'autres chargeurs automatiques <span id="using-other-autoloaders"></span>
+-------------------------------------------
+
+Comme Yii utilise Composer comme gestionnaire de dépendances de paquets, il est recommandé que vous installiez aussi le chargeur automatique de Composer. Si vous utilisez des bibliothèques de tierces parties qui ont besoin de leurs propres chargeurs, vous devez installer ces chargeurs également. 
+
+Lors de l'utilisation conjointe du chargeur automatique de Yii et d'autres chargeurs automatiques, vous devez inclure le fichier `Yii.php` *après* que tous les autres chargeurs automatiques sont installés. Cela fait du chargeur automatique de Yii le premier à répondre à une requête de chargement automatique de classe. Par exemple, le code suivant est extrait du [script d'entrée](structure-entry-scripts.md) du [modèle de projet *basic*](start-installation.md). La première ligne installe le chargeur automatique de Composer, tandis que la seconde installe le chargeur automatique de Yii :
+
+```php
+require(__DIR__ . '/../vendor/autoload.php');
+require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php');
+```
+
+Vous pouvez utiliser le chargeur automatique de Composer seul sans celui de Yii. Néanmoins, en faisant de cette manière, la performance de chargement de vos classes est dégradée et vous devez appliquer les règles de Composer pour que vous classes puissent être chargées automatiquement. 
+
+> Info: si vous voulez ne pas utiliser le chargeur automatique de Yii, vous devez créer votre propre version du fichier `Yii.php` et l'inclure dans votre [script d'entrée](structure-entry-scripts.md).
+
+
+Chargement automatique des classes d'extension <span id="autoloading-extension-classes"></span>
+----------------------------------------------
+
+Le chargeur automatique de Yii est capable de charger automatiquement des classes d'[extension](structure-extensions.md). La seule exigence est que cette extension spécifie la section `autoload` correctement dans son fichier `composer.json`. Reportez-vous à la [documentation de Composer](https://getcomposer.org/doc/04-schema.md#autoload) pour plus de détails sur la manière de spécifier `autoload`.
+
+Dans le cas où vous n'utilisez pas le chargeur automatique de Yii, le chargeur automatique de Composer peut toujours charger les classes d'extensions pour vous.