10 Hal Dasar Yang Perlu Dipelajari Tentang Laravel

Laravel merupakan framework yang sangat populer dikalangan web developer. Laravel merupakan framework dari bahasa pemrograman PHP untuk memaksimalkan penggunaan dalam membangun website yang powerful. Laravel menjadi pilihan utama bagi kebutuhan industri maupun start-up yang ingin memiliki website yang lebih cepat dan dinamis. Laravel sudah dipakai oleh banyak perusahaan yaitu BBC, TourRadar, Pfizer, dan masih banyak lagi perusahaan yang menggunakan termasuk start-up.

10 Hal Dasar Perlu Yang Dipelajari Tentang Laravel

Didalam laravel terdapat hal mendasar yang perlu dipelajari, dasar ini akan menjadi pondasi dalam menguasai laravel. Berikut adalah 10 hal mendasar yang perlu dipelajari dan kuasai di dalam laravel.

1. Routing

Routing merupakan proses menentukan dan mengontrol respon permintaan HTTP dari aplikasi anda berdasarkan URL atau URI yang mereka akses. Sangat penting untuk mengetahui bagaimana cara routing dalam menangani permintaan ke fungsi atau metode yang tepat. Dalam laravel routing dikonfigurasi dalam file routes/web.php untuk menangani permintaan HTTP biasa, dan routes/api.php untuk menangani permintaan terkait dengan API yang dipakai didalam aplikasi anda. Beberapa contoh definisi route di laravel yaitu:

Basic Route

use Illuminate\\Support\\Facades\\Route;
 
Route::get('/greeting', function () {
    return 'Hello World';
});

Route with Parameter

Route::get('/user/{id}', function (string $id) {
    return 'User '.$id;
});

//Anda juga bisa mendefinisikan parameter lebih dari satu juga itu diperlukan

Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    // ...
});

Route With Method

//Method yang ada di route
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);

//pada kasus tertentu anda mungkin perlu menggunakan lebih dari satu method
//anda bisa menggunakan "match" method, method ini memungkinkan anda menggunakan lebih dari satu method

Route::match(['get', 'post'], '/', function () {
    // ...
});

Named Routes

Named Route memungkinkan anda membuat URL yang lebih mudah untuk digunakan. Dengan menggunakan method name, anda bisa memberikan nama yang spesifik untuk route tersebut.

Route::get('/user/profile', function () {
    // ...
})->name('profile');

Route Groups

Route Groups memungkinkan anda berbagi atribut route dalam waktu bersamaan tanpa harus mendefinisikan atribut disetiap route yang ada. Terdapat beberapa Route Groups yang tersedia di laravel, yaitu:

#Middleware

Untuk menggunakan middleware didalam route group, kamu bisa menggunakan method sebelum mendefinisikan grup. Untuk mengeksekusi middleware yang dipakai didalam route group, middleware perlu didefinisikan kedalam bentuk array sebagai berikut:

Route::middleware(['first', 'second'])->group(function () {
    Route::get('/', function () {
        // Uses first & second middleware...
    });
 
    Route::get('/user/profile', function () {
        // Uses first & second middleware...
    });
});

#Controllers

Jika didalam sebuah route group itu memanfaatkan controller yang sama, kamu bisa menggunakan method controller untuk mendefinisikan controller yang dipakai untuk semua route yang ada di dalam grup, contohnya adalah sebagai berikut:

use App\\Http\\Controllers\\OrderController;
 
Route::controller(OrderController::class)->group(function () {
    Route::get('/orders/{id}', 'show');
    Route::post('/orders', 'store');
});

#Route Prefixes

Route Prefixes ini dapat memberikan sebuah inisialisasi pada didalam sebuah grup route, contohnya kita akan memberikan sebuah prefix admin kedalah sebuah route group dengan menggunakan method prefix:

Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Matches The "/admin/users" URL
    });
});

