Qiang Xue
10 years ago
2 changed files with 508 additions and 2 deletions
@ -0,0 +1,506 @@ |
|||||||
|
Actualizando desde Yii 1.1 |
||||||
|
========================== |
||||||
|
|
||||||
|
Existen muchas diferencias entre las versiones 1.1 y 2.0 de Yii ya que el framework fue completamente reescrito |
||||||
|
en su segunda versión. |
||||||
|
Como resultado, actualizar desde la versión 1.1 no es tan trivial como actualizar entre versiones menores. En esta |
||||||
|
guía encontrarás las diferencias más grandes entre estas dos versiones. |
||||||
|
|
||||||
|
Si no has utilizado Yii 1.1 antes, puedes saltear con seguridad esta sección e ir directamente a "[Comenzando con Yii](start-installation.md)". |
||||||
|
|
||||||
|
Por favor nota que Yii 2.0 introduce más características de las que son cubiertas en este resumen. Es altamente recomendado |
||||||
|
que leas a través de toda la guía definitiva para aprender acerca de todas ellas. Hay posibilidades de que algunas |
||||||
|
características que ya has desarrollado por ti mismo ahora sean parte del núcleo de Yii. |
||||||
|
|
||||||
|
|
||||||
|
Instalación |
||||||
|
------------ |
||||||
|
|
||||||
|
Yii 2.0 adopta completamente [Composer](https://getcomposer.org/), el administrador de paquetes de facto de PHP. |
||||||
|
Tanto la instalación del núcleo del framework como las extensiones se manejan a través de Composer. Por favor consulta |
||||||
|
la sección [Comenzando con la Aplicación Básica](start-basic.md) para aprender a instalar Yii 2.0. Si quieres crear extensiones |
||||||
|
o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta la sección [Creando Extensiones](extend-creating-extensions.md) de la guía. |
||||||
|
|
||||||
|
|
||||||
|
Requerimientos de PHP |
||||||
|
--------------------- |
||||||
|
|
||||||
|
Yii 2.0 requiere PHP 5.4 o mayor, lo que es un gran progreso ya que Yii 1.1 funcionaba con PHP 5.2. |
||||||
|
Como resultado, hay muchas diferencias a nivel del lenguaje a las que deberías prestar atención. |
||||||
|
Debajo hay un resumen de los mayores cambios en relación a PHP: |
||||||
|
|
||||||
|
- [Namespaces](http://php.net/manual/es/language.namespaces.php). |
||||||
|
- [Funciones anónimas](http://php.net/manual/es/functions.anonymous.php). |
||||||
|
- Sintáxis cortas de Arrays `[...elementos...]` es utilizado en vez de `array(...elementos...)`. |
||||||
|
- Etiquetas cortas de `echo`. Ahora en las vistas se usa `<?=`. Esto se puede utilizar desde PHP 5.4. |
||||||
|
- [SPL - Biblioteca estándar de PHP](http://php.net/manual/es/book.spl.php). |
||||||
|
- [Enlace estático en tiempo de ejecución](http://php.net/manual/es/language.oop5.late-static-bindings.php). |
||||||
|
- [Fecha y Hora](http://php.net/manual/es/book.datetime.php). |
||||||
|
- [Traits](http://php.net/manual/es/language.oop5.traits.php). |
||||||
|
- [Internacionalización](http://php.net/manual/es/book.intl.php). Yii 2.0 utiliza la extensión `intl` de PHP |
||||||
|
como soporte para internacionalización. |
||||||
|
|
||||||
|
|
||||||
|
Namespace |
||||||
|
--------- |
||||||
|
|
||||||
|
El cambio más obvio en Yii 2.0 es el uso de namespaces. Casi todas las clases del núcleo |
||||||
|
utilizan namespaces, e.j., `yii\web\Request`. El prefijo "C" no se utiliza más en los nombre de clases. |
||||||
|
El esquema de nombre ahora utiliza la ruta de directorios. Por ejemplo, `yii\web\Request` |
||||||
|
indica que el archivo de la clase correspondiente es `web/Request.php`, en el directorio de Yii. |
||||||
|
|
||||||
|
(Puedes utilizar cualquier clase del núcleo sin necesidad de incluir el archivo que la contiene, gracias |
||||||
|
al autoloader de Yii.) |
||||||
|
|
||||||
|
|
||||||
|
Component y Object |
||||||
|
------------------ |
||||||
|
|
||||||
|
Yii 2.0 parte la clase `CComponent` de 1.1 en dos clases: [[yii\base\Object]] y [[yii\base\Component]]. |
||||||
|
La clase [[yii\base\Object|Object]] es una clase base liviana que permite definir [propiedades de objecto](concept-properties.md) |
||||||
|
a través de getters y setters. La clase [[yii\base\Component|Component]] extiende de [[yii\base\Object|Object]] y soporta |
||||||
|
[eventos](concept-events.md) y [comportamientos (behaviors)](concept-behaviors.md). |
||||||
|
|
||||||
|
Si tu clase no necesita las utilizar características de eventos o comportamientos, puedes considerar usar |
||||||
|
[[yii\base\Object|Object]] como clase base. Esto es usualmente el caso de las clases que representan |
||||||
|
estructuras de datos básicas. |
||||||
|
|
||||||
|
|
||||||
|
Configuración de objetos |
||||||
|
------------------------ |
||||||
|
|
||||||
|
La clase [[yii\base\Object|Object]] introduce una manera uniforme de configurar objetos. Cualquier clase descendiente |
||||||
|
de [[yii\base\Object|Object]] debería declarar su constructor (si fuera necesario) de la siguiente manera así |
||||||
|
puede ser propiamente configurado: |
||||||
|
|
||||||
|
```php |
||||||
|
class MyClass extends \yii\base\Object |
||||||
|
{ |
||||||
|
public function __construct($param1, $param2, $config = []) |
||||||
|
{ |
||||||
|
// ... se aplica la inicialización antes de la configuración |
||||||
|
|
||||||
|
parent::__construct($config); |
||||||
|
} |
||||||
|
|
||||||
|
public function init() |
||||||
|
{ |
||||||
|
parent::init(); |
||||||
|
|
||||||
|
// ... se aplica la inicialización después de la configuración |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
En el ejemplo de arriba, el último parámetro del constructor debe tomar un array de configuración |
||||||
|
conteniendo pares clave-valor para la inicialización de las propiedades al final del mismo. |
||||||
|
Puedes sobrescribir el método [[yii\base\Object::init()|init()]] para realizar el trabajo de inicialización |
||||||
|
que debe ser hecho luego de que la configuración ha sido aplicada. |
||||||
|
|
||||||
|
Siguiendo esa convención, podrás crear y configurar nuevos objetos utilizando |
||||||
|
un array de configuración: |
||||||
|
|
||||||
|
```php |
||||||
|
$object = Yii::createObject([ |
||||||
|
'class' => 'MyClass', |
||||||
|
'property1' => 'abc', |
||||||
|
'property2' => 'cde', |
||||||
|
], [$param1, $param2]); |
||||||
|
``` |
||||||
|
|
||||||
|
Se puede encontrar mayor detalle acerca del tema en la sección [Configuración de objetos](concept-configurations.md). |
||||||
|
|
||||||
|
|
||||||
|
Eventos |
||||||
|
------- |
||||||
|
|
||||||
|
En Yii 1, los eventos eran creados definiendo un método `on` (e.j., `onBeforeSave`). En Yii 2, puedes utilizar cualquier nombre de evento. |
||||||
|
Ahora puedes disparar un evento utilizando el método [[yii\base\Component::trigger()|trigger()]]: |
||||||
|
|
||||||
|
```php |
||||||
|
$event = new \yii\base\Event; |
||||||
|
$component->trigger($eventName, $event); |
||||||
|
``` |
||||||
|
|
||||||
|
Para conectar un manejador a un evento, utiliza el método [[yii\base\Component::on()|on()]]: |
||||||
|
|
||||||
|
```php |
||||||
|
$component->on($eventName, $handler); |
||||||
|
// Para desconectar el manejador, utiliza: |
||||||
|
// $component->off($eventName, $handler); |
||||||
|
``` |
||||||
|
|
||||||
|
Hay muchas mejoras en lo que respecta a eventos. Para más detalles, consulta la sección [Eventos](concept-events.md). |
||||||
|
|
||||||
|
|
||||||
|
Path Alias |
||||||
|
---------- |
||||||
|
|
||||||
|
Yii 2.0 extiende el uso de path alias tanto para archivos/directorios como URLs. Yii 2.0 ahora requiere que cada |
||||||
|
alias comience con el carácter `@`, para diferenciarlos de rutas o URLs normales. |
||||||
|
Por ejemplo, el alias `@yii` corresponde al directorio donde Yii se encuentra instalado. Los path alias |
||||||
|
están soportados en la mayor parte del núcleo. Por ejemplo, [[yii\caching\FileCache::cachePath]] puede tomar tanto |
||||||
|
una ruta de directorios normal como un alias. |
||||||
|
|
||||||
|
Un path alias está relacionado de cerca con un namespace. Se recomienda definir un path alias |
||||||
|
por cada namespace raíz, y así poder utilizar el autolader de Yii sin otra configuración. |
||||||
|
Por ejemplo, debido a que `@yii` se refiere al directorio de instalación, una clase |
||||||
|
como `yii\web\Request` puede ser auto-cargada. Si estás utilizando una librería de terceros, |
||||||
|
como Zend Framework, puedes definir un path alias `@Zend` que se refiera al directorio de instalación |
||||||
|
de ese framework. Una vez realizado esto, Yii será capaz de auto-cargar cualquier clase de Zend Framework también. |
||||||
|
|
||||||
|
Se puede encontrar más detalles del tema en la sección [Path Alias](concept-aliases.md). |
||||||
|
|
||||||
|
|
||||||
|
Vistas |
||||||
|
------ |
||||||
|
|
||||||
|
El cambio más significativo con respecto a las vistas en Yii 2 es que la variable especial `$this` (dentro de una vista) |
||||||
|
ya no se refiere al controlador o widget actual. |
||||||
|
En vez de eso, `$this` ahora se refiere al objeto de la *vista*, un concepto nuevo introducido en Yii 2.0. |
||||||
|
El objeto *vista* es del tipo [[yii\web\View]], que representa la parte de las vistas en el patrón MVC. |
||||||
|
of the MVC pattern. Si quieres acceder al controlador o al widget correspondiente desde la propia vista, |
||||||
|
puedes utilizar `$this->context`. |
||||||
|
|
||||||
|
Para renderizar una vista parcial (partial) dentro de otra vista, se utiliza `$this->render()`, no `$this->renderPartial()`. |
||||||
|
El llamado a `render` además tiene que ser mostrado explícitamente a través de `echo`, ya que el método `render()` |
||||||
|
devuelve el resultado de la renderización en vez de mostrarlo directamente. Por ejemplo: |
||||||
|
|
||||||
|
```php |
||||||
|
echo $this->render('_item', ['item' => $item]); |
||||||
|
``` |
||||||
|
|
||||||
|
Además de utilizar PHP como el lenguaje de templates principal, Yii 2.0 está también equipado con soporte |
||||||
|
oficial de otros dos populares lenguajes: Smarty y Twig. El motor de templates de Prado ya no está soportado. |
||||||
|
Para utilizar esos motores, necesitas configurar el componente `view` de la aplicación, definiendo la propiedad [[yii\base\View::$renderers|View::$renderers]]. |
||||||
|
Por favor consulta la sección [Motores de Templates](tutorial-template-engines.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Modelos |
||||||
|
------- |
||||||
|
|
||||||
|
Yii 2.0 utiliza [[yii\base\Model]] como modelo base, algo similar a `CModel` en 1.1. |
||||||
|
La clase `CFormModel` ha sido descartada por completo. Ahora, en Yii 2 debes extender [[yii\base\Model]] para crear clases de modelos. |
||||||
|
|
||||||
|
Yii 2.0 introduce un nuevo método llamado [[yii\base\Model::scenarios()|scenarios()]] para declarar escenarios soportados, |
||||||
|
y para indicar bajo qué escenario un atributo necesita ser validado, puede ser considerado seguro o no, etc. Por ejemplo: |
||||||
|
|
||||||
|
```php |
||||||
|
public function scenarios() |
||||||
|
{ |
||||||
|
return [ |
||||||
|
'backend' => ['email', 'role'], |
||||||
|
'frontend' => ['email', '!name'], |
||||||
|
]; |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
En el ejemplo anterior, se declaran dos escenarios: `backend` y `frontend`. Para el escenario `backend` son considerados seguros |
||||||
|
ambos atributos, `email` y `role`, y pueden ser asignados masivamente. Para el escenario `frontend`, `email` puede ser asignado |
||||||
|
masivamente mientras `role` no. Tanto `email` como `role` deben ser validados utilizando reglas (rules). |
||||||
|
|
||||||
|
El método [[yii\base\Model::rules()|rules()]] aún es utilizado para declara reglas de validación. |
||||||
|
Ten en cuenta que dada la introducción de [[yii\base\Model::scenarios()|scenarios()]], ya no existe el validador `unsafe`. |
||||||
|
|
||||||
|
En la mayoría de los casos, no necesitas sobrescribir [[yii\base\Model::scenarios()|scenarios()]] si el método [[yii\base\Model::rules()|rules()]] |
||||||
|
especifica completamente los escenarios que existirán, y si no hay necesidad de declarar atributos inseguros (`unsafe`). |
||||||
|
|
||||||
|
Para aprender más detalles de modelos, consulta la sección [Modelos](basic-models.md). |
||||||
|
|
||||||
|
|
||||||
|
Controladores |
||||||
|
------------- |
||||||
|
|
||||||
|
Yii 2.0 utiliza [[yii\web\Controller]] como controlador base, similar a `CWebController` en Yii 1.1. |
||||||
|
[[yii\base\Action]] es la clase base para clases de acciones. |
||||||
|
|
||||||
|
El impacto más obvio de estos cambios en tu código es que que cada acción del controlador debe devolver el contenido |
||||||
|
que quieres mostrar en vez de mostrarlo directamente: |
||||||
|
|
||||||
|
```php |
||||||
|
public function actionView($id) |
||||||
|
{ |
||||||
|
$model = \app\models\Post::findOne($id); |
||||||
|
if ($model) { |
||||||
|
return $this->render('view', ['model' => $model]); |
||||||
|
} else { |
||||||
|
throw new \yii\web\NotFoundHttpException; |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Por favor consulta la sección [Controllers](structure-controllers.md) para más detalles acerca de los controladores. |
||||||
|
|
||||||
|
|
||||||
|
Widgets |
||||||
|
------- |
||||||
|
|
||||||
|
Yii 2.0 utiliza [[yii\base\Widget]] como clase base de los widgets, similar a `CWidget` en Yii 1.1. |
||||||
|
|
||||||
|
Para obtener mejor soporte del framework en IDEs, Yii 2.0 introduce una nueva sintáxis para utilizar widgets. |
||||||
|
Los métodos estáticos [[yii\base\Widget::begin()|begin()]], [[yii\base\Widget::end()|end()]], y [[yii\base\Widget::widget()|widget()]] |
||||||
|
fueron incorporados, y deben utilizarse así: |
||||||
|
|
||||||
|
```php |
||||||
|
use yii\widgets\Menu; |
||||||
|
use yii\widgets\ActiveForm; |
||||||
|
|
||||||
|
// Ten en cuenta que debes pasar el resultado a "echo" para mostrarlo |
||||||
|
echo Menu::widget(['items' => $items]); |
||||||
|
|
||||||
|
// Pasando un array para inicializar las propiedades del objeto |
||||||
|
$form = ActiveForm::begin([ |
||||||
|
'options' => ['class' => 'form-horizontal'], |
||||||
|
'fieldConfig' => ['inputOptions' => ['class' => 'input-xlarge']], |
||||||
|
]); |
||||||
|
... campos del formulario aquí ... |
||||||
|
ActiveForm::end(); |
||||||
|
``` |
||||||
|
|
||||||
|
Consulta la sección [Widgets](structure-widgets.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Themes |
||||||
|
------ |
||||||
|
|
||||||
|
Los themes funcionan completamente diferente en Yii 2.0. Ahora están basados en un mecanismo de mapeo de rutas, |
||||||
|
que mapea la ruta de un archivo vista de origen a uno con un theme aplicado. Por ejemplo, si el path map de un theme es |
||||||
|
`['/web/views' => '/web/themes/basic']`, entonces la versión con el theme aplicado del archivo |
||||||
|
`/web/views/site/index.php` será `/web/themes/basic/site/index.php`. Por esta razón, ahora los themes pueden ser |
||||||
|
aplicados a cualquier archivo de vista, incluso una vista renderizada fuera del contexto de un controlador o widget. |
||||||
|
|
||||||
|
Además, el componente `CThemeManager` ya no existe. En cambio, `theme` es una propiedad configurable del componente `view` |
||||||
|
de la aplicación. |
||||||
|
|
||||||
|
Consulta la sección [Utilizando Themes](tutorial-theming.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Aplicaciones de Consola |
||||||
|
----------------------- |
||||||
|
|
||||||
|
Las aplicaciones de consola ahora están organizadas en controladores, tal como aplicaciones Web. Estos controladores |
||||||
|
deben extender de [[yii\console\Controller]], similar a `CConsoleCommand` en 1.1. |
||||||
|
|
||||||
|
Para correr un comando de consola, utiliza `yii <ruta>`, donde `<ruta>` se refiere a la ruta del controlador |
||||||
|
(e.j. `sitemap/index`). Los argumentos anónimos adicionales son pasados como parámetros al método de la acción correspondiente |
||||||
|
del controlador, mientras que los argumentos especificados son pasados de acuerdo a las declaraciones en [[yii\console\Controller::options()]]. |
||||||
|
|
||||||
|
Yii 2.0 soporta la generación automática de información de ayuda de los comandos a través de los bloques de comentarios del archivo. |
||||||
|
|
||||||
|
Por favor consulta la sección [Comandos de Consola](tutorial-console.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
I18N |
||||||
|
---- |
||||||
|
|
||||||
|
Yii 2.0 remueve el formateador de fecha y números previamente incluido en favor del [módulo de PHP PECL intl](http://pecl.php.net/package/intl). |
||||||
|
|
||||||
|
La traducción de mensajes ahora es ejecutada vía el componente `i18n` de la aplicación. |
||||||
|
Este componente maneja un grupo de mensajes origen, lo que te permite utilizar diferentes mensajes |
||||||
|
basados en categorías. |
||||||
|
|
||||||
|
Por favor consulta la sección [Internacionalización](tutorial-i18n.md) para más información. |
||||||
|
|
||||||
|
|
||||||
|
Filtros de Acciones |
||||||
|
------------------- |
||||||
|
|
||||||
|
En Yii 2.0, los filtros de acciones son implementados a través de comportamientos (behaviors). Para definir un |
||||||
|
nuevo filtro personalizado, se debe extender de [[yii\base\ActionFilter]]. Para utilizar el filtro, conecta la clase del filtro |
||||||
|
al controlador como un comportamiento. Por ejemplo, para utilizar el filtro [[yii\filters\AccessControl]], deberías tener |
||||||
|
el siguiente código en el controlador: |
||||||
|
|
||||||
|
```php |
||||||
|
public function behaviors() |
||||||
|
{ |
||||||
|
return [ |
||||||
|
'access' => [ |
||||||
|
'class' => 'yii\filters\AccessControl', |
||||||
|
'rules' => [ |
||||||
|
['allow' => true, 'actions' => ['admin'], 'roles' => ['@']], |
||||||
|
], |
||||||
|
], |
||||||
|
]; |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Consulta la sección [Filtrando](runtime-filtering.md) para mayor detalle del tema. |
||||||
|
|
||||||
|
|
||||||
|
Assets |
||||||
|
------ |
||||||
|
|
||||||
|
Yii 2.0 introduce un nuevo concepto llamado *asset bundle* que reemplaza el concepto de script package encontrado en Yii 1.1. |
||||||
|
|
||||||
|
Un asset bundle es una colección de assets (e.j. archivos JavaScript, archivos CSS, imágenes, etc.) dentro de un directorio. |
||||||
|
Cada asset bundle por una clase que extiende de [[yii\web\AssetBundle]]. |
||||||
|
Al registrar un asset bundle a través de [[yii\web\AssetBundle::register()]], haces que los assets de dicho bundle sean accesibles |
||||||
|
vía Web. A diferencia de Yii 1, la página que registra el bundle contendrá automáticamente las referencias a los archivos |
||||||
|
JavaScript y CSS especificados en el bundle. |
||||||
|
|
||||||
|
Por favor consulta la sección [Manejando Assets](output-assets.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Helpers |
||||||
|
------- |
||||||
|
|
||||||
|
Yii 2.0 introduce muchos comúnmente utilizados helpers estáticos, incluyendo. |
||||||
|
|
||||||
|
* [[yii\helpers\Html]] |
||||||
|
* [[yii\helpers\ArrayHelper]] |
||||||
|
* [[yii\helpers\StringHelper]] |
||||||
|
* [[yii\helpers\FileHelper]] |
||||||
|
* [[yii\helpers\Json]] |
||||||
|
* [[yii\helpers\Security]] |
||||||
|
|
||||||
|
Por favor consulta la sección [Pantallazo de Helpers](helper-overview.md) para más detalles. |
||||||
|
|
||||||
|
Formularios |
||||||
|
----------- |
||||||
|
|
||||||
|
Yii 2.0 introduce el concepto de *campo* para construir formularios utilizando [[yii\widgets\ActiveForm]]. Un campo |
||||||
|
es un contenedor que consiste en una etiqueta, un input, un mensaje de error y/o texto de ayuda. |
||||||
|
Un campo es representado como un objeto [[yii\widgets\ActiveField|ActiveField]]. |
||||||
|
Utilizando estos campos, puedes crear formularios más claramente que antes: |
||||||
|
|
||||||
|
```php |
||||||
|
<?php $form = yii\widgets\ActiveForm::begin(); ?> |
||||||
|
<?= $form->field($model, 'username') ?> |
||||||
|
<?= $form->field($model, 'password')->passwordInput() ?> |
||||||
|
<div class="form-group"> |
||||||
|
<?= Html::submitButton('Login') ?> |
||||||
|
</div> |
||||||
|
<?php yii\widgets\ActiveForm::end(); ?> |
||||||
|
``` |
||||||
|
|
||||||
|
Por favor consulta la sección [Creando Formularios](input-forms.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Query Builder |
||||||
|
------------- |
||||||
|
|
||||||
|
En Yii 1.1, la generación de consultas a la base de datos estaba dividida en varias clases, incluyendo `CDbCommand`, |
||||||
|
`CDbCriteria`, y `CDbCommandBuilder`. Yii 2.0 representa una consulta a la base de datos en términos de un objeto [[yii\db\Query|Query]] |
||||||
|
que puede ser convertido en una declaración SQL con la ayuda de [[yii\db\QueryBuilder|QueryBuilder]] detrás de escena. |
||||||
|
Por ejemplo: |
||||||
|
|
||||||
|
```php |
||||||
|
$query = new \yii\db\Query(); |
||||||
|
$query->select('id, name') |
||||||
|
->from('user') |
||||||
|
->limit(10); |
||||||
|
|
||||||
|
$command = $query->createCommand(); |
||||||
|
$sql = $command->sql; |
||||||
|
$rows = $command->queryAll(); |
||||||
|
``` |
||||||
|
|
||||||
|
Lo mejor de todo, dichos métodos de generación de consultas pueden ser también utilizados mientras se trabaja con [Active Record](db-active-record.md). |
||||||
|
|
||||||
|
Consulta la sección [Query Builder](db-query-builder.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Active Record |
||||||
|
------------- |
||||||
|
|
||||||
|
Yii 2.0 introduce muchísimos cambios con respecto a [Active Record](db-active-record.md). Los dos más obvios se relacionan a |
||||||
|
la generación de consultas y al manejo de relaciones. |
||||||
|
|
||||||
|
La clase de Yii 1.1 `CDbCriteria` es reemplazada por [[yii\db\ActiveQuery]] en Yii 2. Esta clase extiende de [[yii\db\Query]], |
||||||
|
y por lo tanto hereda todos los métodos de generación de consultas. |
||||||
|
Para comenzar a generar una consulta, llamas al método [[yii\db\ActiveRecord::find()]]: |
||||||
|
|
||||||
|
```php |
||||||
|
// Para traer todos los clientes *activos* y ordenarlos por su ID: |
||||||
|
$customers = Customer::find() |
||||||
|
->where(['status' => $active]) |
||||||
|
->orderBy('id') |
||||||
|
->all(); |
||||||
|
``` |
||||||
|
|
||||||
|
Para declarar una relación, simplemente define un método getter que devuelva un objeto [[yii\db\ActiveQuery|ActiveQuery]]. |
||||||
|
El nombre de la propiedad definida en el getter representa el nombre de la relación. Por ejemplo, el siguiente código declara |
||||||
|
una relación `orders` (en Yii 1.1, las relaciones se declaraban centralmente en el método `relations()`): |
||||||
|
|
||||||
|
```php |
||||||
|
class Customer extends \yii\db\ActiveRecord |
||||||
|
{ |
||||||
|
public function getOrders() |
||||||
|
{ |
||||||
|
return $this->hasMany('Order', ['customer_id' => 'id']); |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Ahora puedes utilizar `$customer->orders` para acceder a las órdenes de la tabla relacionada. También puedes utilizar el siguiente |
||||||
|
código para realizar al-vuelo una consulta relacionada con una condición personalizada: |
||||||
|
|
||||||
|
```php |
||||||
|
$orders = $customer->getOrders()->andWhere('status=1')->all(); |
||||||
|
``` |
||||||
|
|
||||||
|
Cuando se utiliza la carga temprana de la relación, Yii 2.0 lo hace diferente de 1.1. En particular, en 1.1 una declaración JOIN |
||||||
|
sería creada para seleccionar tanto los registros de la tabla primaria como los relacionados. En Yii 2.0, dos declaraciones SQL son ejecutadas |
||||||
|
sin utilizar un JOIN: la primera traer todos los modelos primarios, mientras que la segunda trae los registros relacionados |
||||||
|
utilizando como condición la clave primaria de los primarios. |
||||||
|
|
||||||
|
En vez de devolver objetos [[yii\db\ActiveRecord|ActiveRecord]], puedes conectar el método [[yii\db\ActiveQuery::asArray()|asArray()]] |
||||||
|
mientras generas una query que devuelve un gran número de registros. Esto causará que el resultado de la consulta sea devuelto como |
||||||
|
arrays, lo que puede reducir significativamente la necesidad de tiempo de CPU y memoria si el número de registros es grande. |
||||||
|
Por ejemplo: |
||||||
|
|
||||||
|
```php |
||||||
|
$customers = Customer::find()->asArray()->all(); |
||||||
|
``` |
||||||
|
|
||||||
|
Otro cambio es que ya no puedes definir valores por defecto a los atributos a través de propiedades publicas. |
||||||
|
Si lo necesitaras, debes definirlo en el método init de la clase del registro en cuestión. |
||||||
|
|
||||||
|
```php |
||||||
|
public function init() |
||||||
|
{ |
||||||
|
parent::init(); |
||||||
|
$this->status = self::STATUS_NEW; |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Solía haber algunos problemas al sobrescribir el constructor de una clase ActiveRecord en 1.1. Estos ya no están presentes en |
||||||
|
Yii 2.0. Ten en cuenta que al agregar parámetros al constructor podrías llegar a tener que sobrescribir [[yii\db\ActiveRecord::instantiate()]]. |
||||||
|
|
||||||
|
Hay muchos otros cambios y mejoras con respecto a ActiveRecord. Por favor consulta |
||||||
|
la sección [Active Record](db-active-record.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
User e IdentityInterface |
||||||
|
------------------------ |
||||||
|
|
||||||
|
La clase `CWebUser` de 1.1 es reemplazada por [[yii\web\User]], y la clase `CUserIdentity` ya no existe. |
||||||
|
En cambio, ahora debes implementar [[yii\web\IdentityInterface]] lo que es mucho más directo para usar. |
||||||
|
El template de Aplicación Avanzada provee un ejemplo así. |
||||||
|
|
||||||
|
Consulta las secciones [Autenticación](security-authentication.md), [Autorización](security-authorization.md), y [Template de Aplicación Avanzanda](tutorial-advanced-app.md) para más detalles. |
||||||
|
|
||||||
|
|
||||||
|
Manejo de URLs |
||||||
|
-------------- |
||||||
|
|
||||||
|
El manejo de URLs en Yii 2 es similar al de 1.1. Una mejora mayor es que el manejador actual ahora soporta parámetros opcionales. |
||||||
|
Por ejemplo, si tienes una regla declarada como a continuación, entonces coincidirá tanto con `post/popular` como `post/1/popular`. |
||||||
|
En 1.1, tendrías que haber creado dos reglas diferentes para obtener el mismo resultado |
||||||
|
|
||||||
|
```php |
||||||
|
[ |
||||||
|
'pattern' => 'post/<page:\d+>/<tag>', |
||||||
|
'route' => 'post/index', |
||||||
|
'defaults' => ['page' => 1], |
||||||
|
] |
||||||
|
``` |
||||||
|
|
||||||
|
Por favor consulta la sección [Documentación del Manejo de URLs](url.md) para más detalles. |
||||||
|
|
||||||
|
Utilizando Yii 1.1 y 2.x juntos |
||||||
|
------------------------------- |
||||||
|
|
||||||
|
Si tienes código en Yii 1.1 que quisieras utilizar junto con Yii 2.0, por favor consulta |
||||||
|
la sección [Using Yii 1.1 and 2.0 Together](extend-using-v1-v2.md). |
||||||
|
|
Loading…
Reference in new issue