Icons background left side Icons background left side in dark variant
Paplašināms mikro-frameworkis PHP Paplašināms mikro-frameworkis PHP
Icons background right side Icons background right side in dark variant

Learn

Uzziniet par Flight

Flight ir ātra, vienkārša, paplašināma PHP ietvars. Tas ir diezgan daudzpusīgs un to var izmantot jebkura veida tīmekļa lietojumprogrammu izveidošanai. Tas ir izstrādāts ar vienkāršību prātā un ir uzrakstīts veidā, kas ir viegli saprotams un lietojams.

Svarīgas ietvara koncepcijas

Kāpēc ietvars?

Šeit ir īss raksts par to, kāpēc jums vajadzētu izmantot ietvaru. Ir laba prakse saprast ietvaru izmantošanas priekšrocības, pirms sākat to lietot.

Turklāt lielisks pamācību ir izveidojis @lubiana. Lai gan tā nesniedz lielu detalizāciju par Flight konkrēti, šis ceļvedis palīdzēs jums saprast dažas no galvenajām koncepcijām, kas saistītas ar ietvaru, un kāpēc tās ir izdevīgas lietošanai. Jūs varat atrast pamācību šeit.

Flight salīdzinājumā ar citiem ietvariem

Ja jūs pārvietojaties no cita ietvara, piemēram, Laravel, Slim, Fat-Free vai Symfony uz Flight, šī lapa palīdzēs jums saprast atšķirības starp abiem.

Galvenie temati

Automātiska iekļaušana

Uzziniet, kā automātiski iekļaut savas klases jūsu lietojumprogrammā.

Maršrutēšana

Uzziniet, kā pārvaldīt maršrutus jūsu tīmekļa lietojumprogrammā. Tas ietver arī maršrutu grupēšanu, maršrutu parametrus un vidusdienu programmas.

Vidusdienas programmas

Uzziniet, kā izmantot vidusdienas programmas, lai filtrētu pieprasījumus un atbildes jūsu lietojumprogrammā.

Pieprasījumi

Uzziniet, kā apstrādāt pieprasījumus un atbildes jūsu lietojumprogrammā.

Atbildes

Uzziniet, kā sūtīt atbildes saviem lietotājiem.

Notikumi

Uzziniet, kā izmantot notikumu sistēmu, lai pievienotu pielāgotus notikumus jūsu lietojumprogrammā.

HTML veidnes

Uzziniet, kā izmantot iebūvēto skatījumu dzinēju, lai attēlotu savas HTML veidnes.

Drošība

Uzziniet, kā nodrošināt savu lietojumprogrammu pret izplatītām drošības apdraudējumiem.

Konfigurācija

Uzziniet, kā konfigurēt ietvaru jūsu lietojumprogrammai.

Paplašinot Flight

Uzziniet, kā paplašināt ietvaru, pievienojot savas metodes un klases.

Notikumi un filtrēšana

Uzziniet, kā izmantot notikumu sistēmu, lai pievienotu āķus savām metodēm un iekšējām ietvara metodēm.

Atkarību injekcijas konteineris

Uzziniet, kā izmantot atkarību injekcijas konteinerus (DIC), lai pārvaldītu jūsu lietojumprogrammas atkarības.

Ietvara API

Uzziniet par ietvara pamatmetodēm.

Migrācija uz v3

Atpakaļsaderība lielākajā daļā ir saglabāta, taču ir dažas izmaiņas, par kurām jums vajadzētu būt informētam, pārejot no v2 uz v3.

Problemu novēršana

Pastāv dažas izplatītas problēmas, ar kurām jūs varētu saskarties, lietojot Flight. Šī lapa palīdzēs jums novērst šīs problēmas.

Learn/stopping

Aptur

Jūs varat apturēt pamatstruktūru jebkurā brīdī, izsaucot halt metodi:

Flight::halt();

Jūs arī varat norādīt neobligātu HTTP statusa kodu un ziņojumu:

Flight::halt(200, 'Jau drīz atgriezīšos...');

Izsaukot halt, tiks atcelts jebkāds atbildes saturs līdz tam brīdim. Ja vēlaties apturēt pamatstruktūru un izvadīt pašreizējo atbildi, izmantojiet stop metodi:

Flight::stop();

Learn/errorhandling

Kļūdu apstrāde

Kļūdas un izņēmumi

Visas kļūdas un izņēmumi tiek noķerti ar Flight un padoti error metodei. Pēc noklusējuma uzvedība ir nosūtīt vispārēju HTTP 500 Iekšēja servera kļūda atbildi ar kādu kļūdas informāciju.

Jūs varat pārrakstīt šo uzvedību savām vajadzībām:

Flight::map('error', function (Throwable $error) {
  // Apstrādāt kļūdu
  echo $error->getTraceAsString();
});

Pēc noklusējuma kļūdas netiek reģistrētas tīmekļa serverī. Jūs varat to iespējot, mainot konfigurāciju:

Flight::set('flight.log_errors', true);

Nav Atrasts

Kad URL nav atrodams, Flight izsauc notFound metodi. Noklusējuma uzvedība ir nosūtīt HTTP 404 Nav atrasts atbildi ar vienkāršu ziņojumu.

Jūs varat pārrakstīt šo uzvedību savām vajadzībām:

Flight::map('notFound', function () {
  // Apstrādāt nav atrasts
});

Learn/flight_vs_laravel

Flight pret Laravela

Kas ir Laravel?

Laravel ir pilnveidots ietvars, kam ir visas iespējas un lielisks attīstītāju fokusēts ekosistēma, bet par cenu ātrdarbības un sarežģītības ziņā. Laravel mērķis ir, lai attīstītājam būtu augstākā produktivitātes līmenis un lai parasts uzdevums būtu viegli risināms. Laravel ir lieliska izvēle attīstītājiem, kuri vēlas izveidot pilnveidotu uzņēmuma tīmekļa lietotni. Tas nāk ar dažiem kompromisiem, īpaši attiecībā uz veiktspēju un sarežģītību. Laravel pamatu apgūšana var būt viegla, bet prasme darboties ar šī ietvara var prasīt kādu laiku.

Pastāv arī tik daudz Laravel moduļu, ka attīstītāji bieži jūtas, ka vienīgais veids, kā risināt problēmas, ir, izmantojot šos moduļus, kad patiesībā jūs varētu vienkārši izmantot citu bibliotēku vai rakstīt savu kodu.

Plusi salīdzinājumā ar Flight

Mīnusi salīdzinājumā ar Flight

Learn/migrating_to_v3

Migrācija uz v3

Atgriezeniskā saderība lielākoties ir saglabāta, bet ir dažas izmaiņas, par kurām jums vajadzētu zināt, migrējot no v2 uz v3.

Rezultātu buferēšanas uzvedība (3.5.0)

Rezultātu buferēšana ir process, kurā PHP skriptā ģenerētais izvads tiek saglabāts buferī (iekšējs PHP) pirms tiek nosūtīts klientam. Tas ļauj jums modificēt izvadu pirms tā nosūtīšanas klientam.

MVC lietojumprogrammā, vadītājs ir "pārvaldnieks" un tas pārvalda to, ko darbojas skats. Izvades ģenerēšana ārpus vadītāja (vai Flight gadījumā dažreiz anonīmā funkcijā) pārkāpj MVC modeli. Šī izmaiņa ir domāta, lai būtu labāka saskaņa ar MVC modeli un padarītu struktūru paredzamāku un vieglāk lietojamu.

v2 versijā rezultātu buferēšana tika apstrādāta tādā veidā, ka tā konsistenti neaizvēra savu paša izvades buferi, un tas padarīja vienības pārbaudi un strāmošanu sarežģītāku. Lielai daļai lietotāju šī izmaiņa varbūt patiesībā ietekmēt jūs. Tomēr, ja jūs izvadāt saturu ārpus izsaukamajiem un vadītājiem (piemēram, āķī), jums, visticamāk, radīsies problēmas. Satura izvadīšana āķos un pirms struktūra faktiski izpilda to varēja darboties pagātnē, bet tas nedarbosies turpmāk.

Kur var rasties problēmas

// index.php
require 'vendor/autoload.php';

// tikai piemērs
define('START_TIME', microtime(true));

function hello() {
    echo 'Sveika, pasaule!';
}

// papildus kods

Ieslēgt v2 renderēšanas uzvedību

Vai jūs joprojām varat paturēt savu veco kodu tādu, kāds tas ir, neveicot pārrakstīšanu, lai tas darbotos ar v3? Jā, varat! Jūs varat ieslēgt v2 renderēšanas uzvedību, iestatot konfigurācijas opciju flight.v2.output_buffering uz true. Tas ļaus jums turpināt izmantot veco renderēšanas uzvedību, bet ieteicams to labot turpmāk. v4 versijā no struktūras tas tiks noņemts.

// index.php
require 'vendor/autoload.php';

Flight::set('flight.v2.output_buffering', true);

// papildus kods

Dispecera izmaiņas (3.7.0)

Ja jūs tieši esat izsaucis statiskās metodes Dispatcher, tādas kā Dispatcher::invokeMethod(), Dispatcher::execute(), utt., jums būs jāatjaunina jūsu kods, lai tieši nesaucu šīs metodes. Dispatcher ir pārveidots, lai būtu vairāk objektu orientēts, tāpēc atkarību ievades konteinerus var izmantot vieglāk. Ja jums ir nepieciešams izsaukt metodi līdzīgi tam, kā to darīja Dispecers, jūs varat manuāli izmantot kaut ko līdzīgu $rezultāts = $klase->$metode(...$parametri); vai call_user_func_array() vietā.

halt() stop() redirect() un error() izmaiņas (3.10.0)

Noklusējuma uzvedība pirms 3.10.0 bija notīrīt gan galvenes, gan atbildes korpusu. Tas tika mainīts, lai notīrītu tikai atbildes korpusu. Ja jums ir nepieciešams notīrīt arī galvenes, jūs varat izmantot Flight::response()->clear().

Learn/configuration

Konfigurācija

Varat pielāgot dažādas Flight darbības, iestatot konfigurācijas vērtības, izmantojot set metodi.

Flight::set('flight.log_errors', true);

Pieejamie konfigurācijas iestatījumi

Zemāk ir saraksts ar visiem pieejamajiem konfigurācijas iestatījumiem:

Ielādes konfigurācija

Turklāt ir vēl viens konfigurācijas iestatījums ielādētājam. Tas ļaus jums automātiski ielādēt klases ar _ klases nosaukumā.

// Iespējot klases ielādi ar apakšsvītra zīmi
// Pēc noklusējuma ir ieslēgts
Loader::$v2ClassLoading = false;

Mainīgie

Flight ļauj jums saglabāt mainīgos, lai tos varētu izmantot jebkur lietotnē.

// Saglabājiet savu mainīgo
Flight::set('id', 123);

// Cits kur lietotnē
$id = Flight::get('id');

Lai pārbaudītu, vai mainīgais ir iestatīts, varat izdarīt:

if (Flight::has('id')) {
  // Izdarīt kaut ko
}

Mainīgo var notīrīt, darot:

// Notīra id mainīgo
Flight::clear('id');

// Notīra visus mainīgos
Flight::clear();

Flight arī izmanto mainīgos konfigurācijas nolūkiem.

Flight::set('flight.log_errors', true);

Kļūdu apstrāde

Kļūdas un Izņēmumi

Visas kļūdas un izņēmumi tiek uztverti ar Flight un nodoti error metodē. Noklusējuma uzvedība ir nosūtīt vispārēju HTTP 500 Iekšēja servera kļūda atbildi ar dažām kļūdas informācijām.

Jūs varat pārrakstīt šo uzvedību savām vajadzībām:

Flight::map('error', function (Throwable $error) {
  // Apstrādāt kļūdu
  echo $error->getTraceAsString();
});

Pēc noklusējuma kļūdas netiek reģistrētas tīmekļa serverī. To var aktivizēt, mainot konfigurāciju:

Flight::set('flight.log_errors', true);

Nav Atrasts

Kad URL nav atrasts, Flight izsauc notFound metodi. Noklusējuma uzvedība ir nosūtīt HTTP 404 Nav atrasts atbildi ar vienkāršu ziņu.

Jūs varat pārrakstīt šo uzvedību savām vajadzībām:

Flight::map('notFound', function () {
  // Apstrādāt nav atrasts
});

Learn/security

Drošība

Drošība ir svarīga, runājot par tīmekļa lietojumprogrammām. Jums jānodrošina, ka jūsu lietojumprogramma ir droša un ka jūsu lietotāju dati ir droši. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt jūsu tīmekļa lietojumprogrammas.

Virsraksti

HTTP virsraksti ir viens no vieglākajiem veidiem, kā nodrošināt jūsu tīmekļa lietojumprogrammas. Jūs varat izmantot virsrakstus, lai novērstu klikšķināšanu, XSS un citus uzbrukumus. Ir vairāki veidi, kā jūs varat pievienot šos virsrakstus savam lietojumprogrammai.

Divas lieliskas vietnes, lai pārbaudītu jūsu virsrakstu drošību, ir securityheaders.com un observatory.mozilla.org.

Pievienot manuāli

Jūs varat manuāli pievienot šos virsrakstus, izmantojot header metodi Flight\Response objektā.

// Iestatiet X-Frame-Options virsrakstu, lai novērstu klikšķināšanu
Flight::response()->header('X-Frame-Options', 'SAMEORIGIN');

// Iestatiet Content-Security-Policy virsrakstu, lai novērstu XSS
// Piezīme: šis virsraksts var kļūt ļoti sarežģīts, tāpēc jums būs jākonsultējas
//  ar piemēriem internetā jūsu lietojumprogrammai
Flight::response()->header("Content-Security-Policy", "default-src 'self'");

// Iestatiet X-XSS-Protection virsrakstu, lai novērstu XSS
Flight::response()->header('X-XSS-Protection', '1; mode=block');

// Iestatiet X-Content-Type-Options virsrakstu, lai novērstu MIME sniffing
Flight::response()->header('X-Content-Type-Options', 'nosniff');

// Iestatiet Referrer-Policy virsrakstu, lai kontrolētu, cik daudz atsaucēju informācijas tiek nosūtīta
Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade');

// Iestatiet Strict-Transport-Security virsrakstu, lai piespiestu HTTPS
Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');

// Iestatiet Permissions-Policy virsrakstu, lai kontrolētu, kādas funkcijas un API var tikt izmantotas
Flight::response()->header('Permissions-Policy', 'geolocation=()');

Šos var pievienot jūsu bootstrap.php vai index.php failu augšpusē.

Pievienot kā filtru

Jūs varat tos pievienot arī filtrā/ūdenī, piemēram, sekojošā:

// Pievieno virsrakstus filtrā
Flight::before('start', function() {
    Flight::response()->header('X-Frame-Options', 'SAMEORIGIN');
    Flight::response()->header("Content-Security-Policy", "default-src 'self'");
    Flight::response()->header('X-XSS-Protection', '1; mode=block');
    Flight::response()->header('X-Content-Type-Options', 'nosniff');
    Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade');
    Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
    Flight::response()->header('Permissions-Policy', 'geolocation=()');
});

Pievienot kā vidusdaļu

Jūs varat tos pievienot arī kā vidusdaļu. Tas ir labs veids, kā uzturēt savu kodu tīru un sakārtotu.

// app/middleware/SecurityHeadersMiddleware.php

namespace app\middleware;

class SecurityHeadersMiddleware
{
    public function before(array $params): void
    {
        Flight::response()->header('X-Frame-Options', 'SAMEORIGIN');
        Flight::response()->header("Content-Security-Policy", "default-src 'self'");
        Flight::response()->header('X-XSS-Protection', '1; mode=block');
        Flight::response()->header('X-Content-Type-Options', 'nosniff');
        Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade');
        Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
        Flight::response()->header('Permissions-Policy', 'geolocation=()');
    }
}

// index.php vai kur jums ir jūsu maršruti
// FYI, šī tukšā virkne darbojas kā globālais vidusmērķis
// visiem maršrutiem. Protams, jūs varētu to darīt tāpat un pievienot
// to tikai konkrētiem maršrutiem.
Flight::group('', function(Router $router) {
    $router->get('/users', [ 'UserController', 'getUsers' ]);
    // vairāk maršrutu
}, [ new SecurityHeadersMiddleware() ]);

Krustojuma vietnes pieprasījums (CSRF)

Krustojuma vietnes pieprasījums (CSRF) ir uzbrukuma veids, kad ļaunprātīgs vietne var likt lietotāja pārlūkam nosūtīt pieprasījumu uz jūsu vietni. To var izmantot, lai veiktu darbības jūsu vietnē, nenojaušot lietotāju. Flight nesniedz iebūvētu CSRF aizsardzības mehānismu, bet jūs to varat viegli īstenot paši, izmantojot vidusdaļu.

Iestatījumi

Vispirms jums jāizveido CSRF tokens un jāuzglabā tas lietotāja sesijā. To varat izmantot savos veidlapās un pārbaudīt, kad veidlapa tiek iesniegta.

// Izveidojiet CSRF tokenu un uzglabājiet to lietotāja sesijā
// (pieņemot, ka esat izveidojis sesijas objektu un pievienojis to Flight)
// skatiet sesijas dokumentāciju, lai iegūtu vairāk informācijas
Flight::register('session', \Ghostff\Session\Session::class);

// Jums ir jāizveido tikai viens tokens uz sesiju (lai tas darbotos 
// vairākās cilnēs un pieprasījumos tam pašam lietotājam)
if(Flight::session()->get('csrf_token') === null) {
    Flight::session()->set('csrf_token', bin2hex(random_bytes(32)) );
}
<!-- Izmantojiet CSRF tokenu savā veidlapā -->
<form method="post">
    <input type="hidden" name="csrf_token" value="<?= Flight::session()->get('csrf_token') ?>">
    <!-- citas veidlapas lauki -->
</form>

Izmantojot Latte

Jūs varat arī iestatīt pielāgotu funkciju, lai izvadītu CSRF tokenu jūsu Latte veidnēs.

// Iestatiet pielāgotu funkciju, lai izvadītu CSRF tokenu
// Piezīme: Skats ir konfigurēts ar Latte kā skatu motoru
Flight::view()->addFunction('csrf', function() {
    $csrfToken = Flight::session()->get('csrf_token');
    return new \Latte\Runtime\Html('<input type="hidden" name="csrf_token" value="' . $csrfToken . '">');
});

Un tagad savās Latte veidnēs jūs varat izmantot csrf() funkciju, lai izvadītu CSRF tokenu.

<form method="post">
    {csrf()}
    <!-- citas veidlapas lauki -->
</form>

Īsi un vienkārši, vai ne?

Pārbaudiet CSRF tokenu

Jūs varat pārbaudīt CSRF tokenu, izmantojot notikumu filtrus:

// Šī vidusdaļa pārbauda, vai pieprasījums ir POST pieprasījums, un, ja tas ir, pārbauda, vai CSRF tokens ir derīgs
Flight::before('start', function() {
    if(Flight::request()->method == 'POST') {

        // sagūstiet csrf tokenu no veidlapas vērtībām
        $token = Flight::request()->data->csrf_token;
        if($token !== Flight::session()->get('csrf_token')) {
            Flight::halt(403, 'Nederīgs CSRF tokens');
            // vai JSON atbildes
            Flight::jsonHalt(['error' => 'Nederīgs CSRF tokens'], 403);
        }
    }
});

Vai jūs varat izmantot vidusdaļas klasi:

// app/middleware/CsrfMiddleware.php

namespace app\middleware;

class CsrfMiddleware
{
    public function before(array $params): void
    {
        if(Flight::request()->method == 'POST') {
            $token = Flight::request()->data->csrf_token;
            if($token !== Flight::session()->get('csrf_token')) {
                Flight::halt(403, 'Nederīgs CSRF tokens');
            }
        }
    }
}

// index.php vai kur jums ir jūsu maršruti
Flight::group('', function(Router $router) {
    $router->get('/users', [ 'UserController', 'getUsers' ]);
    // vairāk maršrutu
}, [ new CsrfMiddleware() ]);

Krustojuma vietnes skriptu (XSS)

Krustojuma vietnes skriptu (XSS) ir uzbrukuma veids, kad ļaunprātīgs vietne var injicēt kodu jūsu vietnē. Lielākā daļa no šīm iespējām nāk no veidlapas vērtībām, kuras aizpildīs jūsu beigu lietotāji. Jums nekad nevajadzētu uzticēties izvadei no jūsu lietotājiem! Vienmēr pieņemiet, ka visi no viņiem ir labākie hakeri pasaulē. Viņi var injicēt ļaunprātīgu JavaScript vai HTML jūsu lapā. Šis kods var tikt izmantots, lai zagtu informāciju no jūsu lietotājiem vai veiktu darbības jūsu vietnē. Izmantojot Flight skatu klasi, jūsu izejas datus var viegli novērst, lai novērstu XSS uzbrukumus.

// Pieņemsim, ka lietotājs ir gudrs un mēģina to izmantot kā savu vārdu
$name = '<script>alert("XSS")</script>';

// Tas aizsargās izvadi
Flight::view()->set('name', $name);
// Tas izvadīs: &lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;

// Ja jūs izmantojat kaut ko līdzīgu Latte, kas reģistrēts kā jūsu skatu klase, tas arī automātiski aizsargās šo.
Flight::view()->render('template', ['name' => $name]);

SQL injekcija

SQL injekcija ir uzbrukuma veids, kad ļaunprātīgs lietotājs var injicēt SQL kodu jūsu datubāzē. To var izmantot, lai zagtu informāciju no jūsu datubāzes vai veiktu darbības jūsu datubāzē. Atkal jums nekad nevajadzētu uzticēties ievadei no jūsu lietotājiem! Vienmēr pieņemiet, ka viņi ir izsalkuši pēc asins. Jūs varat izmantot sagatavotos pieprasījumus savos PDO objektos, lai novērstu SQL injekciju.

// Pieņemot, ka jums ir Flight::db() reģistrēts kā jūsu PDO objekts
$statement = Flight::db()->prepare('SELECT * FROM users WHERE username = :username');
$statement->execute([':username' => $username]);
$users = $statement->fetchAll();

// Ja jūs izmantojat PdoWrapper klasi, tas var tikt viegli paveikts vienā rindā
$users = Flight::db()->fetchAll('SELECT * FROM users WHERE username = :username', [ 'username' => $username ]);

// Jūs varat darīt to pašu ar PDO objektu ar ? vietturēm
$statement = Flight::db()->fetchAll('SELECT * FROM users WHERE username = ?', [ $username ]);

// Tikai soliet, ka jūs nekad NEIZDARIET kaut ko līdzīgu ...
$users = Flight::db()->fetchAll("SELECT * FROM users WHERE username = '{$username}' LIMIT 5");
// jo kas ja $username = "' OR 1=1; -- "; 
// Pēc vaicājuma izvešanas tas izskatās šādi
// SELECT * FROM users WHERE username = '' OR 1=1; -- LIMIT 5
// Tas izskatās dīvaini, taču tas ir derīgs vaicājums, kas darbosies. Patiesībā,
// tas ir ļoti izplatīts SQL injekcijas uzbrukums, kas atgriezīs visus lietotājus.

CORS

Krustojuma resursu koplietošanas (CORS) mehānisms ļauj daudziem resursiem (piemēram, fontiem, JavaScript utt.) tīmekļa lapā tikt pieprasītiem no citas domēna, kas atrodas ārpus vietnes, no kuras resurss radās. Flight nesniedz iebūvētu funkcionalitāti, bet to var viegli apstrādāt ar ūdeni, lai to izpildītu pirms Flight::start() metodes izsaukšanas.

// app/utils/CorsUtil.php

namespace app\utils;

class CorsUtil
{
    public function set(array $params): void
    {
        $request = Flight::request();
        $response = Flight::response();
        if ($request->getVar('HTTP_ORIGIN') !== '') {
            $this->allowOrigins();
            $response->header('Access-Control-Allow-Credentials', 'true');
            $response->header('Access-Control-Max-Age', '86400');
        }

        if ($request->method === 'OPTIONS') {
            if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_METHOD') !== '') {
                $response->header(
                    'Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD'
                );
            }
            if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') !== '') {
                $response->header(
                    "Access-Control-Allow-Headers",
                    $request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS')
                );
            }

            $response->status(200);
            $response->send();
            exit;
        }
    }

    private function allowOrigins(): void
    {
        // pielāgojiet šeit atļautās viesu vietnes.
        $allowed = [
            'capacitor://localhost',
            'ionic://localhost',
            'http://localhost',
            'http://localhost:4200',
            'http://localhost:8080',
            'http://localhost:8100',
        ];

        $request = Flight::request();

        if (in_array($request->getVar('HTTP_ORIGIN'), $allowed, true) === true) {
            $response = Flight::response();
            $response->header("Access-Control-Allow-Origin", $request->getVar('HTTP_ORIGIN'));
        }
    }
}

// index.php vai kur jums ir jūsu maršruti
$CorsUtil = new CorsUtil();

// Šis ir jāizpilda pirms uzsākšanas.
Flight::before('start', [ $CorsUtil, 'setupCors' ]);

Kļūdu apstrāde

Slēpiet jutīgas kļūdu detaļas ražošanā, lai izvairītos no informācijas noplūdes uzbrucējiem.

// Jūsu bootstrap.php vai index.php

// flightphp/skeleton, tas ir app/config/config.php
$environment = ENVIRONMENT;
if ($environment === 'production') {
    ini_set('display_errors', 0); // Atspējot kļūdu parādīšanu
    ini_set('log_errors', 1);     // Reģistrējiet kļūdas
    ini_set('error_log', '/path/to/error.log');
}

// Jūsu maršrutos vai kontrolieros
// Izmantojiet Flight::halt() paredzētiem kļūdu atbildēm
Flight::halt(403, 'Piekļuve liegta');

Ievades sanitizācija

Nekad neuzticieties lietotāja ievadei. Sanitizējiet to pirms apstrādes, lai novērstu ļaunprātīgu datu iekļūšanu.


// Pieņemsim, ka ir $_POST pieprasījums ar $_POST['input'] un $_POST['email']

// Sanitizējiet virkne ievadi
$clean_input = filter_var(Flight::request()->data->input, FILTER_SANITIZE_STRING);
// Sanitizējiet e-pastu
$clean_email = filter_var(Flight::request()->data->email, FILTER_SANITIZE_EMAIL);

Paroles hashing

Uzglabājiet paroles droši un pārliecinieties par tām droši, izmantojot PHP iebūvētās funkcijas.

$password = Flight::request()->data->password;
// Hash a password when storing (e.g., during registration)
$hashed_password = password_hash($password, PASSWORD_DEFAULT);

// Verify a password (e.g., during login)
if (password_verify($password, $stored_hash)) {
    // Parole atbilst
}

Pieprasījumu ierobežošana

Aizsargājiet pret brutālu spēku uzbrukumiem, ierobežojot pieprasījumu ātrumu, izmantojot kešatmiņu.

// Pieņemot, ka jums ir flightphp/cache instalēts un reģistrēts
// Izmantojot flightphp/cache vidusdaļā
Flight::before('start', function() {
    $cache = Flight::cache();
    $ip = Flight::request()->ip;
    $key = "rate_limit_{$ip}";
    $attempts = (int) $cache->retrieve($key);

    if ($attempts >= 10) {
        Flight::halt(429, 'Pārāk daudz pieprasījumu');
    }

    $cache->set($key, $attempts + 1, 60); // Atjaunot pēc 60 sekundēm
});

Secinājums

Drošība ir svarīga un ir būtiski nodrošināt, lai jūsu tīmekļa lietojumprogrammas būtu drošas. Flight sniedz vairākas funkcijas, lai palīdzētu jums nodrošināt jūsu tīmekļa lietojumprogrammas, taču ir svarīgi vienmēr būt uzmanīgam un nodrošināt, lai jūs darītu visu iespējamo, lai saglabātu jūsu lietotāju datus drošībā. Vienmēr pieņemiet sliktāko un nekad neuzticieties ievadei no jūsu lietotājiem. Vienmēr aizbēdziet izvadi un izmantojiet sagatavotos pieprasījumus, lai novērstu SQL injekcijas. Vienmēr izmantojiet vidusdaļas, lai aizsargātu savas maršrutu no CSRF un CORS uzbrukumiem. Ja jūs darāt visu šo, jūs būsit labi ceļā, lai izveidotu drošas tīmekļa lietojumprogrammas.

Learn/overriding

Pārrakstīšana

Flight ļauj jums pārrakstīt tās noklusējuma funkcionalitāti, lai pielāgotu to savām vajadzībām, neiesaistoties tajā nekādā veidā.

Piemēram, kad Flight nevar sakrist ar URL adresi maršrutam, tas izsauc notFound metodi, kas nosūta vispārēju HTTP 404 atbildi. Jūs varat pārrakstīt šo darbību izmantojot map metodi:

Flight::map('notFound', function() {
  // Parādīt pielāgoto 404. lapu
  include 'errors/404.html';
});

Flight arī ļauj jums aizstāt pamata framework komponentes. Piemēram, jūs varat aizstāt noklusējuma Router klasi ar savu pielāgoto klasi:

// Reģistrējiet savu pielāgoto klasi
Flight::register('router', MyRouter::class);

// Kad Flight ielādē Router instanci, tā ielādēs jūsu klasi
$myrouter = Flight::router();

Framework metodēm, piemēram, map un register, tomēr nevar pārrakstīt. Jums iegūsiet kļūdu, ja mēģināsiet to izdarīt.

Learn/routing

Maršrutizācija

Piezīme: Vēlaties labāk izprast maršrutizāciju? Apmeklējiet "kāpēc ietvars?" lapu, lai iegūtu padziļinātu skaidrojumu.

Vienkārša maršrutizācija Flight ietvarā tiek veikta, salīdzinot URL paraugu ar atgriešanas funkciju vai klases un metodes masīvu.

Flight::route('/', function(){
    echo 'hello world!';
});

Maršruti tiek salīdzināti to definēšanas secībā. Pirmais maršruts, kas atbilst pieprasījumam, tiks izsaukts.

Atgriezeniskās saites/Funkcijas

Atgriezeniskā funkcija var būt jebkurš izsaucams objekts. Tādējādi varat izmantot parastu funkciju:

function hello() {
    echo 'hello world!';
}

Flight::route('/', 'hello');

Klases

Jūs varat izmantot arī statisko metodi no klases:

class Greeting {
    public static function hello() {
        echo 'hello world!';
    }
}

Flight::route('/', [ 'Greeting','hello' ]);

Vai arī, vispirms izveidojot objektu un pēc tam izsaucot metodi:


// Greeting.php
class Greeting
{
    public function __construct() {
        $this->name = 'John Doe';
    }

    public function hello() {
        echo "Hello, {$this->name}!";
    }
}

// index.php
$greeting = new Greeting();

Flight::route('/', [ $greeting, 'hello' ]);
// Jūs varat to darīt arī bez objekta izveides iepriekš
// Piezīme: Nav argumentu, kas tiks ievietoti konstruktora iekšpusē
Flight::route('/', [ 'Greeting', 'hello' ]);
// Turklāt jūs varat izmantot šo īsāko sintaksi
Flight::route('/', 'Greeting->hello');
// vai
Flight::route('/', Greeting::class.'->hello');

Atkarību injekcija, izmantojot DIC (Atkarību injekcijas konteineru)

Ja vēlaties izmantot atkarību injekciju, izmantojot konteineru (PSR-11, PHP-DI, Dice utt.), vienīgais maršrutu veids, kur tas ir pieejams, ir vai nu tieši izveidot objektu paši un izmantot konteineru, lai izveidotu savu objektu, vai izmantot virknes, lai definētu klasi un metodi, kuru izsaukt. Jūs varat doties uz Atkarību injekcijas lapu, lai iegūtu vairāk informācijas.

Šeit ir ātrs piemērs:


use flight\database\PdoWrapper;

// Greeting.php
class Greeting
{
    protected PdoWrapper $pdoWrapper;
    public function __construct(PdoWrapper $pdoWrapper) {
        $this->pdoWrapper = $pdoWrapper;
    }

    public function hello(int $id) {
        // veic kaut ko ar $this->pdoWrapper
        $name = $this->pdoWrapper->fetchField("SELECT name FROM users WHERE id = ?", [ $id ]);
        echo "Hello, world! My name is {$name}!";
    }
}

// index.php

// Iestatiet konteineru ar visiem parametriem, kas jums nepieciešami
// Skatiet Atkarību injekcijas lapu, lai iegūtu vairāk informācijas par PSR-11
$dice = new \Dice\Dice();

// Neaizmirstiet pārdēvēt mainīgo ar '$dice = '!!!!!
$dice = $dice->addRule('flight\database\PdoWrapper', [
    'shared' => true,
    'constructParams' => [ 
        'mysql:host=localhost;dbname=test', 
        'root',
        'password'
    ]
]);

// Reģistrējiet konteineru
Flight::registerContainerHandler(function($class, $params) use ($dice) {
    return $dice->create($class, $params);
});

// Maršruti kā parasti
Flight::route('/hello/@id', [ 'Greeting', 'hello' ]);
// vai
Flight::route('/hello/@id', 'Greeting->hello');
// vai
Flight::route('/hello/@id', 'Greeting::hello');

Flight::start();

Metodes maršrutizācija

Noklusējuma iestatījumos maršrutu paraugi tiek salīdzināti ar visām pieprasījumu metodēm. Jūs varat reaģēt uz konkrētām metodēm, novietojot identifikatoru pirms URL.

Flight::route('GET /', function () {
  echo 'I received a GET request.';
});

Flight::route('POST /', function () {
  echo 'I received a POST request.';
});