Lalu kemudian ada yang dinamakan Route Name Prefixes, yang memberikan string pada sebuah prefix untuk setiap route yang ada didalam grup tersebut. Contohnya kita akan memberikan string admin untuk setiap route yang ada didalam grup, kemudian kita akan memberikan . sebagai trailing untuk karakter tersebut.

Route::name('admin.')->group(function () {
    Route::get('/users', function () {
        // Route assigned name "admin.users"...
    })->name('users');
});

2. Controllers

Controller dalam Laravel adalah kelas yang bertanggung jawab untuk mengelola logika aplikasi dan merespons permintaan dari pengguna. Mereka bertindak sebagai perantara antara routes dan views dalam aplikasi Anda. Ketika pengguna mengakses URL tertentu, controller akan menangani permintaan tersebut dengan melakukan tindakan yang sesuai dan mengembalikan respons yang tepat kepada pengguna.

Dalam Laravel, Anda dapat membuat controller dengan mudah menggunakan perintah Artisan, seperti berikut:

php artisan make:controller NamaController

Perintah di atas akan membuat sebuah file controller baru dalam direktori app/Http/Controllers dengan nama NamaController.php.

Sebagai contoh, mari kita buat controller yang sederhana:

namespace App\\Http\\Controllers;

use Illuminate\\Http\\Request;

class ContohController extends Controller
{
    public function index()
    {
        return view('halaman');
    }

    public function proses(Request $request)
    {
        // Lakukan sesuatu dengan data yang dikirim oleh pengguna melalui form
        $nama = $request->input('nama');

        // Lakukan operasi lain...

        // Kembalikan respons kepada pengguna
        return response("Halo, $nama! Permintaan Anda telah diproses.");
    }
}

Dalam contoh di atas, controller ContohController memiliki dua metode yaitu index() dan proses(). Metode index() akan mereturn tampilan (view) bernama "halaman" ke pengguna, sedangkan metode proses() akan merespons permintaan yang mengandung data dari pengguna.

Controller memungkinkan Anda untuk mengorganisir logika aplikasi dengan baik, mengelompokkan tindakan terkait dalam satu kelas, dan membuat aplikasi lebih mudah untuk dipelihara. Mereka juga memisahkan logika aplikasi dari rute, sehingga meningkatkan struktur dan kejelasan kode Anda.

Setiap kali Anda ingin menangani permintaan tertentu dalam Laravel, Anda perlu membuat rute yang terkait dengan metode yang sesuai dalam controller Anda. Controller menjadi komponen penting dalam arsitektur MVC (Model-View-Controller) yang digunakan oleh Laravel.

3. Blade Templating

Blade Templating adalah view template dalam Laravel yang memungkinkan Anda untuk memisahkan logika dari tampilan dalam aplikasi web Anda. Dengan Blade, Anda dapat membuat tampilan yang dinamis dengan menyisipkan kode PHP ke dalam template. Blade menyediakan sintaks yang intuitif dan mudah digunakan untuk menyusun tampilan halaman web dengan efisien. Blade template file menggunakan .blade.php file extension dan tersimpan didalam folder resources/views.

Fitur-fitur utama dari Blade Templating di Laravel adalah sebagai berikut:

