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:
// ... se aplica la inicialización antes de la configuración
parent::__construct($config);
}
publicfunctioninit()
{
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
publicfunctionscenarios()
{
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
publicfunctionactionView($id)
{
$model=\app\models\Post::findOne($id);
if($model){
return$this->render('view',['model'=>$model]);
}else{
thrownew\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
useyii\widgets\Menu;
useyii\widgets\ActiveForm;
// Ten en cuenta que debes pasar el resultado a "echo" para mostrarlo
echoMenu::widget(['items'=>$items]);
// Pasando un array para inicializar las propiedades del objeto
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()`):
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
publicfunctioninit()
{
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 y 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).