// Jūs nevarat izmantot Flight::get() maršrutiem, jo tas ir metode 
//    mainīgo iegūšanai, nevis maršruta izveidei.
// Flight::post('/', function() { /* code */ });
// Flight::patch('/', function() { /* code */ });
// Flight::put('/', function() { /* code */ });
// Flight::delete('/', function() { /* code */ });

Jūs varat arī mapēt vairākas metodes uz vienu atgriezenisko funkciju, izmantojot | atdalītāju:

Flight::route('GET|POST /', function () {
  echo 'I received either a GET or a POST request.';
});

Turklāt jūs varat iegūt Router objektu, kuram ir daži palīgmetodes, kuras varat izmantot:


$router = Flight::router();

// mapē visas metodes
$router->map('/', function() {
    echo 'hello world!';
});

// GET pieprasījums
$router->get('/users', function() {
    echo 'users';
});
// $router->post();
// $router->put();
// $router->delete();
// $router->patch();

Regulārās izteiksmes

Jūs varat izmantot regulārās izteiksmes savos maršrutos:

Flight::route('/user/[0-9]+', function () {
  // Šis atbilst /user/1234
});

Lai gan šī metode ir pieejama, ieteicams izmantot nosauktus parametrus vai nosauktus parametrus ar regulārām izteiksmēm, jo tie ir lasāmāki un vieglāk uzturami.

Nosauktie parametri

Jūs varat norādīt nosauktos parametrus savos maršrutos, kas tiks nodoti jūsu atgriezeniskajai funkcijai. Tas ir vairāk par maršruta lasāmību nekā kaut kas cits. Lūdzu, skatiet zemāk esošo sadaļu par svarīgu brīdinājumu.

Flight::route('/@name/@id', function (string $name, string $id) {
  echo "hello, $name ($id)!";
});

Jūs varat arī iekļaut regulārās izteiksmes kopā ar saviem nosauktajiem parametriem, izmantojot : atdalītāju:

Flight::route('/@name/@id:[0-9]{3}', function (string $name, string $id) {
  // Šis atbilst /bob/123
  // Bet neatbilst /bob/12345
});

Piezīme: Atbilstības regulārā izteiksmes grupām () ar pozicionālajiem parametriem nav atbalstīta. :'(

Svarīgs brīdinājums

Pats par sevi, piemēram, iepriekš minētajā piemērā, izskatās, ka @name ir tieši saistīts ar mainīgo $name, bet tā nav. Parametru secība atgriezeniskajā funkcijā nosaka, kas tam tiek nodots. Tātad, ja jūs mainītu parametru secību atgriezeniskajā funkcijā, mainīgie tiks arī mainīti. Šeit ir piemērs:

Flight::route('/@name/@id', function (string $id, string $name) {
  echo "hello, $name ($id)!";
});

Un, ja jūs dotos uz sekojošo URL: /bob/123, rezultāts būtu hello, 123 (bob)!. Lūdzu, esiet uzmanīgs, kad uzstādat savus maršrutus un atgriezeniskās funkcijas.

Opciju parametri

Jūs varat norādīt nosauktos parametrus, kas ir izvēles, lai atbilstu, aptverot segmentos iekavās.

Flight::route(
  '/blog(/@year(/@month(/@day)))',
  function(?string $year, ?string $month, ?string $day) {
    // Šis atbilst šādām URL:
    // /blog/2012/12/10
    // /blog/2012/12
    // /blog/2012
    // /blog
  }
);

Visi izvēles parametri, kas netiek atbilsti, tiks nodoti kā NULL.

Zvaigznītes

Atbilstība tiek veikta tikai uz atsevišķiem URL segmentiem. Ja jūs vēlaties atbilst vairākām segmentiem, varat izmantot * zvaigznīti.

Flight::route('/blog/*', function () {
  // Šis atbilst /blog/2000/02/01
});

Lai novirzītu visus pieprasījumus uz vienu atgriezenisko funkciju, jūs varat to izdarīt:

Flight::route('*', function () {
  // Veiciet kaut ko
});

Pāreja

Jūs varat pāradresēt izpildi uz nākamo atbilstošo maršrutu, atgriežot true no savas atgriezeniskās funkcijas.

Flight::route('/user/@name', function (string $name) {
  // Pārbaudiet dažus nosacījumus
  if ($name !== "Bob") {
    // Turpināt uz nākamo maršrutu
    return true;
  }
});

Flight::route('/user/*', function () {
  // Šī funkcija tiks izsaukta
});

Maršruta aliasēšana

Jūs varat piešķirt alias maršrutam, lai URL varētu dinamiski izveidot vēlāk jūsu kodā (piemēram, veidnē).

Flight::route('/users/@id', function($id) { echo 'user:'.$id; }, false, 'user_view');

// vēlāk kaut kur kodā
Flight::getUrl('user_view', [ 'id' => 5 ]); // atgriezīs '/users/5'

Tas ir īpaši noderīgi, ja jūsu URL nejauši mainās. Iepriekšējā piemērā, pieņemsim, ka "lietotāji" tika pārvietoti uz /admin/users/@id vietas. Ar aliasēšanu jūs nekur vairs nevajag mainīt, jo alias tagad atgriezīs /admin/users/5 kā iepriekšējā piemērā.

Maršruta aliasēšana arī darbojas grupās:

Flight::group('/users', function() {
    Flight::route('/@id', function($id) { echo 'user:'.$id; }, false, 'user_view');
});

// vēlāk kaut kur kodā
Flight::getUrl('user_view', [ 'id' => 5 ]); // atgriezīs '/users/5'

Maršruta informācija

Ja vēlaties pārbaudīt atbilstošo maršruta informāciju, jūs varat pieprasīt, lai maršruta objekts tiktu nodots jūsu atgriezeniskajai funkcijai, pievienojot true kā trešo parametru maršruta metodē. Maršruta objekts vienmēr būs pēdējais parametra nodots jūsu atgriezeniskajai funkcijai.

Flight::route('/', function(\flight\net\Route $route) {
  // HTTP metožu masīvs, ar kurām tiek atbilstībā
  $route->methods;

  // Nosaukto parametru masīvs
  $route->params;

  // Atbilstošā regulārā izteiksme
  $route->regex;

  // Satur jebkuru '*' izmantotu URL paraugā
  $route->splat;

  // Rāda URL ceļu...ja jums tas tiešām ir nepieciešams
  $route->pattern;

  // Rāda, kāda starpniekprogrammatūra ir piešķirta šim
  $route->middleware;

  // Rāda, kāds alias piešķirts šim maršrutam
  $route->alias;
}, true);

Maršruta grupēšana

Reizēm var būt vajadzība apvienot saistītos maršrutus kopā (piemēram, /api/v1). Jūs varat to izdarīt, izmantojot group metodi:

Flight::group('/api/v1', function () {
  Flight::route('/users', function () {
    // Atbilst /api/v1/users
  });

  Flight::route('/posts', function () {
    // Atbilst /api/v1/posts
  });
});

Jūs varat pat ligzdot grupas grupās:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() iegūst mainīgos, tas nenosaka maršrutu! Skatiet objekta kontekstu zemāk
    Flight::route('GET /users', function () {
      // Atbilst GET /api/v1/users
    });

    Flight::post('/posts', function () {
      // Atbilst POST /api/v1/posts
    });

    Flight::put('/posts/1', function () {
      // Atbilst PUT /api/v1/posts
    });
  });
  Flight::group('/v2', function () {
    // Flight::get() iegūst mainīgos, tas nenosaka maršrutu! Skatiet objekta kontekstu zemāk
    Flight::route('GET /users', function () {
      // Atbilst GET /api/v2/users
    });
  });
});

Grupēšana ar objekta kontekstu

Jūs joprojām varat izmantot maršruta grupēšanu ar Engine objektu šādā veidā:

$app = new \flight\Engine();
$app->group('/api/v1', function (Router $router) {

  // izmantojiet $router mainīgo
  $router->get('/users', function () {
    // Atbilst GET /api/v1/users
  });

  $router->post('/posts', function () {
    // Atbilst POST /api/v1/posts
  });
});

Resursu maršrutizācija

Jūs varat izveidot maršrutu kopumu resursam, izmantojot resource metodi. Tas izveidos maršrutu kopumu resursam, kas seko RESTful konvencijām.

Lai izveidotu resursu, veiciet sekojošo:

Flight::resource('/users', UsersController::class);

Un, kas notiks fonā, tas izveidos šādus maršrutus:

[
      'index' => 'GET ',
      'create' => 'GET /create',
      'store' => 'POST ',
      'show' => 'GET /@id',
      'edit' => 'GET /@id/edit',
      'update' => 'PUT /@id',
      'destroy' => 'DELETE /@id'
]

Un jūsu controllers izskatīsies šādi:

class UsersController
{
    public function index(): void
    {
    }

    public function show(string $id): void
    {
    }

    public function create(): void
    {
    }

    public function store(): void
    {
    }

    public function edit(string $id): void
    {
    }

    public function update(string $id): void
    {
    }

    public function destroy(string $id): void
    {
    }
}

Piezīme: Jūs varat apskatīt jaunpiešķirtos maršrutus ar runway, izpildot php runway routes.

Resursu maršrutu pielāgošana

Ir dažas iespējas, lai konfigurētu resursu maršrutus.

Alias bāze

Jūs varat konfigurēt aliasBase. Noklusējuma gadījumā alias ir pēdējā URL daļa, kas norādīta. Piemēram, /users/ radīs aliasBase vērtību users. Kad šie maršruti tiek izveidoti, alias ir users.index, users.create utt. Ja vēlaties mainīt alias, iestatiet aliasBase uz vērtību, kuru vēlaties.

Flight::resource('/users', UsersController::class, [ 'aliasBase' => 'user' ]);

Tikai un Izņemot

Jūs varat arī norādīt, kuri maršruti jums jāizveido, izmantojot only un except opcijas.

Flight::resource('/users', UsersController::class, [ 'only' => [ 'index', 'show' ] ]);
Flight::resource('/users', UsersController::class, [ 'except' => [ 'create', 'store', 'edit', 'update', 'destroy' ] ]);

Šīs ir pamata baltas un melnas sarakstu opcijas, lai jūs varētu norādīt, kuri maršruti jums jāizveido.

Starpniekprogrammatūru

Jūs varat arī norādīt starpniekprogrammatūru, kas jāveic katram maršrutam, ko izveido resource metode.

Flight::resource('/users', UsersController::class, [ 'middleware' => [ MyAuthMiddleware::class ] ]);

Plūstoša informācija

Tagad jūs varat straumēt atbildes uz klientu, izmantojot streamWithHeaders() metodi. Tas ir noderīgi, lai nosūtītu lielus failus, ilgstošas darbības procesu vai radītu lielas atbildes. Maršruta straumēšana tiek apstrādāta nedaudz savādāk nekā parasts maršruts.

Piezīme: Straumēšanas atbildes ir pieejamas tikai tad, ja jums ir flight.v2.output_buffering iestatīts uz nepatiesu.

Straumēšana ar manuālām virsrakstiem

Jūs varat straumēt atbildi klientam, izmantojot stream() metodi uz maršruta. Ja jūs to darāt, jums jānosaka visas metodes pašiem, pirms dodat jebko uz klientu. To var izdarīt ar header() php funkciju vai Flight::response()->setRealHeader() metodi.

Flight::route('/@filename', function($filename) {

    // acīmredzot jums būtu jānosaka ceļš un tā tālāk.
    $fileNameSafe = basename($filename);

    // Ja jums ir papildu virsraksti, kas jānosaka šeit pēc maršruta izpildes
    // tie jādefinē pirms jebkādas izdrukas ārā.
    // Tie ir jābūt visi tieši aicinājumi uz header() funkciju vai 
    // izsaukumi uz Flight::response()->setRealHeader()
    header('Content-Disposition: attachment; filename="'.$fileNameSafe.'"');
    // vai
    Flight::response()->setRealHeader('Content-Disposition', 'attachment; filename="'.$fileNameSafe.'"');

    $fileData = file_get_contents('/some/path/to/files/'.$fileNameSafe);

    // Kļūdu noķeršana un tā tālāk
    if(empty($fileData)) {
        Flight::halt(404, 'Fails nav atrasts');
    }

    // manuāli nosakiet satura garumu, ja vēlaties
    header('Content-Length: '.filesize($filename));

    // Straumējiet datus uz klientu
    echo $fileData;

// Šī ir maģiskā rinda šeit
})->stream();

Straumēšana ar virsrakstiem

Jūs varat izmantot arī streamWithHeaders() metodi, lai iestatītu virsrakstus, pirms sākat straumēšanu.

Flight::route('/stream-users', function() {

    // jūs varat pievienot visu papildus virsrakstu, ko vēlaties šeit
    // jums tikai jāizmanto header() vai Flight::response()->setRealHeader()

    // tomēr kā jūs iegūstat savus datus, piemēram...
    $users_stmt = Flight::db()->query("SELECT id, first_name, last_name FROM users");

    echo '{';
    $user_count = count($users);
    while($user = $users_stmt->fetch(PDO::FETCH_ASSOC)) {
        echo json_encode($user);
        if(--$user_count > 0) {
            echo ',';
        }

        // Šis ir nepieciešams, lai nosūtītu datus uz klientu
        ob_flush();
    }
    echo '}';

// Šī ir tā, kā jūs iestatīsit virsrakstus pirms sākat straumēšanu.
})->streamWithHeaders([
    'Content-Type' => 'application/json',
    'Content-Disposition' => 'attachment; filename="users.json"',
    // opcional statusa kods, noklusējums ir 200
    'status' => 200
]);

Learn/flight_vs_symfony

Flight pret Symfoniju

Kas ir Symfony?

Symfony ir kopums ar pārlietojamiem PHP komponentiem un PHP ietvars tīmekļa projektiem.

Standarta pamatne, uz kuras tiek izveidotas labākās PHP lietojumprogrammas. Izvēlieties jebkuru no 50 pieejamajiem neatkarīgajiem komponentiem savām lietojumprogrammām.

Paātriniet jūsu PHP tīmekļa lietojumprogrammu izveidi un uzturēšanu. Beidziet atkārtojošos koda rakstīšanas uzdevumus un baudiet kontroles pār savu kodu priekšrocības.

Plusi salīdzinājumā ar Flight

Mīnusi salīdzinājumā ar Flight

Learn/flight_vs_another_framework

Salīdzinot Flight ar citu ietvaru

Ja jūs pārietat no cita ietvara, piemēram, Laravel, Slim, Fat-Free vai Symfony uz Flight, šī lapa palīdzēs jums saprast atšķirības starp abiem.

Laravel

Laravel ir pilnīgi iezīmēts ietvars, kuram ir visas papardes un brīnumaini izstrādātāja vērsti ekosistēma, bet par cenu veiktspējai un sarežģītībai.

Skatiet salīdzinājumu starp Laravel un Flight.

Slim

Slim ir mikro ietvars, kas ir līdzīgs Flight. Tas ir izstrādāts, lai būtu viegls un viegli lietojams, bet var būt nedaudz sarežģītāks nekā Flight.

Skatiet salīdzinājumu starp Slim un Flight.

Fat-Free

Fat-Free ir pilnas kaudzes ietvars daudz mazākā iepakojumā. Lai arī tam ir visas rīces rīku kastē, tas var padarīt dažus projektus sarežģītākus nekā tie vajadzīgi būtu.

Skatiet salīdzinājumu starp Fat-Free un Flight.

Symfony

Symfony ir modulārs uzņēmumu līmeņa ietvars, kas ir izstrādāts, lai būtu elastīgs un skalējams. Mazākiem projektiem vai jaunajiem izstrādātājiem Symfony var būt nedaudz apburošs.

Skatiet salīdzinājumu starp Symfony un Flight.

Learn/variables 

# Mainīgie

Flight ļauj saglabāt mainīgos, lai tos varētu izmantot jebkur aplikācijā.