1. Struktur Layout: Anda dapat membuat layout utama (master layout) yang berisi elemen-elemen umum, seperti header, footer, atau sidebar, dan kemudian meng-extend layout ini ke tampilan-tampilan spesifik. Hal ini memungkinkan Anda untuk menghindari pengulangan kode yang tidak perlu dalam setiap halaman.
2. Penyusunan Template: Blade menggunakan konvensi sintaks {{ }} untuk menyisipkan variabel dan objek ke dalam tampilan. Misalnya, {{ $nama }} akan menampilkan isi variabel $nama ke dalam tampilan.
3. Looping: Blade menyediakan looping, seperti penggunaan @if, @else, @foreach, dan @while, yang memungkinkan Anda untuk melakukan logika percabangan dan perulangan dalam tampilan.
4. Penggunaan Layout Partials: Anda dapat memecah tampilan menjadi bagian-bagian kecil (partials) dan menyertakan bagian-bagian ini ke dalam tampilan lain menggunakan sintaks @include. Ini membantu dalam organisasi dan penggunaan kembali kode.
5. Komponen dan Slot: Laravel 7.0 dan versi selanjutnya memperkenalkan fitur komponen dan slot dalam Blade. Komponen memungkinkan Anda untuk mengelompokkan logika tampilan yang terkait dalam satu unit yang terpisah. Slot digunakan untuk mengisi konten dinamis ke dalam komponen. Misalnya @component('front.components.course-card-horizontal') memiliki beberapa @slot didalam slot tersebut kita akan mengisi dengan sebuah value, isi dari slot tersebut adalah @slot('nama', $param->nama)
6. Komponen View: Blade juga memungkinkan Anda untuk membuat komponen view, yang merupakan tampilan reusable dengan logika dan tampilan yang tertanam dalam satu kelas.

Contoh Penggunaan Blade Templating:

File master layout (layouts/app.blade.php):

<!DOCTYPE html>
<html>
<head>
    <title>{{ $title }}</title>
</head>
<body>
    @yield('content')
</body>
</html>

File halaman (pages/home.blade.php):

@extends('layouts.app')

@section('content')
    <h1>Halo, {{ $nama }}</h1>
@endsection

Dalam contoh di atas, kita menggunakan layout utama app.blade.php dan menyisipkan konten dari halaman home.blade.php ke dalamnya menggunakan @yield dan @section. Variabel $nama disisipkan ke dalam tampilan menggunakan sintaks Blade {{ $nama }}.

Blade Templating memudahkan Anda dalam menyusun tampilan yang dinamis dan efisien, serta membantu dalam memisahkan tampilan dari logika, sehingga meningkatkan struktur dan kejelasan kode Anda dalam pengembangan aplikasi Laravel.

4. Eloquent ORM

Eloquent ORM adalah fitur utama dalam Laravel yang menyediakan cara yang mudah dan ekspresif untuk berinteraksi dengan basis data dalam aplikasi Anda. "ORM" singkatan dari "Object-Relational Mapping," yang berarti Eloquent memungkinkan Anda untuk menggunakan objek-objek dalam bahasa pemrograman PHP untuk merepresentasikan tabel dan baris dalam basis data.

Dengan Eloquent ORM, Anda tidak perlu menulis kueri SQL secara langsung ataupun memanipulasi basis data menggunakan kode kustom. Sebaliknya, Anda dapat menggunakan model Eloquent untuk mewakili tabel dalam basis data dan metode-metode yang terkait untuk melakukan operasi CRUD (Create, Read, Update, Delete) dengan mudah.

Berikut adalah langkah-langkah untuk menggunakan Eloquent ORM dalam Laravel:

Mendefinisikan Model

Anda perlu membuat Model Class yang mewakili tabel dalam basis data. Model ini harus meng-extend kelas Illuminate\\Database\\Eloquent\\Model dan secara otomatis berisi informasi tentang tabel yang sesuai dengan nama model. Sebagai contoh, jika Anda memiliki tabel "users", maka Anda dapat membuat model dengan nama "User" seperti berikut:

//buat dulu migrasi di laravel, dan laravel akan otomatis membuat migrasi dengan artisan console

php artisan make:migration create_users_table

//masuk kedalam **database/migrations/create_users_table**, kemudian modifikasi migrasi tersebut

<?php

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('users');
    }
};

//migrasikan *datatable* yang sudah dibuat kedalam database

php artisan migrate

//kemudian buat model yang berintegrasi dengan migrasi tersebut

php artisan make:model User

//Model yang sudah dibuat
namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Model;

class User extends Model
{
    protected $table = 'users';
}

Menggunakan Eloquent Querying

Setelah Anda mendefinisikan model, Anda dapat menggunakan berbagai metode Eloquent untuk melakukan query ke dalam basis data. Misalnya, Anda dapat menggunakan metode all() untuk mengambil semua data dari tabel:

