Merge pull request #12341 from jaaf/run-events-behaviors

Added French concept-events.md and concept-behaviors.md [skip ci]

docs/guide-fr/concept-behaviors.md

@@ -0,0 +1,322 @@
+Comportements
+=============
+
+Les comportements (*behaviors* sont des instances de la classe [[yii\base\Behavior]], ou de ses classes filles. Les comportements, aussi connus sous le nom de [mixins](http://en.wikipedia.org/wiki/Mixin), vous permettent d'améliorer les fonctionnalités d'une classe de [[yii\base\Component|composant]] existante sans avoir à modifier les héritages de cette classe. Le fait d'attacher un comportement à un composant injecte les méthodes et les propriétés de ce comportement dans le composant, rendant ces méthodes et ces propriétés accessibles comme si elles avaient été définies dans la classe du composant lui-même. En outre, un comportement peut répondre aux [événements](concept-events.md) déclenchés par le composant, ce qui permet aux comportements de personnaliser l'exécution normale du code du composant.
+
+
+Définition des comportements <span id="defining-behaviors"></span>
+---------------------------
+
+Pour définir un comportement, vous devez créer une classe qui étend la classe  [[yii\base\Behavior]], ou une des ses classes filles. Par exemple :
+
+```php
+namespace app\components;
+
+use yii\base\Behavior;
+
+class MyBehavior extends Behavior
+{
+    public $prop1;
+
+    private $_prop2;
+
+    public function getProp2()
+    {
+        return $this->_prop2;
+    }
+
+    public function setProp2($value)
+    {
+        $this->_prop2 = $value;
+    }
+
+    public function foo()
+    {
+        // ...
+    }
+}
+```
+
+Le code ci-dessus définit la classe de comportement `app\components\MyBehavior` avec deux propriété — `prop1` et `prop2` — et une méthode `foo()`. Notez que la propriété `prop2` est définie via la méthode d'obtention `getProp2` et la méthode d'assignation `setProp2`. Cela est le cas parce que la classe  [[yii\base\Behavior]] étend la classe [[yii\base\Object]] et, par conséquent, prend en charge la définition des [propriétés](concept-properties.md) via les méthodes d'obtention et d'assignation. 
+
+Comme cette classe est un comportement, lorsqu'elle est attachée à un composant, ce composant acquiert alors les propriétés  `prop1` et `prop2`, ainsi que la méthode `foo()`.
+
+> Tip: depuis l'intérieur d'un comportement, vous avez accès au composant auquel le comportement est attaché via la propriété [[yii\base\Behavior::owner]].
+
+> Note: dans le cas où les méthodes  [[yii\base\Behavior::__get()]] et/ou [[yii\base\Behavior::__set()]] du comportement sont redéfinies, vous devez redéfinir les méthodes [[yii\base\Behavior::canGetProperty()]] et/ou [[yii\base\Behavior::canSetProperty()]] également.
+
+Gestion des événements du composant
+-----------------------------------
+
+Si un comportement a besoin de répondre aux événements déclenchés par le composant auquel il est attaché, il doit redéfinir la méthode [[yii\base\Behavior::events()]]. Par exemple:
+
+```php
+namespace app\components;
+
+use yii\db\ActiveRecord;
+use yii\base\Behavior;
+
+class MyBehavior extends Behavior
+{
+    // ...
+
+    public function events()
+    {
+        return [
+            ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
+        ];
+    }
+
+    public function beforeValidate($event)
+    {
+        // ...
+    }
+}
+```
+
+La méthode [[yii\base\Behavior::events()|events()]] doit retourner une liste d'événements avec leur gestionnaire correspondant. L'exemple ci-dessus déclare que l'événement [[yii\db\ActiveRecord::EVENT_BEFORE_VALIDATE|EVENT_BEFORE_VALIDATE]] existe et définit son gestionnaire `beforeValidate()`. En spécifiant un gestionnaire d'événement, vous pouvez utiliser un des formats suivants :
+ 
+* une chaîne de caractères qui fait référence au nom d'une méthode de la classe du comportement, comme dans l'exemple ci-dessus ;
+* un tableau constitué d'un nom d'objet ou de classe et d'un nom de méthode sous forme de chaîne de caractères (sans les parenthèses), p. ex. `[$object, 'methodName']`;
+* une fonction anonyme.
+
+La signature d'un gestionnaire d'événement doit être similaire à ce qui suit, où `event` fait référence au paramètre événement. Reportez-vous à la section [Événements](concept-events.md) pour plus de détail sur les événements.
+
+```php
+function ($event) {
+}
+```
+
+Attacher des comportements <span id="attaching-behaviors"></span>
+-----------------------------
+
+Vous pouvez attacher un comportement à un [[yii\base\Component|composant]] soit de manière statique, soit de manière dynamique. Le première manière est une pratique plus habituelle.
+
+Pour attacher un comportement de manière statique, redéfinissez la méthode [[yii\base\Component::behaviors()|behaviors()]] de la classe du composant auquel le comportement va être attaché. La méthode [[yii\base\Component::behaviors()|behaviors()]] doit retourner une liste de [configurations](concept-configurations.md) de comportements. Chaque comportement peut être soit un nom de classe de comportement, soit un tableau de configuration :
+
+```php
+namespace app\models;
+
+use yii\db\ActiveRecord;
+use app\components\MyBehavior;
+
+class User extends ActiveRecord
+{
+    public function behaviors()
+    {
+        return [
+            // comportement anonyme, nom de la classe de comportement seulement
+            MyBehavior::className(),
+
+            // comportement nommé, nom de classe de comportement seulement
+            'myBehavior2' => MyBehavior::className(),
+
+            // comportement anonyme, tableau de configuration
+            [
+                'class' => MyBehavior::className(),
+                'prop1' => 'value1',
+                'prop2' => 'value2',
+            ],
+
+            // comportement nommé, tableau de configuration
+            'myBehavior4' => [
+                'class' => MyBehavior::className(),
+                'prop1' => 'value1',
+                'prop2' => 'value2',
+            ]
+        ];
+    }
+}
+```
+
+Vous pouvez associer un nom au comportement en spécifiant la clé de tableau correspondant à la configuration du comportement. Dans ce cas, le comportement est appelé *comportement nommé*. Dans l'exemple ci-dessus, il y a deux comportements nommés : `myBehavior2` et `myBehavior4`. Si un comportement n'est pas associé à un nom, il est appelé *comportement anonyme*.
+
+
+Pour attacher un comportement de manière dynamique, appelez la méthode [[yii\base\Component::attachBehavior()]] du composant auquel le comportement va être attaché : 
+
+```php
+use app\components\MyBehavior;
+
+// attache un objet comportement 
+$component->attachBehavior('myBehavior1', new MyBehavior);
+
+// attache un classe de comportement
+$component->attachBehavior('myBehavior2', MyBehavior::className());
+
+// attache un tableau de configuration 
+$component->attachBehavior('myBehavior3', [
+    'class' => MyBehavior::className(),
+    'prop1' => 'value1',
+    'prop2' => 'value2',
+]);
+```
+
+Vous pouvez attacher plusieurs comportements à la fois en utilisant la méthode  [[yii\base\Component::attachBehaviors()]] :
+
+```php
+$component->attachBehaviors([
+    'myBehavior1' => new MyBehavior,  // un comportement nommé
+    MyBehavior::className(),          // un comportement anonyme
+]);
+```
+
+Vous pouvez aussi attacher des comportements via les [configurations](concept-configurations.md) comme ceci :
+
+```php
+[
+    'as myBehavior2' => MyBehavior::className(),
+
+    'as myBehavior3' => [
+        'class' => MyBehavior::className(),
+        'prop1' => 'value1',
+        'prop2' => 'value2',
+    ],
+]
+```
+
+Pour plus de détails, reportez-vous à la section  [Configurations](concept-configurations.md#configuration-format).
+
+Utilisation des comportements <span id="using-behaviors"></span>
+-----------------------------
+
+Pour utiliser un comportement, commencez par l'attacher à un [[yii\base\Component|composant]] en suivant les instructions données ci-dessus. Une fois le comportement attaché au composant, son utilisation est évidente.
+
+Vous pouvez accéder à une variable membre *publique*, ou à une  [propriété](concept-properties.md) définie par une méthode d'obtention et/ou une méthode d'assignation (*getter* et *setter*), du comportement, via le composant auquel ce comportement est attaché : 
+
+```php
+// "prop1" est une propriété définie dans la classe du comportement
+echo $component->prop1;
+$component->prop1 = $value;
+```
+
+Vous pouvez aussi appeler une méthode *publique* du comportement de façon similaire :
+
+```php
+// foo() est une méthode publique définie dans la classe du comportement
+$component->foo();
+```
+
+Comme vous pouvez le voir, bien que le composant `$component` ne définissent pas `prop1` et`foo()`, elles peuvent être utilisées comme si elles faisaient partie de la définition du composant grâce au comportement attaché. 
+
+Si deux comportement définissent la même propriété ou la même méthode, et que ces deux comportement sont attachés au même composant, le comportement qui a été attaché le *premier* prévaut lorsque la propriété ou la méthode est accédée.
+
+Un comportement peut être associé à un nom lorsqu'il est attaché à un composant. Dans un tel cas, vous pouvez accéder à l'objet comportement en utilisant ce nom :
+
+```php
+$behavior = $component->getBehavior('myBehavior');
+```
+
+Vous pouvez aussi obtenir tous les comportements attachés au composant :
+
+```php
+$behaviors = $component->getBehaviors();
+```
+
+
+Détacher des comportements <span id="detaching-behaviors"></span>
+--------------------------
+
+Pour détacher un comportement, appelez [[yii\base\Component::detachBehavior()]] avec le nom associé au comportement :
+
+```php
+$component->detachBehavior('myBehavior1');
+```
+
+Vous pouvez aussi détacher *tous les* comportements : 
+
+```php
+$component->detachBehaviors();
+```
+
+
+Utilisation de  `TimestampBehavior` <span id="using-timestamp-behavior"></span>
+-------------------------
+
+Pour aller à l'essentiel, jetons un coup d'œil à [[yii\behaviors\TimestampBehavior]]. Ce comportement prend automatiquement en charge la mise à jour de l'attribut *timestamp* (horodate) d'un modèle [[yii\db\ActiveRecord|enregistrement actif]] à chaque fois qu'il est sauvegardé via les méthodes `insert()`, `update()` ou `save()`.
+
+Tout d'abord, attachez ce comportement à la classe [[yii\db\ActiveRecord|Active Record (enregistrement actif)]] que vous envisagez d'utiliser :
+
+```php
+namespace app\models\User;
+
+use yii\db\ActiveRecord;
+use yii\behaviors\TimestampBehavior;
+
+class User extends ActiveRecord
+{
+    // ...
+
+    public function behaviors()
+    {
+        return [
+            [
+                'class' => TimestampBehavior::className(),
+                'attributes' => [
+                    ActiveRecord::EVENT_BEFORE_INSERT => ['created_at', 'updated_at'],
+                    ActiveRecord::EVENT_BEFORE_UPDATE => ['updated_at'],
+                ],
+                // si vous utilisez datetime au lieur de l'UNIX timestamp:
+                // 'value' => new Expression('NOW()'),
+            ],
+        ];
+    }
+}
+```
+
+Le comportement ci-dessus spécifie que lorsque l'enregistrement est : 
+
+* inséré, le comportement doit assigner l'horodate UNIX courante aux attributs `created_at` (créé le)  et `updated_at` (mis à jour le) ;
+* mis à jour, le comportement doit assigner l'horodate UNIX courante à l'attribut `updated_at` ;
+
+> Note: pour que la mise en œuvre ci-dessus fonctionne avec une base de données MySQL, vous devez déclarer les colonnes (`created_at`, `updated_at`) en tant que `int(11)` pour qu'elles puissent représenter des horodates UNIX. 
+
+Avec ce code en place, si vous avez un objet `User` (utilisateur) et que vous essayez de le sauvegarder, il verra ses attributs `created_at` et `updated_at` automatiquement remplis avec l'horodate UNIX :
+
+```php
+$user = new User;
+$user->email = 'test@example.com';
+$user->save();
+echo $user->created_at;  // affiche l'horodate courante
+```
+
+Le comportement [[yii\behaviors\TimestampBehavior|TimestampBehavior]] offre également une méthode utile [[yii\behaviors\TimestampBehavior::touch()|touch()]], qui assigne l'horodate courante à un attribut spécifié et le sauvegarde dans la base de données : 
+
+```php
+$user->touch('login_time');
+```
+
+Autres comportements
+--------------------
+
+Il existe plusieurs comportements pré-inclus et extérieurs disponibles :
+
+- [[yii\behaviors\BlameableBehavior]] – remplit automatiquement les attributs spécifiés avec l'identifiant de l'utilisateur courant. 
+- [[yii\behaviors\SluggableBehavior]] – remplit automatiquement l'attribut spécifié avec une valeur utilisable en tant que chaîne purement ASCII (*slug*) dans une URL. 
+- [[yii\behaviors\AttributeBehavior]] – assigne automatiquement une valeur spécifiée à un ou plusieurs attributs d'un objet enregistrement actif lorsque certains événements se produisent. 
+- [yii2tech\ar\softdelete\SoftDeleteBehavior](https://github.com/yii2tech/ar-softdelete) – fournit des méthodes pour une suppression douce et une restauration douce d'un enregistrement actif c.-à-d. positionne un drapeau ou un état qui marque l'enregistrement comme étant effacé.
+- [yii2tech\ar\position\PositionBehavior](https://github.com/yii2tech/ar-position) – permet la gestion de l'ordre des enregistrements dans un champ entier (*integer*) en fournissant les méthodes de remise dans l'ordre.
+
+Comparaison des comportement et des traits <span id="comparison-with-traits"></span>
+------------------------------------------
+
+Bien que les comportements  soient similaires aux [traits](http://www.php.net/traits) par le fait qu'ils *injectent* tous deux leurs propriétés et leurs méthodes dans la classe primaire, ils diffèrent par de nombreux aspects. Comme nous l'expliquons ci-dessous, ils ont chacun leurs avantages et leurs inconvénients. Ils sont plus des compléments l'un envers l'autre, que des alternatives. 
+
+
+### Raisons d'utiliser des comportements <span id="pros-for-behaviors"></span>
+
+Les classes de comportement, comme les classes normales, prennent en charge l'héritage. Les traits, par contre, peuvent être considérés comme des copier coller pris en charge par le langage. Ils ne prennent pas en charge l'héritage. 
+
+Les comportements peuvent être attachés et détachés à un composant de manière dynamique sans qu'une modification de la classe du composant soit nécessaire. Pour utiliser un trait, vous devez modifier le code de la classe qui l'utilise. 
+
+Les comportements sont configurables mais les traits ne le sont pas. 
+
+Les comportement peuvent personnaliser l'exécution du code d'un composant en répondant à ses événements.
+
+Lorsqu'il se produit des conflits de noms entre les différents comportements attachés à un même composant, les conflits sont automatiquement résolus  en donnant priorité au comportement attaché le premier. Les conflits de noms causés par différents traits nécessitent une résolution manuelle en renommant les propriétés et méthodes concernées. 
+
+
+### Raisons d'utiliser des traits <span id="pros-for-traits"></span>
+
+Les traits sont beaucoup plus efficaces que les comportements car les comportements sont des objets qui requièrent plus de temps du processeur et plus de mémoire. 
+
+Les environnement de développement intégrés (EDI) sont plus conviviaux avec les traits car ces derniers sont des constructions natives du langage. 

docs/guide-fr/concept-events.md

@@ -0,0 +1,313 @@
+Événements
+==========
+
+Les événement vous permettent d'injecter du code personnalisé dans le code existant à des points précis de son exécution. Vous pouvez attacher du code personnalisé à un événement de façon à ce que, lorsque l'événement est déclenché, le code s'exécute automatiquement. Par exemple, un objet serveur de courriel  peut déclencher un événement `messageSent` (message envoyé) quand il réussit à envoyer un message. Si vous voulez conserver une trace des messages dont l'envoi a réussi, vous pouvez simplement attacher le code de conservation de la trace à l'événement  `messageSent`.
+
+Yii introduit une classe de base appelée [[yii\base\Component]] pour prendre en charge les événements. Si une classe a besoin de déclencher des événements, elle doit êtendre la classe [[yii\base\Component]], ou une de ses classes filles. 
+
+
+Gestionnaires d'événements <span id="event-handlers"></span>
+--------------------------
+
+Un gestionnaire d'événement est une  [fonction de rappel PHP](http://www.php.net/manual/en/language.types.callable.php) qui est exécutée lorsque l'événement à laquelle elle est attachée est déclenché. Vous pouvez utiliser n'importe laquelle des fonctions de rappel suivantes :
+
+- une fonction PHP globale spécifiée sous forme de chaîne de caractères (sans les parenthèses) p. ex., `'trim'` ;
+- une méthode d'objet spécifiée sous forme de tableau constitué d'un nom d'objet et d'un nom de méthode sous forme de chaîne de caractères (sans les parentèses), p. ex., `[$object, 'methodName']`;
+- une méthode d'une classe statique spécifiée sous forme de tableau constitué d'un nom de classe et d'un nom de méthode sous forme de chaîne de caractères (sans les parenthèses), p. ex., `['ClassName', 'methodName']`;
+- une fonction anonyme p. ex., `function ($event) { ... }`.
+
+La signature d'un gestionnaire d'événement est :
+
+```php
+function ($event) {
+    // $event est un objet de la classe  yii\base\Event ou des ses classes filles
+}
+```
+
+Via le paramètre `$event`, un gestionnaire d'événement peut obtenir l'information suivante sur l'événement qui vient de se produire : 
+
+- le [[yii\base\Event::name|nom de l'événement]];
+- l'[[yii\base\Event::sender|émetteur de l'événement]]: l'objet dont la méthode  `trigger()` a été appelée ;
+- les [[yii\base\Event::data|données personnalisées]]: les données fournies lorsque le gestionnaire d'événement est attaché (les explications arrivent bientôt).
+
+
+Attacher des gestionnaires d'événements <span id="attaching-event-handlers"></span>
+---------------------------------------
+
+Vous pouvez attacher un gestionnaire d'événement en appelant la méthode [[yii\base\Component::on()]] du composant. Par exemple :
+
+```php
+$foo = new Foo;
+
+// le gestionnaire est une fonction globale
+$foo->on(Foo::EVENT_HELLO, 'function_name');
+
+// le gestionnaire est une méthode d'objet
+$foo->on(Foo::EVENT_HELLO, [$object, 'methodName']);
+
+// le gestionnaire est une méthode d'une classe statique
+$foo->on(Foo::EVENT_HELLO, ['app\components\Bar', 'methodName']);
+
+// le gestionnaire est un fonction anonyme
+$foo->on(Foo::EVENT_HELLO, function ($event) {
+    // event handling logic
+});
+```
+
+Vous pouvez aussi attacher des gestionnaires d'événements via les [configurations](concept-configurations.md). Pour plus de détails, reportez-vous à la section [Configurations](concept-configurations.md#configuration-format).
+
+
+Losque vous attachez un gestionnaire d'événement, vous pouvez fournir des données additionnelles telles que le troisième paramètre de [[yii\base\Component::on()]]. Les données sont rendues disponibles au gestionnaire lorsque l'événement est déclenché et que le gestionnaire est appelé. Par exemple :
+
+```php
+// Le code suivant affiche  "abc" lorsque l'événement est déclenché
+// parce que  $event->data contient les données passées en tant que troisième argument à la méthode "on"
+$foo->on(Foo::EVENT_HELLO, 'function_name', 'abc');
+
+function function_name($event) {
+    echo $event->data;
+}
+```
+
+Ordre des gestionnaires d'événements
+------------------------------------
+
+Vous pouvez attacher un ou plusieurs gestionnaires à un seul événement. Lorsqu'un événement est déclenché, les gestionnaires attachés sont appelés dans l'ordre dans lequel ils ont été attachés à l'événement. Si un gestionnaire a besoin d'arrêter l'appel des gestionnaires qui viennent après lui, il doit définir la propriété [[yii\base\Event::handled (géré)]] du paramètre `$event` parameter à `true`:
+
+```php
+$foo->on(Foo::EVENT_HELLO, function ($event) {
+    $event->handled = true;
+});
+```
+
+Par défaut, un gestionnaire nouvellement attaché est ajouté à la file des gestionnaires de l'événement. En conséquence, le gestionnaire est appelé en dernier lorsque l'événement est déclenché. Pour insérer un événement nouvellement attaché en tête de file pour qu'il soit appelé le premier, vous devez appeler [[yii\base\Component::on()]], en lui passant `false` pour le quatrième paramètre `$append`:
+
+```php
+$foo->on(Foo::EVENT_HELLO, function ($event) {
+    // ...
+}, $data, false);
+```
+
+Déclenchement des événements <span id="triggering-events"></span>
+----------------------------
+
+Les événements sont déclenchés en appelant la méthode [[yii\base\Component::trigger()]]. La méthode requiert un  *nom d'événement* et, en option, un objet événement qui décrit les paramètres à passer aux gestionnaires de cet événement. Par exemple :
+
+```php
+namespace app\components;
+
+use yii\base\Component;
+use yii\base\Event;
+
+class Foo extends Component
+{
+    const EVENT_HELLO = 'hello';
+
+    public function bar()
+    {
+        $this->trigger(self::EVENT_HELLO);
+    }
+}
+```
+Avec le code précédent, tout appel à  `bar()` déclenche un événement nommé `hello`.
+
+> Tip: il est recommandé d'utiliser des constantes de classe pour représenter les noms d'événement. Dans l'exemple qui précède, la constante `EVENT_HELLO` représente l'événement `hello`. Cette approche procure trois avantages. Primo, elle évite les erreurs de frappe. Secondo, elle permet aux événements d'être reconnus par le mécanisme d'auto-complètement des EDI. Tertio, vous pouvez dire quels événements sont pris en charge par une classe en vérifiant la déclaration de ses constantes. 
+
+Parfois, lors du déclenchement d'un événement, vous désirez passer des informations additionnelles aux gestionnaires de cet événement. Par exemple, un serveur de courriels peut souhaiter passer les informations sur le message aux gestionnaires de l'événement `messageSent` pour que ces derniers soient informés de certaines particularités des messages envoyés. Pour ce faire, vous pouvez fournir un objet événement comme deuxième paramètre de la méthode [[yii\base\Component::trigger()]]. L'objet événement doit simplement être une instance de la classe [[yii\base\Event]] ou d'une de ses classes filles. Par exemple :
+
+```php
+namespace app\components;
+
+use yii\base\Component;
+use yii\base\Event;
+
+class MessageEvent extends Event
+{
+    public $message;
+}
+
+class Mailer extends Component
+{
+    const EVENT_MESSAGE_SENT = 'messageSent';
+
+    public function send($message)
+    {
+        // ...sending $message...
+
+        $event = new MessageEvent;
+        $event->message = $message;
+        $this->trigger(self::EVENT_MESSAGE_SENT, $event);
+    }
+}
+```
+
+Lorsque la méthode [[yii\base\Component::trigger()]] est appelée, elle appelle tous les gestionnaires attachés à l'événement nommé. 
+
+
+Détacher des gestionnaires d'événements <span id="detaching-event-handlers"></span>
+---------------------------------------
+
+Pour détacher un gestionnaire d'un événement, appelez la méthode [[yii\base\Component::off()]]. Par exemple :
+
+```php
+// le gestionnaire est une fonction globale
+$foo->off(Foo::EVENT_HELLO, 'function_name');
+
+// le gestionnaire est une méthode d'objet
+$foo->off(Foo::EVENT_HELLO, [$object, 'methodName']);
+
+// le gestionnaire est une méthode d'une classe statique 
+$foo->off(Foo::EVENT_HELLO, ['app\components\Bar', 'methodName']);
+
+// le gestionnaire est une fonction anonyme
+$foo->off(Foo::EVENT_HELLO, $anonymousFunction);
+```
+
+Notez qu'en général, vous ne devez pas essayer de détacher une fonction anonyme sauf si vous l'avez stokée quelque part lorsque vous l'avez attachée à un événement. Dans l'exemple ci-dessus, on suppose que la fonctions anonyme est stockée dans une variable nommée  `$anonymousFunction`.
+
+Pour détacher *tous* les gestionnaires d'un événement, appelez simplement la méthode [[yii\base\Component::off()]] sans le deuxième paramètre :
+
+```php
+$foo->off(Foo::EVENT_HELLO);
+```
+
+
+Gestionnaire d'événement au niveau de la classe <span id="class-level-event-handlers"></span>
+-----------------------------------------------
+
+Les sections précédent décrivent comment attacher un gestionnaire à un événement au *niveau d'une instance*. Parfois, vous désirez répondre à un événement déclenché par *chacune des* instances d'une classe plutôt que par une instance spécifique. Au lieu d'attacher l'événement à chacune des instances, vous pouvez attacher le gestionnaire au *niveau de la classe* en appelant la méthode statique [[yii\base\Event::on()]].
+
+Par exemple, un objet [Active Record](db-active-record.md) déclenche un événement  [[yii\db\BaseActiveRecord::EVENT_AFTER_INSERT|EVENT_AFTER_INSERT]]
+à chaque fois qu'il insère un nouvel enregistrement dans la base de données. Afin de suivre les insertions faites par tous les objets [Active Record](db-active-record.md), vous pouvez utiliser le code suivant :
+
+```php
+use Yii;
+use yii\base\Event;
+use yii\db\ActiveRecord;
+
+Event::on(ActiveRecord::className(), ActiveRecord::EVENT_AFTER_INSERT, function ($event) {
+    Yii::trace(get_class($event->sender) . ' is inserted');
+});
+```
+
+Le gestionnaire d'événement est invoqué à chaque fois qu'une instance de la classe [[yii\db\ActiveRecord|ActiveRecord]], ou d'une de ses classes filles, déclenche l'événement [[yii\db\BaseActiveRecord::EVENT_AFTER_INSERT|EVENT_AFTER_INSERT]]. Dans le gestionnaire, vous pouvez obtenir l'objet qui a déclenché l'événement via `$event->sender`.
+
+Losqu'un objet déclenche un événement, il commence par appeler les gestionnaires attachés au niveau de l'instance, puis les gestionnaires attachés au niveau de la classe. 
+
+Vous pouvez déclencher un événement au *niveau de la classe* en appelant la méthode statique [[yii\base\Event::trigger()]]. Un événement déclenché au niveau de la classe n'est associé à aucun objet en particulier. En conséquence, il provoque l'appel des gestionnaires attachés au niveau de la classe seulement. Par exemple :
+
+```php
+use yii\base\Event;
+
+Event::on(Foo::className(), Foo::EVENT_HELLO, function ($event) {
+    echo $event->sender;  // displays "app\models\Foo"
+});
+
+Event::trigger(Foo::className(), Foo::EVENT_HELLO);
+```
+
+Notez que, dans ce cas, `$event->sender` fait référence au nom de la classe qui a déclenché l'événement plutôt qu'à une instance de classe.
+
+> Note: comme les gestionnaires attachés au niveau de la classe répondent aux événements déclenchés par n'importe quelle instance de cette classe, ou de ses classes filles, vous devez utiliser cette fonctionnalité avec précaution, en particulier si la classe est une classe de bas niveau comme la classe [[yii\base\Object]].
+
+Pour détacher un gestionnaire attaché au niveau de la classe, appelez  [[yii\base\Event::off()]]. Par exemple :
+
+```php
+// détache $handler
+Event::off(Foo::className(), Foo::EVENT_HELLO, $handler);
+
+// détache tous les gestionnaires de Foo::EVENT_HELLO
+Event::off(Foo::className(), Foo::EVENT_HELLO);
+```
+
+
+Événement utilisant des interfaces <span id="interface-level-event-handlers"></span>
+----------------------------------
+
+Il y a encore une manière plus abstraite d'utiliser les événements. Vous pouvez créer une interface séparée pour un événement particulier et l'implémenter dans des classes dans lesquelles vous en avez besoin. 
+
+Par exemple, vous pouvez créer l'interface suivante :
+
+```php
+interface DanceEventInterface
+{
+    const EVENT_DANCE = 'dance';
+}
+```
+
+Et ajouter deux classes qui l'implémente :
+
+```php
+class Dog extends Component implements DanceEventInterface
+{
+    public function meetBuddy()
+    {
+        echo "Woof!";
+        $this->trigger(DanceEventInterface::EVENT_DANCE);
+    }
+}
+
+class Developer extends Component implements DanceEventInterface
+{
+    public function testsPassed()
+    {
+        echo "Yay!";
+        $this->trigger(DanceEventInterface::EVENT_DANCE);
+    }
+}
+```
+
+Pour gérer l'évenement `EVENT_DANCE` déclenché par n'importe laquelle de ces classes, appelez [[yii\base\Event::on()|Event::on()]] et passez-lui le nom de l'interface comme premier argument :
+
+```php
+Event::on('DanceEventInterface', DanceEventInterface::EVENT_DANCE, function ($event) {
+    Yii::trace($event->sender->className . ' danse'); // enregistrer le message disant que le chien ou le développeur danse.
+})
+```
+
+Vous pouvez déclencher l'événement de ces classes :
+
+```php
+Event::trigger(DanceEventInterface::className(), DanceEventInterface::EVENT_DANCE);
+```
+
+Notez bien que vous ne pouvez pas déclencher l'événement de toutes les classes qui implémentent l'interface :,
+
+```php
+// NE FONCTIONNE PAS
+Event::trigger('DanceEventInterface', DanceEventInterface::EVENT_DANCE); // error
+```
+
+Pour détacher le gestionnaire d'événement, appelez [[yii\base\Event::off()|Event::off()]]. Par exemple :
+
+```php
+// détache $handler
+Event::off('DanceEventInterface', DanceEventInterface::EVENT_DANCE, $handler);
+
+// détache tous les gestionnaires de DanceEventInterface::EVENT_DANCE
+Event::off('DanceEventInterface', DanceEventInterface::EVENT_DANCE);
+```
+
+
+Événements globaux <span id="global-events"></span>
+------------------
+
+Yii prend en charge ce qu'on appelle les *événements globaux*, qui est une astuce basée sur le mécanisme des événements décrit ci-dessus. L'événement global requiert un singleton accessible globalement tel que l'instance de l'[application](structure-applications.md) elle-même.
+
+Pour créer l'événement global, un émetteur d'événement appelle la méthode `trigger()`  du singleton pour déclencher l'événement au lieu d'appeler la méthode `trigger()` propre à l'émetteur. De façon similaire, les gestionnaires d'événement sont attachés à l'événement sur le singleton. Par exemple :
+
+```php
+use Yii;
+use yii\base\Event;
+use app\components\Foo;
+
+Yii::$app->on('bar', function ($event) {
+    echo get_class($event->sender);  // affiche "app\components\Foo"
+});
+
+Yii::$app->trigger('bar', new Event(['sender' => new Foo]));
+```
+
+Un avantage de l'utilisation d'événement globaux est que vous n'avez pas besoin d'un objet lorsque vous attachez un gestionnaire à l'événement qui est déclenché par l'objet. Au lieu de cela, vous attachez le gestionnaire et déclenchez l'événement via le singleton (p. ex. l'instance d'application). 
+
+Néanmoins, parce que l'espace de noms des événements globaux est partagé par toutes les parties, vous devez nommer les événements globaux avec prudence, par exemple en introduisant une sorte d'espace de noms (p. ex. "frontend.mail.sent", "backend.mail.sent").