--prefer-dist
composer create-project laravel/laravel app01 --prefer-dist
Ennek használata gyorsabb letöltést eredményez. A
Tennivalók
A létrehozott nézetet be kell jegyeznünk az útválasztóba.
Ezt a következő helyen tehetjük meg:
* routes/web.php
A welcome helyére írjuk a home szót:
Route::get('/', function () {
return view('home');
});
Nézzük meg a weboldalt böngészőben:
localhost:8000
Ügyeljünk arra, hogy fusson az Artisan webszerver. Ha valamiért leállítottuk, indítsuk újra:
php artisan serve
===== Artisan parancsok =====
Az Artisan parancsokat **''php artisan''** szavakkal kezdjük,
majd megmondjuk mit szeretnénk. Ne felejtsük el, hogy a
csak projekt gyökérkönyvtárában fognak működni.
Az Artisan parancsok listáját ''php artisan list'' parancs listázza
számunkra egy rövid leírással:
php artisan list
Most nézzük meg útvonalak listáját egy Artisan paranccsal:
php artisan route:list
A kimenet ehhez hasonló:
+--------+----------+----------+------+---------+------------+
| Domain | Method | URI | Name | Action | Middleware |
+--------+----------+----------+------+---------+------------+
| | GET|HEAD | / | | Closure | web |
| | GET|HEAD | api/user | | Closure | api |
| | | | | | auth:api |
+--------+----------+----------+------+---------+------------+
Van egy api/user útvonal is, amit a Laravel projektünk automatikusan tartalmaz.
===== Névjegy =====
Hozzunk létre egy névjegy oldalt (nézetet). Ehhez készítsünk a resources/views könyvtárban
egy about.blade.php nevű fájlt:
resources/views/about.blade.php
Tartalma most két sor legyen:
Tennivalók
Nagy János
Készítsünk számára egy új útvonal-információt. Írjuk az
új bejegyzést a fájl végére:
...
Route::get('/about', function () {
return view('about');
});
Most így néz ki a routes/web.php fájl:
Nézzük meg a böngészőben:
localhost:8000/about
===== Komponensek =====
Nézzük meg a két weblapunk forráskódját.
A blade.php állományok jelenleg nem generálnak szabályos weblapokat.
Ezért, írjunk számukra fejrészt és lábrészt.
Ezeket **komponensek** formájában hozzuk létre, Artisan paranccsal.
Hozzuk létre a Header nevű komponenst:
php artisan make:component Header
Létrejön egy **components** könyvtár **resources/views** könyvtáron belül.
Ezen belül létrejön egy **header.blade.php** fájl.
Írjuk bele a weblap fejrészét:
satodo
Vegyük észre, hogy HTML oldal záró body és html tagét nem írtuk a fájlba.
Hozzuk létre a lábrészt is:
php artisan make:component Footer
Létrejön a **footer.blade.php** fájl. Írjuk bele lábrészt:
Most javítsuk a resources/views könyvtárban a **home.blade.php**
és az **about.blade.php** fájlokat:
Tennivalók
Tennivalók
Nagy János
Az
Az x-header és x-footer után kötelező a / karakter!
Ügyeljünk arra, hogy legyen elindítva az Artisan szerver, majd nézzük meg a böngészőben:
* localhost:8000
* localhost:8000/about
Nézzük meg a weboldalak forráskódját is.
Ötlet: Külön tehetjük a weblap head elemet és tartalmát, és külön a weboldal felső részt:
* head.blade.php
* header.blade.php
* fotter.blade.php
===== A Blade sablon =====
Szeretnék a Blade nézeteket sablonként (template) használni,
vagyis értéket szeretnénk beírni bizonyos helyekre programból,
futási időben.
Készítünk egy listát tartalmazó weblapot, amelyen
szerepelhetnek a teendőink. Legyen a neve **list**.
A fájl tartalma:
Tennivalók
Tennivalók listája
- {{ $todo1 }}
- {{ $todo2 }}
- {{ $todo3 }}
A x-header és x-footer elemek behelyettesítik a fejrészt és a lábrészt.
A {{ $todo1 }} bejegyzés a másik két hasonló bejegyzéssel, változónak foghatók fel, ahova futási időben egy értéket fogunk beírni.
Ha elkészült a Blade sablon, jegyezzük be az útvonalak közzé:
...
Route::get('/list', function () {
return view('list');
});
Az útválasztó **web.app** fájlban hozzuk létre egy asszociatív tömböt,
ahol a kulcsok neve megegyezik a nézetben megadott változónevekkel:
...
Route::get('/list', function () {
$todos['todo1'] = 'PHP tanulás';
$todos['todo2'] = 'composer megismerése';
$todos['todo3'] = 'Laravel tanulása';
return view('list', $todos);
});
A Route::get() függvény paramétereként egy névtelen függvényt hívunk, amelyben
létrehozunk egy tömböt, amiben a három tennivaló van. A névtelen függvény
ez meghívja a view() függvényt, ami megjeleníti a **list** nézetet, amelynek
átadja a $todos tömböt.
Most nézzük meg böngészőben:
localhost:8000/list
Nézzük meg újra a beállított útvonalakat:
php artisan route:list
===== Kontroller létrehozása =====
Az adatokat nem az útválasztóban szokás létrehozni, azokat
egy kontroller kéri el valamilyen modelltől. De most,
maradjunk csak a kontrollernél.
Hozzunk létre egy TodoController nevű kontrollert. Használjuk hozzá Artisan parancsot:
php artisan make:controller TodoController
A következő állomány generálódik:
* app/Http/Controllers/TodoController.php
A létrehozott kontroller a következőt tartalmazza:
Készítsünk egy függvényt a TodoController osztályon belül,
amit írhatunk a // tartalmazó sort követően:
public function list() {
$todos['todo1'] = 'JavaScript tanulás';
$todos['todo2'] = 'Composer megismerése';
$todos['todo3'] = 'Laravel tanulása';
return view('list', $todos);
}
A view() függvényt, most itt hívjuk a kontrollerben és nem
az útválasztóban.
Első paramétere a megjelenítendő nézet, a második paraméter
egy asszociatív tömb, amely tartalmazza a szükséges adatokat
a nézet számára. Ahogy az útválasztóban is tettük, a tömb
minden kulcsszava a nézetben egy változó neve.
A **TodoController.php** teljes tartalma most:
Most be kell jegyeznünk az útválasztóban a kontrollert.
Szerkesszük újra a routes/web.php fájlt.
Az állomány elején mondjuk meg, hogy szeretnénk használni a
TodoController osztályt:
use App\Http\Controllers\TodoController;
Majd javítsuk a /list hivatkozást így:
Route::get('/list', [TodoController::class, 'list']);
Az első paraméter megmondja, hogy ha /list hivatkozás érkezik, akkor a
második paraméterben megadott TodoController osztály list() függvényét futtassuk.
Nézzük meg újra az eredményt, bár látványos változást nem fogunk látni.
Esetleg javítsuk ki az egyik tennivaló szövegét, hogy lássuk a változást,
majd böngészőben:
localhost:8000/list
===== A with használata =====
Az előző fejezetben, a TodoController osztályban az adatokat,
a view() függvény második paraméterében adtuk át. Most lássuk
hogyan adhatjuk át egy másik módszerrel, a with() függvény
használatával.
A TodoController.php fájlban javítsuk a view() függvényünket így:
return view('list')->with('todos', $todos);
A teljes kód:
with('todos', $todos);
}
}
A nézetben javítsuk:
{{ $todos['todo1'] }}
{{ $todos['todo2'] }}
{{ $todos['todo3'] }}
A teljes kód:
Tennivalók
Tennivalók listája
- {{ $todos['todo1'] }}
- {{ $todos['todo2'] }}
- {{ $todos['todo3'] }}
Nézzük meg az eredményt böngészőben:
localhost:8000/list
==== A tömb újratervezése ====
Most tervezzük újra a tömbünket:
$todos = [
'todo1' => 'TypeScript tanulás',
'todo2' => 'Composer megismerése',
'todo3' => 'Laravel tanulása'
];
A teljes kód:
'TypeScript tanulás',
'todo2' => 'Composer megismerése',
'todo3' => 'Laravel tanulása'
];
return view('list')->with('todos', $todos);
}
}
Az első feladatot is átírtam, hogy látszódjon a változás a böngészőben.
Mentsünk és nézzük meg újra a böngészőben:
localhost:8000/list
===== Egy változó bejárása =====
Tervezzük újra a list.blade.php fájlban a listaelemek kiírását.
Jelenleg 3 darab feladatot tud fogadni a list.blade.php sablonunk.
Ha az teendők adatbázisból jönnek, nem tudjuk hány teendő lesz.
Olyan megoldásra van szükségünk, amely iterációval végig megy a
teendők listáján, és legyártja a li elemeket.
Ehhez @foreach utasítás használjuk, amit a @endforeach kulcsszó zár:
@foreach($todos as $item)
{{ $item }}
@endforeach
A teljes kód most így néz ki:
Tennivalók
Tennivalók listája
@foreach($todos as $item)
- {{ $item }}
@endforeach
Az egyik teendőn is változtathatunk, hogy lássuk a változást.
'todo1' => 'Angular tanulás',
Nézzük meg az eredményt a böngészőben:
localhost:8000/list
===== Az adatok view()-ban =====
Újra elővesszük az adatok átadását a view() függvényben.
Az előző fejezetek egyikben egy $todos nevű tömböt adtunk át
a list.blade.php nézetnek. A nézetben ennek megfelelően ilyen
változó kellett szerepeljen: {{ $todos['todo1'] }}.
Vagyis meg kell egyezzen a tömb neve mindkét helyen.
Ha szeretnénk megőrizni a list.blade.php fájlban a $todos
változónevet, de a kontrollerben az adatok egy $data nevű
változóban vannak, akkor írjuk a következőt:
return view('list', [
'todos' => $data
]);
Legyen egy új feladat is:
'todo1' => 'Vue tanulás',
A teljes kód:
'Vue tanulás',
'todo2' => 'Composer megismerése',
'todo3' => 'Laravel tanulása'
];
return view('list', [
'todos' => $data
]);
}
}
Nézzük meg a böngészőben:
localhost:8000/list
===== Adatbázis =====
==== Elérés ====
Az adatok általában adatbázisból jönnek, ezért adatbáziselérést fogunk beállítani.
Vegyük fel az adatbázist, és egy hozzátartozó felhasználót.
A táblákat nem szükséges létrehozni, azokat a Laravel migration
nevű szolgáltatásával hozzuk létre.
Adatbázis hozzáférés beállítására két lehetőség van:
* config/database.php
* .env
A database.php fájlban az alkalmazás végleges helyén megadott
hozzáférést szoktuk beállítani. A fejlesztéshez használjuk
a .env állományt.
Keressük meg a .env fájlban a következő részt:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=
Állítsuk be az adatbázisunk hozzáférési adatait.
Például:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=mytodo
DB_USERNAME=mytodo
DB_PASSWORD=titok
==== Tábla létrehozása ====
A migrációk a következő helyen találhatók:
* database/migrations
Hozzuk létre a saját migrációs osztályunkat a todos tábla elkészítéséhez:
php artisan make:migration create_todos_table
Az elkészült fájl nevében benne lesz az aktuális dátum is.
Egy ilyen fájl jött számomra létre:
* 2021_08_03_205737_create_todos_table.php
A fájl tartalmazni fog egy **up()** és egy **down()** függvényt.
Az up() függvény átírásával kialakítjuk a táblánkat.
A **create_todos_table.php** végződésű állomány tartalma:
id();
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('todos');
}
}
A Schema::create() függvény fogja elkészíteni a táblát.
Az első paraméter az elkészítendő tábla neve.
A következő egy névtelen függvény, amely a Blueprint típusú
objektumot vár paraméterként, ami maga a tábla.
Schema::create('todos', function (Blueprint $table) {
$table->id();
$table->timestamps();
});
A \$table->id(); arra utasítja a migrációs parancsot, hogy hozzon létre egy
id nevű mezőt a táblában. A $table->timestamps(); sor, megmondja, hogy
egy időbélyegek számára is jöjjön létre két mező, automatikusan,
ahol a rekord létrehozása és változtatása lehet feljegyezve.
Ez nekünk kevés, ezért kiegészítjük, átírjuk a mezőmeghatározásokat:
public function up() {
Schema::create('todos', function (Blueprint $table) {
$table->increments('id');
$table->string('task');
$table->boolean('done');
$table->timestamps();
}
}
A \$table->increments('id'); sor egy elsődleges kulcsmezőt hoz létre, egész típussal, amit
automatikusan növel, és a neve "id". A $table->string('task'); egy "task" nevű mezőt hoz létre,
ami string típusú. A következő done nevű mező, boolean típussal. Az utolsó timestamps()
mezők létrehozását meghagytuk.
Futtassuk a következő migrációs utasítást:
php artisan migrate
A parancs hatására, létrejön az adatbázisban a tábla. Ellenőrizzük PhpMyAdmin vagy
mysql kliensen keresztül.
Néhány fontosabb típus, amit megadhatunk függvényként:
* id
* char
* year
* double
* float
* integer
* date
* string
* text
* time
* timestamp
* tinyText
* boolean
* dateTime
* tinyInteger
További [[https://laravel.com/docs/8.x/migrations#available-column-types|típusok ezen a helyen]].
Néhány példa mezők létrehozására, illetve változtatásra:
$table->string('name', 50)->nullable()->change();
$table->increments('id')->first();
$table->dropColumn('valami1');
$table->renameColumn('valami1', 'valami2');
$table->integer('valami_id')->unsigned()->nullable()->change();
$table->unsignedInteger('valami_id')->nullable(false)->change();
==== Adatok feltöltése ====
Az adatokat a **Seeder** nevű szolgáltatással fogjuk feltölteni.
Egy Seeder egy osztályként fog létrejönni.
Hozzunk létre egy feltöltőt:
php artisan make:seeder TodoSeeder
A seeder a következő helyen tárolódik:
* database/seeders/
A fenti Artisan parancs után létrejön egy **TodoSeeder.php** állomány.
Tartalma:
Szükségünk lesz a DB osztályra, vegyük használatba, írjuk az utolsó use után:
use Illuminate\Support\Facades\DB;
Írjuk meg a run() függvényt:
public function run() {
DB::table('todos')->insert([
'task' => 'Linux tanulás',
'done' => '0'
]);
}
A teljes kód:
insert([
'task' => 'Linux tanulás',
'done' => '0'
]);
}
}
Most futtatnunk kell a feltöltőt. Ha több feltöltőnk is van már, akkor
a következő utasítás hatására mind elindul, és feltöltéseket végez:
php artisan db:seed
Ha csak egyetlen feltöltőt akarunk működtetni, adjuk meg az osztálya nevét:
php artisan db:seed --class=TodoSeeder
Ha két rekordot szeretnénk feltölteni, akkor felvehetjük újra:
public function run()
{
//
DB::table('todos')->insert([
'task' => 'Linux tanulás',
'done' => '0'
]);
DB::table('todos')->insert([
'task' => 'Bootstrap tanulás',
'done' => '0'
]);
}
==== Kész táblák frissítése ====
php artisan migrate:refresh
A parancs törli a meglévő adatokat.
==== Kész táblák frissítése adatvesztés nélkül ====
Új migrációs fájl létrehozása:
php artisan make:migration add_premium_column_to_employee_table --table=employee
Beállítom az oszlop adatait.
Futtatjuk a migrációt:
php artisan migrate
Ha az indexekkel probléma van:
* https://laravel.com/docs/8.x/migrations#indexes (2021)
===== Modell használata =====
Most már van adatbázisunk egy **todos** táblával,
amiben fel van véve néhány feladat is.
A kontroller az adatokat egy modelltől fogja megkapni.
Egy **Todos** nevű modellt kell létrehozni. **A modell neve
meg kell egyezzen a tábla nevével, de a modell neve
legyen nagybetűs.**
php artisan make:model Todos
Létrejön egy **Todos.php** fájl.
Tartalma:
Ha a tábla létrehozásakor nem hagytuk meg az időbélyeg mezők
létrehozását, tudassuk a modellel a következő sorral:
public $timestamps = false;
Teljes osztály, ezek után:
class Todos extends Model
{
use HasFactory;
public $timestamps = false;
}
A modellfájlban nincs is más teendőnk.
Most kérjük el a kontrollerben az összes tennivalót.
Nyissuk meg a **TodoController.php** fájlt.
Vegyük használatba a modellt, írjuk az utolsó use után:
use App\Models\Todos;
Hozzunk létre egy új függvényt **getTodos()** néven, a **TodoController** osztályon belül:
function getTodos() {
$data = Todos::all();
return view('list', ['todos' => $data]);
}
Az útválasztóban javítsuk a meghívandó függvény nevét 'list'-ről 'getTodos'-ra:
Route::get('/list', [TodoController::class, 'getTodos']);
Nézzük meg az eredményt böngészőben:
localhost:8000/list
Ehhez hasonlót látunk:
{"id":1,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":2,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":3,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":4,"task":"Linux tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
{"id":5,"task":"Bootstrap tanul\u00e1s","done":0,"created_at":null,"updated_at":null}
Végül javítsunk a nézetfájlon:
Tennivalók
Tennivalók listája
@foreach($todos as $todo)
{{ $todo['task'] }}
@endforeach
Nézzük meg az eredményt:
localhost:8000/list
Innentől a tennivalók adatbázisból jönnek.
===== Tennivaló törlése =====
A nézetfájlban vegyünk fel egy új cellát a táblázatban:
Törlés
Beleírtunk egy linket, ami delet/ útvonalat tartalmazza és egy azonosítót.
Tulajdonképpen egy ilyen üzenet megy át, ha azonosító például 3:
delete/3
A $todo['id'] rész segítségével a törlendő tevékenység azonosító számát adjuk át.
A TodoController osztályban vegyünk fel egy új függvényt deleteTodo() néven:
function deleteTodo($id) {
$data = Todos::find($id);
$data->delete();
return redirect('list');
}
A függvény megkeresi a megadott azonosítójú feladatot, majd törli, végül átirányít a list
nézetre.
Az útválasztóban vegyünk fel egy új útvonalat, amely delete/{id} hatására
meghívja a törlő metódust:
Route::get('delete/{id}', [TodoController::class, 'deleteTodo']);
A {id} szövegben nem lehet szóköz.
Ellenőrizzük a böngészőben és próbáljuk ki a törlést.
localhost:8000/list
===== Tennivaló módosítása =====
Most, tegyük lehetővé adott feladat módosítását.
Ehhez vegyük fel a list.blade.php fájlban egy új cellát,
benne egy új linket:
Szerkesztés
A módosítófelület létrehozásához szükséges egy új nézet.
Legyen a neve edit.blade.php, a következő tartalommal:
Módosítás
Szükségünk van egy nézetre, ahol szerkeszthetjük a kívánt feladatot.
Hozzuk létre a szerkesztő felületet edit.balde.php néven:
Módosítás
Hozzuk létre a kontrollerben egy showTodo() nevű függvényt,
amely kiírja a módosítandó adatokat.
function showTodo($id) {
$data = Todos::find($id);
return view('edit', ['data' => $data]);
}
Most mondjuk meg az útválasztóban, ha valaki hivatkozik egy edit/2
formában, az kapja meg a edit nevű nézetet.
Route::get('edit/{id}', [TodoController::class, 'showTodo']);
Vegyünk fel egy újabb bejegyzést az útválasztóba, amely meghívja a szerkesztőt:
Route::post('edit', [TodoController::class, 'update']);
Majd a hivatkozott update() függvényt hozzuk létre a TodoController-ben is:
function update(Request $req) {
$data = Todos::find($req->id);
$data->task = $req->task;
$data->save();
return redirect('list');
}
A task a mező neve a táblában.
Próbáljuk ki a listaelem módosítását.
localhost:8000/list
===== Tennivaló hozzáadása =====
Tennivaló hozzáadásához szükségünk van egy új nézetre.
Feladat hozzáadása
A TodoController osztályban hozzunk létre egy addTodo() nevű függvényt:
function addTodo(Request $req) {
$todo = new Todos;
$todo->task = $req->task;
$todo->done = 0;
$todo->save();
return redirect('list');
}
Jegyezzük be az útválasztóba:
Route::view('add', 'addtodo');
Route::post('add', [TodoController::class, 'addTodo']);
===== Laravel Breeze azonosítás =====
A tennivalóinkat szeretnék védeni, és csak azonosítás után szeretnénk
az elérést engedélyezni. Ehhez a Laravel Breeze egyszerű azonosító
rendszert fogjuk használni.
Telepítés:
composer require laravel/breeze --dev
Egyszerű scaffolding azonosítás készítése:
php artisan breeze:install
Függőségek rendezése:
npm install && npm run dev
Készítsük el az adatbázis tábláit:
php artisan migrate
Most lesz egy /register és egy /login útvonalunk.
A regisztrációs felületen (/register), vegyünk fel egy felhasználót.
Például:
* Name: janos
* Email: janos@tatami
* Password: 12345678
* Confirm: Password: 12345678
Szeretnénk védeni a /list nézetünket.
Ehhez, keressük meg a routes/web.php fájlban a /list-re vonatkozó részt:
//...
Route::get('/list', function () {
return view('list');
});
Kössünk a végéhez egy azonosítást:
//...
Route::get('/list', function () {
return view('list');
})->middleware('auth');
Ellenőrizzük.
==== Alapértelmezett útvonal ====
Bejelentkezés után a /list útvonalat szeretnénk
látni a dashboard helyett.
Ehhez szerkesszük az app/Providers/RouteServiceProvider.php állományt.
Ott keressük meg a következő sort:
public const HOME = '/dashboard';
Javítsuk így:
public const HOME = '/list';
===== Kilépés =====
Két lehetőségünk van:
* A blade sablon fájlban form elemet használok.
* Írok egy útvonalat, ami képes GET kérést kezelni.
==== Form használata ====
A kilépési lehetőséghez készítsük el a formot:
Próbáljuk ki.
==== Írjunk GET kérést ====
Használjuk az App\Http\Controllers\Auth\AuthenticatedSessionController-t kontrollert:
Az útválasztáshoz adjunk hozzá új bejegyzést.
Az útválasztóban vegyük használatba az elkészült kontrollert:
use App\Http\Controllers\Auth\AuthenticatedSessionController;
Majd vegyük fel egy új útvonalat:
Route::get('/logout', [AuthenticatedSessionController::class, 'destroy']);;
Ezek után a list.blade.php nézetfájlban:
Kilépés
A Kilépésre kattintva működik. Próbáljuk ki.
===== Függelék =====
==== Alternatív projekt készítés ====
=== Szükséges ===
apt install curl docker-compose
=== Projekt létrehozása ===
Az egy-app nevű projekt létrehozása:
curl -s https://laravel.build/egy-app | bash
Létrejön egy **egy-app** nevű könyvtár, benne a laravel alkalmazással.
=== Sail ===
Indítsuk el a Laravel Sail-t.
cd egy-app
./vendor/bin/sail up
Az első indítás eltarthat egy ideig.
Ha megállt az üzenetek továbbítása, a böngészőbe írjuk be:
localhost/
Ügyeljünk arra, hogy a 80-s port szabad legyen, vagy állítsunk be
egy másik portot, a **docker-compose.yml** fájlban:
Keressük meg a portbeállításokat:
ports:
- '${APP_PORT:-8000}:80'
Cseréljük erre:
ports:
- 8000:80
==== Kezdeti konfiguráció ====
Kezdeti konfigurációhoz tanulmányozzuk a **config/app.php** állományt.
==== Alkönyvtárak a kontrollerben ====
Előfordul, hogy a resources/views/ könyvtárban egy újabb könyvtárat
hozunk létre, és abban hozok létre egy nézetfájlt, valahogy így:
resources/views/products/index.blade.php
Ilyen esetben a kontrollerben így hivatkozok a nézetre:
...
public function getData() {
$msg = "vmi";
return view('products.index', compact('msg'));
}
...
Vegyük észre a products után pontot írtam a perjel helyett.
==== composer create-project ====
A composer create-project parancsának sok helyen megadják a --prefer-dist
kapcsolót. Ez nem szükséges, mert ez az alapértelmezés.
Ugyanakkor két "ellentétes" lehetőségünk van:
* --prefer-dist
* --prefer-source
A source hatására forrásból telepíti a projektet.
A --prefer-source kapcsoló egyenértékű ezzel: ---prefer-install=source .
A --prefer-dist hatására gyorsabb lehet a telepítés.
Több információ
* https://getcomposer.org/doc/03-cli.md#create-project
==== Debian GNU/Linux 11 - PHP8.1 ====
apt update
apt -y install lsb-release apt-transport-https ca-certificates
wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/php.list
apt update
apt install php8.1
reboot
php --version
apt install php8.1-mysql
apt install php8.1-xml
apt install php8.1-curl
==== Laravel parancs ====
Composer telepítése:
choco install composer -y
A laravel parancs telepítése:
composer global require laravel/installer
A parancs a következő helyen telepszik:
* c:\Users\janos\AppData\Roaming\Composer\
Ezek után, projekt készítése:
laravel new app01
===== Linkek =====
* https://www.youtube.com/watch?v=376vZ1wNYPA (2021; Laravel 8 angolul)
* https://laravel.com/docs/8.x/controllers (2022; Kontrollerek)