$users = User::all();

Menyimpan Data Baru

Untuk menyimpan data baru ke dalam basis data, Anda bisa membuat objek model baru dan mengisi atribut-atributnya sesuai data yang ingin disimpan, lalu panggil metode save():

$user = new User;
$user->name = 'Akbar';
$user->email = '[email protected]';
$user->save();

Mengambil Data Berdasarkan Kriteria

Anda dapat menggunakan berbagai metode untuk mengambil data berdasarkan kriteria tertentu, seperti where(), find(), first(), dan sebagainya:

$user = User::where('name', 'Akbar')->first();

Melakukan Update Data

Untuk melakukan update data, Anda dapat mengambil objek model yang sudah ada, mengubah atribut-atribut yang ingin diperbarui, dan panggil metode save():

$user = User::find(1);
$user->name = 'Rabka';
$user->save();

Menghapus Data

Untuk menghapus data, Anda dapat mengambil objek model yang sudah ada dan panggil metode delete():

$user = User::find(1);
$user->delete();

Eloquent ORM menyediakan banyak fitur tambahan, seperti hubungan antar model (relationships), validasi data sebelum penyimpanan, peristiwa (events), dan banyak lagi. Fitur-fitur ini membantu Anda dalam mengelola basis data dengan lebih mudah dan efisien, serta memungkinkan Anda untuk fokus pada logika aplikasi daripada pengelolaan basis data secara langsung. Dan diatas hanyalah sebuah contoh sederhana bagaimana melakukan Eloquent ORM, Anda dapat melakukan variasi query yang biasa dilakukan menggunakan logika dari ORM.

5. Eloquent Relationship

Eloquent Relationship adalah fitur yang kuat dalam Laravel yang memungkinkan Anda mendefinisikan dan memanfaatkan hubungan antara model dalam basis data. Dalam istilah Eloquent, hubungan antara model disebut sebagai "Relationships." Hal ini memungkinkan Anda untuk menggambarkan interaksi antara tabel yang berbeda dalam basis data, seperti hubungan one-to-one, one-to-many, many-to-one, dan many-to-many.

Ada beberapa jenis hubungan yang didukung oleh Eloquent:

1. One-to-One: Pada Relationships One-to-One, setiap baris dalam model A berhubungan dengan satu baris dalam model B, dan sebaliknya. Misalnya, Anda memiliki tabel "users" dan "profiles", di mana setiap pengguna memiliki satu profil.
2. One-to-Many: Pada Relationships One-to-Many, setiap baris dalam model A berhubungan dengan banyak baris dalam model B. Misalnya, pada hubungan antara tabel "users" dan "posts", di mana satu pengguna dapat memiliki banyak postingan.
3. Many-to-One: Relationships Many-to-One adalah kebalikan dari hubungan One-to-Many. Setiap baris dalam model B berhubungan dengan satu baris dalam model A. Misalnya, pada hubungan antara tabel "comments" dan "posts", banyak komentar dapat terkait dengan satu postingan.
4. Many-to-Many: Pada Relationships Many-to-Many, setiap baris dalam model A dapat berhubungan dengan banyak baris dalam model B, dan sebaliknya. Misalnya, pada hubungan antara tabel "users" dan "roles", di mana setiap pengguna dapat memiliki banyak peran, dan setiap peran dapat dimiliki oleh banyak pengguna.

Untuk mendefinisikan Eloquent Relationship, Anda harus menambahkan metode-metode khusus dalam model Anda. Sebagai contoh, mari kita lihat Relationships One-to-One dan One-to-Many antara tabel "users" dan "profiles", yaitu:

Model User:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Model;

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }

    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

Model Profile:

namespace App\\Models;

use Illuminate\\Database\\Eloquent\\Model;

class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Dalam contoh di atas, pada model User, kita mendefinisikan metode profile() dan posts(). Metode profile() mendefinisikan Relationships One-to-One dengan model Profile, sedangkan metode posts() mendefinisikan Relationships One-to-Many dengan model Post.

