From 1084be0fb57d77f3887c9cd27c5d4a958872fecc Mon Sep 17 00:00:00 2001 From: Lorenzo Milesi Date: Sun, 12 Oct 2014 21:41:56 +0200 Subject: [PATCH 1/2] Italian translation of intro-upgrade-from-v1.md --- docs/guide-it/intro-upgrade-from-v1.md | 529 +++++++++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 docs/guide-it/intro-upgrade-from-v1.md diff --git a/docs/guide-it/intro-upgrade-from-v1.md b/docs/guide-it/intro-upgrade-from-v1.md new file mode 100644 index 0000000000..147637583f --- /dev/null +++ b/docs/guide-it/intro-upgrade-from-v1.md @@ -0,0 +1,529 @@ +Aggiornare dalla versione 1.1 +============================= + +Ci sono molte differenze tra la versione 1.1 e la 2.0 di Yii, dato che il framework è stato completamente riscritto. +Di conseguenza l'aggiornamento dalla versione 1.1 non è così semplice come passare da una versione minore all'altra. In questa guida +troverai le differenze principali tra le due versioni. + +Se non hai mai usato Yii 1.1 puoi ignorare questa sezione e passare direttamente a "[Come inizare](start-installation.md)". + +Considera che Yii 2.0 introduce più funzionalità di quelle descritte in questo riepilogo. Ti consigliamo di leggere tutta la +guida definitiva per apprenderle tutte. C'è la possibilità che alcune funzionalità che prima dovevi sviluppare da solo sono state +implementate nel codice principale. + + +Installazione +------------- + +Yii 2.0 usa [Composer](https://getcomposer.org/), lo standard di fatto per la gestione dei pacchetti PHP. L'installazione del +framework di base, così come delle estensioni, sono gestite da Composer. Per favore leggi la guida [Installare Yii](start-installation.md) +per comprendere come installare Yii 2.0. Se vuoi creare una nuova estensione, o trasformarne una sviluppata per 1.1 a 2.0, fai riferimento +alla sezione [Creazione estensioni](structure-extensions.md#creating-extensions). + + +Richieste PHP +------------- + +Yii 2.0 richiede PHP 5.4 o superiore, il che è un passaggio notevole rispetto alla richiesta di PHP 5.2 di Yii 1.1. +Di conseguenza ci sono diverse differenze a livello di linguaggio a cui devi fare attenzione. +Di seguito un riepilogo delle principali differenze relative a PHP: + +- [Namespace](http://php.net/manual/en/language.namespaces.php). +- [Funzioni anonime](http://php.net/manual/en/functions.anonymous.php). +- La sintassi breve per gli array `[...elementi...]` è utilizzabile invece di `array(...elementi...)`. +- Le tag brevi per le echo ` 'MyClass', + 'proprieta1' => 'abc', + 'proprieta2' => 'cde', +], [$param1, $param2]); +``` + +Maggiori dettagli sulla configurazione si trovano nella sezione [Configurazione oggetti](concept-configurations.md). + + +Eventi +------ + +In Yii 1 gli eventi venivano creati definendo un metodo `on`-qualcosa (ad es. `onBeforeSave`). In Yii 2 ora puoi usare un qualunque +nome per l'evento. Puoi scatenare un evento chiamando il metodo [[yii\base\Component::trigger()|trigger()]]: + +```php +$event = new \yii\base\Event; +$component->trigger($eventName, $event); +``` + +Per collegare un metodo ad un evento usa il metodo [[yii\base\Component::on()|on()]]: + +```php +$component->on($eventName, $handler); +// Per scollegare il metodo dall'evento, usa: +// $component->off($eventName, $handler); +``` + +Ci sono molti miglioramenti sulle funzionalità degli eventi. Per maggiori dettagli fai riferimento alla sezione +[Eventi](concept-events.md). + + +Alias percorsi +-------------- + +Yii 2.0 espande l'utilizzo degli alias di percorso (Path alias, in inglese) a file e directory sia locali che remoti (URL). Yii 2.0 +richiede ora che un percorso alias inizi con il carattere `@`, per differenziarli da normali percorsi o URL. +Per esempio, l'alias `@yii` si riferisce alla directory di installazione di Yii. Gli alias di percorso sono supportati nella maggior +parte del codice base di Yii. Per esempio, [[yii\caching\FileCache::cachePath]] può ricevere sia un alias che un percorso normale ad +una directory. + +Un alias di percorso è strettamente legato al namespace della classe. Si saccomanda di definire un alias per ogni namespace root, +consentendo così di usare le funzioni di autoload di Yii senza configurazioni aggiuntive. Per esempio, visto che `@yii` si riferisce +alla directory di instllazione di Yii, una classe come `yii\web\Request` può essere caricata automaticamente. Se usi una libreria di terze +parti, come ad esempio il framework Zend, puoi definire un alias `@Zend` che si riferisce alla sua directory di installazione. Fatto +questo, Yii sarà in grado di caricare automaticamente qualunque classe della libreria Zend. + +Maggiori informazioni sugli alias di percorso nella sezione [Aliase](concept-aliases.md). + + +Viste +----- + +Il cambiamento più evidente riguardante le viste è che in Yii 2 la variabile speciale `$this` in una vista non si riferisce più +al controller o al widget corrente. Invece `$this` si riferisce ora all'oggetto *view*, un nuovo concetto introdotto nella versione 2.0. +L'oggetto *view* è di tipo [[yii\web\View]], che rappresenta la parte della vista nel modello MVC. Per accedere al controller o al +widget dalla vista, puoi usare `$this->context`. + +Per effettuare il render di una vista parzioale all'interno di un'altra vista devi usare `$this->render()`, non `$this->renderPartial()`. +La chiamata a `render` deve essere ora esplicitamente mandata in output (tramite `echo`), dato che ora il metodo `render()` restituisce +il risultato dell'elaborazione della vista piuttosto che visualizzarlo. Per esempio: + +```php +echo $this->render('_item', ['item' => $item]); +``` + +Oltre ad usare PHP come linguaggio principale di template, Yii 2.0 supporta ufficialmente anche altri due motori di template: +Smarty e Twig. Il motore Prado non è più supportato. +Per usare questi engine devi configurare il componente `view` impostando la proprietà [[yii\base\View::$renderers|View::$renderers]]. +Fai riferimento alla sezione [Template Engine](tutorial-template-engines.md) per maggiori dettagli. + + +Modelli +------- + +Yii 2.0 usa [[yii\base\Model]] come modello base, simile a `CModel` di 1.1. +La classe `CFormModel` è stata rimossa. In Yii 2 invece devi estendere [[yii\base\Model]] per creare un modello da impiegare in un form. + +Yii 2.0 introduce il nuovo metodo [[yii\base\Model::scenarios()|scenarios()]] per dichiarare gli scenari supportati, e per indicare +in quale scenario devono essere validati gli attributi, se devono essere considerati *safe* o no, e così via. PEr esempio: + +```php +public function scenarios() +{ + return [ + 'backend' => ['email', 'role'], + 'frontend' => ['email', '!role'], + ]; +} +``` + +Nell'esempio sopra sono stati definiti due scenari: `backend` e `frontend`. Per lo scenario `backend` sono considerati sicuri (`safe`) +entrambi gli attributi `email` e `role`, e possono essere assegnati massivamente. Per lo scenario `frontend` l'`email` può essere +assegnata in sicurezza mentre il `role` no. Entrambi i campi dovrebbero essere validati usando regole opportune. + +Viene ancora usato il metodo [[yii\base\Model::rules()|rules()]] per definire le regole di validazione. Nota che in conseguenza +dell'introduzione del metodo [[yii\base\Model::scenarios()|scenarios()]] non esiste più la validazione `unsafe`. + +Nella maggior parte dei casi non avrai la necessità di sovrascrivere [[yii\base\Model::scenarios()|scenarios()]] se il metodo +[[yii\base\Model::rules()|rules()]] specifica già tutti gli scenari esistenti, e se non hai necessità di dichiarare attributi `unsafe`. + +Per apprendere più dettagli in merito ai modelli, fare riferimento alla sezione [Modelli](structure-models.md). + + +Controller +---------- + +Yii 2.0 use [[yii\web\Controller]] come classe base per i controller, che è simile a `CController` di Yii 1.1. +[[yii\base\Action]] è la classe base per le classi di azioni. + +L'impatto più ovvio di questi cambiamenti nel tuo codice è che l'azione di un controller deve tornare il contenuto da visualizzare, invece +di emetterlo direttamente: + +```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; + } +} +``` + +Fai riferimento alla sezione [Controller](structure-controllers.md) per maggiori dettagli in merito. + + +Widget +------ + +Yii 2.0 use [[yii\base\Widget]] come classe base per i widget, simile a `CWidget` di Yii 1.1. + +Per ottenere un supporto migliore al framework usando le IDE, Yii 2.0 introduce una nuova sintassi per l'utilizzo dei widget. Sono stati +introdotti i metodi statici [[yii\base\Widget::begin()|begin()]], [[yii\base\Widget::end()|end()]], e [[yii\base\Widget::widget()|widget()]] +da usare così: + +```php +use yii\widgets\Menu; +use yii\widgets\ActiveForm; + +// Nota che devi emettere a video ("echo") il risultato per visualizzarlo +echo Menu::widget(['items' => $items]); + +// Passaggio di un array per inizializzare le proprietà dell'oggetto +$form = ActiveForm::begin([ + 'options' => ['class' => 'form-horizontal'], + 'fieldConfig' => ['inputOptions' => ['class' => 'input-xlarge']], +]); +... campi di input del form ... +ActiveForm::end(); +``` + +Fai riferimento alla sezione [Widget](structure-widgets.md) per maggiori dettagli. + + +Temi +---- + +I temi sono completamente diversi nella versione 2.0. Ora sono basati su un meccanismo di mappatura dei percorsi, in modo da +creare una corrispondenza tra il percorso di un file vista sorgente e il percorso di un file di vista del tema. Per esempio se la mappa +è `['/web/views' => '/web/themes/basic']`, la versione personalizzata del tema del file +`/web/views/site/index.php` sarà `/web/themes/basic/site/index.php`. Per questo motivo ora i temi possono essere applicati a qualunque +file di vista, anche per una vista elaborata al di fuori del contesto di un controller o di un widget. + +Inoltre non c'è più il componente`CThemeManager`. Esiste invece una proprietà configurabile `theme` del componente `view`. + +Fai rfierimento alla sezione [Temi](output-theming.md) per maggiori dettagli. + + +Applicazioni da console +----------------------- + +Le applicazioni da console (linea di comando) sono ora organizzate come controller, come le applicazioni web. I controller devono quindi +estendere [[yii\console\Controller]], simile alla classe `CConsoleCommand` della versione 1.1. + +Per eseguire un comando da terminale usare `yii `, dove `` rappresenta la rotta di un controller +(es. `sitemap/index`). I parametri anonimi aggiuntivi vengono passati come parametri al relativo metodo dell'azione nel controller, mentre +i parametri specifici (con nome) vengono processati secondo le specifiche di [[yii\console\Controller::options()]]. + +Yii 2.0 supporta la generazione automatica dell'help dei comandi prelevando le informazioni dai blocchi di commento. + +Fai riferimento alla sezione [Console Commands](tutorial-console.md) per ulteriori dettagli. + + +I18N +---- + +Yii 2.0 ha rimosso la formattazione interna di date e numeri in favore del [modulo PECL di PHP](http://pecl.php.net/package/intl). + +La traduzione dei messaggi viene effettuata dal componente `i18n`. +Questo componente gestisce una serie di sorgenti di messaggi, il che ti consente di usare diverse sorgenti di messaggio basate sulle +categorie. + +Fai riferimento alla sezione [Internazionalizzazione](tutorial-i18n.md) per maggiori dettagli. + + +Filtri azioni +------------- + +I filtri sulle azioni vengono ora implementati tramite i *behavior*. Per definire un nuovo filtro personalizzato devi estendere da +[[yii\base\ActionFilter]]. Per usare un filtro collega la relativa classe ai *behavior* del controller. Per esempio, per usare +il filtro [[yii\filters\AccessControl]] dovrai avere questo codice nel controller: + +```php +public function behaviors() +{ + return [ + 'access' => [ + 'class' => 'yii\filters\AccessControl', + 'rules' => [ + ['allow' => true, 'actions' => ['admin'], 'roles' => ['@']], + ], + ], + ]; +} +``` + +Fai riferimento alla sezione [Filtri](structure-filters.md) per maggiori dettagli. + + +Asset +----- + +Yii 2.0 introduce un nuovo concetto chiamato *asset bundle* che rimpiazza il concetto dei pacchetti di script di Yii 1.1. + +Un *asset bundle* è una collezione di file di asset (ad es. file Javascript, CSS, immagini...) all'interno di una directory. +Ogni *asset bundle* è rappresentato da una classe che estende [[yii\web\AssetBundle]]. +Registrando un *asset bundle* tramite il metodo [[yii\web\AssetBundle::register()]], renderai disponibile gli asset di quel pachetto +disponibili via web. Diversamente da Yii 1.1 la pagina che registra il pacchetto conterrà automaticamente le referenze ai file Javascript +e CSS specificati al suo interno. + +Fai riferimento alla sezione [Gestione asset](structure-assets.md) per maggiori informazioni. + + +Helper +------ + +Yii 2.0 introduce molte classi statiche di uso comune, tra cui: + +* [[yii\helpers\Html]] +* [[yii\helpers\ArrayHelper]] +* [[yii\helpers\StringHelper]] +* [[yii\helpers\FileHelper]] +* [[yii\helpers\Json]] + +Fai riferimento alla sezione [Panoramica sugli Helper](helper-overview.md) per maggiori dettagli. + +Form +---- + +Yii 2.0 introduce il concetto di *campo* per la costruzione dei form usando [[yii\widgets\ActiveForm]]. Un campo è un +contentitore costituito da un'etichetta, un input, un messaggio di errore e/o un testo di suggerimento. +Un campo è rappresentato come un oggetto [[yii\widgets\ActiveField|ActiveField]]. +Usando i campi potrai creare un form in un modo molto più pulito che in precedenza: + +```php + + field($model, 'username') ?> + field($model, 'password')->passwordInput() ?> +
+ +
+ +``` + +Fai riferimento alla sezione [Creazione form](input-forms.md) per maggiori dettagli. + + +Query Builder +------------- + +In 1.1 la costruzione di query era dispersa in diverse classi, inclusa `CDbcommand`, +`CDbCriteria`, e `CDbCommandBuilder`. Yii 2.0 gestisce le query mediante un oggetto [[yii\db\Query|Query]] +che può essere trasformato in un comando SQL con l'aiuto di [[yii\db\QueryBuilder|QueryBuilder]] dietro le quinte. +Per esempio: + +```php +$query = new \yii\db\Query(); +$query->select('id, nome') + ->from('user') + ->limit(10); + +$comando = $query->createCommand(); +$sql = $command->sql; +$righe = $command->queryAll(); +``` + +Ma la cosa migliore di tutte è che gli stessi metodi di costruzione delle query possono essere usati con oggetti di +tipo [Active Record](db-active-record.md). + +Fai riferimento alla sezione [Query Builder](db-query-builder.md) per maggiori dettagli. + + +Active Record +------------- + +Yii 2.0 introduce molti cambiamenti agli [Active Record](db-active-record.md). I due più evidenti riguardano la costruzione delle +query e la gestione delle relazioni. + +La classe `CDbCriteria` della versione 1.1 è stata rimpiazzata da [[yii\db\ActiveQuery]]. Questa classe estende [[yii\db\Query]], e +ne eredita quindi tutti i metodi di costruzione delle query. Per iniziare la costruzione di una query devi chiamare +[[yii\db\ActiveRecord::find()]]: + +```php +// Per ottenere tutti i clienti *attivi* e ordinarli per ID: +$clienti = Clienti::find() + ->where(['stato' => $attivo]) + ->orderBy('id') + ->all(); +``` + +Per dichiarare una relazione devi semplicemente definire una *getter* che ritorna un oggetto [[yii\db\ActiveQuery|ActiveQuery]]. +Il nome della proprietà definito dalla *getter* rappresenta il nome della relazione. Ad esempio il codice qui di seguito dichiara +una relazione `ordini` (in 1.1 avresti dovuto farlo nel metodo `relations()`): + +```php +class Cliente extends \yii\db\ActiveRecord +{ + public function getOrdini() + { + return $this->hasMany('Ordine', ['cliente_id' => 'id']); + } +} +``` + +Ora puoi usare `$cliente->ordini` per accedere agli ordini del cliente nella tabella collegata. Puoi usare anche questo codice +per effettuare una query relazionale al volo con una condizione di ricerca personalizzata: + +```php +$ordini = $cliente->getOrdini()->andWhere('stato=1')->all(); +``` + +Quando si usa il caricamento immediato di una relazione, Yii 2.0 si comporta diversamente rispetto alla versione precedente. In +particolare, Yii 1.1 creava una query con JOIN con sia il record primario che la relazione. In Yii 2.0 vengono invece eseguite due +query SQL distinte, senza JOIN: la prima carica le righe della tabella primaria e la seconda recupera le righe della tabella in relazione +basandosi sulle chiavi ottenute dalla prima. + +Invece di tornare oggetti [[yii\db\ActiveRecord|ActiveRecord]], puoi sfruttare il metodo [[yii\db\ActiveQuery::asArray()|asArray()]] +in caso di query che tornano un cospicuo numero di risultati. In questo modo i risultati saranno in formato di array, il che consente +di risparmiare l'utilizzo di CPU e memoria in caso di grandi volumi di record. Per esempio: + +```php +$clienti = Cliente::find()->asArray()->all(); +``` + +Un'altra differenza è che non puoi più definire valori predefiniti per gli attributi tramite proprietà pubbliche. +Se ti servono li puoi impostare nel metodo `init` della tua classe ActiveRecord. + +```php +public function init() +{ + parent::init(); + $this->stato = self::STATO_NUOVO; +} +``` + +Nella versione precedente c'erano problemi nell'override del costruttore di un ActiveRecord. Questi problemi sono stati risolti +in questa versione. Tieni presente che se devi aggiungere parametri al costruttore devi probabilmente sovrascrivere +[[yii\db\ActiveRecord::instantiate()]]. + +Ci sono molti altri cambiamenti e miglioramenti sugli Active Record. Fai riferimento alla sezione +[Active Record](db-active-record.md) per maggiori dettagli. + + +Behavior di Active Record +------------------------- + +Nella 2.0 è stata rimossa la classe base `CActiveRecordBehavior`. Per creare un nuovo behavior devi estendere direttamente +`yii\base\Behavior`. Se la classe deve gestire degli eventi dell'*owner*, devi sovrascrivere il metodo `events()` come qui di seguito: + +```php +namespace app\components; + +use yii\db\ActiveRecord; +use yii\base\Behavior; + +class MioBehavior extends Behavior +{ + // ... + + public function events() + { + return [ + ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate', + ]; + } + + public function beforeValidate($event) + { + // ... + } +} +``` + + +Utenti e IdentityInterface +-------------------------- + +La classe `CWebUser` di Yii 1.1 è stata rimpiazzata da [[yii\web\User]], e non esiste più la +`CUserIdentity`. In Yii 2.0 devi implementare [[yii\web\IdentityInterface]] che risulterà molto più immediata da usare. +Il template dell'applicazione avanzata fornisce un esempio di implementazione di quella libreria. + +Fai riferimento alle sezioni [Autenticazione](security-authentication.md), [Autorizzazione](security-authorization.md) e +[Template applicazione avanzata](tutorial-advanced-app.md) per maggiori informazioni. + + +Gestione degli URL +------------------ + +La gestione degli URL è molto simile a quella implementata in Yii 1.1. Uno dei miglioramenti più rilevanti è che ora sono supportati +i parametri. Per esempio, una regola dichiarata come qui di seguito prenderà sia `post/popolari` che `post/1/popolari`. Nella 1.1 +ci sarebbero volute due regole per lo stesso risultato. + +```php +[ + 'pattern' => 'post//', + 'route' => 'post/index', + 'defaults' => ['page' => 1], +] +``` + +Fai riferimento alla sezione [Url manager](runtime-url-handling.md) per ulteriori dettagli. + +Usare Yii 1.1 e 2.x insieme +--------------------------- + +Se hai del vecchio codice scritto per Yii 1.1 che vuoi usare insieme a Yii 2.0, fai riferimento alla sezione +[Usare Yii 1.1 e 2.0 insieme](tutorial-yii-integration.md). + From 2df95b4e2fde6dac83515aafb17fa4fcad098dfc Mon Sep 17 00:00:00 2001 From: Lorenzo Milesi Date: Sun, 12 Oct 2014 23:15:40 +0200 Subject: [PATCH 2/2] Italian translation of start-installation.md --- docs/guide-it/start-installation.md | 210 ++++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 docs/guide-it/start-installation.md diff --git a/docs/guide-it/start-installation.md b/docs/guide-it/start-installation.md new file mode 100644 index 0000000000..7745175da7 --- /dev/null +++ b/docs/guide-it/start-installation.md @@ -0,0 +1,210 @@ +Installare Yii +============== + +Puoi installare Yii in due modi, usando [Composer](http://getcomposer.org/) o scaricando un archivio. +Il metodo preferito è il primo, perché ti consente di installare [estensioni](structure-extensions.md) o aggiornare il core di Yii +semplicemente eseguendo un comando. + +> Nota: diversamente da Yii 1, le installazioni standard di Yii 2 comportano il download e l'installazione sia del framework che dello scheletro dell'applicazione + + +Installazione via Composer +-------------------------- + +Se non hai già installato Composer puoi farlo seguendo le istruzioni al sito +[getcomposer.org](https://getcomposer.org/download/). Su Linux e Mac OS X puoi installare Composer con questo comando: + + curl -s http://getcomposer.org/installer | php + mv composer.phar /usr/local/bin/composer + +Su Windows devi scaricare ed eseguire [Composer-Setup.exe](https://getcomposer.org/Composer-Setup.exe). + +Fai riferimento alla [documentazione di Composer](https://getcomposer.org/doc/) in casodi errori o se vuoi apprendere maggiori +informazioni sull'uso di Composer. + +Se hai già Composer installato assicurati di avere una versione aggiornata. Puoi aggiornare Composer con il comando +`composer self-update`. + +Una volta installato Composer, puoi installare Yii eseguendo questo comando in una directory accessbile via web: + + composer global require "fxp/composer-asset-plugin:1.0.0-beta2" + composer create-project --prefer-dist yiisoft/yii2-app-basic basic + +Il primo comando installa il [plugin composer asset](https://github.com/francoispluchino/composer-asset-plugin/) +che consente di gestire le dipendenze di bower e npm tramite Composer. Devi eseguire questo comando solo una volta. Il secondo +installa Yii in una directory di nome `basic`. Puoi scegliere un nome diverso, se preferisci. + +> Nota: durante l'installazione potrebbe essere che Composer ti chieda le credenziali di Github, per superato limite di utilizzo +> delle API di Github. Questa situazione è normale perché Composer deve scaricare molte informazioni per tutti i pacchetti da Github. +> Accedendo a Github aumenterà il limite di utilizzo delle API, consentendo a Composer di completare il suo lavoro. Per maggiori +> dettagli fai riferimento alla +> [documentazione di Composer](https://getcomposer.org/doc/articles/troubleshooting.md#api-rate-limit-and-oauth-tokens). + +> Suggerimento: se vuoi installare l'ultima versione di sviluppo di Yii, puoi usare questo comando che aggiunge una +> [opzione di stabilità](https://getcomposer.org/doc/04-schema.md#minimum-stability): +> +> composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic +> +> Considera che la versione di sviluppo di Yii non dovrebbe essere utilizzata per siti di produzione perché potrebbe rendere instabile +> il tuo codice. + + +Installazione da un archivio +---------------------------- + +L'installazione da un archivio compresso comporta tre passaggi: + +1. Scaricare l'archivio da [yiiframework.com](http://www.yiiframework.com/download/). +2. Scompattare l'archivio in una directory accessible via web. +3. Modificare il file `config/web.php` inserendo una chiave segreta per il parametro di configurazione `cookieValidationKey` + (questa operazione viene fatta automaticamente se installi tramite Composer): + + ```php + // !!! insert a secret key in the following (if it is empty) - this is required by cookie validation + 'cookieValidationKey' => 'enter your secret key here', + ``` + + +Altre modalità di installazione +------------------------------- + +Le istruzioni sopra elencate mostrano come installare Yii, e creano inoltre un'applicazione web base funzionante. +Questo approccio è un ottimo punto di partenza per progetti minori, o se stai imparando Yii. + +Ma ci sono altre opzioni disponibili per l'installazione: + +* se vuoi installare solo il core e costruire l'applocazione da zero puoi seguire le istruzioni della sezione + [costruire un'applicazione da zero](tutorial-start-from-scratch.md). +* se vuoi avviare un'applicazione più sofisticata, che meglio si sposa per uno sviluppo di gruppo, puoi considerare l'insallazione del + [template di applicazione avanzata](tutorial-advanced-app.md). + + +Verifica dell'installazione +--------------------------- + +Dopo l'installazione puoi usare il tuo browser per accedere all'applicazione Yii installata con l'URL seguente: + +``` +http://localhost/basic/web/index.php +``` + +Questo indirizzo assume che hai installato Yii in una directory di nome `basic`, direttamente nella *root* del tuo webserver, +e che il webserver è in esecuzione sulla tua macchina locale (`localhost`). Potresti doverlo modificare a seconda del tuo ambiente +di installazione. + +![Installazione di Yii completata con successo](images/start-app-installed.png) + +Dovresti vedere la pagina sopra di congratulazioni. In caso contrario verifica se la tua installazione di PHP soddisfa i requisiti minimi +di Yii. Puoi verificare le richieste in due modi: + +* accedere all'indirizzo `http://localhost/basic/requirements.php` tramite browser; +* lanciando questi comandi: + + ``` + cd basic + php requirements.php + ``` + +Devi configurare la tua installazione di PHP in modo che soddisfi le richieste minime di Yii. E' molto importante che tu stia usando +PHP 5.4 o successivo. Devi inoltre installare le [estensioni PDO di PHP](http://www.php.net/manual/en/pdo.installation.php) e un driver +di database di PDO (come ad esempio `pdo_mysql` per i database MySQL), se la tua applicazione richiede un database. + + +Configurazione del webserver +---------------------------- + +> Informazione: puoi saltare questa parte per ora se stai solo provando Yii e non hai intenzione di installarlo su un server di produzione. + +L'applicazione installata secondo le istruzioni sopra dovrebbe funzionare senza problemi su un server +[Apache](http://httpd.apache.org/) o [Nginx](http://nginx.org/), su Windows, Mac OS X, or Linux equipaggiati con PHP 5.4 o successivo. +Yii 2.0 è anche compatibile con le librerie [HHVM](http://hhvm.com/) di Facebook, tuttavia ci sono alcuni casi limite dove HHVM si +comporta diversamente dal PHP nativo, quindi devi avere maggiore cura se intendi usare HHVM. + +Su un server di produzione vorrai probabilmente che la tua applicazione sia accessibile tramite l'url +`http://www.example.com/index.php` invece di `http://www.example.com/basic/web/index.php`. Questo risultato richiede che punti la +*document root* del tuo webserver nella directory `basic/web`. Vorrai magari anche nascondere `index.php` dall'URL, come descritto +nella sezione [analizzare e generare URL](runtime-url-handling.md). +In questa parte vedrai configurare il tuo server Apache o Nginx per ottenere questo risultato. + +> Informazione: impostando `basic/web` come *document root* impedisci agli utenti finali di accedere al codice e a file/informazioni +riservate memorizzate nelle directory superiori a `basic/web`. Negare l'accesso a queste altre cartelle è sicuramente un vantaggio +per la sicurezza. + +> Informazione: se la tua applicazione andrà installata su un servizio di hosting condiviso non avrai il permesso di modificare la +configurazione del webserver, ma dovrai comunque correggere la struttura della tua applicazione per migliorare la sicurezza. Fai +riferimento alla sezione [ambienti di hosting condiviso](tutorial-shared-hosting.md) per maggiori dettagli. + + +### Configurazione consigliata di Apache + +Usa questa configurazione nel file `httpd.conf` di Apache o nella definizione del tuo *VirtualHost*. Tieni presente che dovrai +modificare `path/to/basic/web` con il percorso reale della tua `basic/web`. + +``` +# Imposta *DocumentRoot* per essere "basic/web" +DocumentRoot "path/to/basic/web" + + + # usa mod_rewrite per gli url SEF + RewriteEngine on + # If a directory or a file exists, use the request directly + RewriteCond %{REQUEST_FILENAME} !-f + RewriteCond %{REQUEST_FILENAME} !-d + # Otherwise forward the request to index.php + RewriteRule . index.php + + # ...altre impostazioni... + +``` + + +### Configurazione consigliata di Nginx + +Devi aver installato PHP con il demone [FPM](http://php.net/install.fpm) per usare [Nginx](http://wiki.nginx.org/). +Usa questa configurazione per Nginx, sostituendo `path/to/basic/web` con il percorso reale di `basic/web` e `mysite.local` con +il nome reale del server web. + +``` +server { + charset utf-8; + client_max_body_size 128M; + + listen 80; ## listen for ipv4 + #listen [::]:80 default_server ipv6only=on; ## listen for ipv6 + + server_name mysite.local; + root /path/to/basic/web; + index index.php; + + access_log /path/to/basic/log/access.log main; + error_log /path/to/basic/log/error.log; + + location / { + # Redirect everything that isn't a real file to index.php + try_files $uri $uri/ /index.php?$args; + } + + # uncomment to avoid processing of calls to non-existing static files by Yii + #location ~ \.(js|css|png|jpg|gif|swf|ico|pdf|mov|fla|zip|rar)$ { + # try_files $uri =404; + #} + #error_page 404 /404.html; + + location ~ \.php$ { + include fastcgi.conf; + fastcgi_pass 127.0.0.1:9000; + #fastcgi_pass unix:/var/run/php5-fpm.sock; + try_files $uri =404; + } + + location ~ /\.(ht|svn|git) { + deny all; + } +} +``` + +Usando questa configurazione dovresti anche impostare `cgi.fix_pathinfo=0` in `php.ini` per evitare molte chiamate di sistema `stat()` +inutili. + +Inoltre considera che nel caso di server HTTPS dovrai aggiungere `fastcgi_param HTTPS on;` così che Yii possa correttamente rilevare +se la connessione è sicura.