French (Français) translation by honeymmmm (you can also view the original English article)
Dans cette mini-série Nettuts +, nous allons créer une application Web à partir de zéro, tout en plongeant dans un nouveau framework PHP qui prend rapidement de l'ampleur, appelé Laravel, un framework PHP 5.3 simple et élégant.
Tout d'abord, nous en apprendrons davantage sur Laravel, et pourquoi c'est un si bon choix pour votre prochaine application Web basée sur PHP.
Introduction: Qu'est-ce que Laravel
Laravel est un framework propre et élégant pour le développement web PHP. En vous libérant du code spaghetti, il vous aide à créer de merveilleuses applications en utilisant une syntaxe simple et expressive. Le développement devrait être une expérience créative que vous appréciez et non quelque chose de douloureux. Profitez de l'air frais!
Laravel est un framework PHP 5.3 qui se décrit comme un «Framework for Web Artisans». Selon son auteur, Taylor Otwell, Laravel s'efforce de ramener la joie à la programmation en rendant Laravel simple, élégant et, surtout, bien documenté.
De mon expérience avec le cadre, je suis tout à fait d’accord pour dire que Laravel atteint ces trois points morts:
- Simple - Les fonctionnalités de Laravel sont faciles à comprendre et à mettre en œuvre. Si vous aimez la simplicité et la facilité de CodeIgniter, alors vous allez adorer Laravel
- Élégant - la plupart des fonctions de Laravel fonctionnent de manière transparente avec très peu de configuration, en s'appuyant sur des conventions standard pour réduire le gonflement du code
- Bien documenté - La documentation de Laravel est complète et toujours à jour. Le créateur d'infrastructure met un point d'honneur à mettre à jour la documentation avant de publier une nouvelle version, en veillant à ce que les personnes apprenant le framework disposent toujours de la documentation la plus récente.
Qu'est-ce qui différencie Laravel?
Comme pour tout framework PHP, Laravel dispose d'une multitude de fonctions qui le différencient du reste du pack. En voici quelques unes qui me semblent les plus importantes (Basé sur http://laravel.com/docs).
Bundles
Bundles sont Laravel comme la poire est à PHP.
Les bundles sont à Laravel car PEAR est à PHP; Ce sont des paquets complémentaires que vous pouvez télécharger et brancher sur votre installation Laravel. À l'heure actuelle, Laravel Bundle Repository contient plusieurs bundles, et d'autres sont ajoutés en permanence. Laravel est fourni avec un outil de ligne de commande appelé Artisan, ce qui le rend extrêmement facile à installer.
L'un de mes paquets Laravel préférés, appelé Bob the Builder, ajoute un outil d'échafaudage utile à Laravel et vous permet de générer différents types de fichiers et de classes adaptés à Laravel, tels que des contrôleurs, des modèles, des migrations et des tests. Cette fonctionnalité est assez similaire à celle des générateurs Rails. Pour installer Bob, utilisez simplement l'utilitaire de ligne de commande Artisan, comme ceci:
php artisan bundle:install bob
Eloquent ORM
Eloquent ORM est l'implémentation PHP ActiveRecord la plus avancée disponible.
Eloquent ORM est, de loin, l’une des meilleures implémentations ORM que j’ai utilisées. Semblable au fonctionnement de Doctrine ORM, il simplifie et simplifie tout travail sur des enregistrements de base de données. Il résume la plupart des fonctions que vous aurez sur les modèles (c.-à-d. Les opérations CRUD) et fournit un moyen flexible d'ajouter plus. De plus, Eloquent ORM vous permet de définir des relations de modèle pour récupérer des enregistrements, en fonction de leur relation avec un autre enregistrement. Par exemple, vous pouvez récupérer tous les enregistrements de fichiers associés à un utilisateur en procédant comme suit:
foreach( $user->Files as $file ) {
echo $file->name;
} Migrations
Les migrations de bases de données sont un excellent utilitaire dans l'arsenal de tout projet - en particulier pour les projets impliquant plusieurs développeurs - en facilitant la mise à jour de votre schéma de base de données avec les modifications des autres membres de l'équipe. A Laravel, les migrations sont intégrées dans le cadre; ils peuvent être exécutés via l'utilitaire de ligne de commande Artisan. Les fonctions Schema Builder de Laravel sont assez simples pour que tout le monde puisse écrire rapidement un changement de schéma de base de données.
Voici un exemple tiré de la documentation de Laravel:
Schema::table('users', function($table)
{
$table->create();
$table->increments('id');
$table->string('username');
$table->string('email');
$table->string('phone')->nullable();
$table->text('about');
$table->timestamps();
}); Unit-Testing
Tu te souviens de ce gars? Programmes Sane FTW
Image reproduite avec l'aimable autorisation de http://www.youthedesigner.com
En tant que partisan du développement piloté par les tests (pour en savoir plus: Guide du débutant sur le développement piloté par les tests), j'adore quand un framework intègre une sorte d'utilitaire de test unitaire. Laravel s'intègre magnifiquement à PHPUnit, en s'appuyant sur son statut de l'un des meilleurs frameworks de tests unitaires PHP. Pour construire un test, étendez simplement la classe PHPUnit_Framework_TestCase, comme ceci:
class MyUnitTest extends PHPUnit_Framework_TestCase
{
public function somethingShouldBeTrue()
{
$this->assertTrue(true);
}
} Pour exécuter les tests de votre application Laravel, utilisons à nouveau l’utilitaire de ligne de commande Artisan:
php artisan test
Cette commande lance tous les tests, qui se trouvent dans le répertoire application/tests de votre application Laravel.
Redis
Redis est une base de données de valeurs-clés, similaire à CouchDB et MongoDB. Il est utilisé par de nombreuses applications Web pour stocker des données non relationnelles, contrairement aux bases de données classiques (telles que MySQL), qui stockent des enregistrements généralement associés. Le soutien de Redis à Laravel est exécuté avec une telle élégance que je ne peux même pas commencer à décrire à quel point il est facile de se lancer.
Une fois votre serveur Redis configuré, ouvrez simplement le fichier database.php et ajoutez votre configuration Redis, comme ceci:
'redis' => array(
'default' => array('host' => '127.0.0.1', 'port' => 6379),
'staging' => array('host' => 'redis-db-staging.host', 'port' => 6379),
'production' => array('host' => 'redis-db-production.host', 'port' => 6379),
) Dès le départ, nous pouvons constater que Laravel prend en charge plusieurs configurations Redis, en fonction de l'environnement de votre application. Une fois que vous avez votre configuration Redis, vous pouvez commencer à appeler Redis, comme ceci:
$redis = Redis::db(); //this gets a Redis object connected to the 'default' configuration
$redis = Redis::db('staging'); //this gets a Redis object connected to the 'staging' configuration
$redis = Redis::db('production'); //this gets a Redis object connected to the 'production' configuration
$redis->set('site', 'Nettuts+');
$site = $redis->get('site');
$sites = $redis->lrange('sites', 0, -1); Laravel fournit un client léger pour nous, de sorte que toutes les commandes Redis peuvent être appelées dans la classe Redis - Laravel se charge de le convertir en une requête Redis appropriée.
Construire une application Web à partir de zéro avec Laravel
Maintenant que nous en savons plus sur Laravel, il est temps de commencer à construire notre application Web avec elle! Tout au long de cette mini-série, nous allons créer notre propre copie Instagram, appelée Instapics. Cette petite application vous permet de poster, d’aimer et de commenter des photos, ainsi que de suivre d’autres utilisateurs. Dans cet esprit, plongeons dedans!
Étape 1: Télécharger Laravel et autres fichiers de projet
Avant de commencer, assurons-nous d'abord de disposer d'un système capable de prendre en charge Laravel. Selon la documentation, Laravel exige ce qui suit:
- PHP 5.3.x - Laravel utilise de nombreuses fonctionnalités spécifiques à PHP 5.3, telles que les fermetures, les liaisons de dernière minute et les espaces de noms.
- The FileInfo library - activée par défaut dans PHP 5.3, mais sur les systèmes Windows, vous devrez peut-être ajouter l'extension dans votre fichier de configuration
PHP.ini. - Mcrypt library - utilisée par Laravel pour le cryptage et la génération de hash, elle est généralement préinstallée avec PHP.
Une fois l'environnement configuré, téléchargeons Laravel et toutes les bibliothèques que nous utiliserons pour Instapics. Téléchargez les fichiers suivants et placez-les dans un dossier accessible par le Web:
- Laravel - http://laravel.com (actuellement v3.2.1)
- Twitter Bootstrap - http://twitter.github.com/bootstrap/ (Actuellement v2.0.4)
- jQuery - http://jquery.com (actuellement v1.7.2)
Dans le dossier racine de Laravel, vous trouverez un dossier public - où tous les fichiers accessibles au public doivent être stockés. Laravel v3.2.1 a des dossiers prédéfinis dans le dossier public pour nos dossiers assets, css, img et js. Placez les fichiers Twitter Bootstrap et jQuery dans leurs dossiers correspondants. À ce stade, votre structure de dossiers doit ressembler à ce qui suit:
Twitter Bootstrap aura des fichiers dans les dossiers css, img et js, et jQuery sera dans le dossier js.
Étape 2: Configurer Encryption Key, Pretty URLs et Virtual Host de Laravel
Avant d’écrire du code, nous devons définir une clé de cryptage que Laravel utilisera pour notre application. Laravel utilise cela pour chiffrer toutes les données dont nous pourrions avoir besoin de chiffrement, telles que les cookies. Ouvrez le fichier application/config/application.php et recherchez le paramètre key. A l'intérieur, la valeur par défaut sera YourSecretKeyGoesHere !. Définissez ceci sur blank; ça devrait ressembler à ça:
/* |-------------------------------------------------------------------------- | Application Key |-------------------------------------------------------------------------- | | This key is used by the encryption and cookie classes to generate secure | encrypted strings and hashes. It is extremely important that this key | remain secret and should not be shared with anyone. Make it about 32 | characters of random gibberish. | */ 'key' => '',
Ensuite, ouvrez une invite Terminal/Command, accédez au répertoire racine de Laravel et utilisez Artisan pour générer une clé:
clé artisanale php:générer
Cela devrait automatiquement générer une clé de cryptage aléatoire de 32 caractères pour Laravel. Si vous avez fait cela correctement, il devrait maintenant ressembler à ceci:
/* |-------------------------------------------------------------------------- | Application Key |-------------------------------------------------------------------------- | | This key is used by the encryption and cookie classes to generate secure | encrypted strings and hashes. It is extremely important that this key | remain secret and should not be shared with anyone. Make it about 32 | characters of random gibberish. | */ 'key' => 'e9Vo0SQDe5HjsvXWcTogqKluVfEqnfEu',
Si vous souhaitez régénérer votre clé, répétez simplement les étapes!
Ensuite, nous devons changer la configuration pour pouvoir accepter les jolies urls et travailler même sans pointer nos requêtes vers index.php. Dans le fichier application/config/application.php, recherchez les éléments suivants:
/* |-------------------------------------------------------------------------- | Application Index |-------------------------------------------------------------------------- | | If you are including the "index.php" in your URLs, you can ignore this. | However, if you are using mod_rewrite to get cleaner URLs, just set | this option to an empty string and we'll take care of the rest. | */ 'index' => 'index.php',
Si vous voulez activer les jolies URL, assurez-vous que le paramètre d'index est vide, comme ceci:
/* |-------------------------------------------------------------------------- | Application Index |-------------------------------------------------------------------------- | | If you are including the "index.php" in your URLs, you can ignore this. | However, if you are using mod_rewrite to get cleaner URLs, just set | this option to an empty string and we'll take care of the rest. | */ 'index' => '',
Si vous utilisez ceci, vous devez vous assurer que mod_rewrite est activé sur votre serveur Web (si vous êtes sur Apache).
Enfin, nous devrons configurer un hôte virtuel pour Laravel. Ce n'est pas vraiment nécessaire dans un environnement de développement, mais pour la production, il est important de ne pas autoriser l'accès à la bibliothèque Laravel et aux fichiers d'application. Comme mentionné ci-dessus, dans les fichiers Laravel, vous devriez voir un dossier, appelé public, où doivent se trouver tous les fichiers accessibles au public. En plus de cela, nous devons nous assurer que notre domaine, http://instapics.com, ne pointe que vers le dossier public et nulle part ailleurs.
La configuration d'un hôte virtuel dépend du serveur Web que vous utilisez. Voici un exemple pour le serveur Web Apache:
<VirtualHost *:80>
ServerName instapics.com
DocumentRoot "D:/Development/htdocs/instapics/public"
<Directory "D:/Development/htdocs/instapics/public">
</Directory>
</VirtualHost> Nous devrions également ajouter le domaine instapics.com à nos fichiers hôtes (car ce domaine n’existe pas vraiment). Sous Windows, éditez le fichier C:\Windows\System32\drivers\etc\hosts; sous Linux / OSX, vous éditez généralement /etc/hosts. Ajoutez cette ligne au fichier:
127.0.0.1 INS appuyez sur ICS.com
Cela informera notre machine que le domaine instapics.com sera résolu en 127.0.0.1, qui est l'ordinateur local.
Étape 3: Configuration du routage
Dans Laravel, toutes les demandes adressées à l’application sont associées à des fonctions ou contrôleurs spécifiques de Routes. Ils sont chargés d'instruire l'application où vont les URL. Par exemple, si nous voulions que http://instapics.com/home affiche le fichier de la vue d'accueil, nous pouvons créer la route suivante dans routes.php, qui se trouve dans le dossier de l'application:
Route::any('home', function()
{
return View::make('home.index');
}) Sinon, si nous devons plutôt acheminer http://instapics.com/home vers un Controller, par exemple le contrôleur home.php, nous pourrions faire quelque chose comme ceci:
Route::controller('home'); Cela conduirait au fichier du contrôleur home.php. Toute méthode d'action sera également disponible.
Une chose importante à noter ici est que, par défaut, Laravel n'achemine PAS vers les contrôleurs comme le font les autres frameworks PHP. C'est par conception. Ce faisant, nous pouvons créer des pages simples sans avoir besoin de créer un contrôleur. Par exemple, si nous voulions créer une page Contact Us statique qui répertorie simplement les informations de contact, nous pouvons simplement faire quelque chose comme ceci:
Route::any('contact-us', function()
{
return View::make('home.contact-us');
}) Ceci acheminerahttp://instapics.com/contact-us et rendre le fichier application/views/home/contact-us.php. Comme nous n'avons pas vraiment de traitement dynamique sur cette page, nous pouvons simplement rendre automatiquement le fichier de vue, ce qui nous évite de créer et de configurer un contrôleur pour ce faire.
Il y a tellement de choses que nous pouvons faire avec Routes in Laravel, qui peut être considéré comme un tutoriel. Choses comme:
- HTTP Verbs - Laravel nous permet de créer des routes en fonction du verbe HTTP utilisé dans la requête. Par exemple, nous pouvons avoir une requête GET sur la route /home pour aller ailleurs.
- Wildcards - cela nous permet d'acheminer une URL avec une valeur générique associée (par exemple, / user / (: num) où (: num) est l'ID de l'utilisateur)
- Filters - ceux-ci nous permettent d'exécuter des fonctionnalités avant ou après l'exécution d'une route, en fonction de la route appelée. Par exemple, nous pouvons créer un filtre auth qui sera appelé avant toutes les routes, à l'exception des routes d'accueil et des routes. Dans CodeIgniter, ceux-ci sont similaires aux Hooks, mais beaucoup plus faciles à implémenter, car les filtres sont basés sur les routes - nous pouvons donc les implémenter pour toutes les requêtes ou juste certaines.
Pour les besoins de cette application Web, nous n’avons besoin que de quelques itinéraires. Tout d'abord, un itinéraire qui associe toutes les demandes aux contrôleurs par défaut. Ouvrez le fichier routes.php et commentez la route par défaut vers le contrôleur Home:
/*
Route::get('/', function()
{
return View::make('home.index');
});
*/ En dessous de ce bit de code, ajoutez la ligne suivante:
Route::controller(Controller::detect());
Cette ligne mappera toutes nos demandes à tous les contrôleurs. Si le contrôleur ou les actions n'existent pas, le système renvoie une réponse 404.
Maintenant, nous créons un itinéraire pour http://instapics.com/about. Techniquement, nous pouvons simplement créer un contrôleur about , mais ce serait un gaspillage, car nous pouvons simplement le placer dans le contrôleur Home. Ajoutez la ligne suivante après la route que nous venons de créer:
Route::controller(Controller::detect());
Route::get('about', 'home@about'); Cet itinéraire dirigera toutes les requêtes vers http://instapics.com/about vers le contrôleur Home et l'action About.
Étape 3. Créez votre premier contrôleur Laravel
Les contrôleurs
Les contrôleurs de Laravel se trouvent dans le dossier application/controllers. Par défaut, le contrôleur Home accepte les requêtes envoyées à la racine de l'application Laravel. Par exemple, aller à http://instapics.com/ ira à la méthode Home-> action_index ().
Pour créer un contrôleur, créez simplement un fichier dans le dossier application/controllers. Par convention, nous voudrons nommer le fichier quelque chose de descriptif qui sera aussi le nom de la classe du contrôleur. Pour l'instant, créons un nouveau contrôleur pour notre mécanisme de connexion, appelé "Login":
class Login_Controller extends Base_Controller
{
public function action_index()
{
//do our login mechanisms here
echo 'test'; //echo test so we can test this controller out
}
} Ensuite, ouvrez votre navigateur et visitez http://instapics.com/login. De là, vous devriez voir le message de test "test" que nous avons placé. Étant donné que, dans le fichier routes.php, nous le configurons pour activer les routes vers tout le contrôleur, cela devrait fonctionner sans aucune configuration supplémentaire. Une fois que vous avez confirmé que cela fonctionne, supprimez simplement le message de débogage. Nous reviendrons sur ce contrôleur dans un prochain article.
Pour l'instant, félicitez-vous; vous venez de créer votre premier contrôleur Laravel!
Plus de plaisir du contrôleur
Filters
Il y a beaucoup plus de choses à faire avec les contrôleurs, plutôt que les passerelles vers les fichiers de vue. Par exemple, rappelez-vous la fonctionnalité Filters que j'ai mentionnée précédemment dans la section des itinéraires? En plus d'être associés à des routes spécifiques, nous pouvons également les joindre à des contrôleurs spécifiques! Créez simplement une méthode __constructor pour le contrôleur et configurez le filtre à cet endroit. Par exemple, si nous devons nous assurer qu'un utilisateur est authentifié pour toutes les méthodes d'un contrôleur, nous pouvons utiliser notre exemple de filtre auth:
public function __construct() {
$this->filter('before', 'auth');
} Cela appellera le filtre auth sur toutes les actions de ce contrôleur. Si nous voulions cibler des actions spécifiques, nous pouvons nous référer à la seule méthode, comme ceci:
public function __construct() {
$this->filter('before', 'filter_name')->only(array('action', 'actionagain'));
} Nous pouvons également utiliser la méthode except pour implémenter le filtre sur toutes les actions, sauf quelques-unes:
public function __construct() {
$this->filter('before', 'filter_name')->except(array('action', 'actionagain'));
} Notez à quel point ce code est expressif?
Nous pouvons même cibler un verbe HTTP spécifique:
public function __construct() {
$this->filter('before', 'filter_name')->except(array('action', 'actionagain'))->on('post');
} The Base_Controller
La plupart des contrôleurs, sinon tous, étendent Base_Controller. Cela nous permet de définir des méthodes qui seront les mêmes pour tous nos contrôleurs. Par exemple, si nous devons créer une méthode de journalisation pour consigner une demande de contrôleur:
class Base_Controller extends Controller {
/**
* Catch-all method for requests that can't be matched.
*
* @param string $method
* @param array $parameters
* @return Response
*/
public function __call($method, $parameters)
{
return Response::error('404');
}
public function logRequest()
{
$route = Request::route();
Log::log('request', "Controller: {$route->controller} / Action: {$route->controller_action} called at ". date('Y-m-d H:i:s'));
}
} Chaque fois que nous voulons enregistrer une requête, nous pouvons simplement appeler$this->logRequest(); dans n'importe quel contrôleur.
RESTful Controllers
Les contrôleurs RESTful de Laravel facilitent l'ajout de réponses RESTful à n'importe quel contrôleur Laravel. Cela facilite la création, par exemple, d'une API RESTful. Pour ce faire, ajoutez simplement l’indicateur $restfulà votre contrôleur:
class Api_Controller extends Base_Controller
{
public $restful = true;
public function post_authenticate()
{
//all POST requests to /api/authenticate will go here
//any other requests that are NOT POST will NOT go here.
}
public function get_user()
{
$user_id = Input::get('id');
//get the USER based on $user_id and return it for whoever requested it
}
public function post_user()
{
$email = Input::get('email');
$password = Input::get('password');
//Create a new User
$user = User::create($email, $password);
}
} Nous allons explorer toutes ces fonctionnalités intéressantes dans les futurs tutoriels, mais pour l'instant, mettons à jour le contrôleur Home. Nous devrons ajouter une méthode action_about, car nous avons créé le http://instapics.com/about route pour diriger vers cette méthode. Ouvrez application / controllers / home.php et mettez-le à jour, comme ceci:
Nous ajoutons
action_à toutes les méthodes d'action de nos contrôleurs (par exemple, action_about). Cela indique à Laravel que ces actions sont visibles sur le site Web. Toute autre méthode, qui n'a pas le préfixeaction_, ne sera pas accessible publiquement.
class Home_Controller extends Base_Controller {
public function action_index()
{
return View::make('home.index');
}
public function action_about()
{
return View::make('home.about');
}
} Étape 4. Créez votre première vue Laravel avec le Blade Templating Engine
Laravel prend en charge deux façons de générer des vues pour une application:
- PHP-based Views - Ce sont des vues qui utilisent PHP comme langage de template.
- Blade-based Views - ces vues utilisent le moteur de template intégré de Laravel, appelé Blade.
Le Blade Templating Engine est un framework de template qui, similaire au fonctionnement de Smarty Templating Engine, utilise des balises et des fonctions personnalisées pour permettre une meilleure séparation de la logique de présentation et du code de l’application.
Par souci de simplicité, nous utiliserons Blade Templating Engine, par opposition aux PHP-based views.
Tous les fichiers de vue utilisant le Blade Templating Engine doivent avoir une extension
.blade.php. Cela dit à Laravel d'utiliser le moteur dans le fichier de vue.
Tout d'abord, créons une mise en page à usage général que nous utiliserons pour toutes nos vues. Créez le dossier application / views / layouts et, à l'intérieur, créez un fichier nommé main.blade.php:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Instapics</title>
{{ Asset::styles() }}
{{ Asset::scripts() }}
</head>
<body>
<div class="navbar navbar-fixed-top">
<div class="navbar-inner">
<div class="container">
<a class="brand" href="home">Instapics</a>
<div class="nav-collapse">
<ul class="nav">
@section('navigation')
<li class="active"><a href="home">Home</a></li>
@yield_section
</ul>
</div><!--/.nav-collapse -->
</div>
</div>
</div>
<div class="container">
@yield('content')
<hr>
<footer>
<p>© Instapics 2012</p>
</footer>
</div> <!-- /container -->
</body>
</html> Maintenant que nous avons notre disposition principale, mettons à jour le fichier d’index. Ouvrez application/views/home/index.blade.php et mettez-le à jour:
@layout('layouts/main')
@section('navigation')
@parent
<li><a href="/about">About</a></li>
@endsection
@section('content')
<div class="hero-unit">
<div class="row">
<div class="span6">
<h1>Welcome to Instapics!</h1>
<p>Instapics is a fun way to share photos with family and friends.</p>
<p>Wow them with your photo-filtering abilities!</p>
<p>Let them see what a great photographer you are!</p>
<p><a href="about" class="btn btn-primary btn-large">Learn more »</a></p>
</div>
<div class="span4">
<img src="http://nettuts.s3.amazonaws.com/2064_laravel/img/phones.png" alt="Instapics!" />
</div>
</div>
</div>
<!-- Example row of columns -->
<div class="row">
<div class="span3">
</div>
<div class="span4">
<a href="#"><img src="http://nettuts.s3.amazonaws.com/2064_laravel/img/badge_ios.png" alt="Get it on iOS" /></a>
</div>
<div class="span4">
<a href="#"><img src="http://nettuts.s3.amazonaws.com/2064_laravel/img/badge_android.png" alt="Get it on Android" /></a>
</div>
</div>
@endsection Passons en revue nos fichiers de vue. Dans le modèle de disposition principal, nous utilisons trois fonctions:
- Le gestionnaire des actifs (
Assets :: styles (), Assets :: scripts ()) - La fonction @section Blade (avec @yield_section)
- Et la fonction @yield Blade
Gestion des actifs
Laravel fournit un moyen robuste de charger des fichiers CSS et JS, via sa fonctionnalité de gestion des actifs. La syntaxe pour ajouter un actif est Assets::add('[asset name]', '[relative url from the public folder'], '[name of dependency, array of dependencies if multiple]'). Le gestionnaire des actifs prend également en charge les dépendances d'actifs, qui permettent à Laravel de charger la dépendance en premier, avant de charger l'actif.
Nous devrons enregistrer nos ressources pour que les fichiers de vue puissent les utiliser. Ouvrez l'application / controllers / base.php et ajoutez le code suivant:
public function __construct()
{
//Assets
Asset::add('jquery', 'js/jquery-1.7.2.min.js');
Asset::add('bootstrap-js', 'js/bootstrap.min.js');
Asset::add('bootstrap-css', 'css/bootstrap.min.css');
Asset::add('bootstrap-css-responsive', 'css/bootstrap-responsive.min.css', 'bootstrap-css');
Asset::add('style', 'css/style.css');
parent::__construct();
} En faisant cela, nous facilitons l'ajout, la suppression ou la mise à jour des actifs dont nous avons besoin. Nous l'avons placé dans la méthode __construct() du contrôleur de base pour ajouter les actifs à tous nos contrôleurs. Pour en tirer parti dans une vue, nous appelons simplement Assets::styles() pour les fichiers CSS et Assets::scripts() pour les fichiers JS dans n'importe quel fichier de vue. Laravel détermine automatiquement le type d'actif en fonction de l'extension de fichier et le charge avec le groupe d'actifs approprié.
@section (et @yield_section)
Les sections nous permettent d'injecter du contenu dans la présentation principale à partir d'une vue. Pour définir quelle partie de notre disposition principale est une section, nous l'entourons de balises @section et @yield_section Blade.
Dans notre fichier d'affichage principal, nous avons marqué les éléments de navigation sous la forme d'une @section (appelée navigation). En regardant maintenant le fichier de vue d'index, nous ajoutons le lien de navigation <> About> à la barre de navigation avec le code suivant:
@section('navigation')
@parent
<li><a href="about">About</a></li>
@endsection En appelant la fonction @parent, nous demandons au fichier de vue d'hériter le contenu de la section d'origine de la présentation principale. Si nous devions supprimer la fonction @parent, comme ceci:
@section('navigation')
<li><a href="/about">About</a></li>
@endsection À présent, la section de navigation du fichier de vue d'index remplacera entièrement la navigation de la présentation principale. Cela rend le processus de modification du code HTML de la mise en page principale encore plus flexible.
@yield
La fonction @yield est similaire à la fonction @section / @yield_section, mais permet à la vue imbriquée de remplir entièrement le contenu. Dans notre fichier d'index, nous avons une fonction @section ('content') qui remplace @yield ('content').
Maintenant, essayons de transmettre certaines variables à nos vues. Tout d'abord, créez un nouveau fichier de vue dans le dossier application / views / home pour la page About. Appelons cela about.blade.php:
@layout('layouts/main')
@section('navigation')
@parent
<li><a href="about">About</a></li>
@endsection
@section('content')
<div class="row">
<div class="span3">
<div class="well sidebar-nav">
<ul class="nav nav-list">
<li class="nav-header">Navigation</li>
@foreach ($sidenav as $sn)
<li @if ($sn['active']) class="active" @endif>
<a href="{{ $sn['url'] }}">{{ $sn['name'] }}</a>
</li>
@endforeach
</ul>
</div>
</div>
<div class="span9">
<h1>About Instapics</h1>
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent ullamcorper lectus et sapien volutpat iaculis. Phasellus arcu justo, commodo ac ornare at, pellentesque vitae nulla. Sed id justo mauris, et semper est. Mauris id dui vitae felis hendrerit sollicitudin ut vel nisi. Phasellus a dolor quis tellus sagittis commodo. Suspendisse potenti. Donec sagittis rhoncus sem in venenatis. Nam sit amet leo metus. Mauris eget nisi eu felis interdum venenatis nec sed ipsum. Integer lobortis, risus non pellentesque pharetra, massa augue vulputate sem, quis sagittis arcu tortor sit amet nisi. Ut quis nibh sem. Morbi malesuada, lorem ac tincidunt venenatis, quam erat rhoncus sapien, et tempus quam mauris sit amet metus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nam varius dictum lectus non placerat.</p>
<p>Cras tincidunt, libero eu dignissim egestas, erat purus mattis urna, vitae pellentesque nisi turpis at velit. Vivamus vitae euismod nisi. Duis luctus ante nec neque fermentum vulputate. Phasellus in dolor quis mauris rhoncus consectetur ut quis lacus. Nulla facilisi. Nullam magna velit, accumsan vehicula consectetur a, vestibulum eget neque. Sed feugiat dui quis ligula convallis sed placerat dui dignissim. Aliquam interdum tempus leo, a hendrerit orci ultrices ut. Aliquam sem dolor, auctor eu mattis id, varius a massa. Fusce facilisis, massa id ultricies lacinia, urna nunc sollicitudin massa, sit amet posuere metus justo vitae metus. Vivamus in dolor quam, ut elementum libero. Proin vehicula diam eu diam consectetur ut imperdiet ipsum pulvinar. Cras eu est quis urna semper adipiscing ut et leo. Curabitur tristique consectetur aliquet. Phasellus quam neque, dapibus non eleifend quis, feugiat vel elit.</p>
</div>
</div>
@endsection De retour dans le contrôleur Home, mettez à jour la méthode action_about ():
public function action_about()
{
return View::make('home.about', array(
'sidenav' => array(
array(
'url' => 'home',
'name' => 'Home',
'active' => false
),
array(
'url' => 'about',
'name' => 'About',
'active' => true
)
)
));
} En examinant notre code, nous voyons que, dans le contrôleur Home, nous passons un array de paramètres. En ce moment, ce sont des valeurs codées en dur, mais elles peuvent provenir de n'importe où, par exemple d'un modèle ou d'une base de données. Ceux-ci sont transmis au fichier de vue, où nous utilisons des balises Blade pour rendre les paramètres.
@foreach ($sidenav as $sn) ... @endforeach
Cela nous permet de parcourir le tableau dans nos paramètres.
<li @if ($sn['active']) class="active" @endif>
Ceci est une déclaration if. Si nous voulions utiliser un autre, cela ressemblerait à ceci:
@if ($sn['active'])
class="active"
@else
class="notactive"
@endif <a href="{{ $sn['url'] }}">{{ $sn['name'] }}</a> C'est le tag de lame le plus fondamental - il fait juste écho à la variable que nous avons définie.
Notez que, dans la plupart des balises Blade, nous utilisons un bon PHP. Cela facilite l'écriture des balises Blade, car nous pourrons utiliser des fonctions PHP natives, telles que isset() ou count(). Il y a aussi d'autres tags Blade que je n'ai pas pu utiliser ici; vous pouvez en apprendre plus à leur sujet dans la documentation Blade. Croyez-moi, c'est assez facile!
Conclusion
Après avoir lu ce tutoriel, nous avons appris:
- Qu'est ce que Laravel
- Qu'est-ce qui différencie Laravel des autres frameworks PHP?
- Où télécharger Laravel
- Comment configurer Laravel
- Comment fonctionne le système de routage de Laravel
- Quelques autres fonctionnalités du système de routage de Laravel
- Comment créer votre premier contrôleur Laravel
- Quelques fonctionnalités supplémentaires avec les contrôleurs Laravel
- Comment créer votre première vue Laravel
- Comment utiliser le moteur de modélisation des lames de Laravel
Laravel est vraiment un cadre incroyable. C'est rapide, simple, élégant et facile à utiliser. Cela mérite absolument d'être considéré comme le cadre à utiliser pour votre prochain projet.
Dans la suite de notre série Building Web Application from Scratch with Laravel , nous découvrirons l'une des meilleures fonctionnalités de Laravel: l'EVuent ORM et le Fluent Query Builder.
Que penses-tu de Laravel? Envisagez-vous de l'utiliser pour votre prochain projet? Faites-moi savoir dans les commentaires! Et si vous êtes membre Tuts + Premium, restez à l’écoute de notre prochain cours Laravel Essentials!