Pada model Profile, kita mendefinisikan metode user(), yang merupakan inverse relationship dari Relationships One-to-One dengan model User.

Setelah Anda mendefinisikan hubungan ini, Anda dapat dengan mudah mengakses data terkait melalui model, seperti:

// Mendapatkan profil pengguna
$user = User::find(1);
$profile = $user->profile;

// Mendapatkan postingan pengguna
$posts = $user->posts;

Dengan menggunakan hubungan Eloquent, Anda dapat dengan mudah mengelola interaksi antara model dalam basis data Anda, dan membantu menjaga struktur dan organisasi aplikasi Anda.

6. Migrations dan Seeders

Migrations dan Seeders adalah dua fitur penting dalam Laravel yang digunakan untuk mengelola skema basis data dan data awal dalam aplikasi Anda.

Migrations

Migrations adalah mekanisme untuk mengelola perubahan skema basis data Anda secara terstruktur dan mudah diulang. Dengan menggunakan Migrations, Anda dapat membuat, mengubah, atau menghapus tabel dan kolom dalam basis data dengan bantuan kode PHP, tanpa perlu menulis SQL langsung. Migrations membantu Anda dan tim Anda untuk berkolaborasi dalam mengatur skema basis data dan memastikan bahwa setiap anggota tim memiliki versi skema basis data yang konsisten.

Setiap migrasi adalah kelas PHP yang berisi dua metode utama: up() untuk menerapkan perubahan skema dan down() untuk mengembalikan perubahan jika diperlukan. Contoh sederhana migrasi untuk membuat tabel "users":

php artisan make:migration create_users_table

use Illuminate\\Database\\Migrations\\Migration;
use Illuminate\\Database\\Schema\\Blueprint;
use Illuminate\\Support\\Facades\\Schema;

class CreateUsersTable extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}

Setelah Anda membuat migrasi, Anda dapat menjalankannya dengan menggunakan perintah Artisan:

php artisan migrate

Perintah di atas akan mengeksekusi semua migrasi yang belum dijalankan sebelumnya.

Seeders

Seeders adalah fitur yang memungkinkan Anda untuk mengisi data awal ke dalam tabel basis data. Data ini dapat berupa data sampel atau data yang diperlukan untuk pengujian atau pengembangan aplikasi. Seeders biasanya digunakan untuk mengisi data awal untuk tabel yang perlu memiliki beberapa entri data sebelum aplikasi dijalankan.

Setiap seeder adalah kelas PHP yang berisi metode run(). Contoh sederhana seeder untuk mengisi data awal ke dalam tabel "role":

php artisan make:seed RoleSeeder

use Illuminate\\Database\\Seeder;
use Illuminate\\Support\\Facades\\DB;

class RoleSeeder extends Seeder
{
    public function run()
    {
        DB::table('roles')->insert([
            ['name' => 'Admin'],
            ['name' => 'User'],
            ['name' => 'Editor'],
        ]);
    }
}

Anda dapat menjalankan seeder dengan menggunakan perintah Artisan:

php artisan db:seed --class=RoleSeeder

Perintah di atas akan menjalankan seeder "RolesTableSeeder" untuk mengisi data awal ke dalam tabel "role".

Dengan menggabungkan Migrations dan Seeders, Anda dapat dengan mudah mengelola skema basis data dan data awal dalam aplikasi Laravel Anda dengan terstruktur dan efisien. Ini membantu Anda mempertahankan basis data dalam keadaan yang konsisten dan siap digunakan saat mengembangkan dan memelihara aplikasi.

7. Middleware

Middleware adalah fitur penting dalam Laravel yang memungkinkan Anda melakukan tindakan tertentu di antara permintaan masuk dan respon yang dikirimkan oleh aplikasi web Anda. Middleware berada di tengah-tengah proses HTTP request dan response, dan memungkinkan Anda memodifikasi atau memeriksa permintaan sebelum sampai ke route handler, serta memodifikasi atau memeriksa response sebelum dikirimkan kembali ke pengguna. Contoh penggunaan middleware adalah untuk autentikasi pengguna, validasi data, log aktivitas, dan lain-lain. Dengan middleware, Anda dapat mengorganisir tindakan-tindakan ini dalam satu tempat dan menerapkannya pada beberapa route atau grup route tertentu.

