Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "learning the basics of Laravel". In the operation of actual cases, many people will encounter such a dilemma. Then let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Installation

The Laravel framework uses Composer to perform installation and dependency management. If you haven't already installed, start installing Composer now.

After installing Composer, you can install Laravel from the command line using the following command:

Composer create-project laravel/laravel your-project-name

Alternatively, you can download it from the Github warehouse. Next, after installing Composer, execute the composer install command from the project root. This command will download and install the dependent components of the framework.

Write permission

After installing Laravel, you also need to set write permissions for the app/storage directory for the web server. Please refer to the installation section for more information about configuration.

Directory structure

After installing the framework, you need to familiarize yourself with the directory structure of the project. The app folder contains directories such as views, controllers, and models. Most of the code in the program will be stored in these directories. You can also take a look at some configuration items in the app/config folder.

Routin

We started to create our first route. In Laravel, the method of simple routing is closure. Open the app/routes.php file and add the following code:

Route::get ('users', function ())

{

Return'Usersgiving'

});

Now, you type / users in the web browser, and you should see Users! Output. Great! Your first route has been created.

Routing can also be assigned to the controller class. For example:

Route::get ('users',' UserController@getIndex')

This route tells the framework / users that the routing request should call the getIndex method of the UserController class. To see more information about the routing controller, check the controller documentation.

Create a view

Next, we will create a view to display our user data. The view is stored in the app/views folder in HTML code. We will store two view files in this folder: layout.blade.php and users.blade.php. First, let's create the layout.blade.php file:

The copy code is as follows:

Laravel Quickstart

@ yield ('content')

Next, we create the users.blade.php view:

The copy code is as follows:

@ extends ('layout')

@ section ('content')

Users!

@ stop

The grammar here may make you feel strange. Because we are using the Laravel template system: Blade. Blade is very fast because only a small number of regular expressions are used to compile your template into raw PHP code. Blade provides powerful features, such as template inheritance, and some commonly used PHP control structure syntax sugars, such as if and for. Check out the Blade documentation to learn more.

Now that we have our view, let's return to / users routing. Instead of returning Usersarguments, we use the view:

The copy code is as follows:

Route::get ('users', function ())

{

Return View::make ('users')

});

Beautiful! Now you have successfully created a view that inherits from layout. Next, let's start with the database layer.

Create a migration

To create tables to hold our data, we will use the Laravel migration system. Migration describes changes to the database, which makes it easy to share with their team members.

First, we configure the database connection. You can configure all database connection information in the app/config/database.php file. By default, Laravel is configured to use SQLite, and a SQLite database is stored in the app/database directory. You can change the driver option of the database configuration file to mysql and configure the mysql connection information.

Next, to create the migration, we will use Artisan CLI. In the project root, execute the following command in the terminal:

The copy code is as follows:

Php artisan migrate:make create_users_table

Then, locate the generated migration file app/database/migrations directory. This file contains a class that contains two methods: up and down. In the up method, you specify the modification of the database table, in the down method you just need to remove it.

Let's define migration as follows:

The copy code is as follows:

Public function up ()

{

Schema::create ('users', function ($table))

{

$table- > increments ('id')

$table- > string ('email')-> unique ()

$table- > string ('name')

$table- > timestamps ()

});

}

Public function down ()

{

Schema::drop ('users')

}

Then, we use the terminal to run the migrate command in the project root to perform the migration:

The copy code is as follows:

Php artisan migrate

If you want to roll back the migration, you can execute the migrate:rollback command. Now that we have the database table, let's add some data!

Eloquent ORM

Laravel provides a great ORM:Eloquent. If you have used the Ruby on Rails framework, you will find that Eloquent is very similar because it follows the ActiveRecord ORM style of database interaction.

First, let's define a model. The ELoquent model can be used to query related data tables, as well as a row within a table. Don't worry, we'll talk about it soon! Models are usually stored in the app/models directory. Let's define a User.php model in this directory, such as:

The copy code is as follows:

Class User extends Eloquent {}

Notice that we didn't tell Eloquent which table to use. Eloquent has a variety of conventions, one is to use the plural form of the model as the database table of the model. It's very convenient!

Using your favorite database management tool, insert a few rows of data into the users table, and we will use Eloquent to get them and pass them to the view.

Now let's modify our / users route as follows:

The copy code is as follows:

Route::get ('users', function ())

{

$users = User::all ()

Return View::make ('users')-> with (' users', $users)

});

Let's take a look at the route. First, the all method of the User model will get all the records from the users table. Next, we pass these records to the view through the with method. The with method accepts a key and a value, so the value can be used in the view.

I'm excited. Now we are ready to display the user in our view!

Display data

Now that we have access to the users classes in our view, we can display them as follows:

The copy code is as follows:

@ extends ('layout')

@ section ('content')

@ foreach ($users as $user)

{{$user- > name}}

@ endforeach

@ stop

You can see that the echo statement was not found. When using Blade, you can use two curly braces to output data. Quite simply, you should now be able to look up the user's name as a response output through the / users route.

This is the end of the introduction to the basics of learning Laravel. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.