```php
// Saglabā savu mainīgo
Flight::set('id', 123);

// Citur aplikācijā
$id = Flight::get('id');

Lai pārbaudītu, vai mainīgais ir iestatīts, varat izdarīt:

if (Flight::has('id')) {
  // Izdarīt kaut ko
}

Mainīgo var notīrīt:

// Notīra id mainīgo
Flight::clear('id');

// Notīra visus mainīgos
Flight::clear();

Flight izmanto mainīgos arī konfigurācijas nolūkos.

Flight::set('flight.log_errors', true);

Learn/dependency_injection_container

Atkarību injekcijas konteiners

Ievads

Atkarību injekcijas konteiners (DIC) ir spēcīgs rīks, kas ļauj jums pārvaldīt jūsu lietojumprogrammas atkarības. Tas ir galvenais koncepts mūsdienu PHP ietvaros un tiek izmantots, lai pārvaldītu objektu instancēšanu un konfigurāciju. Veidi, kādi DIC bibliotēkas ir: Dice, Pimple, PHP-DI, un league/container.

DIC ir greznā veidā teikt, ka tas ļauj jums izveidot un pārvaldīt jūsu klases centrālizētā vietā. Tas ir noderīgi, ja jums ir nepieciešams nodot to pašu objektu vairākām klasēm (piemēram, jūsu kontrolieriem). Viegls piemērs varētu palīdzēt šo padarīt skaidrāku.

Pamata piemērs

Vecais veids, kā darīt lietas, varētu izskatīties šādi:


require 'vendor/autoload.php';

// klase, lai pārvaldītu lietotājus no datu bāzes
class UserController {

    protected PDO $pdo;

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function view(int $id) {
        $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id');
        $stmt->execute(['id' => $id]);

        print_r($stmt->fetch());
    }
}

$User = new UserController(new PDO('mysql:host=localhost;dbname=test', 'lietotājvārds', 'parole'));
Flight::route('/lietotājs/@id', [ $UserController, 'view' ]);

Flight::start();

Jūs varat redzēt no augstāk minētā koda, ka mēs izveidojam jaunu PDO objektu un nododam to mūsu UserController klasei. Tas ir labi mazai lietojumprogrammai, bet kad jūsu lietojumprogramma aug, jūs atklāsiet, ka izveidojat to pašu PDO objektu vairākos vietās. Tieši šeit noder DIC.

Šeit ir tas pats piemērs, izmantojot DIC (izmantojot Dice):


require 'vendor/autoload.php';

// tāda pati klase kā iepriekš. Nav nekā mainījies
class UserController {

    protected PDO $pdo;

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function view(int $id) {
        $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id');
        $stmt->execute(['id' => $id]);

        print_r($stmt->fetch());
    }
}

// izveidot jaunu konteineri
$container = new \Dice\Dice;
// neaizmirstiet atkārtoti piešķirt to sev tāpat kā zemāk!
$container = $container->addRule('PDO', [
    // shared nozīmē, ka tiks atgriezts tas pats objekts katru reizi
    'shared' => true,
    'constructParams' => ['mysql:host=localhost;dbname=test', 'lietotājvārds', 'parole' ]
]);

// Tas reģistrē konteineru apstrādātāju, lai Flight zinātu, ka to izmantot.
Flight::registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

// tagad mēs varam izmantot konteineri, lai izveidotu mūsu UserController
Flight::route('/lietotājs/@id', [ 'UserController', 'view' ]);
// vai arī alternatīvi varat definēt maršrutu šādi
Flight::route('/lietotājs/@id', 'UserController->view');
// vai
Flight::route('/lietotājs/@id', 'UserController::view');

Flight::start();

Es uzdrīkotos iedomāties, ka jūs domājāt, ka piemēram tika pievienots daudz papildu koda. Maģija rodas, kad jums ir cita kontroliera, kuram nepieciešams PDO objekts.


// Ja visi jūsu kontrolieri ir konstruktoru, kuram nepieciešams PDO objekts
// katram zemāk esošajam maršrutam automātiski tiks injicēts !!!
Flight::route('/uzņēmums/@id', 'CompanyController->view');
Flight::route('/organizācija/@id', 'OrganizationController->view');
Flight::route('/kategorija/@id', 'CategoryController->view');
Flight::route('/uzstādījumi', 'SettingsController->view');

Pievienotais bonuss, izmantojot DIC, ir tas, ka vienības testēšana kļūst daudz vienkāršāka. Jūs varat izveidot nepatiesu objektu un nodot to savai klasei. Tas ir milzīgs ieguvums, rakstot tests jūsu lietojumprogrammai!

PSR-11

Flight var izmantot jebkuru PSR-11 atbilstošu konteineri. Tas nozīmē, ka jūs varat izmantot jebkuru konteineri, kas īsteno PSR-11 interfeisu. Šeit ir piemērs, izmantojot League's PSR-11 konteineri:


require 'vendor/autoload.php';

// tāda pati UserController klase kā iepriekš

$container = new \League\Container\Container();
$container->add(UserController::class)->addArgument(PdoWrapper::class);
$container->add(PdoWrapper::class)
    ->addArgument('mysql:host=localhost;dbname=test')
    ->addArgument('lietotājvārds')
    ->addArgument('parole');
Flight::registerContainerHandler($container);

Flight::route('/lietotājs', [ 'UserController', 'view' ]);

Flight::start();

Lai gan tas var būt nedaudz izsmeļošāks nekā iepriekšējais Dice piemērs, tas joprojām izdara darbu ar tādām pašām priekšrocībām!

Pielāgots DIC apstrādātājs

Jūs varat arī izveidot savu DIC apstrādātāju. Tas ir noderīgi, ja jums ir pielāgots konteiners, ko jūs vēlaties izmantot, kas nav PSR-11 (Dice). Skatiet pamata piemēru, kā to izdarīt.

Papildus tam ir dažas noderīgas noklusējuma vērtības, kas atvieglos jūsu dzīvi, izmantojot Flight.

Dzinēja instances

Ja izmantojat Engine instanci savos kontrolieros/starpprogrammatūrā, šeit ir, kā jūs to konfigurētu:


// Kaut kur jūsu sākotnējās datnes
$dzinējs = Flight::app();

$container = new \Dice\Dice;
$container = $container->addRule('*', [
    'substitutions' => [
        // Šeit jūs padodat instanci
        Engine::class => $dzinējs
    ]
]);

$dzinējs->registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

// Tagad jūs varat izmantot Dzinēja instanci savos kontrolieros/starpprogrammatūrā

class MyController {
    public function __construct(Engine $lietojumprogramma) {
        $this->lietojumprogramma = $lietojumprogramma;
    }

    public function index() {
        Šī->lietojumprogramma->render('indekss');
    }
}

Pievienojot citus klases

Ja jums ir citas klases, ko vēlaties pievienot konteinerim, ar Dice tas ir viegli, jo tās automātiski tiks atrisinātas ar konteineri. Šeit ir piemērs:


$container = new \Dice\Dice;
// Ja jums nav jāievēro nekāda savas klases
// jums nav nepieciešams neko definēt!
Flight::registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

class MansPielāgotaisKlase {
    public function analizējietLietu() {
        atgriezt 'lieta';
    }
}

class UserController {

    protected MyCustomClass $MansPielāgotaisKlase;

    public function __construct(MyCustomClass $MansPielāgotaisKlase) {
        Šī->MansPielāgotaisKlase = $MansPielāgotaisKlase;
    }

    public function index() {
        echo $this->MansPielāgotaisKlase->parseThing();
    }
}

Flight::route('/lietotājs', 'UserController->index');

Learn/middleware

Maršruta starpējais kodols

Flight atbalsta maršrutu un grupu maršrutu starpējo kodolu. Starpējais kodols ir funkcija, kas tiek izpildīta pirms (vai pēc) maršruta atzvana. Tas ir lielisks veids, kā pievienot API autentifikācijas pārbaudes jūsu kodā vai validēt, vai lietotājam ir atļauja piekļūt maršrutam.

Pamata starpējais kodols

Šeit ir pamata piemērs:

// Ja sniedzat tikai anonīmu funkciju, tā tiks izpildīta pirms maršruta atzvanīšanas. 
// nav "pēc" maršrutu starpējo funkciju, izņemot klases (skatīt zemāk)
Flight::route('/ceļš', function() { echo ' Šeit es esmu!'; })->addMiddleware(function() {
    echo 'Starpējais kodols pirmais!';
});

Flight::start();

// Tas izvadīs "Starpējais kodols pirmais! Šeit es esmu!"

Ir daži ļoti svarīgi punkti par starpējo kodolu, par kuriem jums jābūt informētiem, pirms to izmantojat:

Starpējo klases

Starpējais kodols var tikt reģistrēts kā klase arī. Ja jums nepieciešama "pēc" funkcionalitāte, jums obligāti jāizmanto klase.

class ManaStarpejaisKlase {
    public function before($params) {
        echo 'Starpējais kodols pirmais!';
    }

    public function after($params) {
        echo 'Starpējais kodols pēdējais!';
    }
}

$ManaStarpejaisKlase = new ManaStarpejaisKlase();
Flight::route('/ceļš', function() { echo ' Šeit es esmu! '; })->addMiddleware($ManaStarpejaisKlase); // arī ->addMiddleware([ $ManaStarpejaisKlase, $ManaStarpejaisKlase2 ]);

Flight::start();

// Tas parādīs "Starpējais kodols pirmais! Šeit es esmu! Starpējais kodols pēdējais!"

Starpējo kļūdu apstrāde

Iedomāsimies, ka jums ir autentifikācijas starpējais kodols, un jūs vēlaties novirzīt lietotāju uz pieteikšanās lapu, ja viņi nav autentificējušies. Jums ir dažas iespējas, ar kurām varat rīkoties:

  1. Jūs varat atgriezt false no starpējās funkcijas, un Flight automātiski atgriezīs kļūdu 403 Aizliegts, bet bez pielāgojumiem.
  2. Jūs varat novirzīt lietotāju uz pieteikšanās lapu, izmantojot Flight::redirect().
  3. Jūs varat izveidot pielāgotu kļūdu starpējā funkcijā un apturēt maršruta izpildi.

Pamata piemērs

Šeit ir vienkāršs atgriešanas false; piemērs:

class ManaStarpejaisKlase {
    public function before($params) {
        if (isset($_SESSION['lietotajs']) === false) {
            return false;
        }

        // jo tas ir true, viss vienkārši turpinās
    }
}

Novirzīšanas piemērs

Šeit ir piemērs, kā novirzīt lietotāju uz pieteikšanās lapu:

class ManaStarpejaisKlase {
    public function before($params) {
        if (isset($_SESSION['lietotajs']) === false) {
            Flight::redirect('/pieteikties');
            exit;
        }
    }
}

Pielāgotas kļūdas piemērs

Iedomāsimies, ka jums ir jāizvada JSON kļūda, jo jūs izstrādājat API. Tas var izskatīties šādi:

class ManaStarpejaisKlase {
    public function before($params) {
        $autentifikācija = Flight::request()->headers['Autorizācija'];
        if(empty($autentifikācija)) {
            Flight::jsonHalt(['kļūda' => 'Lai piekļūtu šai lapai, ir jābūt pierakstītam sistēmā.'], 403);
            // vai
            Flight::json(['kļūda' => 'Lai piekļūtu šai lapai, ir jābūt pierakstītam sistēmā.'], 403);
            exit;
            // vai
            Flight::halt(403, json_encode(['kļūda' => 'Lai piekļūtu šai lapai, ir jābūt pierakstītam sistēmā.']);
        }
    }
}

Maršrutu grupēšana

Jūs varat pievienot maršruta grupu, un tad katram maršrutam šajā grupā būs vienāds starpējais kodols. Tas ir noderīgi, ja jums jāgrupē daudzi maršruti, piemēram, ar Autentifikācijas starpējo kodolu, lai pārbaudītu galvenes API atslēgu.


// pievienots grupas metodei beigās
Flight::group('/api', function() {

    // Šis "tukšais" izskatās maršruts faktiski sakrīt ar /api
    Flight::route('', function() { echo 'api'; }, false, 'api');
    // Tas sakrīt ar /api/lietotāji
    Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotaji');
    // Tas sakrīt ar /api/lietotāji/1234
    Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'skatīt_lietotāju');
}, [ new ApiAuthMiddleware() ]);

Ja jūs vēlaties piemērot globālu starpējo kodolu visiem savas maršrutkārtas, jūs varat pievienot "tukšu" grupu:


// pievienots grupas metodei beigās
Flight::group('', function() {

    // Tas joprojām ir /lietotāji
    Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotaji');
    // Un tas joprojām ir /lietotāji/1234
    Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'skatīt_lietotāju');
}, [ new ApiAuthMiddleware() ]);

Learn/filtering

Filtrēšana

Lidojums ļauj jums filtrēt metodes pirms un pēc to izsaukšanas. Nav iepriekš definētu āķu, ko jums vajadzētu iemācīties atmiņā. Jūs varat filtrēt jebkuru noklusējuma ietvaru metodi, kā arī jebkuras pielāgotas metodes, ko esat atainojis.

Filtrēšanas funkcija izskatās šādi:

function (array &$params, string &$output): bool {
  // Filtrēšanas kods
}

Izmantojot padotos mainīgos, jūs varat manipulēt ievades parametrus un/vai izvadi.

Jūs varat ļaut filtram darboties pirms metodes, izmantojot:

Flight::before('start', function (array &$params, string &$output): bool {
  // Darīt kaut ko
});

Jūs varat ļaut filtram darboties pēc metodes, izmantojot:

Flight::after('start', function (array &$params, string &$output): bool {
  // Darīt kaut ko
});

Jūs varat pievienot tik daudz filtrus, cik vēlaties, jebkurai metodai. Tie tiks izsaukti tādā secībā, kādā tie ir deklarēti.

Šeit ir piemērs par filtrēšanas procesu:

// Atainot pielāgotu metodi
Flight::map('hello', function (string $name) {
  return "Sveiki, $name!";
});

// Pievienot pirms filtru
Flight::before('hello', function (array &$params, string &$output): bool {
  // Manipulēt parametru
  $params[0] = 'Jānis';
  return true;
});

// Pievienot pēc filtra
Flight::after('hello', function (array &$params, string &$output): bool {
  // Manipulēt izvadi
  $output .= " Jums laimīgu dienu!";
  return true;
});

// Izsaukt pielāgoto metodi
echo Flight::hello('Roberts');

Tas vajadzētu parādīt:

Sveiki Jānis! Jums laimīgu dienu!

Ja esat definējis vairākus filtrus, jūs varat pārtraukt ķēdi, atgriežot false jebkurā no jūsu filtra funkcijām:

Flight::before('start', function (array &$params, string &$output): bool {
  echo 'viens';
  return true;
});

Flight::before('start', function (array &$params, string &$output): bool {
  echo 'divi';

  // Tas pārtrauks ķēdi
  return false;
});

// Tas netiks izsaukts
Flight::before('start', function (array &$params, string &$output): bool {
  echo 'trīs';
  return true;
});

Piezīme, pamata metodes, piemēram, map un register, nevar būt filtri, jo tos izsauc tieši, nevis dinamiski.

Learn/requests

Pieprasījumi

Flight īsteno HTTP pieprasījumu kā vienu objektu, ko var piekļūt, izpildot:

$request = Flight::request();

Tipiskie Lietojumi

Strādājot ar pieprasījumu tīmekļa lietotnē, parasti vēlēsities izņemt galveni, vai $_GET vai $_POST parametru, vai pat neapstrādāto pieprasījuma ķermeni. Flight nodrošina vienkāršu saskarni, lai veiktu visas šīs darbības.

Šeit ir piemērs, kā iegūt vaicājuma virknes parametru:

Flight::route('/search', function(){
    $keyword = Flight::request()->query['keyword'];
    echo "Jūs meklējat: $keyword";
    // vaicā datubāzei vai kaut kam citam ar $keyword
});

Šeit ir piemērs varbūt veidlapai ar POST metodi:

Flight::route('POST /submit', function(){
    $name = Flight::request()->data['name'];
    $email = Flight::request()->data['email'];
    echo "Jūs iesniedzāt: $name, $email";
    // saglabājiet datubāzē vai kaut kam citam ar $name un $email
});

Pieprasījuma Objekta Atribūti

Pieprasījuma objekts nodrošina šādus atribūtus:

Jūs varat piekļūt query, data, cookies un files atribūtiem kā masīviem vai objektiem.

Tātad, lai iegūtu vaicājuma virknes parametru, varat darīt:

$id = Flight::request()->query['id'];

Vai arī varat darīt:

$id = Flight::request()->query->id;

NEAPSTRĀDĀTA PIEPRASĪJUMA ĶERMENIS

Lai iegūtu neapstrādāto HTTP pieprasījuma ķermeni, piemēram, strādājot ar PUT pieprasījumiem, varat darīt:

$body = Flight::request()->getBody();

JSON Ievade

Ja jūs sūtāt pieprasījumu ar tipu application/json un datiem {"id": 123} tas būs pieejams no data atribūta:

$id = Flight::request()->data->id;

$_GET

Jūs varat piekļūt $_GET masīvam, izmantojot query atribūtu:

$id = Flight::request()->query['id'];

$_POST

Jūs varat piekļūt $_POST masīvam, izmantojot data atribūtu:

$id = Flight::request()->data['id'];

$_COOKIE

Jūs varat piekļūt $_COOKIE masīvam, izmantojot cookies atribūtu:

$myCookieValue = Flight::request()->cookies['myCookieName'];

$_SERVER

Ir pieejams īsceļš, lai piekļūtu $_SERVER masīvam, izmantojot getVar() metodi:

$host = Flight::request()->getVar['HTTP_HOST'];

Piekļuve Augšupielādētajiem Failiem, izmantojot $_FILES

Jūs varat piekļūt augšupielādētajiem failiem, izmantojot files atribūtu:

$uploadedFile = Flight::request()->files['myFile'];

Failu Augšupielādes Apstrāde

Jūs varat apstrādāt failu augšupielādes, izmantojot ietvaru ar dažām palīgdarbībām. Tas būtībā samazinās līdz faila datu vilkšanai no pieprasījuma un pārvietošanai uz jaunu vietu.

Flight::route('POST /upload', function(){
    // Ja jums bija ievades lauks, piemēram, <input type="file" name="myFile">
    $uploadedFileData = Flight::request()->getUploadedFiles();
    $uploadedFile = $uploadedFileData['myFile'];
    $uploadedFile->moveTo('/path/to/uploads/' . $uploadedFile->getClientFilename());
});

Ja jums ir vairāki augšupielādēti faili, varat tos aplūkot:

Flight::route('POST /upload', function(){
    // Ja jums bija ievades lauks, piemēram, <input type="file" name="myFiles[]">
    $uploadedFiles = Flight::request()->getUploadedFiles()['myFiles'];
    foreach ($uploadedFiles as $uploadedFile) {
        $uploadedFile->moveTo('/path/to/uploads/' . $uploadedFile->getClientFilename());
    }
});

Drošības Piezīme: Vienmēr validējiet un sanitizējiet lietotāju ievadi, īpaši, strādājot ar failu augšupielādēm. Vienmēr validējiet pieļaujamo paplašinājumu tipus, ko ļausiet augšupielādēt, bet jums arī jāvalidē faila "burvju baiti", lai pārliecinātos, ka tas patiešām ir tāda tipu fails, kādu lietotājs apgalvo. Ir pieejami raksti un bibliotēkas, kuras var jums palīdzēt ar to.

Pieprasījuma Galvenes

Jūs varat piekļūt pieprasījuma galvenēm, izmantojot getHeader() vai getHeaders() metodi:

// Varbūt jums ir nepieciešama autorizācijas galvene
$host = Flight::request()->getHeader('Authorization');
// vai
$host = Flight::request()->header('Authorization');

// Ja jums nepieciešams iegūt visas galvenes
$headers = Flight::request()->getHeaders();
// vai
$headers = Flight::request()->headers();

Pieprasījuma Ķermenis

Jūs varat piekļūt neapstrādātajam pieprasījuma ķermenim, izmantojot getBody() metodi:

$body = Flight::request()->getBody();

Pieprasījuma Metode

Jūs varat piekļūt pieprasījuma metodei, izmantojot method atribūtu vai getMethod() metodi:

$method = Flight::request()->method; // faktiski zvana getMethod()
$method = Flight::request()->getMethod();

Piezīme: getMethod() metode vispirms ņem metodi no $_SERVER['REQUEST_METHOD'], pēc tam to var pārrakstīt ar $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'], ja tas pastāv, vai $_REQUEST['_method'], ja tas pastāv.

Pieprasījuma URL

Ir pieejamas dažas palīgmetodes, lai ērti saliktu URL daļas.

Pilns URL

Jūs varat piekļūt pilnam pieprasījuma URL, izmantojot getFullUrl() metodi:

$url = Flight::request()->getFullUrl();
// https://example.com/some/path?foo=bar

Pamata URL

Jūs varat piekļūt pamata URL, izmantojot getBaseUrl() metodi:

$url = Flight::request()->getBaseUrl();
// Pievērsiet uzmanību, nav beigu slīpsvītras.
// https://example.com

Vaicājuma Analīze

Jūs varat nodot URL uz parseQuery() metodi, lai analizētu vaicājuma virkni asociatīvā masīvā:

$query = Flight::request()->parseQuery('https://example.com/some/path?foo=bar');
// ['foo' => 'bar']

Learn/frameworkmethods

Framework Metodes

Flight ir izstrādāts, lai būtu viegli lietojams un saprotams. Zemāk ir pilns metožu kopums ietvariem. Tas sastāv no pamatmetodēm, kas ir parastie statiskie metodes, un paplašināmās metodes, kas ir kartētas metodes, kurām var piemērot filtrus vai pārrakstīt.

Pamatmetodes

Flight::map(virkne $nosaukums, callable $atgriezamā_virziena_funkcija, bool $ietekme_uz_marsrutu = false) // Izveido pielāgotu ietvaru metodi.
Flight::register(virkne $nosaukums, string $klase, masīvs $parametri = [], ?callable $atgriezamā_virziena_funkcija = null) // Reģistrē klasi ietvaru metodē.
Flight::before(virkne $nosaukums, callable $atgriezamā_virziena_funkcija) // Pievieno filtru pirms ietvaru metodes.
Flight::after(virkne $nosaukums, callable $atgriezamā_virziena_funkcija) // Pievieno filtru pēc ietvaru metodes.
Flight::path(virkne $ceļš) // Pievieno ceļu automātiskai klasielu ielādei.
Flight::get(virkne $atslēga) // Iegūst mainīgo.
Flight::set(virkne $atslēga, mixed $vertība) // Iestata mainīgo.
Flight::has(virkne $atslēga) // Pārbauda, vai mainīgais ir iestatīts.
Flight::clear(masīvs|virkne $atslēga = []) // Nodzēš mainīgo.
Flight::init() // Inicializē ietvaru tās noklusētajos iestatījumos.
Flight::app() // Iegūst aplikācijas objekta instanci

Paplašināmās metodes

Flight::start() // Sāk ietvaru.
Flight::stop() // Aptur ietvaru un nosūta atbildi.
Flight::halt(int $kods = 200, virkne $ziņojums = '') // Aptur ietvaru ar neobligātu statusa kodu un ziņojumu.
Flight::route(virkne $parauga, callable $atgriezamā_virziena_funkcija, bool $ietekme_uz_marsrutu = false) // Kartē URL paraugu atpakaļsaukumam.
Flight::group(virkne $parauga, callable $atgriezamā_virziena_funkcija) // Izveido grupēšanu URL, paraugs ir jābūt virknei.
Flight::redirect(virkne $url, int $kods) // Novirza uz citu URL.
Flight::render(virkne $fails, masīvs $datus, ?string $atslēga = null) // Atveido veidnes failu.
Flight::error(Throwable $kļūda) // Nosūta HTTP 500 atbildi.
Flight::notFound() // Nosūta HTTP 404 atbildi.
Flight::etag(virkne $id, virkne $tips = 'string') // Veic ETag HTTP kešošanu.
Flight::lastModified(int $laiks) // Veic pēdējo modificēto HTTP kešošanu.
Flight::json(mixed $datus, int $kods = 200, bool $kodēt = true, virkne $kodēšanas_kopa = 'utf8', int $opcija) // Nosūta JSON atbildi.
Flight::jsonp(mixed $datus, virkne $param = 'jsonp', int $kods = 200, bool $kodēt = true, virkne $kodēšanas_kopa = 'utf8', int $opcija) // Nosūta JSONP atbildi.

Jebkuras pielāgotas metodes, kas pievienotas ar map un register, var arī tikt filtrētas.

Learn/api

Rāmis API Metodes

Flight ir izstrādāta, lai būtu viegli lietojama un saprotama. Tālāk ir sniegts pilnīgs metožu kopums rāmim. Tas sastāv no kodola metodēm, kuras ir parastas statiskas metodes, un paplašināmām metodēm, kuras ir kartētas metodes, ko var filtrēt vai pārrakstīt.

Kodola Metodes

Šīs metodes ir centrālās rāmim un tās nevar tikt pārrakstītas.

Flight::map(string $name, callable $callback, bool $pass_route = false) // Izveido pielāgotu rāmja metodi.
Flight::register(string $name, string $class, array $params = [], ?callable $callback = null) // Reģistrē klasi rāmja metodei.
Flight::unregister(string $name) // Atceļ klases reģistrāciju rāmja metodei.
Flight::before(string $name, callable $callback) // Pievieno filtru pirms rāmja metodes.
Flight::after(string $name, callable $callback) // Pievieno filtru pēc rāmja metodes.
Flight::path(string $path) // Pievieno ceļu klases automātiskai ielādēšanai.
Flight::get(string $key) // Iegūst mainīgo, ko iestata Flight::set().
Flight::set(string $key, mixed $value) // Iestata mainīgo Flight dzinī.
Flight::has(string $key) // Pārbauda, vai mainīgais ir iestatīts.
Flight::clear(array|string $key = []) // Notīra mainīgo.
Flight::init() // Inicializē rāmi uz noklusējuma iestatījumiem.
Flight::app() // Iegūst lietotnes objekta instanci.
Flight::request() // Iegūst pieprasījuma objekta instanci.
Flight::response() // Iegūst atbildes objekta instanci.
Flight::router() // Iegūst maršrutētāja objekta instanci.
Flight::view() // Iegūst skata objekta instanci.

Paplašināmās Metodes

Flight::start() // Sāk rāmja darbību.
Flight::stop() // Apstājas rāmja darbība un nosūta atbildi.
Flight::halt(int $code = 200, string $message = '') // Apstājas rāmja darbība ar opciju statusa kodu un ziņojumu.
Flight::route(string $pattern, callable $callback, bool $pass_route = false, string $alias = '') // Kartē URL paraugu uz atbildes funkciju.
Flight::post(string $pattern, callable $callback, bool $pass_route = false, string $alias = '') // Kartē POST pieprasījuma URL paraugu uz atbildes funkciju.
Flight::put(string $pattern, callable $callback, bool $pass_route = false, string $alias = '') // Kartē PUT pieprasījuma URL paraugu uz atbildes funkciju.
Flight::patch(string $pattern, callable $callback, bool $pass_route = false, string $alias = '') // Kartē PATCH pieprasījuma URL paraugu uz atbildes funkciju.
Flight::delete(string $pattern, callable $callback, bool $pass_route = false, string $alias = '') // Kartē DELETE pieprasījuma URL paraugu uz atbildes funkciju.
Flight::group(string $pattern, callable $callback) // Izveido grupēšanu URL, paraugam jābūt virknē.
Flight::getUrl(string $name, array $params = []) // Ģenerē URL, pamatojoties uz maršruta aliasu.
Flight::redirect(string $url, int $code) // Pāradresē uz citu URL.
Flight::download(string $filePath) // Lejupielādē failu.
Flight::render(string $file, array $data, ?string $key = null) // Attēlo veidnes failu.
Flight::error(Throwable $error) // Nosūta HTTP 500 atbildi.
Flight::notFound() // Nosūta HTTP 404 atbildi.
Flight::etag(string $id, string $type = 'string') // Veic ETag HTTP kešatmiņu.
Flight::lastModified(int $time) // Veic pēdējās izmaiņas HTTP kešatmiņu.
Flight::json(mixed $data, int $code = 200, bool $encode = true, string $charset = 'utf8', int $option) // Nosūta JSON atbildi.
Flight::jsonp(mixed $data, string $param = 'jsonp', int $code = 200, bool $encode = true, string $charset = 'utf8', int $option) // Nosūta JSONP atbildi.
Flight::jsonHalt(mixed $data, int $code = 200, bool $encode = true, string $charset = 'utf8', int $option) // Nosūta JSON atbildi un apstājas rāmja darbība.
Flight::onEvent(string $event, callable $callback) // Reģistrē notikumu klausītāju.
Flight::triggerEvent(string $event, ...$args) // Izsauc notikumu.

Jebkuras pielāgotas metodes, kas pievienotas ar map un register, var arī tikt filtrētas. Lai iegūtu piemērus, kā kartēt šīs metodes, skatiet Paplašinot Flight ceļvedi.

Learn/why_frameworks

Kāpēc ietvaru?

Daudzi programmētāji stingri iebilst pret ietvaru izmantošanu. Viņi argumentē, ka ietvari ir pārpildīti, lēni un grūti apgūstami. Viņi saka, ka ietvari nav nepieciešami un ka jūs varat rakstīt labāku kodu bez tiem. Noteikti var izteikt dažus pamatoti iebildumus pret ietvaru izmantošanu. Tomēr ir arī daudz priekšrocību, izmantojot ietvarus.

Iemesli izmantot ietvaru

Šeit ir daži iemesli, kāpēc jums varētu būt jāapsver ietvara izmantošana:

Flight ir mikroietvars. Tas nozīmē, ka tas ir neliels un viegls. Tas nepiedāvā tik daudz funkcionalitātes kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina lielu daļu funkcionalitātes, kas jums nepieciešama, lai veidotu tīmekļa lietojumprogrammas. Tas arī ir viegli apgūstams un lietojams. Tas padara to par labu izvēli, lai ātri un viegli veidotu tīmekļa lietojumprogrammas. Ja esat jauns ietvaru jomā, Flight ir lielisks iesācēju ietvars, ar kuru sākt. Tas palīdzēs jums iemācīties par ietvaru izmantošanas priekšrocībām, neplūstot jums ar pārāk daudz sarežģītības. Kad esat ieguvis kādu pieredzi ar Flight, būs vieglāk pāriet uz sarežģītākiem ietvariem, piemēram, Laravel vai Symfony, taču Flight joprojām var veiksmīgi veidot izturīgu lietojumprogrammu.

Kas ir Maršrutēšana?

Maršrutēšana ir Flight ietvara pamatā, bet kas tas īsti ir? Maršrutēšana ir process, kurā tiek ņemts URL un tiek saskaņots ar konkrētu funkciju jūsu kodā. Tā ir veids, kā padarīt jūsu tīmekļa vietni dažāda satura, balstoties uz pieprasīto URL. Piemēram, jūs varētu vēlēties parādīt lietotāja profilu, kad viņi apmeklē /lietotājs/1234, bet parādīt visu lietotāju sarakstu, kad viņi apmeklē /lietotāji. Tas ir visu izdarīts caur maršrutēšanu.

Tas varētu darboties šādi:

Un kāpēc ir svarīgi?

Pareiza centralizēta maršrutētāja sistēma faktiski var padarīt jūsu dzīvi dramatiski vieglāku! Tas var būt grūti pamanāms sākumā. Šeit ir daži iemesli, kāpēc:

Es esmu drošs, ka esat iepazinies ar skriptu pa skriptam veidu, kā radīt tīmekļa vietni. Jums var būt fails, ko sauc index.php, kurā ir daudz if paziņojumu, lai pārbaudītu URL un tad izpildītu konkrētu funkciju, pamatojoties uz URL. Tas ir veids, kā maršrutēšana, bet tas nav ļoti organizēts un tas var ātri izvērsties. Flight maršrutēšanas sistēma ir daudz organizētāka un spēcīgāka veidā, kā apstrādāt maršrutēšanu.

Tas?

// /lietotajs/skatit_profila.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    skatitLietotajaProfilu($id);
}

// /lietotajs/rediget_profila.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    reditLietotajaProfilu($id);
}

// u.c...

Vai tas?

// index.php
Flight::route('/lietotajs/@id', ['LietotajaKontrolieris', 'skatitLietotajaProfilu']);
Flight::route('/lietotajs/@id/edit', ['LietotajaKontrolieris', 'reditLietotajaProfilu']);

// Varbūt jūsu app/controllers/LietotajaKontrolieris.php
class LietotajaKontrolieris {
    public function skatitLietotajaProfilu($id) {
        // darīt kaut ko
    }

    public function reditLietotajaProfilu($id) {
        // darīt kaut ko
    }
}

Cerams, jūs sākat ieraudzīt ieguvumus no centralizētas maršrutēšanas sistēmas izmantošanas. Ilgtermiņā to ir daudz vieglāk pārvaldīt un saprast!

Pieprasījumi un Atbildes

Flight nodrošina vienkāršu un vieglu veidu, kā apstrādāt pieprasījumus un atbildes. Tas ir tīmekļa ietvaru būtība. Tas pieņem pieprasījumu no lietotāja pārlūka, apstrādā to, un pēc tam nosūta atbildi. Tā ir veids, kā jūs varat veidot tīmekļa lietojumprogrammas, kas darbojas, piemēram, rāda lietotāja profilu, ļauj lietotājam pierakstīties vai ļauj lietotājam publicēt jaunu bloga ierakstu.

Pieprasījumi

Pieprasījums ir tas, ko lietotāja pārlūks sūta uz jūsu serveri, kad viņi apmeklē jūsu tīmekļa vietni. Šis pieprasījums satur informāciju par to, ko lietotājs vēlas darīt. Piemēram, tas var saturēt informāciju par to, kādu URL lietotājs vēlas apmeklēt, kādu datu lietotājs vēlas nosūtīt uz jūsu serveri vai kādu veidu dati lietotājs vēlas saņemt no jūsu servera. Svarīgi ir zināt, ka pieprasījums ir tikai lasīšanas režīmā. Jūs nevarat mainīt pieprasījumu, bet jūs to varat lasīt.

Flight nodrošina vienkāršu veidu, kā piekļūt informācijai par pieprasījumu. Jūs varat piekļūt informācijai par pieprasījumu, izmantojot Flight::request() metodi. Šī metode atgriež Pieprasījums objektu, kas satur informāciju par pieprasījumu. Jūs varat izmantot šo objektu, lai piekļūtu informācijai par pieprasījumu, piemēram, URL, metodi vai datiem, ko lietotājs nosūtījis uz jūsu serveri.

Atbildes

Atbilde ir tas, ko jūsu serveris nosūta atpakaļ uz lietotāja pārlūku, kad viņi apmeklē jūsu tīmekļa vietni. Šī atbilde satur informāciju par to, ko jūsu serveris vēlas darīt. Piemēram, tas var saturēt informāciju par to, kāda veida datus jūsu serveris vēlas nosūtīt lietotājam, kāda veida datus jūsu serveris vēlas saņemt no lietotāja vai kāda veida datus jūsu serveris vēlas saglabāt lietotāja datorā.

Flight nodrošina vienkāršu veidu, kā nosūtīt atbildi uz lietotāja pārlūku. Jūs varat nosūtīt atbildi, izmantojot Flight::response() metodi. Šī metode nospiež Atbilde objektu kā argumentu un nosūta atbildi uz lietotāja pārlūku. Jūs varat izmantot šo objektu, lai nosūtītu atbildi uz lietotāja pārlūku, piemēram, HTML, JSON vai failu. Flight palīdz jums automātiski ģenerēt dažas atbildes daļas, lai padarītu lietas vieglas,# Kāpēc ietvaru?

Daudzi programmētāji stingri iebilst pret ietvaru izmantošanu. Viņi argumentē, ka ietvari ir pārpildīti, lēni un grūti apgūstami. Viņi saka, ka ietvari nav nepieciešami un ka jūs varat rakstīt labāku kodu bez tiem. Noteikti var izteikt dažus pamatoti iebildumus pret ietvaru izmantošanu. Tomēr ir arī daudz priekšrocību, izmantojot ietvarus.

Iemesli izmantot ietvaru

Šeit ir daži iemesli, kāpēc jums varētu būt jāapsver ietvara izmantošana:

Flight ir mikroietvars. Tas nozīmē, ka tas ir neliels un viegls. Tas nepiedāvā tik daudz funkcionalitātes kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina lielu daļu funkcionalitātes, kas jums nepieciešama, lai veidotu tīmekļa lietojumprogrammas. Tas arī ir viegli apgūstams un lietojams. Tas padara to par labu izvēli, lai ātri un viegli veidotu tīmekļa lietojumprogrammas. Ja esat jauns ietvaru jomā, Flight ir lielisks iesācēju ietvars, ar kuru sākt. Tas palīdzēs jums iemācīties par ietvaru izmantošanas priekšrocībām, neplūstot jums ar pārāk daudz sarežģītības. Kad esat ieguvis kādu pieredzi...

Learn/httpcaching

HTTP kešošana

Flight nodrošina iebūvētu atbalstu HTTP līmeņa kešošanai. Ja kešošanas nosacījums ir izpildīts, Flight atgriezīs HTTP 304 Nav modificēts atbildi. Nākamajā reizē, kad klienta pieprasīs to pašu resursu, viņiem tiks ierosināts izmantot vietējo kešotu versiju.

Pēdējais modificēšanas laiks

Jūs varat izmantot lastModified metodi un padot UNIX laikrādi, lai iestatītu datumu un laiku, kad lapas tika pēdējo reizi modificētas. Klients turpinās izmantot savu kešu līdz pēdējais modificēšanas vērtība tiks mainīta.

Flight::route('/jaunumi', function () {
  Flight::lastModified(1234567890);
  echo 'Šis saturs tiks kešots.';
});

ETag

ETag kešošana ir līdzīga Last-Modified, izņemot to, ka jūs varat norādīt jebkādu id, ko vēlaties izmantot resursam:

Flight::route('/jaunumi', function () {
  Flight::etag('mans-unikālais-id');
  echo 'Šis saturs tiks kešots.';
});

Ņemiet vērā, ka saucot gan lastModified, gan etag, tiks gan iestatīta, gan pārbaudīta kešu vērtība. Ja kešu vērtība ir vienāda starp pieprasījumiem, Flight nekavējoties nosūtīs HTTP 304 atbildi un pārtrauks apstrādi.

Learn/responses

Atbildes

Flight palīdz ģenerēt daļu no atbildes virsrakstiem, bet jūs valdāt pārsvaru pār to, ko nosūtāt atpakaļ lietotājam. Dažreiz jūs varat tieši piekļūt Response objektam, bet lielāko daļu laika jūs izmantosit Flight instanci, lai nosūtītu atbildi.

Pamata atbildes nosūtīšana

Flight izmanto ob_start(), lai buferētu izvadi. Tas nozīmē, ka jūs varat izmantot echo vai print, lai nosūtītu atbildi lietotājam, un Flight to sag捕arīs un nosūtīs atpakaļ lietotājam ar atbilstošajiem virsrakstiem.


// Tas nosūtīs "Hello, World!" lietotāja pārlūkā
Flight::route('/', function() {
    echo "Hello, World!";
});

// HTTP/1.1 200 OK
// Content-Type: text/html
//
// Hello, World!

Kā alternatīvu, jūs varat izsaukt write() metodi, lai pievienotu ķermenim.


// Tas nosūtīs "Hello, World!" lietotāja pārlūkā
Flight::route('/', function() {
    // detalizēts, bet dažreiz izpilda darbu, kad tas jums nepieciešams
    Flight::response()->write("Hello, World!");

    // ja vēlaties iegūt ķermeni, ko esat iestatījis šajā punktā
    // jūs varat to izdarīt šādi
    $body = Flight::response()->getBody();
});

Statusa kodi

Jūs varat iestatīt atbildes statusa kodu, izmantojot status metodi:

Flight::route('/@id', function($id) {
    if($id == 123) {
        Flight::response()->status(200);
        echo "Hello, World!";
    } else {
        Flight::response()->status(403);
        echo "Aizliegts";
    }
});

Ja vēlaties iegūt pašreizējo statusa kodu, varat izmantot status metodi bez jebkādiem argumentiem:

Flight::response()->status(); // 200

Atbildes ķermeņa iestatīšana

Jūs varat iestatīt atbildes ķermeni, izmantojot write metodi, tomēr, ja jūs kaut ko echo vai print, tas tiks sag捕arīts un nosūtīts kā atbildes ķermenis caur izvades buferēšanu.

Flight::route('/', function() {
    Flight::response()->write("Hello, World!");
});

// tas pats kā

Flight::route('/', function() {
    echo "Hello, World!";
});

Atbildes ķermeņa notīrīšana

Ja vēlaties notīrīt atbildes ķermeni, jūs varat izmantot clearBody metodi:

Flight::route('/', function() {
    if($someCondition) {
        Flight::response()->write("Hello, World!");
    } else {
        Flight::response()->clearBody();
    }
});

Atbildes ķermeņa atsauces izpildīšana

Jūs varat izpildīt atsauci uz atbildes ķermeni, izmantojot addResponseBodyCallback metodi:

Flight::route('/users', function() {
    $db = Flight::db();
    $users = $db->fetchAll("SELECT * FROM users");
    Flight::render('users_table', ['users' => $users]);
});

// Tas gzipos visas atbildes par jebkuru maršrutu
Flight::response()->addResponseBodyCallback(function($body) {
    return gzencode($body, 9);
});

Jūs varat pievienot vairākas atsauces, un tās tiks izpildītas secībā, kādā tās tika pievienotas. Tā kā šī var pieņemt jebkuru izsaucamu, tā var pieņemt klases masīvu [ $class, 'method' ], slēgšanu $strReplace = function($body) { str_replace('hi', 'there', $body); };, vai funkcijas nosaukumu 'minify', ja jums būtu funkcija, lai samazinātu jūsu html kodu piemēram.

Piezīme: Maršruta atsauces nedarbosies, ja jūs izmantojat flight.v2.output_buffering konfigurācijas opciju.

Specifiska maršruta atsauce

Ja vēlaties, lai tas attiektos tikai uz konkrētu maršrutu, jūs varētu pievienot atsauci pašā maršrutā:

Flight::route('/users', function() {
    $db = Flight::db();
    $users = $db->fetchAll("SELECT * FROM users");
    Flight::render('users_table', ['users' => $users]);

    // Tas gzipos tikai atbildi šim maršrutam
    Flight::response()->addResponseBodyCallback(function($body) {
        return gzencode($body, 9);
    });
});

Vidēja opcija

Jūs varat arī izmantot vidējo, lai pielāgotu atsauci visiem maršrutiem, izmantojot vidēji:

// MinifyMiddleware.php
class MinifyMiddleware {
    public function before() {
        // Pielietojiet atsauci šeit uz response() objektu.
        Flight::response()->addResponseBodyCallback(function($body) {
            return $this->minify($body);
        });
    }

    protected function minify(string $body): string {
        // kaut kā samazināt ķermeni
        return $body;
    }
}

// index.php
Flight::group('/users', function() {
    Flight::route('', function() { /* ... */ });
    Flight::route('/@id', function($id) { /* ... */ });
}, [ new MinifyMiddleware() ]);

Atbildes virsraksta iestatīšana

Jūs varat iestatīt virsrakstu, piemēram, atbildes satura veidu, izmantojot header metodi:


// Tas nosūtīs "Hello, World!" lietotāja pārlūkā kā vienkāršu tekstu
Flight::route('/', function() {
    Flight::response()->header('Content-Type', 'text/plain');
    // vai
    Flight::response()->setHeader('Content-Type', 'text/plain');
    echo "Hello, World!";
});

JSON

Flight nodrošina atbalstu JSON un JSONP atbilžu nosūtīšanai. Lai nosūtītu JSON atbildi, jūs pārsniedzat datus, kas jākodo JSON formātā:

Flight::json(['id' => 123]);

Piezīme: Pēc noklusējuma Flight nosūtīs Content-Type: application/json virsrakstu kopā ar atbildi. Tas arī izmantos konstantus JSON_THROW_ON_ERROR un JSON_UNESCAPED_SLASHES, kad kodē JSON.

JSON ar statusa kodu

Jūs varat arī pārsūtīt statusa kodu kā otro argumentu:

Flight::json(['id' => 123], 201);

JSON ar skaistu izskatu

Jūs varat arī pārsūtīt argumentu pēdējā pozīcijā, lai iespējotu skaistu izskatu:

Flight::json(['id' => 123], 200, true, 'utf-8', JSON_PRETTY_PRINT);

Ja jūs maināt opcijas, ko nododat Flight::json(), un vēlaties vienkāršāku sintaksi, jūs varat vienkārši pārsaukt JSON metodi:

Flight::map('json', function($data, $code = 200, $options = 0) {
    Flight::_json($data, $code, true, 'utf-8', $options);
});

// Un tagad to var izmantot šādi
Flight::json(['id' => 123], 200, JSON_PRETTY_PRINT);

JSON un izpildes apstādināšana (v3.10.0)

Ja vēlaties nosūtīt JSON atbildi un apstādināt izpildi, jūs varat izmantot jsonHalt metodi. Tas ir noderīgi gadījumiem, kad jūs pārbaudāt varbūt kādu autorizāciju, un, ja lietotājs nav autorizēts, jūs varat nekavējoties nosūtīt JSON atbildi, notīrīt esošo ķermeņa saturs un apstādināt izpildi.

Flight::route('/users', function() {
    $authorized = someAuthorizationCheck();
    // Pārbaudiet, vai lietotājs ir autorizēts
    if($authorized === false) {
        Flight::jsonHalt(['error' => 'Nav autorizēts'], 401);
    }

    // Turpiniet ar pārējo maršrutu
});

Pirms v3.10.0 jūs būtu jāveic kaut kas tāds:

Flight::route('/users', function() {
    $authorized = someAuthorizationCheck();
    // Pārbaudiet, vai lietotājs ir autorizēts
    if($authorized === false) {
        Flight::halt(401, json_encode(['error' => 'Nav autorizēts']));
    }

    // Turpiniet ar pārējo maršrutu
});

JSONP

JSONP pieprasījumiem jūs varat izvēles veidā pārsūtīt vaicājuma parametra nosaukumu, ko izmantojat, lai noteiktu jūsu atsauces funkciju:

Flight::jsonp(['id' => 123], 'q');

Tātad, veicot GET pieprasījumu, izmantojot ?q=my_func, jums vajadzētu saņemt izeju:

my_func({"id":123});

Ja jūs neizpildāt vaicājuma parametra nosaukumu, tas noklusējuma būs jsonp.

Tomburgizzard uz citu URL

Jūs varat pārsūtīt pašreizējo pieprasījumu, izmantojot redirect() metodi un pārsūtot jaunu URL:

Flight::redirect('/new/location');

Pēc noklusējuma Flight nosūta HTTP 303 ("Redzēt citu") statusa kodu. Jūs varat izvēles veidā iestatīt pielāgotu kodu:

Flight::redirect('/new/location', 401);

Apstāšanās

Jūs varat apstāties ietvarā jebkurā brīdī, izsaucot halt metodi:

Flight::halt();

Jūs arī varat norādīt opcionalu HTTP statusa kodu un ziņojumu:

Flight::halt(200, 'Atgriezīsimies drīz...');

Izsaucot halt, tiks izmests jebkurš atbildes saturs līdz tam punktam. Ja vēlaties apstāties ietvarā un izvadīt pašreizējo atbildi, izmantojiet stop metodi:

Flight::stop();

Atbildes datu notīrīšana

Jūs varat notīrīt atbildes ķermeni un virsrakstus, izmantojot clear() metodi. Tas notīrīs jebkurus virsrakstus, kas piešķirti atbildei, notīrīs atbildes ķermeni un iestatīs statusa kodu uz 200.

Flight::response()->clear();

Tikai atbildes ķermeņa notīrīšana

Ja jūs vēlaties tikai notīrīt atbildes ķermeni, jūs varat izmantot clearBody() metodi:

// Tas joprojām saglabās jebkurus virsrakstus, kas iestatīti uz response() objektu.
Flight::response()->clearBody();

HTTP kešatmiņa

Flight nodrošina iebūvētu atbalstu HTTP līmeņa kešatmiņai. Ja kešatmiņas nosacījums ir izpildīts, Flight nosūtīs HTTP 304 Not Modified atbildi. Nākamreiz, kad klients pieprasīs to pašu resursu, viņiem tiks lūgts izmantot viņu lokāli kešoto versiju.

Maršruta līmeņa kešatmiņa

Ja vēlaties kešot visu atbildi, jūs varat izmantot cache() metodi un pārsūtīt laiku kešot.


// Tas kešos atbildi uz 5 minūtēm
Flight::route('/news', function () {
  Flight::response()->cache(time() + 300);
  echo 'Šis saturs tiks kešots.';
});

// Alternatīvi jūs varat izmantot virkni, ko jūs nodosiet
// uz strtotime() metodi
Flight::route('/news', function () {
  Flight::response()->cache('+5 minutes');
  echo 'Šis saturs tiks kešots.';
});

Pēdējais modificēts

Jūs varat izmantot lastModified metodi un pārsūtīt UNIX laika zīmogu, lai iestatītu datumu un laiku, kad lapa tika pēdējoreiz modificēta. Klients turpinās izmantot savu kešu līdz pēdējā modificētā vērtība tiks mainīta.

Flight::route('/news', function () {
  Flight::lastModified(1234567890);
  echo 'Šis saturs tiks kešots.';
});

ETag

ETag kešatmiņa ir līdzīga Last-Modified, izņemot to, ka jūs varat norādīt jebkuru id, ko vēlaties resursam:

Flight::route('/news', function () {
  Flight::etag('my-unique-id');
  echo 'Šis saturs tiks kešots.';
});

Paturiet prātā, ka izsaukot gan lastModified, gan etag, abi iestatīs un pārbaudīs kešatmiņas vērtību. Ja kešatmiņas vērtība ir vienāda starp pieprasījumiem, Flight uzreiz nosūtīs HTTP 304 atbildi un apstādinās apstrādi.

Faila lejupielāde (v3.12.0)

Ir palīgmetode, lai lejupielādētu failu. Jūs varat izmantot download metodi un pārsūtīt ceļu.

Flight::route('/download', function () {
  Flight::download('/path/to/file.txt');
});

Learn/frameworkinstance

Framework instances

Vietā zīmēt Flight kā globālu statisku klasi, Jūs varat izpildespienākumu palaižot kā objekta instanci.

require 'flight/autoload.php';

$app = Flight::app();

$app->route('/', function () {
  echo 'sveika, pasaule!';
});

$app->start();

Tātad vietā, lai izsauktu statisko metodi, Jūs izsauktu instances metodi ar tādu pašu nosaukumu uz Dzinēja objektu.

Learn/redirects

Pāradresācijas

Jūs varat pāradresēt pašreizējo pieprasījumu, izmantojot redirect metodi un padodot jaunu URL:

Flight::redirect('/jauna/vietas');

Pēc noklusējuma Flight nosūta HTTP 303 statusa kodu. Jūs varat izvēlēties iestatīt pielāgotu kodu:

Flight::redirect('/jauna/vietas', 401);

Learn/events

Pasākumu sistēma Flight PHP (v3.15.0+)

Flight PHP ievieš vieglu un intuitīvu pasākumu sistēmu, kas ļauj reģistrēt un izsistīt pielāgotus pasākumus jūsu lietojumprogrammā. Pievienojot Flight::onEvent() un Flight::triggerEvent(), jūs tagad varat pieslēgties jūsu lietojumprogrammas dzīves cikla nozīmīgajiem brīžiem vai definēt savus pasākumus, lai padarītu jūsu kodu modulāru un paplašināmu. Šīs metodes ir daļa no Flight kartējamajām metodēm, tas nozīmē, ka jūs varat pārdefinēt to uzvedību, lai pielāgotu to savām vajadzībām.

Šis ceļvedis aptver visu, kas jums jāzina, lai uzsāktu darbu ar pasākumiem, ieskaitot, kāpēc tie ir vērtīgi, kā tos izmantot un praktiskus piemērus, lai palīdzētu iesācējiem saprast to potenciālu.

Kāpēc izmantot pasākumus?

Pasākumi ļauj jums atdalīt dažādas jūsu lietojumprogrammas daļas, lai tās stipri neatkarētu viena no otras. Šī atdalīšana—bieži saukta par atslēgšanu—padara jūsu kodu vieglāk atjauninātu, paplašinātu vai labotu. Tā vietā, lai uzrakstītu visu vienā lielā blokā, jūs varat sadalīt savu loģiku mazākos, neatkarīgos gabalos, kas reaģē uz konkrētām darbībām (pasākumiem).

Iedomājieties, ka jūs veidojat bloga lietojumprogrammu:

Bez pasākumiem jūs visu šo iepazīsiet vienā funkcijā. Ar pasākumiem jūs varat to sadalīt: viena daļa saglabā komentāru, otra izsist pasākumu, piemēram, 'comment.posted', un atsevišķi klausītāji apstrādā e-pastu un reģistrēšanu. Tas saglabā jūsu kodu tīrāku un ļauj jums pievienot vai noņemt funkcijas (piemēram, paziņojumus), nepieskaroties pamatloģikai.

Bieži lietojumi

Pasākumu klausītāju reģistrēšana

Lai klausītos uz pasākumu, izmantojiet Flight::onEvent(). Šī metode ļauj jums definēt, kas notiks, kad pasākums notiek.

Sintakse

Flight::onEvent(string $event, callable $callback): void

Kā tas darbojas

Jūs "pierakstāties" uz pasākumu, sakot Flight, ko darīt, kad tas notiek. Atgriezeniskā funkcija var pieņemt argumentus, kas tiek nodoti no pasākuma izsistšanas.

Flight pasākumu sistēma ir sinhrona, kas nozīmē, ka katrs pasākumu klausītājs tiek izpildīts secīgi, viens pēc otra. Kad jūs izsitat pasākumu, visi reģistrētie klausītāji šim pasākumam tiks izpildīti līdz beigām, pirms jūsu kods turpinās. Tas ir svarīgi saprast, jo tas atšķiras no asinkronajiem pasākumu sistēmām, kur klausītāji var darboties paralēli vai vēlāk.

Vienkāršs piemērs

Flight::onEvent('user.login', function ($username) {
    echo "Laipni lūdzam atpakaļ, $username!";
});

Šeit, kad pasākums 'user.login' tiek izsists, tas sveicinās lietotāju pēc vārda.

Galvenie punkti

Pasākumu izsistīšana

Lai izsistītu pasākumu, izmantojiet Flight::triggerEvent(). Tas norāda Flight, lai izpildītu visus klausītājus, kas reģistrēti šim pasākumam, nododot jebkādus datus, ko sniedzat.

Sintakse

Flight::triggerEvent(string $event, ...$args): void

Vienkāršs piemērs

$username = 'alice';
Flight::triggerEvent('user.login', $username);

Tas izsist pasākumu 'user.login' un nosūta 'alice' klausītājam, ko mēs definējām iepriekš, kas izvadīs: Laipni lūdzam atpakaļ, alice!.

Galvenie punkti

Pasākumu klausītāju reģistrēšana

...

Turbīnā turpmāks klausītājs: Ja klausītājs atgriež false, nekādi papildu klausītāji šim pasākumam netiks izpildīti. Tas ļauj jums apturēt pasākumu ķēdi, pamatojoties uz noteiktām nosacījumiem. Atcerieties, ka klausītāju secība ir svarīga, jo pirmais, kas atgriež false, apturēs pārējo izpildi.

Piemērs:

Flight::onEvent('user.login', function ($username) {
    if (isBanned($username)) {
        logoutUser($username);
        return false; // Aptur nākamos klausītājus
    }
});
Flight::onEvent('user.login', function ($username) {
    sendWelcomeEmail($username); // šis nekad netiks nosūtīts
});

Pasākumu metožu pārdefinēšana

Flight::onEvent() un Flight::triggerEvent() ir pieejami, lai tiktu paplašināti, tas nozīmē, ka jūs varat pārdefinēt to darbību. Tas ir lieliski piemērots pieredzējušiem lietotājiem, kuri vēlas pielāgot pasākumu sistēmu, piemēram, pievienojot reģistrēšanu vai mainot, kā pasākumi tiek izsisti.

Piemērs: Pielāgojot onEvent

Flight::map('onEvent', function (string $event, callable $callback) {
    // Reģistrēt katru pasākumu reģistrāciju
    error_log("Jauns pasākumu klausītājs pievienots: $event");
    // Izsist standarta uzvedību (pieņemot, ka ir iekšēja pasākumu sistēma)
    Flight::_onEvent($event, $callback);
});

Tagad, katru reizi, kad jūs reģistrējat pasākumu, tas tiek ierakstīts pirms turpināšanas.

Kāpēc pārdefinēt?

Kur ievietot savus pasākumus

Kā iesācējs, jūs varat jautāt: kur reģistrēt visus šos pasākumus savā lietojumprogrammā? Flight vienkāršība nozīmē, ka nav stingru noteikumu—jūs varat tos ievietot kur vien tas ir piemērots jūsu projektam. Tomēr, saglabājot tos organizētus, jūs palīdzat uzturēt savu kodu, kad jūsu lietojumprogramma aug. Šeit ir daži praktiski varianti un labākās prakses, pielāgotas Flight vieglajai būtībai:

Variants 1: Jūsu galvenajā index.php

Nelielām lietojumprogrammām vai ātriem prototipiem jūs varat reģistrēt pasākumus tieši savā index.php failā kopā ar maršrutiem. Tas viss saglabā vienā vietā, kas ir labi, kad vienkāršība ir jūsu galvenā prioritāte.

require 'vendor/autoload.php';

// Reģistrēt pasākumus
Flight::onEvent('user.login', function ($username) {
    error_log("$username pieteicies " . date('Y-m-d H:i:s'));
});

// Definēt maršrutus
Flight::route('/login', function () {
    $username = 'bob';
    Flight::triggerEvent('user.login', $username);
    echo "Pieteicies!";
});

Flight::start();

Variants 2: Atsevišķs events.php fails

Nedaudz lielākai lietojumprogrammai apsveriet iespēju pārvietot pasākumu reģistrācijas uz veltītu failu, piemēram, app/config/events.php. Iekļaujiet šo failu savā index.php pirms maršrutiem. Tas atdarina, kā maršruti bieži tiek organizēti app/config/routes.php Flight projektos.

// app/config/events.php
Flight::onEvent('user.login', function ($username) {
    error_log("$username pieteicies " . date('Y-m-d H:i:s'));
});

Flight::onEvent('user.registered', function ($email, $name) {
    echo "E-pasts nosūtīts uz $email: Laipni lūdzam, $name!";
});
// index.php
require 'vendor/autoload.php';
require 'app/config/events.php';

Flight::route('/login', function () {
    $username = 'bob';
    Flight::triggerEvent('user.login', $username);
    echo "Pieteicies!";
});

Flight::start();

Variants 3: Tuvojoties, kur viņi tiek izsisti

Vēl viens pieejas veids ir reģistrēt pasākumus tuvu vietai, kur tie tiek izsisti, piemēram, iekšā kontrolierī vai maršruta definīcijā. Tas labi darbojas, ja pasākums ir specifisks vienai jūsu lietojumprogrammas daļai.

Flight::route('/signup', function () {
    // Reģistrēt pasākumu šeit
    Flight::onEvent('user.registered', function ($email) {
        echo "Laipni lūdzam e-pastā nosūtītā $email!";
    });

    $email = 'jane@example.com';
    Flight::triggerEvent('user.registered', $email);
    echo "Pieteicies!";
});

Labākā prakse Flight

Padoms: Grupējiet pēc mērķa

Failā events.php grupējiet saistītus pasākumus (piemēram, visus lietotāju saistītos pasākumus kopā) ar komentāriem skaidrībai:

// app/config/events.php
// Lietotāju pasākumi
Flight::onEvent('user.login', function ($username) {
    error_log("$username pieteicies");
});
Flight::onEvent('user.registered', function ($email) {
    echo "Laipni lūdzam uz $email!";
});

// Lapas pasākumi
Flight::onEvent('page.updated', function ($pageId) {
    unset($_SESSION['pages'][$pageId]);
});

Šī struktūra labi paplašinās un paliks draudzīga iesācējiem.

Piemēri iesācējiem

Pastaigāsim cauri dažiem reālās pasaules scenārijiem, lai parādītu, kā pasākumi darbojas un kāpēc tie ir noderīgi.

Piemērs 1: Lietotāja pieteikšanās reģistrēšana

// Solis 1: Reģistrēt klausītāju
Flight::onEvent('user.login', function ($username) {
    $time = date('Y-m-d H:i:s');
    error_log("$username pieteicies plkst. $time");
});

// Solis 2: Izsist to savā lietojumprogrammā
Flight::route('/login', function () {
    $username = 'bob'; // Pieņemiet, ka tas nāk no formas
    Flight::triggerEvent('user.login', $username);
    echo "Sveiki, $username!";
});

Kāpēc tas ir noderīgi: Pieteikšanās kods nenojauš par reģistrēšanu—tas tikai izsisti pasākumu. Jūs vēlāk varat pievienot vairāk klausītāju (piemēram, nosūtīt sveiciena e-pastu) bez maršruta mainīšanas.

Piemērs 2: Paziņošana par jauniem lietotājiem

// Klausītājs jaunām reģistrācijām
Flight::onEvent('user.registered', function ($email, $name) {
    // Simulējiet e-pasta nosūtīšanu
    echo "E-pasts nosūtīts uz $email: Laipni lūdzam, $name!";
});

// Izsisti to, kad kāds piesakās
Flight::route('/signup', function () {
    $email = 'jane@example.com';
    $name = 'Jane';
    Flight::triggerEvent('user.registered', $email, $name);
    echo "Paldies, ka reģistrējāties!";
});

Kāpēc tas ir noderīgi: Reģistrācijas loģika koncentrējas uz lietotāja radīšanu, kamēr pasākums apstrādā paziņojumus. Jūs varētu vēlāk pievienot vairāk klausītāju (piemēram, reģistrēt reģistrāciju) gadījumā, ja tas būs nepieciešams.

Piemērs 3: Kešatmiņas dzēšana

// Klausītājs kešatmiņas dzēšanai
Flight::onEvent('page.updated', function ($pageId) {
    unset($_SESSION['pages'][$pageId]); // Izmet kešatmiņu sesijā, ja nepieciešams
    echo "Kešatmiņa dzēsta lapai $pageId.";
});

// Izsist to, kad lapa tiek rediģēta
Flight::route('/edit-page/(@id)', function ($pageId) {
    // Pieņemiet, ka mēs esam atjauninājuši lapu
    Flight::triggerEvent('page.updated', $pageId);
    echo "Lapa $pageId atjaunināta.";
});

Kāpēc tas ir noderīgi: Rediģēšanas kods nezina par kešatmiņu—tas tikai signalizē par atjauninājumu. Citas lietojumprogrammas daļas var reaģēt, kā nepieciešams.

Labākās prakses

Pasākumu sistēma Flight PHP, izmantojot Flight::onEvent() un Flight::triggerEvent(), piedāvā jums vienkāršu, bet spēcīgu veidu, kā veidot elastīgas lietojumprogrammas. Ļaujot dažādām jūsu lietojumprogrammas daļām sazināties viena ar otru caur pasākumiem, jūs varat saglabāt savu kodu organizētu, atkārtoti izmantojamu un viegli paplašināmu. Neatkarīgi no tā, vai reģistrējat darbības, nosūtāt paziņojumus vai pārvaldāt atjauninājumus, pasākumi palīdz to darīt bez loģikas sapīšanos. Turklāt, ar iespēju pārdefinēt šīs metodes, jums ir brīvība pielāgot sistēmu savām vajadzībām. Sāciet ar mazu pasākumu un skatieties, kā tas transformē jūsu lietojumprogrammas struktūru!

Iebūvēti pasākumi

Flight PHP nāk ar dažiem iebūvētiem pasākumiem, kurus jūs varat izmantot, lai pieslēgtos rāmja dzīves ciklam. Šie pasākumi tiek izsisti noteiktos punktos pieprasījuma/atbildes ciklā, ļaujot jums izpildīt pielāgotu loģiku, kad noteiktas darbības notiek.

Iebūvēto pasākumu saraksts

Learn/views

Skati

Flight nodrošina pamata templēšanas funkcionalitāti pēc noklusējuma. Lai parādītu skata templātu, izsauciet render metodi ar templāta faila nosaukumu un opcijas templātu datiem:

Flight::render('hello.php', ['name' => 'Bob']);

Datubāzi, ko jūs nododat iekšā, automātiski ievada templātā un var būt atsauce kā lokāls mainīgais. Templāta faili ir vienkārši PHP faili. Ja hello.php templāta faila saturs ir:

Sveiki, <?= $name ?>!

Izvade būtu:

Sveiki, Bob!

Jūs arī varat manuāli iestatīt skata mainīgos, izmantojot set metodi:

Flight::view()->set('name', 'Bob');

Mainīgais name tagad ir pieejams visos jūsu skatos. Tātad vienkārši varat darīt:

Flight::render('hello');

Ņemiet vērā, ka norādot templāta nosaukumu render metodē, jūs varat izlaist .php paplašinājumu.

Pēc noklusējuma Flight meklēs views direktoriju templātu failiem. Jūs varat iestatīt alternatīvu ceļu saviem templātiem, iestatot šādu konfigurāciju:

Flight::set('flight.views.path', '/ceļš/līdz/views');

Izkārtojumi

Ir parasts, ka tīmekļa vietnēm ir viens izkārtojuma templāta fails, kurā mainās saturs. Lai attēlotu saturu, kas jāizmanto izkārtojumā, jūs varat nodot opcijas parametru render metodē.

Flight::render('header', ['heading' => 'Sveiki'], 'headerContent');
Flight::render('body', ['body' => 'Pasaulē'], 'bodyContent');

Jūsu skatam tad būs saglabāti mainīgie ar nosaukumiem headerContent un bodyContent. Tad jūs varat attēlot savu izkārtojumu, darot:

Flight::render('layout', ['title' => 'Mājas lapā']);

Ja templātu faili izskatās šādi:

header.php:

<h1><?= $heading ?></h1>

body.php:

<div><?= $body ?></div>

layout.php:

<html>
  <head>
    <title><?= $title ?></title>
  </head>
  <body>
    <?= $headerContent ?>
    <?= $bodyContent ?>
  </body>
</html>

Izvade būtu:

<html>
  <head>
    <title>Mājas lapā</title>
  </head>
  <body>
    <h1>Sveiki</h1>
    <div>Pasaulē</div>
  </body>
</html>

Pielāgoti skati

Flight ļauj nomainīt noklusējuma skata dzinēju, vienkārši reģistrējot savu skata klasi. Šeit ir, kā jūs izmantotu Smarty templāta dzinēju savām skatam:

// Ielādēt Smarty bibliotēku
require './Smarty/libs/Smarty.class.php';

// Reģistrējiet Smarty kā skata klasi
// Iepriekš padodot atsauces funkciju, lai konfigurētu Smarty, ielādējot
Flight::register('view', Smarty::class, [], function (Smarty $smarty) {
  $smarty->setTemplateDir('./templates/');
  $smarty->setCompileDir('./templates_c/');
  $smarty->setConfigDir('./config/');
  $smarty->setCacheDir('./cache/');
});

// Piešķiriet templāta datus
Flight::view()->assign('name', 'Bob');

// Rādīt templātu
Flight::view()->display('hello.tpl');

Lai būtu pilnīgs, jums vajadzētu arī pārrakstīt Flight noklusējuma render metodi:

Flight::map('render', function(string $template, array $data): void {
  Flight::view()->assign($data);
  Flight::view()->display($template);
});

Learn/templates

HTML Skatījumi un veidnes

Flight pēc noklusējuma nodrošina dažas pamata veidņu funkcionalitātes.

Flight ļauj jums aizstāt noklusējuma skatījumu dzinēju, vienkārši reģistrējot savu skatu klasi. Ritiniet lejup, lai redzētu piemērus par to, kā izmantot Smarty, Latte, Blade un citus!

Iebūvēts Skatījumu Dzinējs

Lai parādītu skata veidni, izsauciet render metodi ar veidņu faila nosaukumu un opciju veidņu datiem:

Flight::render('hello.php', ['name' => 'Bob']);

Veidņu dati, kurus jūs nododat, automātiski tiek injicēti veidnē un var būt atsaucami kā vietējā mainīgā. Veidņu faili ir vienkārši PHP faili. Ja hello.php veidnes faila saturs ir:

Hello, <?= $name ?>!

Izeja būtu:

Hello, Bob!

Jūs arī varat manuāli iestatīt skata mainīgos, izmantojot set metodi:

Flight::view()->set('name', 'Bob');

Mainīgais name tagad ir pieejams visos jūsu skatījumos. Tātad jūs varat vienkārši darīt:

Flight::render('hello');

Ņemiet vērā, ka, nosakot veidnes nosaukumu render metodi, jūs varat izlaist .php paplašinājumu.

Noklusējuma Flight meklēs views direktorijā veidņu failus. Jūs varat iestatīt alternatīvu ceļu savām veidnēm, iestatot sekojošo konfigurāciju:

Flight::set('flight.views.path', '/path/to/views');

Izkārtojumi

Ir ierasti, ka vietnēm ir viens izkārtojuma veidnes fails ar mainīgu saturu. Lai attēlotu saturu, kas tiks izmantots izkārtojumā, varat nodot opciju parametru render metodei.

Flight::render('header', ['heading' => 'Hello'], 'headerContent');
Flight::render('body', ['body' => 'World'], 'bodyContent');

Jūsu skatījumā tad būs saglabāti mainīgie, kuri saucas headerContent un bodyContent. Tad varat renderēt savu izkārtojumu darot:

Flight::render('layout', ['title' => 'Home Page']);

Ja veidņu faili izskatās šādi:

header.php:

<h1><?= $heading ?></h1>

body.php:

<div><?= $body ?></div>

layout.php:

<html>
  <head>
    <title><?= $title ?></title>
  </head>
  <body>
    <?= $headerContent ?>
    <?= $bodyContent ?>
  </body>
</html>

Izeja būtu:

<html>
  <head>
    <title>Home Page</title>
  </head>
  <body>
    <h1>Hello</h1>
    <div>World</div>
  </body>
</html>

Smarty

Šeit ir kā jūs varat izmantot Smarty veidņu dzinēju saviem skatījumiem:

// Ielādējiet Smarty bibliotēku
require './Smarty/libs/Smarty.class.php';

// Reģistrējiet Smarty kā skata klasi
// Tāpat nododiet atgriezenisko izsaukumu funkciju, lai konfigurētu Smarty ielādēšanas laikā
Flight::register('view', Smarty::class, [], function (Smarty $smarty) {
  $smarty->setTemplateDir('./templates/');
  $smarty->setCompileDir('./templates_c/');
  $smarty->setConfigDir('./config/');
  $smarty->setCacheDir('./cache/');
});

// Piešķiriet veidņu datus
Flight::view()->assign('name', 'Bob');

// Parādiet veidni
Flight::view()->display('hello.tpl');

Lai pabeigtu, jums arī vajadzētu pārrakstīt Flight noklusējuma render metodi:

Flight::map('render', function(string $template, array $data): void {
  Flight::view()->assign($data);
  Flight::view()->display($template);
});

Latte

Šeit ir kā jūs varat izmantot Latte veidņu dzinēju saviem skatījumiem:

// Reģistrējiet Latte kā skata klasi
// Tāpat nododiet atgriezenisko izsaukumu funkciju, lai konfigurētu Latte ielādēšanas laikā
Flight::register('view', Latte\Engine::class, [], function (Latte\Engine $latte) {
  // Šeit Latte saglabās jūsu veidnes, lai paātrinātu lietas
    // Viens interesants aspekts par Latte ir tas, ka tas automātiski atjauno jūsu
    // kešatmiņu, kad jūs veicat izmaiņas savās veidnēs!
    $latte->setTempDirectory(__DIR__ . '/../cache/');

    // Paziņojiet Latte, kur būs jūsu skatījumu saknes direktorija.
    $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../views/'));
});

// Un apkopojiet to, lai jūs varētu izmantot Flight::render() pareizi
Flight::map('render', function(string $template, array $data): void {
  // Tas ir līdzīgu $latte_engine->render($template, $data);
  echo Flight::view()->render($template, $data);
});

Blade

Šeit ir kā jūs varat izmantot Blade veidņu dzinēju saviem skatījumiem:

Vispirms jums jāinstalē BladeOne bibliotēka, izmantojot Composer:

composer require eftec/bladeone

Tad jūs varat konfigurēt BladeOne kā skata klasi Flight:

<?php
// Ielādējiet BladeOne bibliotēku
use eftec\bladeone\BladeOne;

// Reģistrējiet BladeOne kā skata klasi
// Tāpat nododiet atgriezenisko izsaukumu funkciju, lai konfigurētu BladeOne ielādēšanas laikā
Flight::register('view', BladeOne::class, [], function (BladeOne $blade) {
  $views = __DIR__ . '/../views';
  $cache = __DIR__ . '/../cache';

  $blade->setPath($views);
  $blade->setCompiledPath($cache);
});

// Piešķiriet veidņu datus
Flight::view()->share('name', 'Bob');

// Parādiet veidni
echo Flight::view()->run('hello', []);

Lai pabeigtu, jums arī vajadzētu pārrakstīt Flight noklusējuma render metodi:

<?php
Flight::map('render', function(string $template, array $data): void {
  echo Flight::view()->run($template, $data);
});

Šajā piemēru hello.blade.php veidnes fails varētu izskatīties šādi:

<?php
Hello, {{ $name }}!

Izeja būtu:

Hello, Bob!

Ievērojot šos soļus, jūs varat integrēt Blade veidņu dzinēju ar Flight un izmantot to, lai renderētu savus skatījumus.

Learn/flight_vs_fat_free

Lidojums pret Fat-Free

Kas ir Fat-Free?

Fat-Free (mīļi pazīstams kā F3) ir spēcīgs, taču viegli lietojams PHP mikro-karkass, kas ir izstrādāts, lai palīdzētu veidot dinamiskas un izturīgas tīmekļa lietojumprogrammas - ātri!

Lidojums salīdzināts ar Fat-Free daudzos veidos un visticamāk ir tuvākais radinieks funkciju un vienkāršības ziņā. Fat-Free ir daudz funkciju, ko Lidojumam nav, bet tajā pašā laikā ir daudz funkciju, kuras ir Lidojumam. Fat-Free sāk atklāt savu vecumu un nav tik populārs kā agrāk bija.

Atnovēršanas pasākumi kļūst aizvien retāki un kopiena nav tik aktīva kā agrāk. Kods ir pietiekami vienkāršs, taču dažreiz sintakses disciplīnas trūkums var padarīt to grūti lasāmu un saprotamu. Tas darbojas ar PHP 8.3, taču pats kods joprojām izskatās tāpat kā dzīvo PHP 5.3.

Plusi salīdzinājumā ar Lidojumu

Mīnusi salīdzinājumā ar Lidojumu

Learn/extending

Paplašināšana

Flight ir izstrādāts kā paplašināms rīku komplekts. Rīku komplekts nāk ar komplektu noklusējuma metožu un komponentu, bet ļauj jums pievienot savas metodes, reģistrēt savas klases vai pat aizvietot esošās klases un metodes.

Ja meklējat DIC (atkarību injekcijas konteineru), dodieties uz Atkarību injekcijas konteinera lapu.

Metožu kartēšana

Lai kartētu savu vienkāršo pielāgoto metodi, izmantojiet map funkciju:

// Kartējiet savu metodi
Flight::map('hello', function (string $name) {
  echo "sveiks $name!";
});

// Izsauciet savu pielāgoto metodi
Flight::hello('Bob');

Lai gan ir iespējams veidot vienkāršas pielāgotas metodes, ieteicams vienkārši izveidot standarta funkcijas PHP. Tam ir automātiska pabeigšana IDE un tas ir vieglāk lasāms. Atbilstošais iepriekš minētā koda variants būtu:

function hello(string $name) {
  echo "sveiks $name!";
}

hello('Bob');

Tas tiek izmantots vairāk, kad nepieciešams nodot mainīgos savā metodē, lai iegūtu gaidīto vērtību. Izmantojot register() metodi zemāk, tas ir vairāk paredzēts konfigurācijas nodošanai un pēc tam jūsu iepriekš konfigurētās klases izsaukšanai.

Klases reģistrācija

Lai reģistrētu savu klasi un konfigurētu to, izmantojiet register funkciju:

// Reģistrējiet savu klasi
Flight::register('user', User::class);

// Iegūstiet instanci no savas klases
$user = Flight::user();

Reģistrācijas metode arī ļauj jums nodot parametrus savai klases konstruktora metodei. Tādējādi, kad ielādējat savu pielāgoto klasi, tā tiks iepriekš initializēta. Jūs varat definēt konstruktora parametrus, nododot papildu masīvu. Šeit ir piemērs, kā ielādēt datubāzes savienojumu:

// Reģistrējiet klasi ar konstruktora parametriem
Flight::register('db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass']);

// Iegūstiet instanci no savas klases
// Tas izveidos objektu ar definētajiem parametriem
//
// new PDO('mysql:host=localhost;dbname=test','user','pass');
//
$db = Flight::db();

// un, ja jums tas būs nepieciešams vēlāk savā kodā, vienkārši izsauciet to pašu metodi vēlreiz
class SomeController {
  public function __construct() {
    $this->db = Flight::db();
  }
}

Ja jūs nododat papildu atgriezeniskās saites parametru, tas tiks izpildīts uzreiz pēc klases konstrukcijas. Tas ļauj veikt jebkādas sagatavošanas procedūras jūsu jaunajam objektam. Atgriezeniskās saites funkcijai ir viens parametrs, jauna objekta instance.

// Atgriezeniskā saite tiks nodota objektam, kas tika konstruēts
Flight::register(
  'db',
  PDO::class,
  ['mysql:host=localhost;dbname=test', 'user', 'pass'],
  function (PDO $db) {
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  }
);

Noklusējuma iestatījumos, katru reizi, kad ielādējat savu klasi, jūs saņemsiet kopēju instanci. Lai iegūtu jaunu klases instanci, vienkārši nododiet false kā parametru:

// Kopīga klases instance
$shared = Flight::db();

// Jauna klases instance
$new = Flight::db(false);

Ņemiet vērā, ka kartētām metodēm ir priekšroka pār reģistrētām klasēm. Ja jūs deklarējat abus, izmantojot to pašu nosaukumu, tiks izsaukta tikai kartētā metode.

Žurnālfailu veidošana

Flight nav iebūvēta žurnālfailu sistēma, tomēr ir ļoti viegli izmantot žurnālfailu bibliotēku ar Flight. Šeit ir piemērs, izmantojot Monolog bibliotēku:

// index.php vai bootstrap.php

// Reģistrējiet žurnālu ar Flight
Flight::register('log', Monolog\Logger::class, ['name'], function(Monolog\Logger $log) {
    $log->pushHandler(new Monolog\Handler\StreamHandler('path/to/your.log', Monolog\Logger::WARNING));
});

Tagad, kad tas ir reģistrēts, jūs to varat izmantot savā lietotnē:

// Jūsu kontrolierī vai maršrutā
Flight::log()->warning('Tas ir brīdinājuma ziņojums');

Tas ierakstīs ziņojumu žurnālfailā, kuru jūs norādījāt. Ko darīt, ja vēlaties ierakstīt kaut ko, kad notiek kļūda? Jūs varat izmantot error metodi:

// Jūsu kontrolierī vai maršrutā

Flight::map('error', function(Throwable $ex) {
    Flight::log()->error($ex->getMessage());
    // Rādīt savu pielāgoto kļūdas lapu
    include 'errors/500.html';
});

Jūs arī varētu izveidot pamata APM (pieteikumu veiktspējas uzraudzības) sistēmu izmantojot before un after metodes:

// Jūsu bootstrap failā

Flight::before('start', function() {
    Flight::set('start_time', microtime(true));
});

Flight::after('start', function() {
    $end = microtime(true);
    $start = Flight::get('start_time');
    Flight::log()->info('Pieprasījums '.Flight::request()->url.' ilga ' . round($end - $start, 4) . ' sekundes');

    // Jūs varētu arī pievienot savus pieprasījuma vai atbildes galvenes
    // lai tās reģistrētu (esiet uzmanīgi, jo tas varētu būt
    // daudz datu, ja jums ir daudz pieprasījumu)
    Flight::log()->info('Pieprasījuma galvenes: ' . json_encode(Flight::request()->headers));
    Flight::log()->info('Atbildes galvenes: ' . json_encode(Flight::response()->headers));
});

Rīku komplekta metožu aizvietošana

Flight ļauj jums mainīt tā noklusējuma funkcionalitāti, lai tā atbilstu jūsu vajadzībām, neizmainot nekādu kodu. Jūs varat skatīt visas metodes, kuras varat aizvietot šeit.

Piemēram, kad Flight nevar atbilstoši maršrutam savienot URL, tas izsauc notFound metodi, kas sūta vispārēju HTTP 404 atbildi. Jūs varat aizvietot šo uzvedību izmantojot map metodi:

Flight::map('notFound', function() {
  // Rādīt pielāgotu 404 lapu
  include 'errors/404.html';
});

Flight arī ļauj jums aizvietot rīku komplekta kodolkomponentus. Piemēram, jūs varat aizvietot noklusējuma maršrutētāja klasi ar savu pielāgoto klasi:

// Reģistrējiet savu pielāgoto klasi
Flight::register('router', MyRouter::class);

// Kad Flight ielādē maršrutētāja instanci, tā ielādēs jūsu klasi
$myrouter = Flight::router();

Tomēr, rīku komplekta metodes, piemēram, map un register, nevar tikt aizvietotas. Jūs saņemsiet kļūdu, ja mēģināsiet to izdarīt.

Learn/json

JSON

Flight nodrošina atbalstu JSON un JSONP atbildēm. Lai nosūtītu JSON atbildi, jums ir jāpadod dati, kas tiks pārveidoti par JSON formātu:

Flight::json(['id' => 123]);

JSONP pieprasījumiem jūs varam papildus norādīt vietrādi parametra nosaukumu, kuru izmantojat, lai definētu savu atsauces funkciju:

Flight::jsonp(['id' => 123], 'q');

Tātad, veicot GET pieprasījumu, izmantojot ?q=my_func, jums vajadzētu saņemt izvadi:

my_func({"id":123});

Ja neesat norādījis vietrādi parametra nosaukumu, tas pēc noklusējuma būs jsonp.

Learn/flight_vs_slim

Flight pret Slim

Kas ir Slim?

Slim ir PHP mikrostruktūra, kas palīdz ātri izveidot vienkāršas, bet jaudīgas tīmekļa lietojumprogrammas un API.

Daudz no iedvesmas v3 funkciju lidojumam patiešām nāca no Slīma. Ceļu grupēšana un vidējā programmatūra izpilde konkrētā secībā ir divas funkcijas, kas tika iedvesmotas no Slīma. Slīma v3 tika izlaista orientējoties uz vienkāršību, bet ir bijis dažādi vērtējumi attiecībā uz v4.

Plusi salīdzinot ar Lidojumu

Mīnusi salīdzinot ar lidojumu

Learn/autoloading

Automātiska ielāde

Automātiska ielāde ir koncepcija PHP, kurā norādāt direktoriju vai direktorijas, no kurienes ielādēt klases. Tas ir daudz noderīgāks nekā izmantojot require vai include, lai ielādētu klases. Tas ir arī priekšnoteikums, lai izmantotu komponista pakotnes.

Pēc noklusējuma jebkura Flight klase tiek automātiski ielādēta jūsu dēļ pateicoties komponistam. Tomēr, ja vēlaties ielādēt savas klases, varat izmantot Flight::path() metodi, lai norādītu direktoriju, no kuras ielādēt klases.

Pamata piemērs

Pieņemsim, ka mums ir direktoriju koks līdzīgs sekojošajam:

# Piemēra ceļš
/home/user/project/my-flight-project/
├── app
│   ├── cache
│   ├── config
│   ├── controllers - satur šī projekta kontrolierus
│   ├── translations
│   ├── UTILS - satur klases tikai šai lietojumprogrammai (tas ir ar lielajiem burtiem nolūka labad piemēram vēlāk)
│   └── views
└── public
    └── css
    └── js
    └── index.php

Jūs, iespējams, esat pamanījis, ka šis ir tas pats failu struktūra kā šī dokumentācijas vietne.

Katru direktoriju varat norādīt ielādēšanai šādi:


/**
 * public/index.php
 */

// Pievienot ceļu autovadītājam
Flight::path(__DIR__.'/../app/controllers/');
Flight::path(__DIR__.'/../app/utils/');

/**
 * app/controllers/MyController.php
 */

// bez nosaukumu telpājums nepieciešams

// Visas automātiski ielādētās klases tiek ieteiktas būt Pascal Case (katrs vārds lielajiem burtiem, bez atstarpēm)
// Kopš 3.7.2 versijas, jūs varat izmantot Pascal_Snake_Case savām klases nosaukumiem, palaistot Loader::setV2ClassLoading(false);
class MyController {

    public function index() {
        // darīt kaut ko
    }
}

Telpvārdi (Namespaces)

Ja jums ir telpvārdi, tas patiešām kļūst ļoti viegli īstenot to. Jums vajadzētu izmantot Flight::path() metodi, lai norādītu saknes direktoriju (nevis dokumenta sakne vai public/ mape) jūsu lietojumprogrammai.


/**
 * public/index.php
 */

// Pievienot ceļu autovadītājam
Flight::path(__DIR__.'/../');

Tagad šis būtu jūsu kontroliera izskats. Apskatiet tālāk esošo piemēru, bet pievērsiet uzmanību komentāriem svarīgai informācijai.

/**
 * app/controllers/MyController.php
 */

// telpvārdiem nepieciešami
// telpvārdi ir analogi direktoriju struktūrai
// telpvārdiem jāievēro tāda pati lietu struktūra kā direktorijām
// telpvārdi un direktorijas nevar saturēt nekādus pasvītras zīmes (ja nav iestatīts Loader::setV2ClassLoading(false))
namespace app\controllers;

// Visas automātiski ielādētās klases tiek ieteiktas būt Pascal Case (katrs vārds lielajiem burtiem, bez atstarpēm)
// Kopš 3.7.2 versijas, jūs varat izmantot Pascal_Snake_Case savām klases nosaukumiem, palaistot Loader::setV2ClassLoading(false);
class MyController {

    public function index() {
        // darīt kaut ko
    }
}

Un ja vēlētos automātiski ielādēt klasi jūsu utils direktorijā, varētu darīt būtiski to pašu:


/**
 * app/UTILS/ArrayHelperUtil.php
 */

// telpvārds jāsakrīt ar direktoriju struktūru un gadījumu (pievērsiet uzmanību UTILS direktorijai, kas ir visas lielas burti
//     kā failu koks iepriekš)
namespace app\UTILS;

class ArrayHelperUtil {

    public function changeArrayCase(array $array) {
        // darīt kaut ko
    }
}

Pasvītras zīmes klases nosaukumos

Kopš 3.7.2 versijas, jūs varat izmantot Pascal_Snake_Case savām klases nosaukumiem, palaistot Loader::setV2ClassLoading(false);. Tas ļaus jums izmantot pasvītras zīmes savos klases nosaukumos. Tas nav ieteicams, bet tas ir pieejams tiem, kam tas ir nepieciešams.


/**
 * public/index.php
 */

// Pievienot ceļu autovadītājam
Flight::path(__DIR__.'/../app/controllers/');
Flight::path(__DIR__.'/../app/utils/');
Loader::setV2ClassLoading(false);

/**
 * app/controllers/My_Controller.php
 */

// bez nosaukumu telpājums nepieciešams

class My_Controller {

    public function index() {
        // darīt kaut ko
    }
}

Learn/troubleshooting

Problemløgšana

Šī lapa palīdzēs jums novērst vispārējas problēmas, ar kurām jūs varat saskarties, izmantojot Flight.

Parastās problēmas

404 Netika Atrasts vai Negaidīta Maršruta Uzvedība

Ja jums tiek rādīta 404 Netika Atrasta kļūda (bet jūs zvērās par savu dzīvi, ka tā patiešām tur ir un tas nav tikai kļūda rakstīšanā), tas varētu būt problēma jums atgriežot vērtību savā maršruta gala punktā, nevis vienkārši to echojot. Šī iemesla dēļ tam ir nodoma, bet dažiem izstrādātājiem tas var nejauši notikt.

 
Flight::route('/hello', function(){
    // Tas var izraisīt 404 Netika Atrasta kļūdu
    return 'Sveika, pasaule!';
});

// To, iespējams, jūs vēlaties
Flight::route('/hello', function(){
    echo 'Sveika, pasaule!';
});

Iemesls tam ir īpaša mehānisms, kas iebūvēts maršrutētājā, kas apstrādā atgriezto izvadi kā vienu "pāreju uz nākamo maršrutu". Jūs varat redzēt šādu uzvedību dokumentācijā sadaļā Maršrutēšana.

Klase Netika Atrasta (automašīnas ielāde nedarbojas)

Šai problēmai var būt daži iemesli. Zemāk ir daži piemēri, bet pārliecinieties, ka jūs arī apskatāt sadaļu automašīna.

Nepareizs Faila Nosaukums

Visbiežākais ir tas, ka klases nosaukums nesakrīt ar faila nosaukumu.

Ja jums ir klase ar nosaukumu ManāKlase, tad failam vajadzētu būt nosauktam ManāKlase.php. Ja jums ir klase ar nosaukumu ManāKlase un fails ir nosaukts manāklase.php, tad automātisks ielādētājs to nespēs atrast.

Nepareizs Vardraba

Ja jūs izmantojat vardrabas, tad vardraba atbilst šaurmaiņa struktūrai.

// kods

// ja jūsu ManaisKontrolieris ir app/kontrolieri direktorijā un tas ir vardrabā
// tas nestrādās.
Flight::route('/hello', 'ManaisKontrolieris->sveiki');

// jums būs jāizvēlas viens no šiem variantiem
Flight::route('/hello', 'app\kontrolieri\ManaisKontrolieris->sveiki');
// vai ja jums ir lietošanas paziņojums augšā

lieto app\kontrolieri\ManaisKontrolieris;

Flight::route('/hello', [ ManaisKontrolieris::class, 'sveiki' ]);
// var būt arī rakstīts
Flight::route('/hello', ManaisKontrolieris::class.'->sveiki');
// arī...
Flight::route('/hello', [ 'app\kontrolieri\ManaisKontrolieris', 'sveiki' ]);

path() nav definēta

Skeleta lietotnē, tas ir definēts config.php failā, bet, lai jūsu klases tiktu atrastas, jums jāpārliecinās, ka path() metode ir definēta (probablyto saka visu jūsu direktorijas saknes) pirms jūs mēģināt to izmantot.

 
// Pievienojiet ceļu autoloaderim
Flight::path(__DIR__.'/../');

Install

Instalācija

Lejupielādēt failus.

Ja izmantojat Composer, varat izpildīt sekojošo komandu:

composer require flightphp/core

VAI arī varat lejupielādēt failus tieši un izvilkt tos savā tīmekļa direktorijā.

Konfigurējiet savu tīmekļa serveri.

Apache

Lai Apache, rediģējiet savu .htaccess failu ar šādu informāciju:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

Piezīme: Ja jums ir nepieciešams izmantot Flight apakškatalogu, pievienojiet rindu RewriteBase /apakskatalogs/ tieši pēc RewriteEngine On.

Piezīme: Ja vēlaties aizsargāt visus servera failus, piemēram, db vai env failu. Ievietojiet šo savā .htaccess failā:

RewriteEngine On
RewriteRule ^(.*)$ index.php

Nginx

Lai Nginx, pievienojiet sekojošo savā servera deklarācijā:

server {
  location / {
    try_files $uri $uri/ /index.php;
  }
}

Izveidojiet savu index.php failu.

<?php

// Ja izmantojat Composer, pieprasiet autovadītāju.
require 'vendor/autoload.php';
// ja neizmantojat Composer, ielādējiet pamatni tieši
// require 'flight/Flight.php';

// Tad definējiet maršrutu un piešķiriet funkciju, lai apstrādātu pieprasījumu.
Flight::route('/', function () {
  echo 'sveika pasaule!';
});

// Visbeidzot, startējiet pamatni.
Flight::start();

Guides/blog

Vienkārša emuāra izveide ar Flight PHP

Šis ceļvedis nodrošina soļus, kā izveidot pamata emuāru, izmantojot Flight PHP ietvaru. Jūs izveidosiet projektu, definēsiet maršrutus, pārvaldīsiet ierakstus, izmantojot JSON, un attēlosiet tos ar Latte veidņu dzinēju, tādējādi demonstrējot Flight vienkāršību un elastību. Ceļojuma beigās jums būs funkcionāls emuārs ar sākumlapu, individuālām ierakstu lapām un izveides formu.

Prasības

1. solis: Iestatiet savu projektu

Sāciet, izveidojot jaunu projekta direktoriju un instalējot Flight, izmantojot Composer.

  1. Izveidojiet direktoriju:

    mkdir flight-blog
cd flight-blog

  2. Instalējiet Flight:

    composer require flightphp/core

  3. Izveidojiet publisko direktoriju: Flight izmanto vienu ieejas punktu (index.php). Izveidojiet public/ mapi tam:

    mkdir public

  4. Pamata index.php: Izveidojiet public/index.php ar vienkāršu “hello world” maršrutu:

    <?php
require '../vendor/autoload.php';

Flight::route('/', function () {
   echo 'Sveiki, Flight!';
});

Flight::start();

  5. Palaidiet iebūvēto serveri: Pārbaudiet savu iestatījumu, izmantojot PHP izstrādes serveri:

    php -S localhost:8000 -t public/

    Apmeklējiet http://localhost:8000, lai redzētu “Sveiki, Flight!”.

2. solis: Organizējiet sava projekta struktūru

Lai nodrošinātu tīru iestatījumu, strukturējiet savu projektu šādi:

flight-blog/
├── app/
│   ├── config/
│   └── views/
├── data/
├── public/
│   └── index.php
├── vendor/
└── composer.json

3. solis: Instalējiet un konfigurējiet Latte

Latte ir viegla veidņu dzinēja, kas labi integrējas ar Flight.

  1. Instalējiet Latte:

    composer require latte/latte

  2. Konfigurējiet Latte Flight: Atjauniniet public/index.php, lai reģistrētu Latte kā skata dzinēju:

    <?php
require '../vendor/autoload.php';

use Latte\Engine;

Flight::register('view', Engine::class, [], function ($latte) {
   $latte->setTempDirectory(__DIR__ . '/../cache/');
   $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../app/views/'));
});

Flight::route('/', function () {
   Flight::view()->render('home.latte', ['title' => 'Mans emuārs']);
});

Flight::start();

  3. Izveidojiet izkārtojuma veidni: app/views/layout.latte:

    <!DOCTYPE html>
<html>
<head>
<title>{$title}</title>
</head>
<body>
<header>
    <h1>Mans emuārs</h1>
    <nav>
        <a href="/">Sākums</a> | 
        <a href="/create">Izveidot ierakstu</a>
    </nav>
</header>
<main>
    {block content}{/block}
</main>
<footer>
    <p>&copy; {date('Y')} Flight emuārs</p>
</footer>
</body>
</html>

  4. Izveidojiet sākumlapa veidni: app/views/home.latte:

    {extends 'layout.latte'}

{block content}
    <h2>{$title}</h2>
    <ul>
    {foreach $posts as $post}
        <li><a href="/post/{$post['slug']}">{$post['title']}</a></li>
    {/foreach}
    </ul>
{/block}

    Restartējiet serveri, ja esat to izslēguši, un apmeklējiet http://localhost:8000, lai redzētu attēloto lapu.

  5. Izveidojiet datu failu:

    Izmantojiet JSON failu, lai simulētu datu bāzi vienkāršības labad.

    data/posts.json:

    [
   {
       "slug": "pirmais-ieraksts",
       "title": "Mans pirmais ieraksts",
       "content": "Šis ir mans pirmais emuāra ieraksts ar Flight PHP!"
   }
]

4. solis: Definējiet maršrutus

Atsevišķiet savus maršrutus konfigurācijas failā labākai organizācijai.

  1. Izveidojiet routes.php: app/config/routes.php:

    <?php
Flight::route('/', function () {
   Flight::view()->render('home.latte', ['title' => 'Mans emuārs']);
});

Flight::route('/post/@slug', function ($slug) {
   Flight::view()->render('post.latte', ['title' => 'Ieraksts: ' . $slug, 'slug' => $slug]);
});

Flight::route('GET /create', function () {
   Flight::view()->render('create.latte', ['title' => 'Izveidot ierakstu']);
});

  2. Atjauniniet index.php: Iekļaujiet maršrutu failu:

    <?php
require '../vendor/autoload.php';

use Latte\Engine;

Flight::register('view', Engine::class, [], function ($latte) {
   $latte->setTempDirectory(__DIR__ . '/../cache/');
   $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../app/views/'));
});

require '../app/config/routes.php';

Flight::start();

5. solis: Glabājiet un iegūstiet emuāru ierakstus

Pievienojiet metodes, lai ielādētu un saglabātu ierakstus.

  1. Pievienojiet ierakstu metodi: index.php pievienojiet metodi ierakstu ielādei:

    Flight::map('posts', function () {
   $file = __DIR__ . '/../data/posts.json';
   return json_decode(file_get_contents($file), true);
});

  2. Atjauniniet maršrutus: Izmainiet app/config/routes.php, lai izmantotu ierakstus:

    <?php
Flight::route('/', function () {
   $posts = Flight::posts();
   Flight::view()->render('home.latte', [
       'title' => 'Mans emuārs',
       'posts' => $posts
   ]);
});

Flight::route('/post/@slug', function ($slug) {
   $posts = Flight::posts();
   $post = array_filter($posts, fn($p) => $p['slug'] === $slug);
   $post = reset($post) ?: null;
   if (!$post) {
       Flight::notFound();
       return;
   }
   Flight::view()->render('post.latte', [
       'title' => $post['title'],
       'post' => $post
   ]);
});

Flight::route('GET /create', function () {
   Flight::view()->render('create.latte', ['title' => 'Izveidot ierakstu']);
});

6. solis: Izveidojiet veidnes

Atjauniniet savas veidnes, lai attēlotu ierakstus.

  1. Ieraksta lapa (app/views/post.latte):

    {extends 'layout.latte'}

{block content}
    <h2>{$post['title']}</h2>
    <div class="post-content">
        <p>{$post['content']}</p>
    </div>
{/block}

7. solis: Pievienojiet ierakstu izveidi

Rīkojieties ar formas iesniegšanu, lai pievienotu jaunus ierakstus.

  1. Izveidojiet formu (app/views/create.latte):

    {extends 'layout.latte'}

{block content}
    <h2>{$title}</h2>
    <form method="POST" action="/create">
        <div class="form-group">
            <label for="title">Nosaukums:</label>
            <input type="text" name="title" id="title" required>
        </div>
        <div class="form-group">
            <label for="content">Saturs:</label>
            <textarea name="content" id="content" required></textarea>
        </div>
        <button type="submit">Saglabāt ierakstu</button>
    </form>
{/block}

  2. Pievienojiet POST maršrutu: app/config/routes.php:

    Flight::route('POST /create', function () {
   $request = Flight::request();
   $title = $request->data['title'];
   $content = $request->data['content'];
   $slug = strtolower(str_replace(' ', '-', $title));

   $posts = Flight::posts();
   $posts[] = ['slug' => $slug, 'title' => $title, 'content' => $content];
   file_put_contents(__DIR__ . '/../../data/posts.json', json_encode($posts, JSON_PRETTY_PRINT));

   Flight::redirect('/');
});

  3. Pārbaudiet to:

    • Apmeklējiet http://localhost:8000/create.
    • Iesniedziet jaunu ierakstu (piemēram, “Otrais ieraksts” ar kādu saturu).
    • Pārbaudiet sākumlapu, lai redzētu to sarakstā.

8. solis: Uzlabojiet ar kļūdu apstrādi

Pārdefinējiet notFound metodi, lai uzlabotu 404 pieredzi.

index.php:

Flight::map('notFound', function () {
    Flight::view()->render('404.latte', ['title' => 'Lapa nav atrasta']);
});

Izveidojiet app/views/404.latte:

{extends 'layout.latte'}

{block content}
    <h2>404 - {$title}</h2>
    <p>Atvainojiet, šī lapa neeksistē!</p>
{/block}

Nākamie soļi

Secinājums

Jūs esat izveidojis vienkāršu emuāru ar Flight PHP! Šis ceļvedis demonstrē pamatfunkcijas, piemēram, maršrutēšanu, veidņu veidošanu ar Latte un formu iesniegšanu, vienlaikus saglabājot lietas vieglas. Izpētiet Flight dokumentāciju, lai uzzinātu vairāk par uzlabotām funkcijām, kas palīdzēs attīstīt jūsu emuāru tālāk!

License

MIT licences (MIT)

=====================

Autortiesības © 2024 @mikecao, @n0nag0n

Atļauja tiek piešķirta bez maksas jebkuram personai, kas iegūst šīs programmatūras kopiju un saistītos dokumentus (turpmāk - "Programmatūra"), izmantot Programmatūru jebkurā veidā bez ierobežojumiem, ieskaitot tiesības izmantot, kopēt, modificēt, apvienot, publicēt, izplatīt, licencēt un/vai pārdot Programmatūras kopijas, un atļaut personas, kam Programmatūra tiek nodrošināta to darīt, pakļautas zemāk minētajām nosacījumiem:

Minētās autortiesību paziņojums un šī atļaujas paziņojums ir jāiekļauj visās kopijās vai būtiskajos Programmatūras daļās.

PROGRAMMATŪRA TIEK NODROŠINĀTA "KĀ TĀDA", BEZ JEBKĀDAS GARANTIJAS IZTEIKTAS VAI IMPLICITAS, IETVEROT, BET NEIEROBEŽOTI, MERCHANTĀLĀS KVALITĀTES UN PIEMĒROTĪBAS KONKRĒTIEM MĒRĶIEM UN NEPĀRKĀPJUMS. NEVIENĀ GADĪJUMĀ AUTORI VAI AUTORTIESĪBU IEDZĪVOTĀJI NAV ATBILDĪGI PAR JEBKURU PRASĪBU, KAITĒJUMU VAI CITĀM SAISTĪBĀM, NEATKARĪGI NO TĀ, VAI TĀS IERAKSTS, IAUCIENS VAI CITĀDI RADIES SAISTĪBĀ AR PROGRAMMATŪRU VAI LIETOŠANU VAI CITĀDĀM DARĪBĀM AR PROGRAMMATŪRU.

About

Kas ir Flight?

Flight ir ātrs, vienkāršs, paplašināms ietvars PHP. Tas ir diezgan daudzfunkcionāls un var tikt izmantots jebkāda veida tīmekļa lietojumprogrammu veidošanai. Tas ir izstrādāts ar vienkāršību prātā un ir uzrakstīts tā, lai būtu viegli saprotams un lietojams.

Flight ir lielisks iesācēju ietvars tiem, kuri ir jauni PHP un vēlas iemācīties, kā veidot tīmekļa lietojumprogrammas. Tas ir arī lielisks ietvars pieredzējušiem izstrādātājiem, kuri vēlas vairāk kontroli pār savām tīmekļa lietojumprogrammām. Tas ir izstrādāts, lai viegli veidotu RESTful API, vienkāršu tīmekļa lietojumprogrammu vai sarežģītu tīmekļa lietojumprogrammu.

Ātrais sākums

Vispirms instalējiet to ar Composer

composer require flightphp/core

vai varat lejupielādēt repo zip failu šeit. Tad jums būtu jābūt pamata index.php failam, piemēram, sekojošam:

<?php

// ja instalēts ar composer
require 'vendor/autoload.php';
// vai ja instalēts manuāli, izmantojot zip failu
// require 'flight/Flight.php';

Flight::route('/', function() {
  echo 'sveika pasaule!';
});

Flight::route('/json', function() {
  Flight::json(['hello' => 'world']);
});

Flight::start();

Tas arī viss! Jums ir pamata Flight lietojumprogramma. Tagad varat palaist šo failu ar php -S localhost:8000 un apmeklēt http://localhost:8000 savā pārlūkprogrammā, lai redzētu rezultātu.

Vienkārši pietiekami, vai ne?
Uzziniet vairāk par Flight dokumentācijā!

Vai tas ir ātrs?

Jā! Flight ir ātrs. Tas ir viens no ātrākajiem pieejamajiem PHP ietvariem. Jūs varat redzēt visus salīdzinājumus vietnē TechEmpower

Skatiet salīdzinājumu zemāk ar dažiem citiem populāriem PHP ietvariem.

Ietvars Plaintext Reqs/sec JSON Reqs/sec
Flight 190,421 182,491
Yii 145,749 131,434
Fat-Free 139,238 133,952
Slim 89,588 87,348
Phalcon 95,911 87,675
Symfony 65,053 63,237
Lumen 40,572 39,700
Laravel 26,657 26,901
CodeIgniter 20,628 19,901

Skeleta/Paraugprogrammu

Ir piemēra lietojumprogramma, kas var palīdzēt jums sākt darbu ar Flight ietvaru. Dodieties uz flightphp/skeleton, lai iegūtu instrukcijas, kā sākt! Jūs varat arī apmeklēt paraugus lapu, lai gūtu iedvesmu par dažām lietām, ko varat darīt ar Flight.

Kopiena

Mēs esam Matrix čatā

Matrix

Un Discord

Ieguldījumi

Ir divi veidi, kā jūs varat ieguldīt Flight:

  1. Jūs varat ieguldīt pamatā esošajā ietvarā, apmeklējot pamatkrātuvi.
  2. Jūs varat ieguldīt dokumentācijā. Šī dokumentācijas vietne tiek hostēta vietnē Github. Ja pamanāt kļūdu vai vēlaties kaut ko uzlabot, laipni aicināti to izlabot un iesniegt izmaiņu pieprasījumu! Mēs cenšamies sekot notikumiem, bet jauninājumi un tulkojumi ir laipni gaidīti.

Prasības

Flight prasa PHP 7.4 vai jaunāku.

Piezīme: PHP 7.4 tiek atbalstīts, jo pašreizējā rakstīšanas laikā (2024) PHP 7.4 ir noklusējuma versija dažām LTS Linux izplatīšanām. Pāriešana uz PHP >8 radītu daudz neērtību šiem lietotājiem. Ietvars arī atbalsta PHP >8.

Licences

Flight tiek izlaists saskaņā ar MIT licenci.

Awesome-plugins/php_cookie

Sīkfaili

overclokk/cookie ir vienkārša bibliotēka sīkfailu pārvaldībai jūsu lietotnē.

Instalēšana

Instalēšana ir vienkārša ar komponistu.

composer require overclokk/cookie

Izmantos̄ana

Lietošana ir tik vienkārša kā jaunas metodes reģistrēšana Flight klases.


use Overclokk\Cookie\Cookie;

/*
 * Iestatiet savā palaišanas vai public/index.php failā
 */

Flight::register('cookie', Cookie::class);

/**
 * ExampleController.php
 */

class ExampleController {
    public function login() {
        // Iestatiet sīkfailu

        // jums vajadzētu, lai tas būtu false, tādēļ, lai jūs saņemtu jaunu instanci
        // izmantojiet zemāk esošo komentāru, ja vēlaties autovērstjanu
        /** @var \Overclokk\Cookie\Cookie $cookie */
        $cookie = Flight::cookie(false);
        $cookie->set(
            'stay_logged_in', // sīkfaila nosaukums
            '1', // vērtība, kuru vēlaties iestatīt
            86400, // cik sekundes sīkfailam būtu jāpastāv
            '/', // ceļš, kurā būs pieejams sīkfails
            'example.com', // domēns, kurā būs pieejams sīkfails
            true, // sīkfails tiks pārraidīts tikai pār šifrētu HTTPS savienojumu
            true // sīkfails būs pieejams tikai caur HTTP protokolu
        );

        // pēc izvēles, ja vēlaties saglabāt noklusējuma vērtības
        // un ātri iestatīt sīkfailu ilgu laiku
        $cookie->forever('stay_logged_in', '1');
    }

    public function home() {
        // Pārbaudiet, vai jums ir sīkfails
        if (Flight::cookie()->has('stay_logged_in')) {
            // ielieciet tos piemēram, informācijas panelī.
            Flight::redirect('/dashboard');
        }
    }
}

Awesome-plugins/php_encryption

PHP Šifrēšana

defuse/php-encryption ir bibliotēka, kas var tikt izmantota datu šifrēšanai un atšifrēšanai. Uzsākšana ir diezgan vienkārša, lai sāktu šifrēt un atšifrēt datus. Viņiem ir lielisks rokasgrāmata, kas palīdz izskaidrot pamatus par to, kā izmantot bibliotēku, kā arī svarīgu drošības aspektu, kas saistīti ar šifrēšanu.

Instalēšana

Instalēšana ir vienkārša ar komponistu.

composer require defuse/php-encryption

Iestatījumi

Pēc tam jums būs jāģenerē šifrēšanas atslēga.

vendor/bin/generate-defuse-key

Tas izvadīs atslēgu, ko būsiet jāsargā. Jūs varētu saglabāt atslēgu savā app/config/config.php failā masīvā faila apakšdaļā. Lai gan tas nav ideāla vieta, tas vismaz ir kaut kas.

Lietošana

Tagad, kad jums ir bibliotēka un šifrēšanas atslēga, varat sākt šifrēt un atšifrēt datus.


use Defuse\Crypto\Crypto;
use Defuse\Crypto\Key;

/*
 * Uzstādiet savā bootstrap vai public/index.php failā
 */

// Šifrēšanas metode
Flight::map('encrypt', function($sastāvs_dati) {
    $šifrēšanas_atslēga = /* $config['encryption_key'] vai file_get_contents no vietas, kur likāt atslēgu */;
    return Crypto::encrypt($sastāvs_dati, Key::loadFromAsciiSafeString($šifrēšanas_atslēga));
});

// Atšifrēšanas metode
Flight::map('decrypt', function($šifrētie_dati) {
    $šifrēšanas_atslēga = /* $config['encryption_key'] vai file_get_contents no vietas, kur likāt atslēgu */;
    try {
        $sastāvs_dati = Crypto::decrypt($šifrētie_dati, Key::loadFromAsciiSafeString($šifrēšanas_atslēga));
    } catch (Defuse\Crypto\Exception\WrongKeyOrModifiedCiphertextException $ex) {
        // Uzbrukums! Vai nu tika ielādēta nepareizā atslēga, vai arī šifrētais teksts ir mainījies, kopš tas tika izveidots - vai nu sabojājies datu bāzē vai nodomāti modificējis Eva, mēģinot veikt uzbrukumu.

        // ... apstrādājiet šo gadījumu tādā veidā, kas ir piemērots jūsu lietojumprogrammai ...
    }
    return $sastāvs_dati;
});

Flight::route('/encrypt', function() {
    $šifrētie_dati = Flight::encrypt('Šis ir noslēpums');
    echo $šifrētie_dati;
});

Flight::route('/decrypt', function() {
    $šifrētie_dati = '...'; // Iegūstiet šifrētos datus no kaut kurienes
    $atšifrētie_dati = Flight::decrypt($šifrētie_dati);
    echo $atšifrētie_dati;
});

Awesome-plugins/php_file_cache

flightphp/cache

Gaisma, vienkārša un patstāvīga PHP iekšējā kešatmiņas klase

Priekšrocības

Šī dokumentācija izmanto šo bibliotēku, lai kešotu katru no lappusēm!

Noklikšķiniet šeit, lai skatītu kodu.

Uzstādīšana

Uzstādīšana, izmantojot composer:

composer require flightphp/cache

Izmantošana

Izmantošana ir samērā vienkārša. Tas saglabā kešatmiņas failu kešatmiņas direktorijā.

use flight\Cache;

$app = Flight::app();

// Jūs nododat direktoriju, kur kešatmiņa tiks saglabāta, konstruktora iekšā
$app->register('cache', Cache::class, [ __DIR__ . '/../cache/' ], function(Cache $cache) {

    // Tas nodrošina, ka kešatmiņa tiek izmantota tikai ražošanas režīmā
    // ENVIRONMENT ir konstante, kas tiek iestatīta jūsu bootstrapa failā vai citur jūsu lietojumprogrammā
    $cache->setDevMode(ENVIRONMENT === 'development');
});

Tad jūs varat to izmantot savā kodā šādi:


// Iegūt kešatmiņas instanci
$cache = Flight::cache();
$data = $cache->refreshIfExpired('simple-cache-test', function () {
    return date("H:i:s"); // atgriezt datus, kas jākodē
}, 10); // 10 sekundes

// vai
$data = $cache->retrieve('simple-cache-test');
if(empty($data)) {
    $data = date("H:i:s");
    $cache->store('simple-cache-test', $data, 10); // 10 sekundes
}

Dokumentācija

Apmeklējiet https://github.com/flightphp/cache pilnai dokumentācijai un noteikti apskatiet piemērus mapē.

Awesome-plugins/permissions

FlightPHP/Atļaujas

Tas ir atļauju modulis, ko var izmantot jūsu projektos, ja jums ir vairākas lomas jūsu lietotnē, un katram no tiem ir nedaudz atšķirīga funkcionalitāte. Šis modulis ļauj definēt atļaujas katrai rolei un pēc tam pārbaudīt, vai pašreizējam lietotājam ir atļauja piekļūt konkrētai lapai vai veikt konkrētu darbību.

Noklikšķiniet šeit GitHub repozitorijai.

Uzstādīšana

Izpildiet composer require flightphp/permissions, un esat gatavs darbam!

Lietošana

Vispirms jums ir jāiestata savas atļaujas, tad jums jāpasaka savai lietotnei, ko šīs atļaujas nozīmē. Galu galā jūs pārbaudīsiet savas atļaujas ar $Permissions->has(), ->can() vai is(). has() un can() ir vienādas funkcijas, bet sauktas atšķirīgi, lai jūsu kods būtu lasāmāks.

Pamata piemērs

Iedomāsimies, ka jums ir funkcija jūsu lietotnē, kas pārbauda, vai lietotājs ir pierakstījies. Jūs varat izveidot atļauju objektu šādi:

// index.php
require 'vendor/autoload.php';

// kods

// pēc tam, iespējams, jums ir kaut kas, kas jums paziņo, kāda ir pašreizējā lietotāja loma
// visticamāk, jums ir kaut kas, kas nosaka pašreizējo lomu
// no sesijas mainīgā, kas to definē
// pēc reģistrēšanās, pretējā gadījumā viņiem būs "viesis" vai "publiska" loma.
$current_role = 'admins';

// iestatīt atļaujas
$permission = new \flight\Permissions($current_role);
$permission->defineRule('pieslēdzies', function($current_role) {
    return $current_role !== 'viesis';
});

// Iespējams, ka vēlēsieties šo objektu noturētiegavēkur visur
Flight::set('permission', $permission);

Tad kādā kontrolierī varētu būt kaut kas tāds.

<?php

// dažs kontrolieris
class DaļasKontrolieris {
    public function daļasDarbība() {
        $atļauja = Flight::get('permission');
        if ($atļauja->has('pieslēdzies')) {
            // dari kaut ko
        } else {
            // dari ko citu
        }
    }
}

Jūs varat izmantot arī to, lai sekotu, vai tiem ir atļauja kaut ko darīt jūsu lietotnē. Piemēram, ja jums ir veids, kā lietotāji var mijiedarboties ar saviem ierakstiem jūsu programmā, jūs varat pārbaudiet, vai viņiem ir atļauja veikt konkrētas darbības.

$current_role = 'admins';

// iestatīt atļaujas
$permission = new \flight\Permission($current_role);
$permission->defineRule('ieraksts', function($current_role) {
    if($current_role === 'admins') {
        $atļaujas = ['izveidot', 'lasīt', 'labot', 'dzēst'];
    } else if($current_role === 'redaktors') {
        $atļaujas = ['izveidot', 'lasīt', 'labot'];
    } else if($current_role === 'autors') {
        $atļaujas = ['izveidot', 'lasīt'];
    } else if($current_role === 'līdzstrādnieks') {
        $atļaujas = ['izveidot'];
    } else {
        $atļaujas = [];
    }
    return $atļaujas;
});
Flight::set('permission', $permission);

Tad kaut kur kontrolierī...

class IerakstaKontrolieris {
    public function izveidot() {
        $atļauja = Flight::get('permission');
        if ($atļauja->can('ieraksts.izveidot')) {
            // dari kaut ko
        } else {
            // dari ko citu
        }
    }
}

Injicēt atkarības

Jūs varat injicēt atkarības closure, kas definē atļaujas. Tas ir noderīgi, ja jums ir kāda veida pārslēgšana, ID vai jebkura cita dati, pret kuriem vēlaties pārbaudīt. Tas pats attiecas uz Klases->Metodes zvana veidiem, izņemot to, ka argumentus definējat metodē.

Closure

$Permission->defineRule('pasūtījums', function(string $current_role, MyDependency $MyDependency = null) {
    // ... kods
});

// jūsu kontroliera failā
public function izveidotPasūtījumu() {
    $MyDependency = Flight::myDependency();
    $atļauja = Flight::get('permission');
    if ($atļauja->can('pasūtījums.izveidot', $MyDependency)) {
        // dari kaut ko
    } else {
        // dari ko citu
    }
}

Klases

namespace ManLietotne;

class Atļaujas {

    public function pasūtījums(string $current_role, MyDependency $MyDependency = null) {
        // ... kods
    }
}

Saīsinājums, lai iestatītu atļaujas ar klasēm

Jūs varat izmantot arī klases, lai definētu savas atļaujas. Tas ir noderīgi, ja jums ir daudz atļauju, un vēlaties uzturēt savu kodu tīru. Jūs varat darīt kaut ko tādu kā šis:

<?php

// palaistāmais kods
$Permissions = new \flight\Permission($current_role);
$Permissions->defineRule('pasūtījums', 'ManLietotne\Atļaujas->pasūtījums');

// myapp/Permissions.php
namespace ManLietotne;

class Atļaujas {

    public function pasūtījums(string $current_role, int $lietotāja_id) {
        // Asumējot, ka šis ir iestatīts iepriekš
        /** @var \flight\database\PdoWrapper $db */
        $db = Flight::db();
        $atļautās_atļaujas = [ 'lasīt' ]; // ikviens var skatīties pasūtījumu
        if($current_role === 'menedžeris') {
            $atļautās_atļaujas[] = 'izveidot'; // vadītāji var izveidot pasūtījumus
        }
        $dažs īpašs_tētis_no_db = $db->fetchField('SELECT dažs_īpašs_tētis FROM iestatījumi WHERE id = ?', [ $lietotāja_id ]);
        if($dažs_īpašs_tētis_no_db) {
            $atļautās_atļaujas[] = 'labot'; // Ja lietotājam ir īpaša tētis, viņi var atjaunināt pasūtījumus
        }
        if($current_role === 'admins') {
            $atļautās_atļaujas[] = 'dzēst'; // administratori var dzēst pasūtījumus
        }
        return $atļautās_atļaujas;
    }
}

Cool daļa ir tāda, ka ir arī saīsinājums, ko varat izmantot (kas var būt arī kešēta!!!), kur vienkārši pateiksit atļauju klasei atkartot visus metodus klasē. Tāpēc, ja ir metode ar nosaukumu pasūtījums() un metode ar nosaukumu uzņēmums(), šīs automātiski tiks atkartotas, lai jūs varētu vienkārši izpildīt $Permissions->has('pasūtījums.lasīt') vai $Permissions->has('uzņēmums.lasīt') un tas strādās. To definēt ir ārkārtīgi grūti, tāpēc palieciet šeit kopā ar mani. Jums vienkārši jāizdara šādi:

Izveidojiet atļauju klases grupēšanai.

class ManasAtļaujas {
    public function pasūtījums(string $current_role, int $pasūtījuma_id = 0): array {
        // kods, lai noteiktu atļaujas
        return $atļaujas_masīvs;
    }

    public function uzņēmums(string $current_role, int $uzņēmuma_id): array {
        // kods, lai noteiktu atļaujas
        return $atļaujas_masīvs;
    }
}

Tad padarīt atļaujas atrodamas, izmantojot šo bibliotēku.

$Atļaujas = new \flight\Permission($current_role);
$Atļaujas->defineRulesFromClassMethods(ManasAtļaujas::class);
Flight::set('permissions', $Atļaujas);

Visbeidzot, zvaniet atļaujai savā kodā, lai pārbaudītu, vai lietotājam ir atļauts veikt noteiktu atļauju.

class DažsKontrolieris {
    public function izveidotPasūtījumu() {
        if(Flight::get('permissions')->can('pasūtījums.izveidot') === false) {
            die('Jums nav atļauts izveidot pasūtījumu. Atvainojiet!');
        }
    }
}

Kešošana

Lai iespējotu kešošanu, skatiet vienkāršo wruczak/phpfilecache bibliotēku. Zemāk ir piemērs, kā iespējot to.


// šis $app var būt daļa no jūsu koda vai
// varat vienkārši padot null, un tas tiks iegūts
// no Flight::app() konstruktorā
$app = Flight::app();

// Pašlaik tas pieņem šo vienumu kā failu kešu. Citus var viegli
// pievienot nākotnē. 
$Kešatmiņa = new Wruczek\PhpFailaKešatmiņa\PhpFailaKešatmiņa;

$Atļaujas = new \flight\Permission($current_role, $app, $Kešatmiņa);
$Atļaujas->defineRulesFromClassMethods(ManasAtļaujas::class, 3600); // 3600 ir cik daudz sekundes to kešot. Atstājiet to uz neatcelšanu

Un dodieties!

Awesome-plugins/simple_job_queue

Vienkārša Darba Rinda

Vienkārša Darba Rinda ir bibliotēka, ko var izmantot, lai apstrādātu darbus asinkroni. To var izmantot ar beanstalkd, MySQL/MariaDB, SQLite un PostgreSQL.

Instalēt

composer require n0nag0n/simple-job-queue

Izmantošana

Lai tas darbotos, jums nepieciešams veids, kā pievienot darbus rindai un veids, kā apstrādāt darbus (darbinieks). Tālāk ir sniegti piemēri, kā pievienot darbu rindai un kā apstrādāt darbu.

Pievienošana Flight

Šīs pievienošana Flight ir vienkārša un tiek veikta, izmantojot metodi register(). Tālāk ir piemērs, kā to pievienot Flight.

<?php
require 'vendor/autoload.php';

// Mainiet ['mysql'] uz ['beanstalkd'], ja vēlaties izmantot beanstalkd
Flight::register('queue', n0nag0n\Job_Queue::class, ['mysql'], function($Job_Queue) {
    // ja jums jau ir PDO savienojums ar Flight::db();
    $Job_Queue->addQueueConnection(Flight::db());

    // vai, ja izmantojat beanstalkd/Pheanstalk
    $pheanstalk = Pheanstalk\Pheanstalk::create('127.0.0.1');
    $Job_Queue->addQueueConnection($pheanstalk);
});

Jauna darba pievienošana

Kad pievienojat darbu, jums jānorāda caurule (rinda). Tas ir salīdzināms ar kanālu RabbitMQ vai cauruli beanstalkd.

<?php
Flight::queue()->selectPipeline('send_important_emails');
Flight::queue()->addJob(json_encode([ 'something' => 'that', 'ends' => 'up', 'a' => 'string' ]));

Darbinieka palaišana

Šeit ir piemēra fails, kā palaist darbinieku.

<?php

require 'vendor/autoload.php';

$Job_Queue = new n0nag0n\Job_Queue('mysql');
// PDO savienojums
$PDO = new PDO('mysql:dbname=testdb;host=127.0.0.1', 'user', 'pass');
$Job_Queue->addQueueConnection($PDO);

// vai, ja izmantojat beanstalkd/Pheanstalk
$pheanstalk = Pheanstalk\Pheanstalk::create('127.0.0.1');
$Job_Queue->addQueueConnection($pheanstalk);

$Job_Queue->watchPipeline('send_important_emails');
while(true) {
    $job = $Job_Queue->getNextJobAndReserve();

    // pielāgojiet, kā jums labāk guļ naktī (tikai datu bāzu rindām, beanstalkd šī instrukcija nav nepieciešama)
    if(empty($job)) {
        usleep(500000);
        continue;
    }

    echo "Apstrādā {$job['id']}\n";
    $payload = json_decode($job['payload'], true);

    try {
        $result = doSomethingThatDoesSomething($payload);

        if($result === true) {
            $Job_Queue->deleteJob($job);
        } else {
            // tas izņem to no gatavo rindu un ievieto citā rindā, kuru var paņemt un "izsist" vēlāk.
            $Job_Queue->buryJob($job);
        }
    } catch(Exception $e) {
        $Job_Queue->buryJob($job);
    }
}

Ilgu Procesu Apstrāde ar Supervisord

Supervisord ir procesu kontroles sistēma, kas nodrošina, ka jūsu darbinieku procesi paliek aktīvi nepārtraukti. Šeit ir detalizētāks ceļvedis, kā to iestatīt ar savu Vienkāršo Darba Rindu darbinieku:

Supervisord instalēšana

# Uz Ubuntu/Debian
sudo apt-get install supervisor

# Uz CentOS/RHEL
sudo yum install supervisor

# Uz macOS ar Homebrew
brew install supervisor

Darbinieka skripta izveide

Vispirms saglabājiet savu darbinieka kodu veltītā PHP failā:

<?php

require 'vendor/autoload.php';

$Job_Queue = new n0nag0n\Job_Queue('mysql');
// PDO savienojums
$PDO = new PDO('mysql:dbname=your_database;host=127.0.0.1', 'username', 'password');
$Job_Queue->addQueueConnection($PDO);

// Iestatiet cauruli, kuru vēlaties uzraudzīt
$Job_Queue->watchPipeline('send_important_emails');

// Ierakstiet darbinieka sākumu
echo date('Y-m-d H:i:s') . " - Darbinieks uzsākts\n";

while(true) {
    $job = $Job_Queue->getNextJobAndReserve();

    if(empty($job)) {
        usleep(500000); // Miega 0.5 sekundes
        continue;
    }

    echo date('Y-m-d H:i:s') . " - Apstrādā darba {$job['id']}\n";
    $payload = json_decode($job['payload'], true);

    try {
        $result = doSomethingThatDoesSomething($payload);

        if($result === true) {
            $Job_Queue->deleteJob($job);
            echo date('Y-m-d H:i:s') . " - Darbs {$job['id']} veiksmīgi pabeigts\n";
        } else {
            $Job_Queue->buryJob($job);
            echo date('Y-m-d H:i:s') . " - Darbs {$job['id']} neizdevās, aprakts\n";
        }
    } catch(Exception $e) {
        $Job_Queue->buryJob($job);
        echo date('Y-m-d H:i:s') . " - Izņēmums apstrādājot darbu {$job['id']}: {$e->getMessage()}\n";
    }
}

Supervisord konfigurēšana

Izveidojiet konfigurācijas failu savam darbiniekam:

[program:email_worker]
command=php /path/to/worker.php
directory=/path/to/project
autostart=true
autorestart=true
startretries=3
stderr_logfile=/var/log/simple_job_queue_err.log
stdout_logfile=/var/log/simple_job_queue.log
user=www-data
numprocs=2
process_name=%(program_name)s_%(process_num)02d

Galvenās konfigurācijas opcijas:

Darbinieku pārvaldība ar Supervisorctl

Pēc konfigurācijas izveides vai modificēšanas:

# Pārlādēt supervisor konfigurāciju
sudo supervisorctl reread
sudo supervisorctl update

# Kontrolēt konkrētus darbinieku procesus
sudo supervisorctl start email_worker:*
sudo supervisorctl stop email_worker:*
sudo supervisorctl restart email_worker:*
sudo supervisorctl status email_worker:*

Vairāku Cauruļu Palaišana

Vairāku cauruļu gadījumā izveidojiet atsevišķus darbinieku failus un konfigurācijas:

[program:email_worker]
command=php /path/to/email_worker.php
# ... citas konfigurācijas ...

[program:notification_worker]
command=php /path/to/notification_worker.php
# ... citas konfigurācijas ...

Uzraudzība un Ieraksti

Pārbaudiet ierakstus, lai uzraudzītu darbinieku aktivitāti:

# Apskatīt ierakstus
sudo tail -f /var/log/simple_job_queue.log

# Pārbaudīt statusu
sudo supervisorctl status

Šis iestatījums nodrošina, ka jūsu darba darbinieki turpina darboties, pat pēc avārijām, servera restartēšanas vai citiem jautājumiem, padarot jūsu rindu sistēmu uzticamu ražošanas vidēm.

Awesome-plugins/index

Lieliskie spraudņi

Flight ir ļoti paplašināms. Ir daudz spraudņu, kas var tikt izmantoti, lai pievienotu funkcionalitāti jūsu Flight lietojumprogrammai. Daži no tiem oficiāli tiek atbalstīti no Flight komandas, savukārt citi ir mikro/lite bibliotēkas, lai palīdzētu jums sākt.

Kešošana

Kešošana ir lieliska veids, kā paātrināt jūsu lietojumprogrammu. Ir daudz kešošanas bibliotēku, kas var tikt izmantotas ar Flight.

Dīversija

Dīversija ir būtiska, kad jūs izstrādājat savā lokālajā vide. Ir daži spraudņi, kas var uzlabot jūsu dīversijas pieredzi.

Datubāzes

Datubāzes ir vairumam lietojumprogrammu pamats. Tā ir veids, kā saglabāt un atgūt datus. Dažas datubāzu bibliotēkas vienkārši ir wrapperi, lai rakstītu vaicājumus, bet dažas ir pilnvērtīgi ORM.

Sesija

Sesijas nav īsti noderīgas API, bet, lai izveidotu tīmekļa lietojumprogrammu, sesijas var būt būtiskas, lai saglabātu stāvokli un pieteikšanās informāciju.

Templēšana

Templēšana ir būtiska jebkurai tīmekļa lietojumprogrammai ar lietotāja saskarni. Ir daudz templēšanas dzinēju, kas var tikt izmantoti ar Flight.

Contributing

Vai jums ir spraudnis, ko vēlaties koplietot? Iesniedziet pieprasījumu pull, lai to pievienotu sarakstam!

Awesome-plugins/ghost_session

Ghostff/Session

PHP sesijas pārvaldnieks (nebloķējošs, mirkļa, segments, sesijas šifrēšana). Izmanto PHP open_ssl, lai opcijas šifrētu/atšifrētu sesijas datus. Atbalsta failus, MySQL, Redis un Memcached.

Noklikšķiniet šeit, lai apskatītu kodu.

Instalācija

Instalējiet ar composer.

composer require ghostff/session

Pamata konfigurācija

Jums nav nepieciešams nodot neko, lai izmantotu noklusējuma iestatījumus ar savu sesiju. Jūs varat izlasīt par citiem iestatījumiem Github Readme.


use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

// viena lieta, kas jāatceras, ir tā, ka jums ir jāpievieno sava sesija katru reizi, kad ielādējat lapu
// vai jums būs jāizpilda auto_commit savā konfigurācijā.

Vienkāršs piemērs

Šeit ir vienkāršs piemērs, kā jūs varētu to lietot.

Flight::route('POST /login', function() {
    $session = Flight::session();

    // šeit paveiciet savu pieteikšanās loģiku
    // validējiet paroli u.c.

    // ja pieteikšanās ir veiksmīga
    $session->set('is_logged_in', true);
    $session->set('user', $user);

    // jebkurā reizē, kad rakstāt uz sesiju, jums jāpievieno tas apzināti.
    $session->commit();
});

// Šī pārbaude var būt ierobežotajā lapas loģikā vai iesaiņota ar starpprogrammu.
Flight::route('/some-restricted-page', function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }

    // šeit paveiciet savu ierobežotās lapas loģiku
});

// starpprogrammas versija
Flight::route('/some-restricted-page', function() {
    // parastā lapas loģika
})->addMiddleware(function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }
});

Vairāk sarežģīts piemērs

Šeit ir sarežģītāks piemērs, kā jūs varētu to lietot.


use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

// norādiet pielāgotu ceļu uz savu sesijas konfigurācijas failu un piešķiriet tam nejaušu virkni sesijas ID
$app->register('session', Session::class, [ 'path/to/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) {
        // vai jūs varat manuāli pārrakstīt konfigurācijas opcijas
        $session->updateConfiguration([
            // ja vēlaties glabāt sesijas datus datubāzē (labs, ja vēlaties kaut ko līdzīgu, "atslēgt mani visās ierīcēs" funkcionalitāte)
            Session::CONFIG_DRIVER        => Ghostff\Session\Drivers\MySql::class,
            Session::CONFIG_ENCRYPT_DATA  => true,
            Session::CONFIG_SALT_KEY      => hash('sha256', 'my-super-S3CR3T-salt'), // lūdzu, mainiet to uz kaut ko citu
            Session::CONFIG_AUTO_COMMIT   => true, // dariet to tikai, ja tas ir nepieciešams un/vai ir grūti pievienot() jūsu sesiju.
                                                   // papildus varat veikt Flight::after('start', function() { Flight::session()->commit(); });
            Session::CONFIG_MYSQL_DS         => [
                'driver'    => 'mysql',             # Datubāzes vadītājs PDO dns piem. (mysql:host=...;dbname=...)
                'host'      => '127.0.0.1',         # Datubāzes host
                'db_name'   => 'my_app_database',   # Datubāzes nosaukums
                'db_table'  => 'sessions',          # Datubāzes tabula
                'db_user'   => 'root',              # Datubāzes lietotājvārds
                'db_pass'   => '',                  # Datubāzes parole
                'persistent_conn'=> false,          # Izvairieties no jaunas savienojuma izveides katru reizi, kad skripts vēlas runāt ar datubāzi, kas nodrošinās ātrāku tīmekļa lietojumprogrammu. ATRAST GRŪTI SEV
            ]
        ]);
    }
);

Palīdzība! Mana sesijas dati netiek saglabāti!

Vai jūs iestatāt savus sesijas datus un tie netiek saglabāti starp pieprasījumiem? Iespējams, ka esat aizmirsis pievienot savus sesijas datus. Jūs varat to izdarīt, izsaucot $session->commit(), kad esat iestatījis savus sesijas datus.

Flight::route('POST /login', function() {
    $session = Flight::session();

    // šeit paveiciet savu pieteikšanās loģiku
    // validējiet paroli u.c.

    // ja pieteikšanās ir veiksmīga
    $session->set('is_logged_in', true);
    $session->set('user', $user);

    // jebkurā reizē, kad rakstāt uz sesiju, jums jāpievieno tas apzināti.
    $session->commit();
});

Otra opcija, kā to izdarīt, ir tad, kad jūs iestatāt savu sesijas pakalpojumu, jums jānorāda auto_commit kā true savā konfigurācijā. Tas automātiski pievienos jūsu sesijas datus pēc katra pieprasījuma.


$app->register('session', Session::class, [ 'path/to/session_config.php', bin2hex(random_bytes(32)) ], function(Session $session) {
        $session->updateConfiguration([
            Session::CONFIG_AUTO_COMMIT   => true,
        ]);
    }
);

Turklāt jūs varat veikt Flight::after('start', function() { Flight::session()->commit(); });, lai pievienotu savus sesijas datus pēc katra pieprasījuma.

Dokumentācija

Apmeklējiet Github Readme, lai iegūtu pilnu dokumentāciju. Konfigurācijas opcijas ir labs dokumentēts default_config.php failā. Kods ir vienkāršs saprast, ja vēlaties pats izpētīt šo pakotni.

Awesome-plugins/pdo_wrapper

PdoWrapper PDO Palīgklase

Flight ir palīgklase PDO. Tas ļauj viegli vaicāt savu datu bāzi ar visu sagatavoto/izpildīto/fetchAll() šaubību. Tas ievērojami vienkāršo, kā jūs varat vaicāt savu datu bāzi. Katra rindas rezultāts tiek atgriezts kā "Flight Collection" klase, kas ļauj piekļūt datiem, izmantojot masīva sintaksi vai objekta sintaksi.

Reģistrējot PDO Palīgklasi

// Reģistrējiet PDO palīgklasi
Flight::register('db', \flight\database\PdoWrapper::class, ['mysql:host=localhost;dbname=cool_db_name', 'user', 'pass', [
        PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'utf8mb4\'',
        PDO::ATTR_EMULATE_PREPARES => false,
        PDO::ATTR_STRINGIFY_FETCHES => false,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
    ]
]);

Lietošana

Šis objekts paplašina PDO, tāpēc visi normālie PDO metodēs ir pieejami. Tika pievienotas šādas metodes, lai atvieglotu datu bāzes vaicājumu veikšanu:

runQuery(string $sql, array $params = []): PDOStatement

Izmantojiet šo INSERTS, UPDATE vai ja plānojat izmantot SELECT cilpas iekšā

$db = Flight::db();
$statement = $db->runQuery("SELECT * FROM table WHERE something = ?", [ $something ]);
while($row = $statement->fetch()) {
    // ...
}

// Vai ierakstiet datubāzē
$db->runQuery("INSERT INTO table (name) VALUES (?)", [ $name ]);
$db->runQuery("UPDATE table SET name = ? WHERE id = ?", [ $name, $id ]);

fetchField(string $sql, array $params = []): mixed

Izvelk pirmo lauku no vaicājuma

$db = Flight::db();
$count = $db->fetchField("SELECT COUNT(*) FROM table WHERE something = ?", [ $something ]);

fetchRow(string $sql, array $params = []): array

Izvelk vienu rindu no vaicājuma

$db = Flight::db();
$row = $db->fetchRow("SELECT id, name FROM table WHERE id = ?", [ $id ]);
echo $row['name'];
// vai
echo $row->name;

fetchAll(string $sql, array $params = []): array

Izvelk visus rindas no vaicājuma

$db = Flight::db();
$rows = $db->fetchAll("SELECT id, name FROM table WHERE something = ?", [ $something ]);
foreach($rows as $row) {
    echo $row['name'];
    // vai
    echo $row->name;
}

Piezīme par IN() sintaksi

Tai ir noderīga aploksne IN() apgalvojumiem. Vienu jautājuma zīmi vienkārši varat padot kā vietotni IN() un pēc tam masīvu ar vērtībām. Šeit ir piemērs, kā tas varētu izskatīties:

$db = Flight::db();
$name = 'Bob';
$company_ids = [1,2,3,4,5];
$rows = $db->fetchAll("SELECT id, name FROM table WHERE name = ? AND company_id IN (?)", [ $name, $company_ids ]);

Pilns piemērs

// Piemēra maršruts un kā jūs izmantotu šo apvalku
Flight::route('/users', function () {
    // Iegūt visus lietotājus
    $users = Flight::db()->fetchAll('SELECT * FROM users');

    // Plūsmas visi lietotāji
    $statement = Flight::db()->runQuery('SELECT * FROM users');
    while ($user = $statement->fetch()) {
        echo $user['name'];
        // vai echo $user->name;
    }

    // Iegūt vienu lietotāju
    $user = Flight::db()->fetchRow('SELECT * FROM users WHERE id = ?', [123]);

    // Iegūt vienu vērtību
    $count = Flight::db()->fetchField('SELECT COUNT(*) FROM users');

    // Speciālā IN() sintakse, lai palīdzētu (pārliecinieties, ka IN ir lieli burti)
    $users = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [[1,2,3,4,5]]);
    // jūs varētu arī darīt šo
    $users = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [ '1,2,3,4,5']);

    // Ievietot jaunu lietotāju
    Flight::db()->runQuery("INSERT INTO users (name, email) VALUES (?, ?)", ['Bob', 'bob@example.com']);
    $insert_id = Flight::db()->lastInsertId();

    // Atjaunināt lietotāju
    Flight::db()->runQuery("UPDATE users SET name = ? WHERE id = ?", ['Bob', 123]);

    // Dzēst lietotāju
    Flight::db()->runQuery("DELETE FROM users WHERE id = ?", [123]);

    // Iegūt ietekmēto rindu skaitu
    $statement = Flight::db()->runQuery("UPDATE users SET name = ? WHERE name = ?", ['Bob', 'Sally']);
    $affected_rows = $statement->rowCount();

});

Awesome-plugins/migrations

Migrācijas

Migrācija jūsu projektam uzrauga visus datu bāzes izmaiņas, kas saistītas ar jūsu projektu.
byjg/php-migration ir ļoti noderīga kodola bibliotēka, lai jūs varētu sākt.

Instalēšana

PHP bibliotēka

Ja vēlaties izmantot tikai PHP bibliotēku savā projektā:

composer require "byjg/migration"

Komandrindas interfeiss

Komandrindas interfeiss ir patstāvīgs un neprasa to instalēt kopā ar jūsu projektu.

Jūs varat instalēt globāli un izveidot simbolisko saiti.

composer require "byjg/migration-cli"

Lūdzu, apmeklējiet byjg/migration-cli, lai iegūtu vairāk informācijas par Migrācijas CLI.

Atbalstītās datu bāzes

Datu bāze Dzinējs Savienojuma virkne
Sqlite pdo_sqlite sqlite:///path/to/file
MySql/MariaDb pdo_mysql mysql://lietotāja_vārds:parole@hostname:ports/datu_bāze
Postgres pdo_pgsql pgsql://lietotāja_vārds:parole@hostname:ports/datu_bāze
Sql Server pdo_dblib, pdo_sysbase Linux dblib://lietotāja_vārds:parole@hostname:ports/datu_bāze
Sql Server pdo_sqlsrv Windows sqlsrv://lietotāja_vārds:parole@hostname:ports/datu_bāze

Kā tas darbojas?

Datu bāzes migrācija izmanto TĪRU SQL, lai pārvaldītu datu bāzes versijas.
Lai tas darbotos, jums nepieciešams:

SQL skripti

Skripti ir sadalīti trīs skriptu grupās:

Skriptu direktorija ir:

 <root dir>
     |
     +-- base.sql
     |
     +-- /migrations
              |
              +-- /up
                   |
                   +-- 00001.sql
                   +-- 00002.sql
              +-- /down
                   |
                   +-- 00000.sql
                   +-- 00001.sql

Multi izstrādes vide

Ja strādājat ar vairākiem izstrādātājiem un vairākiem zara, ir grūti noteikt nākamo numuru.

Šajā gadījumā jums ir papildinājums "-dev" pēc versijas numura.

Skatiet scenāriju:

Abos gadījumos izstrādātāji izveidos failu ar nosaukumu 43-dev.sql. Abi izstrādātāji pārskatīs UP un DOWN bez problēmām, un jūsu lokālā versija būs 43.

Bet izstrādātājs 1 apvieno jūsu izmaiņas un izveido gala versiju 43.sql (git mv 43-dev.sql 43.sql). Ja izstrādātājs 2 atjauninās jūsu vietējo zaru, viņam būs fails 43.sql (no izstrādātāja 1) un jūsu fails 43-dev.sql.
Ja viņš mēģina migrēt UP vai DOWN, migrācijas skripts uzrakstīs un brīdinās viņu, ka ir DIVAS versijas 43. Šajā gadījumā izstrādātājam 2 būs jāatjaunina jūsu fails uz 44-dev.sql un jāturpina strādāt līdz apvienojat jūsu izmaiņas un ģenerējat gala versiju.

PHP API izmantošana un integrēšana savos projektos

Pamatlietošana ir

Skatiet piemēru:

<?php
// Izveidojiet savienojuma URI
// Skatiet vairāk: https://github.com/byjg/anydataset#connection-based-on-uri
$connectionUri = new \ByJG\Util\Uri('mysql://migrateuser:migratepwd@localhost/migratedatabase');

// Reģistrējiet datu bāzi vai datu bāzes, kas var apstrādāt šo URI:
\ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);

// Izveidojiet migrācijas instance
$migration = new \ByJG\DbMigration\Migration($connectionUri, '.');

// Pievienojiet atgriezenisko saiti progresam, lai saņemtu informāciju par izpildi
$migration->addCallbackProgress(function ($action, $currentVersion, $fileInfo) {
    echo "$action, $currentVersion, ${fileInfo['description']}\n";
});

// Atjaunojiet datu bāzi, izmantojot "base.sql" skriptu
// un palaidiet VISUS esošos skriptus, lai paaugstinātu datu bāzes versiju līdz jaunākajai versijai
$migration->reset();

// Palaidiet VISUS esošos skriptus, lai paaugstinātu vai samazinātu datu bāzes versiju
// no pašreizējās versijas līdz $version numuram;
// Ja versijas numurs nav noteikts, migrējiet līdz pēdējai datu bāzes versijai
$migration->update($version = null);

Migrācijas objekts kontrolē datu bāzes versiju.

Izstrādājot versiju kontroli savā projektā

<?php
// Reģistrējiet datu bāzi vai datu bāzes, kas var apstrādāt šo URI:
\ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);

// Izveidojiet migrācijas instance
$migration = new \ByJG\DbMigration\Migration($connectionUri, '.');

// Šī komanda izveidos versijas tabulu jūsu datu bāzē
$migration->createVersion();

Iegūstot pašreizējo versiju

<?php
$migration->getCurrentVersion();

Pievienojiet atgriezenisko saiti, lai kontrolētu progresu

<?php
$migration->addCallbackProgress(function ($command, $version, $fileInfo) {
    echo "Veicot komandu: $command pie versijas $version - ${fileInfo['description']}, ${fileInfo['exists']}, ${fileInfo['file']}, ${fileInfo['checksum']}\n";
});

Iegūstot Db Dzinēja instanci

<?php
$migration->getDbDriver();

Lai to izmantotu, lūdzu, apmeklējiet: https://github.com/byjg/anydataset-db

Daļēju migrāciju novēršana (nav pieejama MySQL)

Daļēja migrācija ir tad, ja migrācijas skripts tiek pārtraukts procesa vidū kļūdas vai manuālas pārtraukšanas dēļ.

Migrācijas tabula būs ar statusu daļējs uz augšu vai daļējs uz leju, un to nepieciešams labot manuāli, pirms var atkārtoti migrēt.

Lai izvairītos no šīs situācijas, jūs varat norādīt, ka migrācija tiks izpildīta transakcijas kontekstā.
Ja migrācijas skripts neizdodas, transakcija tiks atcelta, un migrācijas tabula tiks iezīmēta kā pabeigta, un versija būs tūlītēji iepriekšējā versija pirms skripta, kas izraisīja kļūdu.

Lai šo funkciju aktivizētu, jums jāizsauc metode withTransactionEnabled, nododot true kā parametru:

<?php
$migration->withTransactionEnabled(true);

PIEZĪME: Šī funkcija nav pieejama MySQL, jo tas neatbalsta DDL komandas transakcijas ietvaros.
Ja jūs izmantosiet šo metodi ar MySQL, migrācija to klusi ignorēs.
Vairāk informācijas: https://dev.mysql.com/doc/refman/8.0/en/cannot-roll-back.html

Ieteikumi SQL migrāciju rakstīšanai Postgres

Par trigeru un SQL funkciju izveidi

-- DARI
CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
    BEGIN
        -- Pārbaudiet, vai ir norādīts empname un alga
        IF NEW.empname IS NULL THEN
            RAISE EXCEPTION 'empname nedrīkst būt null'; -- nav svarīgi, vai šie komentāri ir tukši vai nē
        END IF; --

        IF NEW.salary IS NULL THEN
            RAISE EXCEPTION '% nedrīkst būt null alga', NEW.empname; --
        END IF; --

        -- Kas strādā pie mums, kad viņiem par to jāmaksā?
        IF NEW.salary < 0 THEN
            RAISE EXCEPTION '% nedrīkst būt negatīva alga', NEW.empname; --
        END IF; --

        -- Atcerieties, kurš izmainīja algu, kad
        NEW.last_date := current_timestamp; --
        NEW.last_user := current_user; --
        RETURN NEW; --
    END; --
$emp_stamp$ LANGUAGE plpgsql;

-- NEDARI
CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
    BEGIN
        -- Pārbaudiet, vai ir norādīts empname un alga
        IF NEW.empname IS NULL THEN
            RAISE EXCEPTION 'empname nedrīkst būt null';
        END IF;
        IF NEW.salary IS NULL THEN
            RAISE EXCEPTION '% nedrīkst būt null alga', NEW.empname;
        END IF;

        -- Kas strādā pie mums, kad viņiem par to jāmaksā?
        IF NEW.salary < 0 THEN
            RAISE EXCEPTION '% nedrīkst būt negatīva alga', NEW.empname;
        END IF;

        -- Atcerieties, kurš izmainīja algu, kad
        NEW.last_date := current_timestamp;
        NEW.last_user := current_user;
        RETURN NEW;
    END;
$emp_stamp$ LANGUAGE plpgsql;

Tā kā PDO datu bāzes abstrakcijas slānis nevar izpildīt SQL komandu partijas, kad byjg/migration lasa migrācijas failu, tas ir jāizdala visus SQL faila saturus pie semikolu un jāizpilda komandas viena pa viena.
Tomēr ir viens veids, kā komanda var saturēt vairākas semikolas tās ķermenī: funkcijas.

Lai pareizi analizētu funkcijas, byjg/migration 2.1.0 sāka sadalīt migrācijas failus pēc semikola + EOL secības, nevis tikai pēc semikolas.
Šādā veidā, ja jūs pievienojat tukšu komentāru pēc katra iekšējā semikola funkcijas definīcijā, byjg/migration to varēs pareizi analizēt.

Diemžēl, ja jūs aizmirsīsiet pievienot kādu no šiem komentāriem, bibliotēka sadalīs CREATE FUNCTION paziņojumu multiple parts, un migrācija neizdosies.

Izvairieties no kolonnas rakstzīmes (:)

-- DARI
CREATE TABLE bookings (
  booking_id UUID PRIMARY KEY,
  booked_at  TIMESTAMPTZ NOT NULL CHECK (CAST(booked_at AS DATE) <= check_in),
  check_in   DATE NOT NULL
);

-- NEDARI
CREATE TABLE bookings (
  booking_id UUID PRIMARY KEY,
  booked_at  TIMESTAMPTZ NOT NULL CHECK (booked_at::DATE <= check_in),
  check_in   DATE NOT NULL
);

Tā kā PDO izmanto kolonnas rakstzīmi, lai prefixētu nosauktos parametrus sagatavotās komandas, tās izmantošana izraisa to, ka tas aptrūkst citos kontekstos.

Piemēram, PostgreSQL komandas var izmantot ::, lai konvertētu vērtības starp tipiem.
No otras puses, PDO to uztvers kā nederīgu nosauktu parametru nederīgā kontekstā un neizdosies, kad tas mēģinās to izpildīt.

Vienīgā veida, kā izlabot šo neatbilstību, ir pilnībā izvairīties no kolonnām (šajā gadījumā PostgreSQL ir alternatīva sintakse: CAST(value AS type)).

Izmantojiet SQL redaktoru

Visbeidzot, manuālas SQL migrāciju rakstīšana var būt nogurdinoša, taču to ir ievērojami vieglāk izdarīt, ja izmantojat redaktoru, kas spēj saprast SQL sintaksi, piedāvā pabeigšanu, introspektē jūsu pašreizējo datu bāzes shēmu un / vai automātiski formatē jūsu kodu.

Dažādu migrāciju apstrāde vienā shēmā

Ja jums ir jāizveido dažādi migrācijas skripti un versijas vienā shēmā, tas ir iespējams, bet tas ir ļoti riskanti un es neieteiktu to darīt.

Lai to izdarītu, jums jāizveido dažādas "migrācijas tabulas", nododot parametru konstruktora parametrā.

<?php
$migration = new \ByJG\DbMigration\Migration("db:/uri", "/path", true, "JAUNA_MIGRĀCIJAS_TABULAS_NOSAUKUMS");

Drošības apsvērumu dēļ šī funkcija nav pieejama komandrindā, bet jūs varat izmantot vides mainīgo MIGRATION_VERSION, lai glabātu nosaukumu.

Mēs patiešām iesakām neizmantot šo funkciju. Ieteikums ir viena migrācija vienai shēmā.

Vienības testu izpilde

Pamatvienības testus var izpildīt ar:

vendor/bin/phpunit

Datu bāzu testu izpilde

Lai veiktu integrācijas testus, jums jābūt datu bāzēm, kas darbojas. Mēs esam nodrošinājuši pamata docker-compose.yml, un jūs varat to izmantot, lai uzsāktu datu bāzes testēšanai.

Datu bāzu palaidīšana

docker-compose up -d postgres mysql mssql

Testu izpilde

vendor/bin/phpunit
vendor/bin/phpunit tests/SqliteDatabase*
vendor/bin/phpunit tests/MysqlDatabase*
vendor/bin/phpunit tests/PostgresDatabase*
vendor/bin/phpunit tests/SqlServerDblibDatabase*
vendor/bin/phpunit tests/SqlServerSqlsrvDatabase*

Pēc izvēles jūs varat iestatīt resursdatora un paroles iestatījumus, ko izmanto vienības testos.

export MYSQL_TEST_HOST=localhost     # noklusējums uz localhost
export MYSQL_PASSWORD=newpassword    # izmantojiet '.', ja vēlaties nulles paroli
export PSQL_TEST_HOST=localhost      # noklusējums uz localhost
export PSQL_PASSWORD=newpassword     # izmantojiet '.', ja vēlaties nulles paroli
export MSSQL_TEST_HOST=localhost     # noklusējums uz localhost
export MSSQL_PASSWORD=Pa55word
export SQLITE_TEST_HOST=/tmp/test.db      # noklusējums uz /tmp/test.db

Awesome-plugins/session

FlightPHP Sesija - Viegls Failu Bāzes Sesiju Apstrādātājs

Šis ir viegls, failu bāzes sesiju apstrādātāja paplašinājums Flight PHP Framework. Tas nodrošina vienkāršu, taču jaudīgu risinājumu sesiju pārvaldīšanai, ar tādām funkcijām kā neblokējoša sesiju lasīšana, opcionalā šifrēšana, automātiskā apstiprināšana un testa režīms izstrādei. Sesiju dati tiek glabāti failos, padarot to ideāli piemērotu lietojumprogrammām, kurām nav nepieciešama datu bāze.

Ja vēlaties izmantot datu bāzi, apskatiet ghostff/session paplašinājumu ar daudzām no šīm pašām funkcijām, bet ar datu bāzes atbalstu.

Apmeklējiet Github repozitoriju pilnīgai avota kodu un detaļu apskatei.

Instalācija

Uzstādiet paplašinājumu, izmantojot Composer:

composer require flightphp/session

Pamata Lietošana

Šeit ir vienkāršs piemērs, kā izmantot flightphp/session paplašinājumu savā Flight lietojumprogrammā:

require 'vendor/autoload.php';

use flight\Session;

$app = Flight::app();

// Reģistrējiet sesiju pakalpojumu
$app->register('session', Session::class);

// Piemēra maršruta izmantošana ar sesiju
Flight::route('/login', function() {
    $session = Flight::session();
    $session->set('user_id', 123);
    $session->set('username', 'johndoe');
    $session->set('is_admin', false);

    echo $session->get('username'); // Izvade: johndoe
    echo $session->get('preferences', 'default_theme'); // Izvade: default_theme

    if ($session->get('user_id')) {
        Flight::json(['message' => 'Lietotājs ir pieteicies!', 'user_id' => $session->get('user_id')]);
    }
});

Flight::route('/logout', function() {
    $session = Flight::session();
    $session->clear(); // Notīra visus sesiju datus
    Flight::json(['message' => 'Veiksmīgi izrakstījās']);
});

Flight::start();

Galvenie Punkti

Konfigurācija

Jūs varat pielāgot sesiju apstrādātāju, pārsūtot opciju masīvu, reģistrējot:

$app->register('session', Session::class, [
    'save_path' => '/custom/path/to/sessions',         // Direktorija sesiju failiem
    'encryption_key' => 'a-secure-32-byte-key-here',   // Iespējot šifrēšanu (32 baiti ieteicami AES-256-CBC)
    'auto_commit' => false,                            // Atspējot automātisko apstiprināšanu manuālai kontrolei
    'start_session' => true,                           // Automātiski uzsākt sesiju (noklusējums: true)
    'test_mode' => false                               // Iespējot testa režīmu izstrādei
]);

Konfigurācijas Opcijas

Opcija Apraksts Noklusējuma Vērtība
save_path Direktorija, kurā glabājas sesiju faili sys_get_temp_dir() . '/flight_sessions'
encryption_key Atslēga AES-256-CBC šifrēšanai (nopietna) null (nav šifrēšanas)
auto_commit Automātiski saglabāt sesiju datus izbeigšanās brīdī true
start_session Automātiski uzsākt sesiju true
test_mode Darbība testa režīmā bez PHP sesiju ietekmes false
test_session_id Pielāgota sesijas ID testa režīmā (opcijas) Nejauši ģenerēts, ja nav iestatīts

Uzlabota Lietošana

Manuāla Apstiprināšana

Ja atspējojat automātisko apstiprināšanu, jums manuāli jāsaglabā izmaiņas:

$app->register('session', Session::class, ['auto_commit' => false]);

Flight::route('/update', function() {
    $session = Flight::session();
    $session->set('key', 'value');
    $session->commit(); // Skaidri saglabāt izmaiņas
});

Sesijas Drošība ar Šifrēšanu

Iespējot šifrēšanu sensitīviem datiem:

$app->register('session', Session::class, [
    'encryption_key' => 'your-32-byte-secret-key-here'
]);

Flight::route('/secure', function() {
    $session = Flight::session();
    $session->set('credit_card', '4111-1111-1111-1111'); // Automātiski šifrēts
    echo $session->get('credit_card'); // Atšifrēts pie atgūšanas
});

Sesijas Atjaunošana

Atjaunojiet sesijas ID drošībai (piemēram, pēc pieteikšanās):

Flight::route('/post-login', function() {
    $session = Flight::session();
    $session->regenerate(); // Jauns ID, saglabā datus
    // VAI
    $session->regenerate(true); // Jauns ID, izdzēš vecos datus
});

Middleware Piemērs

Aizsargājiet maršrutus ar sesiju balstītu autentifikāciju:

Flight::route('/admin', function() {
    Flight::json(['message' => 'Laipni lūdzam administratora panelī']);
})->addMiddleware(function() {
    $session = Flight::session();
    if (!$session->get('is_admin')) {
        Flight::halt(403, 'Piekļuve liegta');
    }
});

Tas ir tikai vienkāršs piemērs, kā izmantot šo vidusdaļā. Detalizētākai piemēram skatiet middleware dokumentāciju.

Metodes

Session klase nodrošina šīs metodes:

Visas metodes, izņemot get() un id(), atgriež Session instance, lai saistītu izsaukumus.

Kāpēc Izmantot Šo Paplašinājumu?

Tehniskās Detaļas

Ieguldījumi

Ieguldījumi ir laipni gaidīti! Forkojiet rep(res-zitoriju, veiciet izmaiņas un iesniedziet pull pieprasījumu. Ziņojiet par kļūdām vai ieteiciet funkcijas, izmantojot Github problēmu izsekošanu.

Licences

Šis paplašinājums ir licencēts saskaņā ar MIT licenci. Lai iegūtu detaļas, skatiet Github repozitoriju.

Awesome-plugins/runway

Lidmašīnas

Lidmašīnas ir CLI lietotne, kas palīdz pārvaldīt jūsu Flight lietojumprogrammas. Tā var ģenerēt kontrolierus, parādīt visus maršrutus un vairāk. Tā balstīta uz lielisko adhocore/php-cli bibliotēku.

Uzklikšķiniet šeit, lai skatītu kodu.

Instalēšana

Instalējiet to ar komponistu.

composer require flightphp/runway

Pamata konfigurācija

Pirmo reizi palaižot Lidmašīnas, tā vadīs jūs caur iestatīšanas procesu un izveidos .runway.json konfigurācijas failu jūsu projekta saknē. Šajā failā būs dažas nepieciešamās konfigurācijas, lai Lidmašīnas pareizi darbotos.

Lietojums

Lidmašīnā ir vairākas komandas, ar kurām varat pārvaldīt savu Flight lietojumprogrammu. Ir divi viegli veidi, kā izmantot Lidmašīnas.

  1. Ja izmantojat ietvaru projektu, varat izpildīt php runway [komanda] no savu projekta saknes.
  2. Ja izmantojat Lidmašīnas kā paketi, kas instalēts ar komponistu, varat izpildīt vendor/bin/runway [komanda] no savu projekta saknes.

Lai iegūtu papildinformāciju par jebkuru komandu, jūs varat padot --help karodziņa.

php runway routes --help

Šeit ir daži piemēri:

Ģenerēt kontrolieri

Balstoties uz konfigurāciju jūsu .runway.json failā, noklusējuma atrašanās vieta jums ģenerēs kontrolieri app/controllers/ direktorijā.

php runway make:controller MyController

Ģenerēt aktīvās ierakstu modeles

Balstoties uz konfigurāciju jūsu .runway.json failā, noklusējuma atrašanās vieta jums ģenerēs kontrolieri app/records/ direktorijā.

php runway make:record users

Ja, piemēram, ir users tabula ar sekojošu shēmu: id, name, email, created_at, updated_at, fails līdzīgs sekojošajam tiks izveidots app/records/UserRecord.php failā:

<?php

declare(strict_types=1);

namespace app\records;

/**
 * ActiveRecord klase lietotāju tabulai.
 * @link https://docs.flightphp.com/awesome-plugins/active-record
 * 
 * @property int $id
 * @property string $name
 * @property string $email
 * @property string $created_at
 * @property string $updated_at
 * // šeit jūs varat pievienot attiecības, kad tās definētas $relations masīvā
 * @property CompanyRecord $company Attēlots attiecību piemērs
 */
class UserRecord extends \flight\ActiveRecord
{
    /**
     * @var array $relations Uzstādiet attiecības modeļim
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $relations = [];

    /**
     * Konstruktors
     * @param mixed $databaseConnection Datu bāzes savienojums
     */
    public function __construct($databaseConnection)
    {
        parent::__construct($databaseConnection, 'users');
    }
}

Parādīt visus maršrutus

Tas parādīs visus maršrutus, kas pašlaik ir reģistrēti ar Flight.

php runway routes

Ja vēlaties skatīt tikai konkrētus maršrutus, jūs varat padot karodziņu, lai filtrētu maršrutus.

# Parādīt tikai GET maršrutus
php runway routes --get

# Parādīt tikai POST maršrutus
php runway routes --post

# u.c.

Lidmašīnas pielāgošana

Ja jūs izveidojat paketi Flight, vai vēlaties pievienot savas pielāgotas komandas savā projektā, to varat izdarīt, izveidojot src/commands/, flight/commands/, app/commands/ vai commands/ direktoriju savam projektam/paketei.

Lai izveidotu komandu, jums vienkārši jāpaplašina AbstractBaseCommand klase un jāimplementē vismaz __construct metode un execute metode.

<?php

declare(strict_types=1);

namespace flight\commands;

class ExampleCommand extends AbstractBaseCommand
{
    /**
     * Konstruktors
     *
     * @param array<string,mixed> $config JSON konfigurācija no .runway-config.json
     */
    public function __construct(array $config)
    {
        parent::__construct('make:example', 'Izveidot piemēru dokumentācijai', $config);
        $this->argument('<funny-gif>', 'Smaida GIF nosaukums');
    }

    /**
     * Izpilda funkciju
     *
     * @return void
     */
    public function execute(string $controller)
    {
        $io = $this->app()->io();

        $io->info('Izveido piemēru...');

        // Kaut ko dariet šeit

        $io->ok('Piemērs izveidots!');
    }
}

Skatiet adhocore/php-cli Dokumentāciju, lai iegūtu vairāk informācijas par to, kā izveidot savas pielāgotas komandas savā Flight lietojumprogrammā!

Awesome-plugins/tracy_extensions

Tracy Flight Panel Paplašinājumi

Tas ir paplašinājumu kopums, lai padarītu darbu ar Flight nedaudz bagātāku.

Tas ir Panelis

Flight Bar

Un katrs panelis rāda ļoti noderīgu informāciju par jūsu lietojumprogrammu!

Flight Data Flight Database Flight Request

Noklikšķiniet šeit, lai apskatītu kodu.

Uzstādīšana

Izpildiet composer require flightphp/tracy-extensions --dev un jūs esat ceļā!

Konfigurācija

Ir ļoti maz konfigurācijas, ko jūs vajadzētu veikt, lai sāktu darbu. Jums būs jāinicializē Tracy tīklā, pirms to izmantosiet https://tracy.nette.org/en/guide:

<?php

use Tracy\Debugger;
use flight\debug\tracy\TracyExtensionLoader;

// bootstrap kods
require __DIR__ . '/vendor/autoload.php';

Debugger::enable();
// Jums var būt nepieciešams norādīt savu vidi ar Debugger::enable(Debugger::DEVELOPMENT)

// ja jūsu lietojumprogrammā izmantojat datubāzes savienojumus, ir 
// nepieciešama PDO iesaiņojums, ko izmantot TIKAI ATTISTĪBĀ (ne ražošanā, lūdzu!)
// Tam ir tādi paši parametri kā parastajam PDO savienojumam
$pdo = new PdoQueryCapture('sqlite:test.db', 'user', 'pass');
// vai, ja to pievienojat Flight ietvaram
Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'user', 'pass']);
// tagad, kad jūs veicat vaicājumu, tas reģistrēs laiku, vaicājumu un parametrus

// Tas savieno punktus
if(Debugger::$showBar === true) {
    // Tam jābūt nepatiesam, vai Tracy patiešām nevar attēlot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

// vēl kods

Flight::start();

Papildu konfigurācija

Sesijas dati

Ja jums ir pielāgota sesijas apstrādātājs (piemēram, ghostff/session), jūs varat nodot jebkuru sesiju datu masīvu Tracy un tas automātiski to izvadīs jums. Jūs to pārsūtāt ar session_data atslēgu otrajā parametru TracyExtensionLoader konstruktorā.


use Ghostff\Session\Session;
// vai izmantojiet flight\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

if(Debugger::$showBar === true) {
    // Tam jābūt nepatiesam, vai Tracy patiešām nevar attēlot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]);
}

// maršruti un citas lietas...

Flight::start();

Latte

Ja jums ir Latte uzstādīts jūsu projektā, jūs varat izmantot Latte paneli, lai analizētu savus veidnes. Jūs varat nodot Latte instanci TracyExtensionLoader konstruktoram ar latte atslēgu otrajā parametru.


use Latte\Engine;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('latte', Engine::class, [], function($latte) {
    $latte->setTempDirectory(__DIR__ . '/temp');

    // šeit jūs pievienojat Latte paneli Tracy
    $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension);
});

if(Debugger::$showBar === true) {
    // Tam jābūt nepatiesam, vai Tracy patiešām nevar attēlot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

Awesome-plugins/apm

FlightPHP APM Dokumentācija

Laipni lūdzam FlightPHP APM — jūsu lietotnes personīgais veiktspējas treneris! Šis ceļvedis ir jūsu maršruts, lai iestatītu, lietotu un apgūtu Lietojumprogrammu veiktspējas uzraudzību (APM) ar FlightPHP. Neatkarīgi no tā, vai jūs meklējat lēnas pieprasījuma vai vienkārši vēlaties izpētīt latentuma grafikus, mēs jums palīdzēsim. Padarīsim jūsu lietotni ātrāku, jūsu lietotājus laimīgākus un jūsu atkļūdošanas sesijas vieglākas!

Kāpēc APM ir svarīgs

Iedomājieties sekojošo: jūsu lietotne ir aizņemts restorāns. Bez veida, kā izsekot, cik ilgi pasūtījumi tiek veikti vai kur virtuvē ir kavēšanās, jūs minat, kādēļ klienti aiziet neapmierināti. APM ir jūsu sous-chef — tas uzrauga katru soli, sākot no ienākošiem pieprasījumiem līdz datu bāzes vaicājumiem, un noraksta visu, kas palēnina jūsu gaitu. Lēnas lapas zaudē lietotājus (pētījumi apgalvo, ka 53% pamet, ja vietne ielādējas ilgāk par 3 sekundēm!), un APM palīdz jums pamanīt šīs problēmas pirms tās jums sāp. Tas ir proaktīvs prāta miers — mazāk "kāpēc tas ir saplēsts?" mirkļu, vairāk "skaties, cik gludi tas darbojas!" uzvaras.

Instalācija

Sāciet ar Composer:

composer require flightphp/apm

Jums būs nepieciešams:

Sākums

Šeit ir jūsu soli pa solim uz APM lielisko pasauli:

1. Reģistrējiet APM

Ievietojiet šo kodu savā index.php vai services.php failā, lai sāktu uzraudzību:

use flight\apm\logger\LoggerFactory;
use flight\Apm;

$ApmLogger = LoggerFactory::create(__DIR__ . '/../../.runway-config.json');
$Apm = new Apm($ApmLogger);
$Apm->bindEventsToFlightInstance($app);

Kas notiek šeit?

Pro padoms: Paraugu ņemšana Ja jūsu lietotne ir aizņemta, katra pieprasījuma žurnāļu saglabāšana var palielināt slodzi. Izmantojiet paraugu likmi (no 0.0 līdz 1.0):

$Apm = new Apm($ApmLogger, 0.1); // Žurnāli 10% pieprasījumu

Tas uztur veiktspēju ātru, vienlaikus sniedzot jums kvalitatīvus datus.

2. Konfigurējiet to

Izpildiet šo, lai izveidotu savu .runway-config.json:

php vendor/bin/runway apm:init

Kas tas dara?

Kāpēc divas vietas? Neapstrādātās metrikas ātri sakrājas (domājiet par filtrētām žurnālu datnēm). Darbinieks tās apstrādā struktūrētā galamērķī priekš paneļa. Uztur lietas kārtībā!

3. Apstrādājiet metrikas ar darbinieku

Darbinieks pārveido neapstrādātās metrikas par paneļa gataviem datiem. Izpildiet to vienreiz:

php vendor/bin/runway apm:worker

Kas tas dara?

Turpiniet darbināt to Dzīvām lietotnēm jūs vēlēsieties nepārtrauktu apstrādi. Šeit ir jūsu iespējas:

Kāpēc uztraukties? Bez darbinieka jūsu panelis ir tukšs. Tas ir tilts starp neapstrādātajiem žurnāliem un rīcībai nepieciešamajiem ieskatiem.

4. Palaižiet paneli

Redziet jūsu lietotnes vitālos datus:

php vendor/bin/runway apm:dashboard

Kas tas?

Pielāgojiet to:

php vendor/bin/runway apm:dashboard --host 0.0.0.0 --port 8080 --php-path=/usr/local/bin/php

Piekļūstiet URL savā pārlūkprogrammā un izpētiet!

Ražošanas režīms

Ražošanā jums, iespējams, nāksies izmēģināt dažādas tehnikas, lai panāktu paneļa darbību, jo ir iespējams, ka tur ir ugunsmūri un citi drošības pasākumi. Šeit ir dažas iespējas:

Vēlaties citu paneli?

Ja vēlaties, varat izveidot savu paneli! Pārlūkojiet vendor/flightphp/apm/src/apm/presenter direktoriju, lai iegūtu idejas par to, kā prezentēt datus savai panelei!

Paneļa funkcijas

Panelis ir jūsu APM HQ — šeit ir tas, ko jūs redzēsiet:

Papildinājumi:

Piemērs: Pieprasījums uz /users varētu parādīt:

Pievienojot pielāgotus notikumus

Izsekojiet jebko — kā API zvanu vai maksājumu procesu:

use flight\apm\CustomEvent;

$app->eventDispatcher()->emit('apm.custom', new CustomEvent('api_call', [
    'endpoint' => 'https://api.example.com/users',
    'response_time' => 0.25,
    'status' => 200
]));

Kur tas tiks parādīts? Paneļa pieprasījumu detalizētās sadaļas zem "Pielāgoti notikumi" — izplatināms ar jauku JSON formātu.

Izmantošanas gadījums:

$start = microtime(true);
$apiResponse = file_get_contents('https://api.example.com/data');
$app->eventDispatcher()->emit('apm.custom', new CustomEvent('external_api', [
    'url' => 'https://api.example.com/data',
    'time' => microtime(true) - $start,
    'success' => $apiResponse !== false
]));

Tagad jūs redzēsiet, vai tas API palēnina jūsu lietotni!

Datu bāzes uzraudzība

Izsekojiet PDO vaicājumus šādi:

use flight\database\PdoWrapper;

$pdo = new PdoWrapper('sqlite:/path/to/db.sqlite');
$Apm->addPdoConnection($pdo);

Ko jūs iegūstat:

Uzziniet:

Piemēra izvade:

Darbinieka opcijas

Regulējiet darbinieku pēc saviem vēlmēm:

Piemērs:

php vendor/bin/runway apm:worker --daemon --batch_size 100 --timeout 3600

Darbojas stundu, apstrādājot 100 metrikas vienlaikus.

Problēmu risināšana

Iestiprinat? Izmēģiniet šos:

Awesome-plugins/tracy

Tracy

Tracy ir fantastisks kļūdu apstrādātājs, ko var izmantot ar Flight. Tam ir vairākas panelis, kas var palīdzēt jums atkļūdot jūsu lietojumprogrammu. Ir ļoti viegli paplašināt un pievienot savus paneļus. Flight komanda ir izveidojusi dažus paneļus speciāli Flight projektam, izmantojot flightphp/tracy-extensions spraudni.

Instalācija

Instalējiet ar komponistu. Un jums faktiski vajadzēs instalēt to bez izstrādes versijas, jo Tracy tiek piegādāts ar ražošanas kļūdu apstrādes komponentu.

composer require tracy/tracy

Pamata konfigurācija

Ir dažas pamata konfigurācijas opcijas, lai sāktu. Par tām varat lasīt vairāk Tracy dokumentācijā.


require 'vendor/autoload.php';

use Tracy\Debugger;

// Iespējot Tracy
Debugger::enable();
// Debugger::enable(Debugger::DEVELOPMENT) // dažreiz ir jābūt skaidrai (arī Debugger::PRODUCTION)
// Debugger::enable('23.75.345.200'); // varat norādīt arī IP adreses masīvu

// Šeit tiks reģistrēti kļūdas un izņēmumi. Pārliecinieties, ka šis katalogs pastāv un ir rakstāms.
Debugger::$logDirectory = __DIR__ . '/../log/';
Debugger::$strictMode = true; // rādīt visas kļūdas
// Debugger::$strictMode = E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED; // visas kļūdas, izņemot novecojušus paziņojumus
if (Debugger::$showBar) {
    $app->set('flight.content_length', false); // ja Tracy josla ir redzama, tad Flight nevar iestatīt satura garumu

    // Tas ir specifisks Tracy paplašinājumam Flight, ja jūs to esat iekļāvuši
    // pretējā gadījumā komentējiet to.
    new TracyExtensionLoader($app);
}

Noderīgi padomi

Kad jūs atkļūvojat savu kodu, ir dažas ļoti noderīgas funkcijas, lai izvadītu datus jums.

Awesome-plugins/active_record

Flight Aktīvais Ieraksts

Aktīvais ieraksts ir datubāzes entitātes kartēšana uz PHP objektu. Sakot vienkārši, ja jums ir lietotāju tabula jūsu datubāzē, jūs varat "tulkot" rindu šajā tabulā uz User klasi un $user objektu jūsu kodā. Skatiet pamatu piemēru.

Noklikšķiniet šeit uz noliktavas GitHub.

Pamatu Piemērs

Pieņemam, ka jums ir šāda tabula:

CREATE TABLE users (
    id INTEGER PRIMARY KEY, 
    name TEXT, 
    password TEXT 
);

Tagad jūs varat izveidot jaunu klasi, lai attēlotu šo tabulu:

/**
 * Aktīvā ieraksta klase parasti ir vienskaitļa formā
 * 
 * Ieteicams pievienot tabulas īpašības kā komentārus šeit
 * 
 * @property int    $id
 * @property string $name
 * @property string $password
 */ 
class User extends flight\ActiveRecord {
    public function __construct($database_connection)
    {
        // jūs to varat iestatīt šādā veidā
        parent::__construct($database_connection, 'users');
        // vai šādā veidā
        parent::__construct($database_connection, null, [ 'table' => 'users']);
    }
}

Tagad skatiet, kā notiek burvība!

// sqlite gadījumā
$database_connection = new PDO('sqlite:test.db'); // tas ir tikai piemēram, jūs, iespējams, izmantotu reālu datubāzes savienojumu

// mysql gadījumā
$database_connection = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'username', 'password');

// vai mysqli
$database_connection = new mysqli('localhost', 'username', 'password', 'test_db');
// vai mysqli bez objektu balstīta izveidošana
$database_connection = mysqli_connect('localhost', 'username', 'password', 'test_db');

$user = new User($database_connection);
$user->name = 'Bobby Tables';
$user->password = password_hash('kāds foršs parole');
$user->insert();
// vai $user->save();

echo $user->id; // 1

$user->name = 'Joseph Mamma';
$user->password = password_hash('kāds foršs parole atkal!!!');
$user->insert();
// šeit nevar izmantot $user->save(), jo tas domās, ka tas ir atjauninājums!

echo $user->id; // 2

Un bija tik viegli pievienot jaunu lietotāju! Tagad, kad datubāzē ir lietotāja rinda, kā to izvilkt?

$user->find(1); // atrast id = 1 datubāzē un atgriezt to.
echo $user->name; // 'Bobby Tables'

Un kas notiks, ja vēlaties atrast visus lietotājus?

$users = $user->findAll();

Ko teikt par noteiktu nosacījumu?

$users = $user->like('name', '%mamma%')->findAll();

Redzat, cik tas ir aizraujoši? Instalēsim to un sāksim!

Instalācija

Vienkārši instalējiet ar Composer

composer require flightphp/active-record

Izmantošana

To var izmantot kā patstāvīgu bibliotēku vai kopā ar Flight PHP rāmci. Pilnīgi atkarīgs no jums.

Patstāvīgi

Vienkārši pārliecinieties, ka nododat PDO savienojumu konstruktoram.

$pdo_connection = new PDO('sqlite:test.db'); // tas ir tikai piemēram, jūs, iespējams, izmantotu reālu datubāzes savienojumu

$User = new User($pdo_connection);

Negribiet katru reizi iestatīt savu datubāzes savienojumu konstruktorā? Skatiet Datubāzes Savienojuma Pārvaldība citām idejām!

Reģistrēt kā metodi Flight

Ja jūs izmantojat Flight PHP rāmi, varat reģistrēt aktīvā ieraksta klasi kā pakalpojumu, bet jums to patiesībā nav jāizdara.

Flight::register('user', 'User', [ $pdo_connection ]);

// tad jūs varat to izmantot šādi kontrolierī, funkcijā utt.

Flight::user()->find(1);

runway Metodes

runway ir CLI rīks Flight, kas ir izstrādāts ar īpašu komandu šai bibliotēkai.

# Izmantošana
php runway make:record database_table_name [class_name]

# Piemērs
php runway make:record users

Tas izveidos jaunu klasi mapē app/records/ kā UserRecord.php ar sekojošo saturu:

<?php

declare(strict_types=1);

namespace app\records;

/**
 * Aktīvā ieraksta klase lietotāju tabulai.
 * @link https://docs.flightphp.com/awesome-plugins/active-record
 *
 * @property int $id
 * @property string $username
 * @property string $email
 * @property string $password_hash
 * @property string $created_dt
 */
class UserRecord extends \flight\ActiveRecord
{
    /**
     * @var array $relations Iestatīt attiecības modelim
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $relations = [
        // 'relation_name' => [ self::HAS_MANY, 'RelatedClass', 'foreign_key' ],
    ];

    /**
     * Konstruktor
     * @param mixed $databaseConnection Savienojums ar datubāzi
     */
    public function __construct($databaseConnection)
    {
        parent::__construct($databaseConnection, 'users');
    }
}

CRUD funkcijas

find($id = null) : boolean|ActiveRecord

Atrast vienu ierakstu un piešķirt to pašreizējam objektam. Ja jūs nododat $id kādu vērtību, tas veiks meklēšanu pēc primārā atslēga ar šo vērtību. Ja nekas netiek nodots, tas vienkārši atradīs pirmo ierakstu tabulā.

Turklāt jūs varat nodot tam citas palīgmetodes, lai vaicātu jūsu tabulu.

// atrast ierakstu ar dažiem nosacījumiem iepriekš
$user->notNull('password')->orderBy('id DESC')->find();

// atrast ierakstu pēc noteikta id
$id = 123;
$user->find($id);

findAll(): array<int,ActiveRecord>

Atrast visus ierakstus tabulā, kuru jūs norādāt.

$user->findAll();

isHydrated(): boolean (v0.4.0)

Atgriež true, ja pašreizējais ieraksts ir bijis hidrogenizēts (iegūts no datubāzes).

$user->find(1);
// ja ir atrasts ieraksts ar datiem...
$user->isHydrated(); // true

insert(): boolean|ActiveRecord

Ievieto pašreizējo ierakstu datubāzē.

$user = new User($pdo_connection);
$user->name = 'demo';
$user->password = md5('demo');
$user->insert();
Teksta balstītas primārās atslēgas

Ja jums ir teksta balstīta primārā atslēga (piemēram, UUID), jūs varat iestatīt primārās atslēgas vērtību pirms ievietošanas vienā no diviem veidiem.

$user = new User($pdo_connection, [ 'primaryKey' => 'uuid' ]);
$user->uuid = 'some-uuid';
$user->name = 'demo';
$user->password = md5('demo');
$user->insert(); // vai $user->save();

vai jūs varat ļaut primārajai atslēgai automātiski tikt ģenerētai jūsu vietā.

class User extends flight\ActiveRecord {
    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users', [ 'primaryKey' => 'uuid' ]);
        // jūs varat arī iestatīt primāro atslēgu šādā veidā, nevis augstāk norādītajā masīvā.
        $this->primaryKey = 'uuid';
    }

    protected function beforeInsert(self $self) {
        $self->uuid = uniqid(); // vai kā citādi nepieciešams ģenerēt jūsu unikālos id
    }
}

Ja jūs neiestatāt primāro atslēgu pirms ievietošanas, tā tiks iestatīta uz rowid un datubāze to ģenerēs jums, taču tā neuzturēsies, jo šis lauks var nepastāvēt jūsu tabulā. Tāpēc ieteicams izmantot notikumu, lai automātiski to apstrādātu.

update(): boolean|ActiveRecord

Atjaunina pašreizējo ierakstu datubāzē.

$user->greaterThan('id', 0)->orderBy('id desc')->find();
$user->email = 'test@example.com';
$user->update();

save(): boolean|ActiveRecord

Ievieto vai atjaunina pašreizējo ierakstu datubāzē. Ja ierakstam ir id, tas atjauninās, citādi tas ievietos.

$user = new User($pdo_connection);
$user->name = 'demo';
$user->password = md5('demo');
$user->save();

Piezīme: Ja jums ir attiecības, kas definētas klasē, tās tiek rekurzīvi saglabātas, ja tās ir bijušas definētas, instancētas un ir netīri dati, ko atjaunināt. (v0.4.0 un augstāks)

delete(): boolean

Dzēš pašreizējo ierakstu no datubāzes.

$user->gt('id', 0)->orderBy('id desc')->find();
$user->delete();

Jūs arī varat dzēst vairākus ierakstus, veicot meklēšanu iepriekš.

$user->like('name', 'Bob%')->delete();

dirty(array $dirty = []): ActiveRecord

Netīri dati attiecas uz datiem, kas ir mainīti ierakstā.

$user->greaterThan('id', 0)->orderBy('id desc')->find();

// šajā brīdī nav "netīru" datu.

$user->email = 'test@example.com'; // tagad e-pasts tiek uzskatīts par "netīru", jo tas ir mainījies.
$user->update();
// tagad nav nevienu datu, kas ir netīri, jo tie ir atjaunināti un uzglabāti datubāzē

$user->password = password_hash('jaunā parole'); // tagad šis ir netīrs
$user->dirty(); // neko nenododot, tiks notīrīti visi netīrie ieraksti.
$user->update(); // nekas netiks atjaunināts, jo nekas netika sagūstīts kā netīrs.

$user->dirty([ 'name' => 'kaut kas', 'password' => password_hash('cita parole') ]);
$user->update(); // gan vārds, gan parole tiek atjaunināti.

copyFrom(array $data): ActiveRecord (v0.4.0)

Tas ir alias dirty() metodei. Tas ir nedaudz vairāk skaidrāks par to, ko jūs darāt.

$user->copyFrom([ 'name' => 'kaut kas', 'password' => password_hash('cita parole') ]);
$user->update(); // abi vārds un parole tiek atjaunināti.

isDirty(): boolean (v0.4.0)

Atgriež true, ja pašreizējais ieraksts ir mainīts.

$user->greaterThan('id', 0)->orderBy('id desc')->find();
$user->email = 'test@email.com';
$user->isDirty(); // true

reset(bool $include_query_data = true): ActiveRecord

Atjauno pašreizējo ierakstu tā sākotnējā stāvoklī. Tas ir ļoti labi izmantot ciklu tipa uzvedībā. Ja nododat true, tas arī atiestatīs vaicājuma datus, kas tika izmantoti, lai atrastu pašreizējo objektu (pamatuzvedība).

$users = $user->greaterThan('id', 0)->orderBy('id desc')->find();
$user_company = new UserCompany($pdo_connection);

foreach($users as $user) {
    $user_company->reset(); // sāk ar tīru lapu
    $user_company->user_id = $user->id;
    $user_company->company_id = $some_company_id;
    $user_company->insert();
}

getBuiltSql(): string (v0.4.1)

Pēc tam, kad esat izpildījis find(), findAll(), insert(), update(), vai save() metodi, jūs varat iegūt SQL, kas tika izveidots un izmantot to problēmu risināšanai.

SQL Vaicājumu Metodes

select(string $field1 [, string $field2 ... ])

Jūs varat atlasīt tikai dažus no kolonnām tabulā, ja vēlaties (tas ir efektīvāk tiešām plašām tabulām ar daudzām kolonnām)

$user->select('id', 'name')->find();

from(string $table)

Tehniski jūs varat izvēlēties arī citu tabulu! Kāpēc gan ne?!

$user->select('id', 'name')->from('user')->find();

join(string $table_name, string $join_condition)

Jūs pat varat pievienot citu tabulu datubāzē.

$user->join('contacts', 'contacts.user_id = users.id')->find();

where(string $where_conditions)

Jūs varat iestatīt dažus pielāgotus where argumentus (jūs nevarat iestatīt parametrus šajā where paziņojumā)

$user->where('id=1 AND name="demo"')->find();

Drošības Piezīme - Iespējams, ka jūs sadarbojas ar kaut ko līdzīgu $user->where("id = '{$id}' AND name = '{$name}'")->find();. Lūdzu, NEDARĪT TO!!! Tas var būt pakļauts tam, ko sauc par SQL injekcijas uzbrukumiem. Ir daudz rakstu tiešsaistē, lūdzu, Google "sql injekcijas uzbrukumi php" un jūs atradīsiet daudz rakstu par šo tēmu. Pareizā metode, kā to apstrādāt ar šo bibliotēku, ir tā, ka, nevis šo where() metodi, jūs to darītu vairāk līdzīgi $user->eq('id', $id)->eq('name', $name)->find();. Ja jums ir absolūti jādara tā, PDO bibliotēkai ir $pdo->quote($var), lai to izdzēstu priekš jums. Tikai pēc tam, kad esat izmantojuši quote(), varat to izmantot where() paziņojumā.

group(string $group_by_statement)/groupBy(string $group_by_statement)

Grupējiet savus rezultātus pēc noteikta nosacījuma.

$user->select('COUNT(*) as count')->groupBy('name')->findAll();

order(string $order_by_statement)/orderBy(string $order_by_statement)

Kārtot atgriezto vaicājumu noteiktā veidā.

$user->orderBy('name DESC')->find();

limit(string $limit)/limit(int $offset, int $limit)

Ierobežojiet atgriezto ierakstu skaitu. Ja tiek norādīta otrā int, tā būs offset, limits tieši tāpat kā SQL.

$user->orderby('name DESC')->limit(0, 10)->findAll();

WHERE nosacījumi

equal(string $field, mixed $value) / eq(string $field, mixed $value)

Kur field = $value

$user->eq('id', 1)->find();

notEqual(string $field, mixed $value) / ne(string $field, mixed $value)

Kur field <> $value

$user->ne('id', 1)->find();

isNull(string $field)

Kur field IS NULL

$user->isNull('id')->find();

isNotNull(string $field) / notNull(string $field)

Kur field IS NOT NULL

$user->isNotNull('id')->find();

greaterThan(string $field, mixed $value) / gt(string $field, mixed $value)

Kur field > $value

$user->gt('id', 1)->find();

lessThan(string $field, mixed $value) / lt(string $field, mixed $value)

Kur field < $value

$user->lt('id', 1)->find();

greaterThanOrEqual(string $field, mixed $value) / ge(string $field, mixed $value) / gte(string $field, mixed $value)

Kur field >= $value

$user->ge('id', 1)->find();

lessThanOrEqual(string $field, mixed $value) / le(string $field, mixed $value) / lte(string $field, mixed $value)

Kur field <= $value

$user->le('id', 1)->find();

like(string $field, mixed $value) / notLike(string $field, mixed $value)

Kur field LIKE $value vai field NOT LIKE $value

$user->like('name', 'de')->find();

in(string $field, array $values) / notIn(string $field, array $values)

Kur field IN($value) vai field NOT IN($value)

$user->in('id', [1, 2])->find();

between(string $field, array $values)

Kur field BETWEEN $value AND $value1

$user->between('id', [1, 2])->find();

OR Nosacījumi

Ir iespējams savus nosacījumus ietīt OR paziņojumā. To var izdarīt, izmantojot startWrap() un endWrap() metodi vai norādīt 3. parametru nosacījumam pēc lauka un vērtības.

// Metode 1
$user->eq('id', 1)->startWrap()->eq('name', 'demo')->or()->eq('name', 'test')->endWrap('OR')->find();
// Tas novērtēs `id = 1 AND (name = 'demo' OR name = 'test')`

// Metode 2
$user->eq('id', 1)->eq('name', 'demo', 'OR')->find();
// Tas novērtēs `id = 1 OR name = 'demo'`

Attiecības

Jūs varat iestatīt vairākus veidus attiecības, izmantojot šo bibliotēku. Jūs varat iestatīt vienu->daudz un vienu->vienu attiecības starp tabulām. Tas prasa mazliet papildus sagatavošanu klasē iepriekš.

Iestatīt $relations masīvu nav grūti, bet pareizā sintakse var būt mulsinoša.

protected array $relations = [
    // jūs varat nosaukt atslēgu kā vēlaties. Aktīvā ieraksta nosaukums, iespējams, ir labs. Piemērs: lietotājs, kontakts, klients
    'user' => [
        // obligāti
        // self::HAS_MANY, self::HAS_ONE, self::BELONGS_TO
        self::HAS_ONE, // šis ir attiecību veids

        // obligāti
        'Some_Class', // šī ir 'otra' Aktīvā ieraksta klase, uz kuru atsaucas

        // obligāti
        // atkarībā no attiecību veida
        // self::HAS_ONE = ārējā atslēga, kas atsaucas uz pievienošanu
        // self::HAS_MANY = ārējā atslēga, kas atsaucas uz pievienošanu
        // self::BELONGS_TO = lokālā atslēga, kas atsaucas uz pievienošanu
        'local_or_foreign_key',
        // tikai FYI, tas arī pievienojas tikai uz "otras" modeļa primāro atslēgu

        // izvēles
        [ 'eq' => [ 'client_id', 5 ], 'select' => 'COUNT(*) as count', 'limit' 5 ], // papildu nosacījumi, kurus vēlaties, pievienojot attiecību
        // $record->eq('client_id', 5)->select('COUNT(*) as count')->limit(5))

        // izvēles
        'back_reference_name' // ja vēlaties atsaukt šo attiecību atpakaļ uz sevi, piemēram, `$user->contact->user`;
    ];
]
class User extends ActiveRecord{
    protected array $relations = [
        'contacts' => [ self::HAS_MANY, Contact::class, 'user_id' ],
        'contact' => [ self::HAS_ONE, Contact::class, 'user_id' ],
    ];

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }
}

class Contact extends ActiveRecord{
    protected array $relations = [
        'user' => [ self::BELONGS_TO, User::class, 'user_id' ],
        'user_with_backref' => [ self::BELONGS_TO, User::class, 'user_id', [], 'contact' ],
    ];
    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'contacts');
    }
}

Tagad mums ir atsauces iestatītas, lai mēs varētu tās izmantot ļoti viegli!

$user = new User($pdo_connection);

// atrast jaunāko lietotāju.
$user->notNull('id')->orderBy('id desc')->find();

// iegūt kontaktus, izmantojot attiecību:
foreach($user->contacts as $contact) {
    echo $contact->id;
}

// vai mēs varam doties otrā virzienā.
$contact = new Contact();

// atrast vienu kontaktu
$contact->find();

// iegūt lietotāju, izmantojot attiecību:
echo $contact->user->name; // tas ir lietotāja vārds

Ļoti jauki, vai ne?

Iestatīt Pielāgotus Datus

Reizēm jums var būt nepieciešams pievienot kaut ko unikālu savam Aktīvam Ierakstam, piemēram, pielāgotu aprēķinu, kas varētu būt vieglāk pievienot objektam, kas pēc tam būtu nodots, piemēram, šablonam.

setCustomData(string $field, mixed $value)

Jūs pievienojat pielāgoto datu ar setCustomData() metodi.

$user->setCustomData('page_view_count', $page_view_count);

Un tad jūs vienkārši atsaucaties uz to kā uz normālu objekta īpašību.

echo $user->page_view_count;

Notikumi

Vēl viena super jauka funkcija šajā bibliotēkā ir notikumi. Notikumi tiek aktivizēti noteiktos brīžos, pamatojoties uz noteiktām metodēm, ko jūs izsaucat. Tie ir ļoti noderīgi, lai automātiski izveidotu datus jums.

onConstruct(ActiveRecord $ActiveRecord, array &config)

Tas ir ļoti noderīgi, ja nepieciešams iestatīt noklusējuma savienojumu vai kaut ko tamlīdzīgu.

// index.php vai bootstrap.php
Flight::register('db', 'PDO', [ 'sqlite:test.db' ]);

//
//
//

// User.php
class User extends flight\ActiveRecord {

    protected function onConstruct(self $self, array &$config) { // neaizmirstiet par & atsauci
        // jūs varētu to izdarīt, lai automātiski iestatītu savienojumu
        $config['connection'] = Flight::db();
        // vai arī šo
        $self->transformAndPersistConnection(Flight::db());

        // jūs varat arī šādi iestatīt tabulas nosaukumu.
        $config['table'] = 'users';
    } 
}

beforeFind(ActiveRecord $ActiveRecord)

Šis visticamāk ir noderīgs, ja jums nepieciešams vaicājuma manipulācija katru reizi.

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeFind(self $self) {
        // vienmēr palaist id >= 0, ja tā jums patīk
        $self->gte('id', 0); 
    } 
}

afterFind(ActiveRecord $ActiveRecord)

Šis visticamāk ir noderīgāks, ja jums katru reizi ir jāpalaista kāda loģika, kad šis ieraksts tiek iegūts. Vai jums jādešifrē kaut kas? Vai jums katru reizi jāveic pielāgots skaitīšanas vaicājums (neefektīvs, bet, nu...).

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function afterFind(self $self) {
        // kaut ko dešifrējot
        $self->secret = yourDecryptFunction($self->secret, $some_key);

        // varbūt glabājot kaut ko pielāgotu, piemēram, vaicājumu???
        $self->setCustomData('view_count', $self->select('COUNT(*) count')->from('user_views')->eq('user_id', $self->id)['count']; 
    } 
}

beforeFindAll(ActiveRecord $ActiveRecord)

Šis varētu būt tikai noderīgs, ja jums nepieciešama vaicājuma manipulācija katru reizi.

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeFindAll(self $self) {
        // vienmēr palaist id >= 0, ja tā jums patīk
        $self->gte('id', 0); 
    } 
}

afterFindAll(array<int,ActiveRecord> $results)

Līdzīgi afterFind(), bet jūs varat to izdarīt visiem ierakstiem!

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function afterFindAll(array $results) {

        foreach($results as $self) {
            // darīt kaut ko foršu līdzīgi kā afterFind()
        }
    } 
}

beforeInsert(ActiveRecord $ActiveRecord)

Ļoti noderīgi, ja nepieciešams iestatīt noklusējuma vērtības katru reizi.

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeInsert(self $self) {
        // iestatīt dažus labus noklusējumus
        if(!$self->created_date) {
            $self->created_date = gmdate('Y-m-d');
        }

        if(!$self->password) {
            $self->password = password_hash((string) microtime(true));
        }
    } 
}

afterInsert(ActiveRecord $ActiveRecord)

Varbūt jums ir lietotāja scenārijs, lai mainītu datus pēc ievietošanas?

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function afterInsert(self $self) {
        // jūs darāt sevi
        Flight::cache()->set('most_recent_insert_id', $self->id);
        // vai jebkas cits...
    } 
}

beforeUpdate(ActiveRecord $ActiveRecord)

Ļoti noderīgi, ja jums vajag dažas noklusējuma vērtības katru reizi atjaunināšanai.

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeInsert(self $self) {
        // iestatīt dažus labus noklusējumus
        if(!$self->updated_date) {
            $self->updated_date = gmdate('Y-m-d');
        }
    } 
}

afterUpdate(ActiveRecord $ActiveRecord)

Varbūt jums ir lietotāja gadījums, lai mainītu datus pēc atjaunināšanas?

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function afterInsert(self $self) {
        // jūs darāt sevi
        Flight::cache()->set('most_recently_updated_user_id', $self->id);
        // vai jebkas cits....
    } 
}

beforeSave(ActiveRecord $ActiveRecord)/afterSave(ActiveRecord $ActiveRecord)

Tas ir noderīgi, ja vēlaties, lai notikumi notiktu gan ievietošanas, gan atjaunināšanas laikā. Es ietaupīšu jums garu skaidrojumu, bet, esmu pārliecināts, ka jūs varat uzminēt, kas tas ir.

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeSave(self $self) {
        $self->last_updated = gmdate('Y-m-d H:i:s');
    } 
}

beforeDelete(ActiveRecord $ActiveRecord)/afterDelete(ActiveRecord $ActiveRecord)

Nezinu, ko jūs šeit vēlētos darīt, bet šeit nav spriedumu! Iet uz priekšu!

class User extends flight\ActiveRecord {

    public function __construct($database_connection)
    {
        parent::__construct($database_connection, 'users');
    }

    protected function beforeDelete(self $self) {
        echo 'Viņš bija drosmīgs karavīrs... :cry-face:';
    } 
}

Datubāzes Savienojuma Pārvaldība

Kad jūs izmantojat šo bibliotēku, jūs varat iestatīt datubāzes savienojumu dažādos veidos. Jūs varat iestatīt savienojumu konstruktorā, jūs varat iestatīt to caur konfigurācijas mainīgo $config['connection'] vai jūs varat iestatīt to caur setDatabaseConnection() (v0.4.1). 

$pdo_connection = new PDO('sqlite:test.db'); // piemēram
$user = new User($pdo_connection);
// vai
$user = new User(null, [ 'connection' => $pdo_connection ]);
// vai
$user = new User();
$user->setDatabaseConnection($pdo_connection);

Ja vēlaties izvairīties no katra reizes $database_connection iestatīšanas, ir veidi, kā to izdarīt!

// index.php vai bootstrap.php
// Iestatiet šo kā reģistrētu klasi Flight
Flight::register('db', 'PDO', [ 'sqlite:test.db' ]);

// User.php
class User extends flight\ActiveRecord {

    public function __construct(array $config = [])
    {
        $database_connection = $config['connection'] ?? Flight::db();
        parent::__construct($database_connection, 'users', $config);
    }
}

// Un tagad, nav nepieciešami argumenti!
$user = new User();

Piezīme: Ja plānojat veikt vienību testēšanu, to izdarot, var rasties grūtības, bet kopumā, jo jūs varat injicēt savu savienojumu ar setDatabaseConnection() vai $config['connection'], tas nav pārāk slikti.

Ja jums nepieciešams atsvaidzināt datubāzes savienojumu, piemēram, ja jūs veicat garu CLI skriptu un periodiski nepieciešams atsvaidzināt savienojumu, jūs varat atkārtoti iestatīt savienojumu ar $your_record->setDatabaseConnection($pdo_connection).

Ieteikums

Lūdzu, dariet to. :D

Iestatīšana

Kad jūs piedalāties, pārliecinieties, ka izpildāt composer test-coverage, lai uzturētu 100% testēšanas pārklājumu (šis nav patiesais vienību testēšanas pārklājums, drīzāk integrācijas testēšana).

Tāpat pārliecinieties, ka izpildāt composer beautify un composer phpcs, lai novērstu jebkādas linting kļūdas.

Licence

MIT

Awesome-plugins/latte

Kafija

Kafija ir pilnīgi aprīkota veidnes dzinējs, kurš ir ļoti viegli lietojams un jūtas tuvāk PHP sintaksei nekā Twig vai Smarty. To ir arī ļoti viegli paplašināt un pievienot savus filtrus un funkcijas.

Uzstādīšana

Uzstādiet ar komponistu.

composer require latte/latte

Pamata konfigurācija

Ir dažas pamata konfigurācijas iespējas, ar kurām sākt. Jūs varat lasīt vairāk par tām Kafijas dokumentācijā.


use Latte\Engine as LatteEngine;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('latte', LatteEngine::class, [], function(LatteEngine $latte) use ($app) {

    // Šeit Kafija saglabās jūsu veidnes, lai paātrinātu lietas
    // Viena jauka lieta par Kafiju ir tā, ka tā automātiski atsvaidzina jūsu
    // kešatmiņu, kad padarāt izmaiņas veidnēs!
    $latte->setTempDirectory(__DIR__ . '/../cache/');

    // Pateiciet Kafijai, kur būs jūsu skatu saknes direktorija.
    // $app->get('flight.views.path') ir iestatīts failā config.php
    // Jūs varētu arī vienkārši izdarīt kaut ko tādu kā `__DIR__ . '/../views/'`
    $latte->setLoader(new \Latte\Loaders\FileLoader($app->get('flight.views.path')));
});

Vienkāršs izkārtojuma piemērs

Šeit ir vienkāršs izkārtojuma faila piemērs. Šis fails tiks izmantots, lai iesaiņotu visus jūsu citus skatus.

<!-- app/views/layout.latte -->
<!doctype html>
<html lang="en">
    <head>
        <title>{$title ? $title . ' - '}Mans App</title>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <header>
            <nav>
                <!-- jūsu navigācijas elementi šeit -->
            </nav>
        </header>
        <div id="content">
            <!-- Šeit ir burvība -->
            {block content}{/block}
        </div>
        <div id="footer">
            &copy; Autortiesības
        </div>
    </body>
</html>

Un tagad mums ir jūsu fails, kas tiks renderēts iekšējā šajā satura blokā:

<!-- app/views/home.latte -->
<!-- Tas stāsta Kafijai, ka šis fails ir "iekšā" layout.latte failā -->
{extends layout.latte}

<!-- Šis ir saturs, kurš tiks renderēts iekšējā izkārtojumā iekšējā satura blokā -->
{block content}
    <h1>Mājas lapā</h1>
    <p>Laipni lūdzam mans app!</p>
{/block}

Tad, kad jūs ejat renderēt to iekšā savā funkcijā vai kontrolierī, jūs darītu kaut kas tāds:

// vienkāršs maršruts
Flight::route('/', function () {
    Flight::latte()->render('home.latte', [
        'title' => 'Mājas Lapā'
    ]);
});

// vai, ja izmantojat kontrolieri
Flight::route('/', [HomeController::class, 'index']);

// HomeController.php
class HomeController
{
    public function index()
    {
        Flight::latte()->render('home.latte', [
            'title' => 'Mājas Lapā'
        ]);
    }
}

Skatiet Kafijas dokumentāciju, lai iegūtu vairāk informācijas par to, kā izmantot Kafiju tā pilnīgākajā potenciālā!

Awesome-plugins/awesome_plugins

Forši spraudņi

Flight ir neticami paplašināms. Ir pieejams vairāk nekā daži spraudņi, kurus var izmantot, lai pievienotu funkcionalitāti jūsu Flight lietojumam. Daži no tiem tiek oficiāli atbalstīti no Flight komandas, bet citi ir mikro/vieglas bibliotēkas, lai palīdzētu jums sākt.

API Dokumentācija

API dokumentācija ir izšķiroša nozīme jebkuram API. Tā palīdz izstrādātājiem saprast, kā mijiedarboties ar jūsu API un ko gaidīt pretī. Ir pieejami vairāki rīki, lai palīdzētu jums ģenerēt API dokumentāciju jūsu Flight projektiem.

Lietojumprogrammu veiktspējas uzraudzība (APM)

Lietojumprogrammu veiktspējas uzraudzība (APM) ir izšķiroša nozīme jebkurai lietojumprogrammai. Tā palīdz jums saprast, kā jūsu lietojumprogramma darbojas un kur ir šaurās vietas. Ir pieejami vairāki APM rīki, kurus var izmantot kopā ar Flight.

Autentifikācija/Autorizācija

Autentifikācija un autorizācija ir izšķiroša nozīme jebkurai lietojumprogrammai, kas prasa noteikt kontroli par to, kas var piekļūt kam.

Kešatmiņa

Kešatmiņa ir lielisks veids, kā paātrināt jūsu lietojumprogrammu. Ir pieejamas vairākas kešatmiņas bibliotēkas, kuras var izmantot kopā ar Flight.

CLI

CLI lietojumprogrammas ir lielisks veids, kā mijiedarboties ar jūsu lietojumprogrammu. Jūs varat tās izmantot, lai ģenerētu kontrolierus, parādītu visas maršrutus un daudz ko citu.

Sīkdatnes

Sīkdatnes ir lielisks veids, kā glabāt nelielus datus klienta pusē. Tos var izmantot, lai glabātu lietotāja preferences, lietojumprogrammas iestatījumus un daudz ko citu.

Kļūdu novēršana

Kļūdu novēršana ir izšķiroša, kad jūs attīstāt savā vietējā vidē. Ir pieejami daži spraudņi, kas var uzlabot jūsu kļūdu novēršanas pieredzi.

Datu bāzes

Datu bāzes ir pamatā lielākajām lietojumprogrammām. Tā ir vieta, kur jūs glabājat un iegūstat datus. Dažas datu bāzu bibliotēkas ir vienkārši apvalki vaicājumu rakstīšanai, bet dažas ir pilnīgi izstrādātas ORM.

Šifrēšana

Šifrēšana ir izšķiroša jebkurai lietojumprogrammai, kas glabā sensitīvus datus. Datu šifrēšana un atšifrēšana nav grūta, bet pareiza šifrēšanas atslēgas glabāšana var būt grūti. Visizšķirošākais ir nekad neglabāt jūsu šifrēšanas atslēgu publiskajā direktorijā vai to nodot savā koda krātuvē.

Darbu rinda

Darbu rindas ir ļoti noderīgas, lai asinkroni apstrādātu uzdevumus. Tas var būt epastu sūtīšana, attēlu apstrāde vai jebkas, kas nav jāveic reāllaikā.

Sesija

Sesijas nav īsti noderīgas API, bet, veidojot tīmekļa lietojumprogrammu, sesijas var būt izšķirošas stāvokļa un pieteikšanās informācijas uzturēšanā.

Šablonēšana

Šablonēšana ir pamatā jebkurai tīmekļa lietojumprogrammai ar UI. Ir pieejami vairāki šablonēšanas dzinēji, kurus var izmantot kopā ar Flight.

Piedalīšanās

Vai jums ir spraudnis, ko vēlaties dalīties? Iesniedziet vilkšanas pieprasījumu, lai to pievienotu sarakstam!

Media

Mediji

Mēs esam centušies noskaidrot, ko varam par dažādiem mediju veidiem internetā ap Flight. Skatiet zemāk dažādus resursus, kurus varat izmantot, lai uzzinātu vairāk par Flight.

Raksti un pārskati

Videoklipi un pamācības

Examples

Nepieciešams ātrs sākums?

Jums ir divas iespējas, kā uzsākt jaunu Flight projektu:

Kopienas sniegtie piemēri:

Nepieciešama iedvesma?

Lai gan šie nav oficiāli atbalstīti no Flight komandas, tie var dot jums idejas, kā strukturēt savus projektus, kas izveidoti ar Flight!

Vēlaties dalīties ar savu piemēru?

Ja jums ir projekts, ko vēlaties dalīties, lūdzu, iesniedziet pull pieprasījumu, lai pievienotu to šim sarakstam!

Install/install

Instalācija

Lejupielādējiet failus

Pārliecinieties, ka jūsu sistēmā ir instalēts PHP. Ja tas nav, noklikšķiniet šeit, lai iegūtu norādes par to, kā to instalēt savai sistēmai.

Ja izmantojat Composer, varat izpildīt šādu komandu:

composer require flightphp/core

VAI arī varat failus lejupielādēt šeit tieši un izpauzēt tos savā tīmekļa katalogā.

Konfigurējiet savu tīmekļa serveri

Iebūvētais PHP attīstības serveris

Šis ir pa tālu vienkāršākais veids, kā sākt darbu. Jūs varat izmantot iebūvēto serveri, lai palaistu savu lietotni un pat izmantotu SQLite datu bāzi (pilnībā atbalstīts sqlite3 jūsu sistēmā) un neprasītu pilnīgi neko! Vienkārši izpildiet šo komandu, kad PHP ir instalēts:

php -S localhost:8000

Tad atveriet pārlūkprogrammu un dodieties uz http://localhost:8000.

Ja jūs vēlaties padarīt savas projekta dokumentu saknes mapes citu direktoriju (Piem.: jūsu projekts ir ~/mansprojekts, bet jūsu dokumentu sakne ir ~/mansprojekts/public/), tad varat izpildīt šo komandu, kad atrodaties ~/mansprojekts direktorijā:

php -S localhost:8000 -t public/

Tad atveriet pārlūkprogrammu un dodieties uz http://localhost:8000.

Apache

Pārliecinieties, ka Apache jau ir instalēts jūsu sistēmā. Ja nē, meklējiet, kā instalēt Apache savā sistēmā.

Attiecībā uz Apache rediģējiet savu .htaccess failu ar šādiem ierakstiem:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA,L]

Piezīme: Ja jums ir jāizmanto Flight apakšdirektorijā, pievienojiet rindu RewriteBase /apaksmappe/ tieši pēc RewriteEngine On.

Piezīme: Ja vēlaties aizsargāt visus servera failus, piem., datu bāzes vai env failus. Ievietojiet šo savā .htaccess failā:

RewriteEngine On
RewriteRule ^(.*)$ index.php

Nginx

Pārliecinieties, ka Nginx jau ir instalēts jūsu sistēmā. Ja nē, meklējiet, kā instalēt Nginx savā sistēmā.

Attiecībā uz Nginx pievienojiet šo savā servera norādē:

server {
  location / {
    try_files $uri $uri/ /index.php;
  }
}

Izveidojiet savu index.php failu

<?php

// Ja izmantojat Composer, pieprasiet autoloāderi.
require 'vendor/autoload.php';
// ja nelietojat Composer, ielādējiet framework tieši
// require 'flight/Flight.php';

// Pēc tam definējiet maršrutu un piešķiriet funkciju, kas apstrādā pieprasījumu.
Flight::route('/', function () {
  echo 'sveika pasaule!';
});

// Beigās startējiet framework.
Flight::start();

PHP instalēšana

Ja jums jau ir instalēts php jūsu sistēmā, droši turpiniet šīs norādes un pārietiet uz lejupielādes sadaļu

Protams! Šeit ir norādes, kā instalēt PHP uz macOS, Windows 10/11, Ubuntu un Rocky Linux. Arī iekļauti būs detalizēti ieteikumi par dažādu PHP versiju instalēšanu.

macOS

PHP instalēšana izmantojot Homebrew

  1. Instalējiet Homebrew (ja vēl nav instalēts):

    • Atveriet termināli un izpildiet: 
      /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

  2. Instalējiet PHP:

    • Instalējiet jaunāko versiju: 
      brew install php
    • Lai instalētu konkrētu versiju, piemēram, PHP 8.1: 
      brew tap shivammathur/php
brew install shivammathur/php/php@8.1

  3. Pārslēdzieties starp PHP versijām:

    • Atslēdziet pašreizējo versiju un pievienojiet vēlamo versiju: 
      brew unlink php
brew link --overwrite --force php@8.1
    • Pārbaudiet instalēto versiju: 
      php -v

Windows 10/11

PHP manuālā instalācija

  1. Lejupielādējiet PHP:

    • Apmeklējiet PHP Windows versijas un lejupielādējiet jaunāko vai konkrētu versiju (piem., 7.4, 8.0) kā zip failu bez pavedieniem.

  2. Izpakošana PHP:

    • Izpako lejupielādēto zip failu uz C:\php.

  3. Pievienojiet PHP sistēmas PATH:

    • Dodies uz Sistēmas īpašības > Vides mainīgie.
    • Sadaļā Sistēmas mainīgie atradīt Ceļš un noklikšķiniet uz Rediģēt.
    • Pievienojiet ceļu C:\php (vai kur izpakojāt PHP).
    • Noklikšķiniet uz Labi, lai aizvērtu visus logus.

  4. Konfigurējiet PHP:

    • Kopējiet php.ini-development uz php.ini.
    • Rediģējiet php.ini, lai konfigurētu PHP pēc nepieciešamības (piem., iestatiet extension_dir, aktivizējiet paplašinājumus).

  5. Pārbaudiet PHP instalāciju:

    • Atveriet komandrindu un izpildiet: 
      php -v

Vairāku PHP versiju instalēšana

  1. Atkārtojiet iepriekšminētos soļus katrai versijai, ievietojot katru atsevišķā mapē (piem., C:\php7, C:\php8).

  2. Pārslēdzieties starp versijām, pielāgojot sistēmas PATH mainīgo, lai norādītu uz vēlamo versijas direktoriju.

Ubuntu (20.04, 22.04, utt.)

PHP instalēšana, izmantojot apt

  1. Atjauniniet pakotņu sarakstus:

    • Atveriet termināli un izpildiet: 
      sudo apt update

  2. Instalējiet PHP:

    • Uzstādiet jaunāko PHP versiju: 
      sudo apt install php
    • Lai instalētu konkrētu versiju, piemēram, PHP 8.1: 
      sudo apt install php8.1

  3. Instalējiet papildu moduļus (nav obligāti):

    • Piemēram, lai instalētu MySQL atbalstu: 
      sudo apt install php8.1-mysql

  4. Pārslēdzieties starp PHP versijām:

    • Lietojiet update-alternatives: 
      sudo update-alternatives --set php /usr/bin/php8.1

  5. Pārbaudiet instalēto versiju:

    • Izpildiet: 
      php -v

Rocky Linux

PHP instalēšana, izmantojot yum/dnf

  1. Iespējojiet EPEL repozitoriju:

    • Atveriet termināli un izpildiet: 
      sudo dnf install epel-release

  2. Uzstādiet Remi repozitoriju:

    • Izpildiet: 
      sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
sudo dnf module reset php

  3. Instalējiet PHP:

    • Lai instalētu noklusējuma versiju: 
      sudo dnf install php
    • Lai instalētu konkrētu versiju, piemēram, PHP 7.4: 
      sudo dnf module install php:remi-7.4

  4. Pārslēdzieties starp PHP versijām:

    • Izmantojiet dnf moduļa komandu: 
      sudo dnf module reset php
sudo dnf module enable php:remi-8.0
sudo dnf install php

  5. Pārbaudiet instalēto versiju:

    • Izpildiet: 
      php -v

Vispārīgas piezīmes

Guides

Ceļveži

Flight PHP ir izstrādāts, lai būtu vienkāršs, taču jaudīgs, un mūsu ceļveži palīdzēs jums soli pa solim izveidot reāls pasaules lietojumprogrammas. Šie praktiskie pamācības pavada jūs cauri pilnīgām projekta izstrādēm, lai parādītu, kā Flight var tikt efektīvi izmantots.

Oficiālie Ceļveži

Emuāra izveide

Uzziniet, kā izveidot funkcionālu emuāra lietojumprogrammu ar Flight PHP. Šis ceļvedis pavada jūs cauri:

Šī pamācība ir ideāla iesācējiem, kuri vēlas redzēt, kā visas sastāvdaļas saskan reālā lietojumprogrammā.

Neoficiālie Ceļveži

Lai gan šie ceļveži oficiāli netiek uzturēti Flight komandas, tie ir vērtīgi resursi, ko izveidojusi kopiena. Tie aptver dažādas tēmas un lietošanas gadījumus, sniedzot papildu ieskatus flight PHP izmantošanā.

RESTful API izveide ar Flight Framework

Šis ceļvedis pavada jūs cauri RESTful API izveidošanai, izmantojot Flight PHP framework. Tas aptver pamatus API izveidošanai, ceļu definēšanai un JSON atbilžu atgriešanai.

Vienkārša emuāra izveide

Šis ceļvedis pavada jūs cauri vienkārša emuāra izveidei, izmantojot Flight PHP framework. Tam faktiski ir 2 daļas: viena, lai aptvertu pamatus, un otra, lai aptvertu sarežģītas tēmas un uzlabojumus ražošanai gatavam emuāram.

Pokémon API izveide PHP: Iesācēju ceļvedis

Šis jautrais ceļvedis pavada jūs, izveidojot vienkāršu Pokémon API, izmantojot Flight PHP. Tas aptver pamatus API izveidošanai, ceļu definēšanai un JSON atbilžu atgriešanai.

Līdzdalība

Vai jums ir ideja par ceļvedi? Atrasts kļūda? Mēs sveicam ieguldījumus! Mūsu ceļveži tiek uzturēti FlightPHP dokumentācijas krātuvē.

Ja jūs esat izveidojis kaut ko interesantu ar Flight un vēlaties to dalīties kā ceļvedis, lūdzu, iesniedziet pull pieprasījumu. Dalīšanās ar jūsu zināšanām palīdz Flight kopienai augt.

Meklējat API dokumentāciju?

Ja meklējat specifisku informāciju par Flight kodolu funkcijām un metodēm, pārbaudiet mūsu dokumentācijas Mācību sadaļu.