Setiap middleware adalah kelas PHP yang mengimplementasikan kontrak Illuminate\\Contracts\\Http\\Middleware\\Middleware dan menggunakan metode handle() untuk memproses permintaan. Middleware dapat diberi nama untuk identifikasi dan dapat ditempatkan dalam berbagai urutan sesuai kebutuhan.

Contoh sederhana middleware untuk memeriksa apakah pengguna sudah terautentikasi:

namespace App\\Http\\Middleware;

use Closure;
use Illuminate\\Http\\Request;

class AuthenticateMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        if (!auth()->check()) {
            return redirect('/login');
        }

        return $next($request);
    }
}

Dalam contoh di atas, middleware AuthenticateMiddleware memeriksa apakah pengguna sudah terautentikasi dengan menggunakan fungsi auth()->check(). Jika pengguna belum terautentikasi, maka middleware akan mengalihkan permintaan ke halaman login. Jika pengguna sudah terautentikasi, maka middleware akan melanjutkan permintaan ke route handler selanjutnya dengan menggunakan $next($request).

Untuk menerapkan middleware pada route tertentu, Anda bisa menambahkannya ke dalam file app/Http/Kernel.php dalam grup routeMiddleware, dan memberikan alias untuk middleware tersebut:

protected $routeMiddleware = [
    'auth' => \\App\\Http\\Middleware\\AuthenticateMiddleware::class,
];

Selanjutnya, Anda dapat menggunakan alias 'auth' pada route yang memerlukan autentikasi:

Route::get('/dashboard', function () {
    // Hanya pengguna yang terautentikasi yang bisa mengakses halaman dashboard
})->middleware('auth');

Middleware memungkinkan Anda untuk melakukan banyak tindakan secara modular dan terstruktur dalam aplikasi Laravel Anda. Hal ini membantu meningkatkan keamanan, pengelolaan, dan efisiensi dalam pengembangan aplikasi web.

8. Validation

Validation adalah proses memeriksa data yang dikirimkan oleh pengguna untuk memastikan bahwa data tersebut memenuhi kriteria atau format yang diharapkan sebelum data tersebut diproses lebih lanjut oleh aplikasi. Dalam konteks aplikasi web, validasi biasanya dilakukan pada data yang dikirimkan melalui formulir oleh pengguna sebelum data tersebut disimpan dalam basis data atau digunakan untuk tindakan lain dalam aplikasi.

Dalam Laravel, Validation dapat dilakukan dengan mudah menggunakan fitur bawaan yang disediakan oleh framework. Validation membantu Anda memastikan bahwa data yang masuk adalah data yang valid dan sesuai dengan aturan atau format tertentu sebelum diolah lebih lanjut. Jika data tidak valid, Anda dapat memberikan pesan error yang sesuai kepada pengguna agar mereka tahu bagaimana cara memperbaiki data yang salah.

Berikut adalah contoh bagaimana Anda dapat melakukan validasi dalam Laravel:

use Illuminate\\Http\\Request;
use Illuminate\\Support\\Facades\\Validator;

public function store(Request $request)
{
    $validator = Validator::make($request->all(), [
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users,email',
        'password' => 'required|min:8|confirmed',
    ]);

    if ($validator->fails()) {
        return redirect()->back()->withErrors($validator)->withInput();
    }

    // Lanjutkan dengan menyimpan data atau melakukan tindakan lainnya jika data valid
}

