add concept-components.md

docs/guide-es/concept-components.md

+Componentes
+===========
+
+Los componentes son los principales bloques de construcción de las aplicaciones Yii. Los componentes son instancias de
+[[yii\base\Component]] o de una clase extendida. Las tres características principales que los componentes proporcionan
+a las otras clases son:
+
+* [Propiedades](concept-properties.md)
+* [Eventos](concept-events.md)
+* [Comportamientos](concept-behaviors.md),
+
+Por separado y combinadas, estas características hacen que las clases Yii sean mucho mas personalizables y sean mucho
+más fáciles de usar. Por ejemplo, el incluido [[yii\jui\DatePicker|widget de selección de fecha]], un componente de la
+interfaz de usuario, puede ser utilizado en una [vista](structure-view.md) para generar un selector de fechas interactivo:
+
+```php
+use yii\jui\DatePicker;
+
+echo DatePicker::widget([
+    'language' => 'ru',
+    'name'  => 'country',
+    'clientOptions' => [
+        'dateFormat' => 'yy-mm-dd',
+    ],
+]);
+```
+
+Las propiedades del widget son facilmente modificables porque la clase se extiende de [[yii\base\Component]].
+
+Mientras que los componentes son muy potentes, son un poco más pesados que los objetos normales, debido al hecho de que
+necesitan más memoria y tiempo de CPU para poder soportar [eventos](concept-events.md) y [comportamientos](concept-behaviors.md) en particular.
+Si tus componentes no necesitan estas dos características, deberías considerar extender tu componente directamente de
+[[yii\base\Object]] en vez de [[yii\base\Component]]. De esta manera harás que tus componentes sean mucho más eficientes que
+que objetos PHP normales, pero con el añadido soporte para [propiedades](concept-properties.md).
+
+Cuando extiendes tu clase de [[yii\base\Component]] o [[yii\base\Object]], se recomienda que sigas las siguientes
+convenciones:
+
+- Si sobrescribes el constructor, especifica un parámetro `$config` como el *último* parámetro del constructor, y después
+  pasa este parámetro al constructor de la clase "padre".
+- Siempre llama al constructor del "padre" al *final* de su propio constructor.
+- Si sobrescribes el método [[yii\base\Object::init()]], asegúrate de que llamas a la implementación de la clase "padre"
+  *al principio* de tu método `init`.
+
+Por ejemplo:
+
+```php
+namespace yii\components\MyClass;
+
+use yii\base\Object;
+
+class MyClass extends Object
+{
+    public $prop1;
+    public $prop2;
+
+    public function __construct($param1, $param2, $config = [])
+    {
+        // ... inicialización antes de la configuración está siendo aplicada
+
+        parent::__construct($config);
+    }
+
+    public function init()
+    {
+        parent::init();
+
+        // ... inicialización despues de la configuración esta siendo aplicada
+    }
+}
+```
+
+Siguiendo esas directrices hará que tus componentes sean [configurables](concept-configurations.md) cuando son creados. Por ejemplo:
+
+```php
+$component = new MyClass(1, 2, ['prop1' => 3, 'prop2' => 4]);
+// alternativamente
+$component = \Yii::createObject([
+    'class' => MyClass::className(),
+    'prop1' => 3,
+    'prop2' => 4,
+], [1, 2]);
+```
+
+> Información: Mientras que el enfoque de llamar [[Yii::createObject()]] parece mucho más complicado, es mucho más potente
+  debido al hecho de que se implementa en la parte superior de un [contenedor de inyección de dependencia](concept-di-container.md).
+  
+
+La clase [[yii\base\Object]] hace cumplir el siguiente ciclo de vida del objeto:
+
+1. Pre-inicialización en el constructor. Puedes establecer los valores predeterminados de propiedades aquí.
+2. Configuración del objeto a través de `$config`. La configuración puede sobrescribir los valores prdeterminados dentro
+   del constructor.
+3. Post-inicialización dentro de [[yii\base\Object::init()|init()]]. Puedes sobrescribir este método para realizar
+   comprobaciones de validez y normalización de las propiedades.
+4. LLamadas a métodos del objeto.
+
+
+Los tres primeros pasos ocurren dentro del constructor del objeto. Esto significa que una vez obtengas la instancia de
+un objeto, ésta ha sido inicializada para que puedas utilizarla adecuadamente.