Dalam contoh di atas, kita menggunakan fasilitas validasi dari Laravel dengan membuat validator menggunakan Validator::make(). Kemudian, kita mendefinisikan aturan validation untuk setiap data yang dikirimkan oleh pengguna dalam bentuk array assosiatif. Misalnya, name harus berupa string yang tidak boleh lebih dari 255 karakter, email harus berupa alamat email yang unik dalam tabel "users", dan password harus minimal 8 karakter dan harus dikonfirmasi dengan input lain bernama password_confirmation.

Jika ada data yang tidak memenuhi aturan validation, $validator->fails() akan mengembalikan nilai true, dan Anda dapat mengalihkan pengguna kembali ke halaman sebelumnya dengan pesan error dan input sebelumnya yang masih diisi (untuk memudahkan pengguna memperbaiki data).

Validation adalah fitur yang sangat penting untuk memastikan data yang masuk ke aplikasi Anda adalah data yang valid dan aman. Dengan menggunakan fitur validation yang disediakan oleh Laravel, Anda dapat lebih mudah dan efisien dalam mengelola data yang masuk dan menghindari potensi masalah keamanan dan kesalahan data.

9. Authentication dan Authorization

Authentication dan Authorization adalah dua konsep penting dalam pengembangan aplikasi web yang berfokus pada keamanan dan kontrol akses pengguna.

A. Autentikasi (Authentication):

Authentication adalah proses verifikasi identitas pengguna untuk memastikan bahwa pengguna adalah orang yang memiliki akun tersebut. Dalam konteks aplikasi web, autentikasi biasanya melibatkan verifikasi username dan password atau metode lainnya yang dapat membuktikan identitas pengguna.

Contoh Authentication: Misalnya, pada halaman login, pengguna diminta untuk memasukkan username dan password. Setelah mengirimkan formulir, aplikasi akan memeriksa apakah username dan password yang dimasukkan sesuai dengan yang ada dalam basis data pengguna. Jika sesuai, maka pengguna dianggap terautentikasi dan diizinkan untuk mengakses bagian dari aplikasi yang memerlukan autentikasi.

public function login(Request $request)
{
    $credentials = $request->only('email', 'password');

    if (Auth::attempt($credentials)) {
        // Autentikasi berhasil, lakukan tindakan selanjutnya
        return redirect()->intended('/dashboard');
    } else {
        // Autentikasi gagal, kembali ke halaman login dengan pesan error
        return redirect()->back()->withErrors(['email' => 'Email atau password salah.']);
    }
}

B. Otorisasi (Authorization):

Authorization adalah proses yang dilakukan setelah autentikasi untuk menentukan apakah pengguna memiliki izin atau wewenang untuk mengakses sumber daya atau melakukan tindakan tertentu dalam aplikasi. Dengan kata lain, otorisasi menentukan apa yang diizinkan dan apa yang tidak diizinkan untuk dilakukan oleh pengguna terautentikasi.

Contoh Authorization: Misalnya, dalam aplikasi forum, hanya pengguna yang membuat postingan tertentu yang diizinkan untuk mengedit atau menghapus postingan tersebut. Otorisasi akan memverifikasi apakah pengguna yang sedang login memiliki izin untuk mengakses fitur tersebut sebelum mengizinkan aksi tersebut dilakukan.

public function update(Request $request, $id)
{
    $post = Post::findOrFail($id);

    if ($post->user_id === auth()->user()->id) {
        // Pengguna yang sedang login adalah pemilik postingan, izinkan untuk mengedit
        $post->update($request->all());
        return redirect()->route('posts.show', ['post' => $post])->with('success', 'Postingan berhasil diperbarui.');
    } else {
        // Pengguna tidak memiliki izin untuk mengedit postingan
        return redirect()->route('posts.show', ['post' => $post])->with('error', 'Anda tidak diizinkan untuk mengedit postingan ini.');
    }
}

Dalam contoh di atas, sebelum mengizinkan pengguna untuk mengedit postingan, kita memverifikasi apakah user_id dari postingan cocok dengan id pengguna yang sedang login.

10. Artisan Console

Artisan Console adalah bagian dari kerangka kerja Laravel yang memungkinkan pengguna untuk berinteraksi dengan aplikasi melalui baris perintah. Artisan menyediakan berbagai perintah yang dapat digunakan untuk menjalankan tugas-tugas tertentu, seperti migrasi database, pembuatan model, pengaturan lingkungan, dll, jadi dapat disimpulkan Artisan Console berfungsi sebagai alat untuk mengelola berbagai tugas pada aplikasi Laravel.

Berikut adalah beberapa aspek penting tentang Artisan Console di Laravel:

1. Menjalankan Perintah: Artisan Console dapat diakses melalui terminal atau command prompt dengan menjalankan perintah php artisan. Ini akan menampilkan daftar perintah yang tersedia.
2. Daftar Perintah Bawaan: Laravel sudah menyediakan banyak perintah bawaan, seperti:
   • make:controller: Untuk membuat controller baru.
   • make:model: Untuk membuat model baru.
   • make:migration: Untuk membuat file migrasi database baru.
   • migrate: Untuk menjalankan migrasi database.
   • db:seed: Untuk memasukkan data awal ke dalam database.
   • route:list: Untuk melihat daftar rute yang telah didefinisikan dalam aplikasi.
   • Dan banyak lagi.
3. Membuat Perintah Kustom: Selain perintah bawaan, pengguna juga dapat membuat perintah kustom mereka sendiri untuk tugas-tugas khusus yang dibutuhkan dalam aplikasi. Ini memungkinkan pengguna untuk mengotomatisasi tugas-tugas yang sering dilakukan.
4. Argumen dan Opsi: Perintah Artisan dapat menerima argumen dan opsi. Argumen adalah nilai yang diperlukan oleh perintah untuk berfungsi, sedangkan opsi adalah argumen yang bersifat opsional. Misalnya, perintah untuk membuat model mungkin memerlukan argumen "nama model", tetapi opsi seperti "--table" untuk menentukan nama tabel yang digunakan oleh model.
5. Menampilkan Output: Artisan Console memberikan output yang informatif saat menjalankan perintah, seperti pesan kesalahan jika ada, atau informasi tambahan tentang tugas yang dijalankan.
6. Environment Configuration: Dalam beberapa perintah, Artisan dapat menggunakan environment untuk mempengaruhi perilaku perintah yang berjalan di lingkungan development atau production.

Artisan Console adalah salah satu fitur kunci yang membuat Laravel menjadi framework yang kuat dan efisien dalam pengembangan aplikasi web. Dengan menggunakan Artisan, pengembang dapat mengotomatisasi banyak tugas repetitif, meningkatkan produktivitas, dan menjaga konsistensi kode dalam proyek mereka.

Kesimpulan

Dari artikel "10 Hal Dasar yang Perlu Dipelajari tentang Laravel" dapat disimpulkan bahwa Laravel adalah sebuah framework PHP yang sangat kuat dan populer untuk pengembangan aplikasi web. Artikel ini telah membahas sepuluh hal dasar yang perlu dipahami oleh pengembang pemula maupun yang berpengalaman dalam membangun proyek dengan menggunakan Laravel.

Dengan memahami dan menguasai kesepuluh hal dasar tersebut, para pengembang dapat mengoptimalkan potensi Laravel dan membangun aplikasi web yang kuat, efisien, dan handal. Semangat belajar dan eksplorasi akan menjadi kunci kesuksesan dalam mengembangkan aplikasi dengan framework Laravel.

Jadi tunggu apa lagi, di BWA kita juga menyediakan Bootcamp Membangun Sebuah Website Menggunakan Laravel bagi yang masih pemula dan ingin membangun jenjang karir sebagai Laravel Developer, atau bagi anda yang ingin lebih mendalami laravel bisa cek Kelas Mastering Laravel 8: Bikin Website jual Furniture. Dengan mengikuti kelas yang ada di BWA anda juga dapat menambah portofolio dan menambah ilmu untuk memulai karir Laravel Developer. Karena dari BuildWith Angga, #semuabisabelajar