Learn

Uzziniet par Flight

Flight ir ātrs, vienkāršs, paplašināms PHP ietvars. Tas ir diezgan daudzfunkcionāls un var tikt izmantots, lai izveidotu jebkura veida tīmekļa lietotni. Tas ir izveidots, ņemot vērā vienkāršību, un ir rakstīts tā, lai būtu viegli saprotams un izmantot.

Svarīgie ietvara koncepti

Kāpēc Ietvars?

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

Papildus ir izveidots lielisks pamācības materiāls no @lubiana. Lai gan tas nenodarbojas ar izpratni konkrēti par Flight, šī gids palīdzēs jums saprast dažus galvenos konceptus, kas saistīti ar ietvaru un kāpēc tos ir izdevīgi izmantot. Pamācības materiālu var atrast šeit.

Salīdzinājums starp Flight un citiem ietvariem

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

Pamata Tēmas

Automātiskā ielāde

Uzziniet, kā automātiski ielādēt savas klases savā lietotnē.

Maršrutēšana

Uzziniet, kā pārvaldīt maršrutus savai tīmekļa lietotnei. Tas ietver maršrutu grupēšanu, maršruta parametrus un starprocesoru.

Starprocesors

Uzziniet, kā izmantot starprocesorus, lai filtrētu pieprasījumus un atbildes savā lietotnē.

Pieprasījumi

Uzziniet, kā pārvaldīt pieprasījumus un atbildes savā lietotnē.

Atbildes

Uzziniet, kā nosūtīt atbildes savas lietotājiem.

HTML Sagataves

Uzziniet, kā izmantot iebūvēto skatu dzinēju, lai renderētu savas HTML sagataves.

Drošība

Uzziniet, kā nodrošināt jūsu lietotni pret izplatītiem drošības draudiem.

Konfigurācija

Uzziniet, kā konfigurēt ietvaru savai lietotnei.

Flight Paplašināšana

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

Notikumi un Filtrēšana

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

Atkarību Ievietošanas Konteiners

Uzziniet, kā izmantot atkarību ievietošanas konteinerus (DIC), lai pārvaldītu savas lietotnes atkarības.

Ietvara API

Uzziniet par ietvara pamatmetodēm.

Migrācija uz v3

Sengalējama saderība lielākoties ir saglabāta, bet ir dažas izmaiņas, par kurām jums vajadzētu būt informētiem, pārejot no v2 uz v3.

Problēmu Risināšana

Pastāv dažas izplatītas problēmas, ar kurām jūs varat 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

• Laravel ir milzīga ekosistēma ar attīstītājiem un moduļiem, kas var tikt izmantoti, lai atrisinātu bieži sastopamas problēmas.
• Laravel ir pilnveidota ORM, kas var tikt izmantota, lai mijiedarbotos ar jūsu datu bāzi.
• Laravel ir neiespējams daudzums dokumentācijas un pamācību, kas var tikt izmantotas, lai izprastu ietvaru.
• Laravel ir iekļauts autentifikācijas sistēma, kas var tikt izmantota, lai nodrošinātu jūsu lietotni.
• Laravel piedāvā podkāstus, konferences, sanāksmes, video un citas resursus, kas var tikt izmantoti, lai iemācītos ietvaru.
• Laravel ir vērsts uz pieredzējušiem attīstītājiem, kuri vēlas izveidot pilnveidotu uzņēmuma tīmekļa lietotni.

Mīnusi salīdzinājumā ar Flight

• Laraveli ir daudz kas notiek aiz priekškoda, ko Flight nedar. Tas nāk ar dramatisku cenu attiecībā uz veiktspēju. Skatīt TechEmpower rādītājus vairāk informācijas.
• Flight ir vērsts uz attīstītāju, kurš vēlas izveidot vieglu, ātru un viegli lietojamu tīmekļa lietotni.
• Flight ir vērsts uz vienkāršību un lietojamību.
• Viena no Flight pamata funkcijām ir tā, ka tā dara visu iespējamo, lai nodrošinātu atpakaļēju saderību. Laravel rada lielas frāzes starp svarīgiem versijas.
• Flight ir domāts attīstītājiem, kuri pirmo reizi iet ietvaru zemē.
• Flight nav atkarību, kamēr Laravelam ir briesmīgs skaits atkarību
• Flight spēj veidot uzņēmuma līmeņa lietojumprogrammas, bet tam nav tik daudz parauga koda kā Laravelam. Tas prasīs lielāku attīstītāja disciplīnu, lai lietas būtu labi organizētas un labi strukturētas.
• Flight dod attīstītājam lielāku kontroli pār lietotni, kamēr Laravelam ir daudz burvju aizkulisēs, kas var būt biedējošs.

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:

• flight.base_url ?string - Pārrakstīt pieprasījuma pamata URL. (pēc noklusējuma: null)
• flight.case_sensitive bool - Reģistra jutīga atbilstība URL. (pēc noklusējuma: false)
• flight.handle_errors bool - Ļauj Flight apstrādāt visas kļūdas iekšpusē. (pēc noklusējuma: true)
• flight.log_errors bool - Reģistrēt kļūdas tīmekļa servera kļūdu žurnālā. (pēc noklusējuma: false)
• flight.views.path string - Katalogs, kas satur skata veidnes failus. (pēc noklusējuma: ./views)
• flight.views.extension string - Skata veidnes faila paplašinājums. (pēc noklusējuma: .php)
• flight.content_length bool - Iestatīt Content-Length galveni. (pēc noklusējuma: true)
• flight.v2.output_buffering bool - Izmantot veco datu buferēšanas metodi. Skat. migrating to v3. (pēc noklusējuma: false)

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 liela lieta, ja runa ir par taustītām vietnēm. Jūs vēlaties nodrošināt, ka jūsu lietotne ir droša un jūsu lietotāju dati ir pasargāti. Flight nodrošina vēlamo funkciju kļūdu drošināšanai.

Galvenes

HTTP galvenes ir viens no vieglākajiem veidiem, kā nodrošināt jūsu taustītas vietnes. Jūs varat izmantot galvenes, lai novērstu klikškināšanu, XSS un citas uzbrūķa veidus. Ir vairīgi veidi, kā pievienot šādas galvenes savai lietotnei.

Lieliskas šīsu galvenu drošības pārbaudei ir saita securityheaders.com un observatory.mozilla.org.

Pievienot Manuāli

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

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

// Iestatiet Content-Security-Policy galveni, lai novērstu XSS
// Piezīme: šāda galvene var būt ļoti sarežģīta, tāpēc jūs vājat
//  konsultēties par piemēriem internetā savai lietotnei
Flight::response()->header("Content-Security-Policy", "default-src 'self'");

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

// Iestatiet X-Content-Type-Options galveni, lai novērstu MIME pacelšanu
Flight::response()->header('X-Content-Type-Options', 'nosniff');

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

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

// Iestatiet Atļaujas-politikas galveni, lai kontrolētu, kuras funkcijas un API var lietot
Flight::response()->header('Permissions-Policy', 'geolocation=()');

Šīs var pievienot lietotnes bootstrap.php vai index.php failu augšdaivā.

Pievienot kā Filtru

Jūs arī varat pievienot tos kā filtru/pīķi šādi:

// Pievienojiet galvenes kā filtru
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ā Starpstibi

Jūs arī varetu pievienot tos kopā ar starpstibi klasi. Tas ir labs veids, kā saglabāt jūsu kodu tāru un pārskatāmu.

// 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ā vietā jūs tiit savaus maršrutus
// FYI, ši tukša grupa kalpo kā globālais starpstibi visiem maršrutiem. Protams, jūs varētu darīt to pašu un pielāgot tikai
// to tikai konkrētiem maršrutiem.
Flight::group('', function(Router $router) {
    $router->get('/users', [ 'UserController', 'getUsers' ]);
    // vairāki maršruti
}, [ new SecurityHeadersMiddleware() ]);

Plpie mājas lapas ievilkšana (CSRF)

Plpie mājas lapas ievilkšana (CSRF) ir uzbrukumu veids, kuru ļaunumsligīga mājas lapa var piespiest lietotāja pārlūkprogrammu nosūtīt pieprasījumu jūsu mājas lapai. Tas var tikt izmantots, lai veiktu darbības jūsu mājas lapā bez lietotāja zināšanām. Flight nenodrošina iebūvētu CSRF aizsardzi, bet to var viegli ieviest, izmantojot starpstibojas.

Iestatīšana

Vispirms jums jāģenerē CSRF žetons un jāsaglabā lietotāja sesijā. Tad jūs varat izmantot šo žetonu savos veidlapos un pārbaudīt to, kad veidlapa tiek iesniegta.

// Ģenerēt CSRF žetonu un saglabāt to lietotāja sesijā
// (pieņemsim, ka esat izveidojis sesijas objektu un pievienojis to Flight)
// skatiet sesijas dokumentāciju uzzināt vaiera
Flight::register('sesija', \Ghostff\Sesija\Sesija::class);

// Jums ir jāģenerē viens žetons sesiju (tāpēc tas darbojas
// pār vairākām cilnēm un pieprasījumiem attiecībā uz to pašu lietotāju)
jā gad.('sesī'->sanemt('csrf_zētons') === nu1uls) {
    'sesija'->iestati('csrf_zētons', bin2hex(nejatrine_atstarpes(32)) );
}

<!­­ Izmantojiet CSRF žetonu jūsu veidlapā ­­>
<form method="post">
    <input type="hidden" name="csrf_zētons" value="<?= 'sesija'->sanemt('csrf_zētons') ?>">
    <!­- citi veidlapas lauki ­->
</form>

Izmantojot Latte

Jūs arī varat uzstādīt pielāgotu funkciju, lai izvadītu CSRF žetonu jūsu Latte veidlapās.

// Uzstādiet pielāgotu funkciju, lai izvadītu CSRF žetonu
// Piezīme: Skats konfigurēts ar Latte kā skatu dzinēju
Flight::skats()->izveidoFunkciju('csrf', funkcija() {
    $csrfZētons = 'sesija'->sanemt('csrf_zētons');
    atgriezt jaunu \Latte\PalaišiHtml('<input type="hidden" name="csrf_zētons" value="' . $csrfZētons . '">');
});

Un tagad jūsu Latte veidlapās jūs varat izmantot csrf() funkciju, lai izvadītu CSRF žetonu.

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

Īss un vienkāršs, vai ne?

Pārbaudīt CSRF žetonu

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

// Šis starpstibi pārbauda, vai pieprasījums ir POST pieprasījums un, ja tā ir, tas pārbauda, vai CSRF žetons ir derīgs
Flight::before('start', function() {
    ja('iesniegums'->metode == 'POST') {

        // noformēt CSRF žetonu no veidlapas vērtībām
        $zētons = 'prasījums'->dati->csrf_zētons;
        ja($zētons !== 'sesija'->sanemt('csrf_zētons')) {
            Flight::halt(403, 'Nederīgs CSRF žetons');
            // vai JSON atbildes nolaižana
            Flight::jsonHalt(['klauda' => 'Nederīgs CSRF žetons'], 403);
        }
    }
});

Vai arī varat izmantot starpstibi klasi:

// app/starpsībija/CsrfMiddleware.php

atseviškums app\starpsībija;

klase CsrfMiddleware
{
    publiska funkcija pirms(array $parametri): nulles
    {
        ja('prasījums'->metode == 'POST') {
            $zētons = 'prasījums'->dati->csrf_zētons;
            ja($zētons !== 'sesija'->sanemt('csrf_zētons')) {
                Flight::halt(403, 'Nederīgs CSRF žetons');
            }
        }
    }
}

// index.php vai kur jūs turat savas maršrutus
Flight::group('', funkcija(Ruteris $mautējs) {
    $mautējs->iegūt('/lietotāji', [ 'LietotājsKontrolieris', 'iegūtLietotājus' ]);
    // vairāki maršruti
}, [ jauns CsrfMiddleware() ]);

Kross-mājas lapas skriptēšana (XSS)

Kross-mājas lapu skriptēšana (XSS) ir uzbrukumu veids, kad ļaunumsligīga mājas lapa var ieviest kodu jūsu mājas lapā. Lielākā daļa šo iespēju nāk no veidlapu vērtībām, ko aizpilda jūsu lietotāji. Jūs nekad nekam nedraūzējieties no savu lietotāju ievades! Vietā vienmēr uzskatāt, ka tie visi ir labākie hakkeri pasaulē. Viņi var ieviest ļaunprātīgu JavaScript vai HTML jūsu lapā. Šo kodu var izmantot, lai nozagt informāciju no jūsu lietotājiem vai veikt darbības jūsu mājas lapā. Izmantojot Flight skata klasi, jūs varat viegli izbēgt izeju, lai novērstu XSS uzbrūkus.

// Paredzam, ka lietotājs ir izdomājīgs, mēģinot to izmantot kā savu vārdu
vards = '<script>alert("XSS")</script>';

// Tas izbēgs izeju
Flight::skats()->iestati('vards', vards);
// Tas izvadīs: &lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;

// Ja izmantojat kaut ko tādu kā Latte, reģistrēts kā jūsu skata klase, tas arī automātiski izvairīsies no šāda veida koda.
Flight::skats()->renderē('veidne', ['vards' => vards]);

SQL injekcija

SQL injekcija ir uzbrukumu veids, kuru ļaunumsligīgs lietotājs var injicēt SQL kodu jūsu datu bāzē. Tas var tikt izmantots, lai nozagt informāciju no jūsu datu bāzes vai veikt darbības jūsu datu bāzē. Atkal jums nekad nevajadzētu paļauties uz ievadi no jūsu lietotājiem! Vietā vienmēr uzskatiet, ka viņi ir uz nemieru. Jūs varat izmantot sagatavotas pieslēguma vietas savos PDO objektos, lai novērstu SQL injekciju.

// Paredzot, ka Flight: db() ir reģistrēts kā jūsu PDO objekts
izaicinājums = Flight::db()->sagatavot('Izvēlēties * no lietotājiem, kur lietotājvārds = :lietotājvārds');
izaicinājums->izpilda([ ':lietotājvārds' => lietotājvārds ]);
lietotāji = izaicinājums->izlasītVisus();

// Ja izmantojat PdoApaķešu klasi, to var viegli izdarīt vienā rindā
lietotāji = Flight::db()->izlasītVisus('Izvēlēties * no lietotājiem, kur lietotājvārds = :lietotājvārds', [ 'lietotājvārds' => lietotājvārds ]);

// Jūs varat darīt to pašu ar PDO objektu ar ? vietturēm
izaicinājums = Flight::db()->izlasītVisus('Izvēlēties * no lietotājiem, kur lietotājvārds = ?', [ lietotājvārds ]);

// Vieta nekad NEKAD nedariet kaut ko tādu kā...
lietotāji = Flight::db()->izlasītVisus("Izvēlēties * no lietotājiem, kur lietotājvārds = '{$lietotājvārds}' LIMIT 5");
// jo ko ja $lietotājvārds = "' VAI 1 = 1; -- "; 
// Kad uzgriezieni tiek izveidoti šādi
// IZVELĒT * no lietotājiem, kur lietotājvārds = '' VAI 1 = 1; -- LIMITS 5
{/* ir dīvains, bet tas ir derīgs pieprašana, kas strādās. Pate ir tas ir ļoti izplatīts SQL injekcijas uzbrukums, kas atgriezīs# Drošība

Drošība ir liela lieta, ja runa ir par tīmekļa lietotnēm. Jūs vēlaties nodrošināties, ka jūsu lietotne ir droša un ka lietotāju dati ir pasargāti. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt savas tīmekļa lietotnes.

## Galvenes

HTTP galvenes ir viens no vieglākajiem veidiem, kā nodrošināt jūsu tīmekļa lietotnes drošību. Jūs varat izmantot galvenes, lai novērstu klikšķināšanas aizbiedēšanu, XSS un citas uzbrukuma formas. Ir vairāki veidi, kā pievienot šīs galvenes savai lietotnei.

Labi vietnes, kurās varat pārbaudīt savu galvu drošību, ir [securityheaders.com](https://securityheaders.com/) un [observatory.mozilla.org](https://observatory.mozilla.org/).

### Pievienot Manuāli

Jūs varat manuāli pievienot šīs galvenes, izmantojot `header` metodi objektam `Flight\Response`.
```php
// Iestatiet X-Frame-Options galvu, lai novērstu klikšķināšanu
Flight::response()->header('X-Frame-Options', 'SAMEORIGIN');

// Iestatiet Content-Security-Policy galvu, lai novērstu XSS
// Piezīme: šai galvei var kļūt diezgan sarežģīta, tāpēc jums vajadzētu
// apmeklēt piemērus internetā jūsu lietotnei
Flight::response()->header("Content-Security-Policy", "default-src 'self'");

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

// Iestatiet X-Content-Type-Options galvu, lai novērstu MIME sviestināšanu
Flight::response()->header('X-Content-Type-Options', 'nosniff');

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

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

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

Šīs var pievienot jūsu bootstrap.php vai index.php failiem.

Pievienot kā Filtru

Jūs arī varat pievienot tos kā filtru/kaitinātāju, piemēram:

// Pievienojiet galvenes kā filtru
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ā Starpmaiziņu

Jūs arī varat pievienot tos kā starpmaiziņas klasi. Tas ir labs veids, kā saglabāt jūsu kodu tīru un organizētu.

// app/middleware/SecurityHeadersMiddleware.php

telpa app\middleware;

klase SecurityHeadersMiddleware
{
    publiska funkcija pirms( masīvs $parametri): tukšs
    {
        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 jūs turat savus maršrutus
// FYI, šī tukšā grupa darbojas kā globālā starpmaiziņa visiem maršrutiem. Protams, jūs varētu darīt to pašu un vienkārši pievienot
// to tikai konkrētiem maršrutiem.
Flight::group('', funkcija(Router $maisītājs) {
    $maisītājs->iegūt('/lietotāji', [ 'LietotājuKontrolieris', 'iegūtLietotājus' ]);
    // vairāki maršruti
}, [ jauns SecurityHeadersMiddleware() ]);

Krustu vietu pieprasījumu viltots (CSRF)

Krustu vietu pieprasījumu viltots (CSRF) ir uzbrukuma veids, kur ļaunumsliegta tīmekļa lapa var padarīt lietotāja pārlūkprogrammu sūtīt pieprasījumu uz jūsu tīmekļa lapu. Tas var tikt izmantots, lai veiktu darbības jūsu tīmekļa lapā bez lietotāja zināšanām. Flight nepiedāvā iebūvētu CSRF aizsardzības mehānismu, bet to var viegli ieviest, izmantojot starpmaiziņu.

Iestatīšana

Vispirms jums jāģenerē CSRF žetons un jāsaglabā lietotāja sesijā. Jūs varat izmantot šo žetonu savos veidlapos un pārbaudīt to, kad veidlapa tiek iesniegta.

// Ģenerēt CSRF žetonu un saglabāt to lietotāja sesijā
// (ja esat izveidojis sesijas objektu un piesaistījis to Flight)
// skatiet sesijas dokumentāciju saņemt vairāk informācijas
Flight::register('sesija', \Ghostff\Sesija\Sesija::class);

// Jums ir jāģenerē viens žetons sesijai (tāpēc tas strādā
// pār vairākām cilnēm un pieprasījumiem attiecībā uz to pašu lietotāju)
ja(Flight::sesija()->get('csrf_zetons') === null) {
    Flight::sesija()->set('csrf_zetons', bin2hex(random_bytes(32)));
}

<!-- Izmantojiet CSRF žetonu savā veidlapā -->
<form method="post">
    <input type="hidden" name="csrf_zetons" value="<?= Flight::sesija()->get('csrf_zetons') ?>">
    <!-- citas veidlapas laukas -->
</form>

Izmantojot Latte

Jūs arī varat iestatīt pielāgotu funkciju, lai izvadītu CSRF žetonu jūsu Latte veidlapās.

// Uzstādiet pielāgotu funkciju, lai izvadītu CSRF žetonu
// Piezīme: Skats konfigurēts ar Latte kā skata dzinēju
Flight::skats()->addFunction('csrf', function() {
    $csrfZetons = Flight::sesija()->get('csrf_zetons');
    return new \Latte\Runtime\Html('<input type="hidden" name="csrf_zetons" value="' . $csrfZetons . '">');
});

Un tagad jūsu Latte veidlapās jūs varat izmantot csrf() funkciju, lai izvadītu CSRF žetonu.

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

Īss un vienkāršs, vai ne?

Pārbaudīt CSRF žetonu

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

// Šis starpmaiziņa pārbauda, vai pieprasījums ir POST pieprasījums un, ja tā ir, tas pārbauda, vai CSRF žetons ir derīgs
Flight::before('start', function() {
    if(Flight::request()->method == 'POST') {

        // saņemt CSRF žetonu no veidlapas vērtībām
        $zetons = Flight::request()->data->csrf_zetons;
        if($zetons !== Flight::sesija()->get('csrf_zetons')) {
            Flight::halt(403, 'Nederīgs CSRF žetons');
            // vai JSON atbildes apstāšanās
            Flight::jsonHalt(['kļūda' => 'Nederīgs CSRF žetons'], 403);
        }
    }
});

Vai arī varat izmantot starpmaiziņas klasi:

// app/middleware/CsrfMiddleware.php

namespace app\middleware;

klase CsrfMiddleware
{
    publiska funkcija pirms( masīvs $parametri): tukšs
    {
        if(Flight::request()->method == 'POST') {
            $zetons = Flight::request()->data->csrf_zetons;
            if($zetons !== Flight::sesija()->get('csrf_zetons')) {
                Flight::halt(403, 'Nederīgs CSRF žetons');
            }
        }
    }
}

// index.php vai kur jūs turat savus maršrutus
Flight::group('', funkcija(Router $maisītājs) {
    $maisītājs->iegūt('/lietotāji', [ 'LietotājuKontrolieris', 'iegūtLietotājus' ]);
    // vairāki maršruti
}, [ jauns CsrfMiddleware() ]);

Krustu vietu skriptēšana (XSS)

Krustu vietu skriptēšana (XSS) ir uzbrukuma veids, kad ļaunumsliegta tīmekļa lapa var injicēt kodu jūsu tīmekļa lapā. Lielākā daļa šo iespēju nāk no veidlapu vērtībām, ko aizpilda jūsu lietotāji. Jums nekad nevajadzētu uzticēties jūsu lietotāju ievadei! Vienmēr pieņemiet, ka visi no viņiem ir labākie hakkeri pasaulē. Viņi var injicēt kaitīgu JavaScript vai HTML jūsu lapā. Šo kodu var izmantot, lai nozagt informāciju no jūsu lietotājiem vai veikt darbības jūsu tīmekļa lapā. Izmantojot Flight skates klasi, jūs varat viegli izslēgt izvadi, lai novērstu XSS uzbrukumus.

// Pēc noklusējuma pieņemsim, ka lietotājs ir gudrs un mēģina to izmantot kā savu vārdu
vārds = '<script>alert("XSS")</script>';

// Tas izslēgs izvadi
Flight::skats()->set('vārds', $vārds);
// Tas izvadīs: &lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;

// Ja izmantojat kaut ko līdzīgu kā Latte, reģistrēts kā jūsu skates klase, tas arī automātiski izslēgs izvadi.
Flight::skats()->renderēt('veidne', ['vārds' => $vārds]);

SQL injekcija

SQL injekcija ir uzbrukuma veids, kad ļaunumsliegts lietotājs var injicēt SQL kodu jūsu datu bāzē. Tas var tikt izmantots, lai nozagt informāciju no jūsu datu bāzes vai veikt darbības jūsu datu bāzē. Atkal nekad neuzticieties ievadei no jūsu lietotājiem! Viemēr pieņemiet, ka viņi ir asiņu centienācī. Jūs varat izmantot sagatavotās apgalvojumu vietas savos PDO objektos, lai novērstu SQL injekciju.

// Paredzot, ka Flight::db() ir reģistrēts kā jūsu PDO objekts
apgalvojums = Flight::db()->sagatavot('Izvēlēties * no lietotājiem, kur lietotājvārds = :lietotājvārds');
apgalvojums->izpildīt([ ':lietotājvārds' => $lietotājvārds ]);
lietotāji = apgalvojums->izgūtVisus();

// Ja izmantojat PdoApglūtas klasi, to var viegli izdarīt vienā rindā
lietotāji = Flight::db()->izgūtVisus('Izvēlēties * no lietotājiem, kur lietotājvārds = :lietotājvārds', [ 'lietotājvārds' => $lietotājvārds ]);

// Jūs varat darīt to pašu ar PDO objektu ar ? vietasnorādēm
apgalvojums = Flight::db()->izgūtVisus('Izvēlēties * no lietotājiem, kur lietotājvārds = ?', [ $lietotājvārds ]);

// Vieta apsolieties nekad NEDARĪT ko tādu kā šo...
lietotāji = Flight::db()->izgūtVisus("Izvēlēties * no lietotājiem, kur lietotājvārds = '{$lietotājvārds}' LIMIT 5");
// jo ja $lietotājvārds = "' VAI 1=1; -- "; 
// Pēc kārtas ir izveidots tas šādi
// Izvēlēties * no lietotājiem, kur lietotājvārds = '' VAI 1=1; -- LIMITS 5
{/* var izskaties dīvaini, bet tas ir derīgs vaiera, kas darbosies. Patiesībā
// tas ir ļoti izplatīts SQL injicēšanas uzbrukums, kas atgriezīs visus lietotājus.

CORS

Krustu resursu koplietošanas (CORS) mehānisms ir mehānisms, kas ļauj daudz resursu (piemēram, fontus, JavaScript utt.) tīmekļa lapā pieprasīt no cita domēna ārpus domēna, no kura resurss nāca. Flight neuzlādē iebūvētas funkcionalitātes, bet to var viegli apstrādāt, pievienojot āķi, kurš izpildās pirms tiek izsaukts Flight::start() metode.

Nobeigums

Drošība ir būtiska, un ir svarīgi nodrošināt, ka jūsu tīmekļa lietotnes ir drošas. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt savas tīmekļa lietotnes, bet ir svarīgi vienmēr būt uzmanīgiem un nodrošināt, ka jūs darāt visu iespējamo, lai pasargātu savu lietotāju datus. Vieta vienmēr pieņem sliktāko un nekad neuzticieties ievadei no savu lietotāju. Vieta vienmēr izvairieties no izejas un izmantojiet sagatavotus apgalvojumus, lai novērstu SQL injekcijas. Vieta vienmēr izmantojiet starpmaiziņas, lai aizsargātu savus maršrutus no CSRF un CORS uzbrukumiem. Ja jūs veicat visus šos pasākumus, jūs būsiet labā ceļā uz drošu tīmekļa lietotņu izstrādi.

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šrutēšana

Piezīme: Vai vēlaties uzzināt vairāk par maršrutēšanu? Apmeklējiet "kāpēc izmantot ietvaru?" lapu, lai iegūtu padziļinātu paskaidrojumu.

Pamata maršrutēšana Flight ietvarā tiek veikta, saskaņojot URL paraugu ar atzvanas funkciju vai klases un metodes masīvu.

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

Maršruti tiek saskaņoti tādā secībā, kādā tie ir definēti. Pirmajam saskaņotajam maršrutam tiks izsaukts.

Atzvanas/Funkcijas

Atzvana var būt jebkura uzgalvota objekts. Tātad jūs varat izmantot parastu funkciju:

function sveiki() {
    echo 'sveika, pasaule!';
}

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

Klases

Jūs varat izmantot arī klases statisko metodi:

class Sveiciens {
    public static function sveika() {
        echo 'sveika, pasaule!';
    }
}

Flight::route('/', [ 'Sveiciens','sveika' ]);

Vai arī, izveidojot objektu pirmo reizi un pēc tam izsaukot metodi:

// Sveiciens.php
class Sveiciens
{
    public function __construct() {
        $this->vards = 'Jānis Bērziņš';
    }

    public function sveika() {
        echo "Sveiki, {$this->vards}!";
    }
}

// index.php
$sveiciens = new Sveiciens();

Flight::route('/', [ $sveiciens, 'sveika' ]);
// Jūs varat to darīt arī bez objekta izveides pirmo reizi
// Piezīme: Neviens arguments netiks ievietots konstruktorā
Flight::route('/', [ 'Sveiciens', 'sveika' ]);
// Turklāt jūs varat izmantot šo īsāko sintaksi
Flight::route('/', 'Sveiciens->sveika');
// vai
Flight::route('/', Sveiciens::class.'->sveika');

Atkarības ielikšana, izmantojot DIC (Dependency Injection Container)

Ja vēlaties izmantot atkarību ielikšanu, izmantojot konteineru (PSR-11, PHP-DI, Dice, utt.), vienīgais maršrutu veids, kur tas ir pieejams, ir vai nu tieši izveidojot objektu pats un, izmantojot konteineru, lai izveidotu objektu, vai izmantojot virknes, lai definētu klasi un metodi, lai to izsauktu. Varat doties uz Atkarību ielikšanas lapu, lai iegūtu vairāk informācijas.

Šeit ir ātrs piemērs:

lietojiet flight\database\PdoWrapper;

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

    public function sveika(int $id) {
        // izdarīt kaut ko ar $this->pdoWrapper
        $vards = $this->pdoWrapper->fetchField("SELECT name FROM users WHERE id = ?", [ $id ]);
        echo "Sveiki, pasaule! Mani sauc {$vards}!";
    }
}

// index.php

// Iestatiet konteineru ar nepieciešamajām parametriem
// Skatiet Atkarību ielikšanas lapu, lai iegūtu vairāk informācijas par PSR-11
$dice = new \Dice\Dice();

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

// Reģistrēt konteinera apstrādātāju
Flight::registerContainerHandler(function($class, $params) use ($dice) {
    return $dice->create($class, $params);
});

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

Flight::start();

Metodes Maršrutēšana

Pēc noklusējuma maršruta paraugi tiek saskaņoti ar visiem pieprasījuma metodēm. Varat reaģēt uz konkrētām metodēm, ievietojot identifikatoru pirms URL.

Flight::route('GET /', function () {
  echo 'Es saņēmu GET pieprasījumu.';
});

Flight::route('POST /', function () {
  echo 'Es saņēmu POST pieprasījumu.';
});

// Jūs nevarat izmantot Flight::get() maršrutiem, jo tas ir metode
//    lai iegūtu mainīgos, nevis izveidotu maršrutu.
// Flight::post('/', function() { /* kods */ });
// Flight::patch('/', function() { /* kods */ });
// Flight::put('/', function() { /* kods */ });
// Flight::delete('/', function() { /* kods */ });

Jūs arī varat piesaistīt vairākas metodes vienai atzvanas funkcijai, izmantojot | atdalītāju:

Flight::route('GET|POST /', function () {
  echo 'Es saņēmu gan GET, gan POST pieprasījumu.';
});

Turklāt jūs varat iegūt Maršruta objektu, kuram ir dažas palīgfunkcijas, ko izmantot:

$maršrutētājs = Flight::router();

// atkartot visus veidus
$maršrutētājs->map('/', function() {
    echo 'sveika, pasaule!';
});

// Iegūt pieprasījumu GET
$maršrutētājs->get('/lietotāji', function() {
    echo 'lietotāji';
});
// $maršrutētājs->post();
// $maršrutētājs->put();
// $maršrutētājs->delete();
// $maršrutētājs->patch();

Regulārās izteiksmes

Varat izmantot regulāros izteikumus savos maršrutos:

Flight::route('/lietotājs/[0-9]+', function () {
  // Tas sakrīt ar /lietotājs/1234
});

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

Nosauktie Parametri

Varat norādīt nosauktos parametrus savos maršrutos, kas tiks nodoti uz jūsu atzvana funkciju.

Flight::route('/@vārds/@id', function (string $vārds, string $id) {
  echo "sveiki, $vārds ($id)!";
});

Jūs varat iekļaut arī regulārās izteiksmes savos nosauktajos parametros ar izmantojot : atdalītāju:

Flight::route('/@vārds/@id:[0-9]{3}', function (string $vārds, string $id) {
  // Tas sakrīt ar /bobs/123
  // Bet nesakrīs ar /bobs/12345
});

Piezīme: Atbilstošs regex grupas () nosauktajos parametros netiek atbalstīts. :'(

Neobligātie Parametri

Jūs varat norādīt nosauktos parametrus, kas ir neobligāti saskaņošanai, aptverot segmentus iekavās.

Flight::route(
  '/blogs(/@gads(/@mēnesis(/@diena)))',
  function(?string $gads, ?string $mēnesis, ?string $diena) {
    // Tas sakrīt ar sekojošajiem URL:
    // /blogs/2012/12/10
    // /blogs/2012/12
    // /blogs/2012
    // /blogs
  }
);

Jebkuri neobligātie parametri, kas nesakrīt, tiks nodoti kā NULL.

Vaļējie Zīmēmji

Saskanēšana tiek veikta tikai ar atsevišķiem URL segmentiem. Ja vēlaties saskanēt ar vairākiem segmentiem, jūs varat izmantot * vaļējo zīmēmju.

Flight::route('/blogs/*', function () {
  // Tas sakrīt ar /blogs/2000/02/01
});

Lai maršrutētu visus pieprasījumus uz vienu atzvanas funkciju, jūs varat:

Flight::route('*', function () {
  // Darīt kaut ko
});

Nodod

Jūs varat nodot izpildi nākamajam saskanētajam maršrutam, atgriežot true no savas atzvanas funkcijas.

Flight::route('/lietotājs/@vārds', function (string $vārds) {
  // Pārbaudiet kādu nosacījumu
  if ($vārds !== "Bobs") {
    // Turpiniet uz nākamo maršrutu
    return true;
  }
});

Flight::route('/lietotājs/*', function () {
  // Šis tiks izsaukts
});

Maršruta Aliasēšana

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

Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotāja_skats');

// vēlāk kādā vietā kodā
Flight::getUrl('lietotāja_skats', [ 'id' => 5 ]); // atgriezīs '/lietotāji/5'

Šis ir īpaši noderīgi, ja jūsu URL mainās. Iepriekš minētajā piemērā teiksim, ka lietotāji tika pārvietoti uz /admin/lietotāji/@id vietā. Ar aliasu palīdzību jums nav jāmaina neviens aliasa atsauces punkts, jo aliasa atsauces punkts tagad atgriezīs /admin/lietotāji/5, kā iepriekš piemērā.

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

Flight::group('/lietotāji', function() {
    Flight::route('/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotāja_skats');
});

// vēlāk kādā kodā
Flight::getUrl('lietotāja_skats', [ 'id' => 5 ]); // atgriezīs '/lietotāji/5'

Maršruta Informācija

Ja vēlaties pārbaudīt saskanētā maršruta informāciju, jūs varat pieprasīt maršruta objektu tikt nodotam uz jūsu atzvanas funkciju, padodot true kā trešo parametru maršruta metodē. Maršruta objekts vienmēr būs pēdējais parametrs, ko nodod jūsu atzvanas funkcijai.

Flight::route('/', function(\flight\net\Route $maršruts) {
  // Metodes saskaņota ar HTTP metodi sarakstu
  $maršruts->metodes;

  // Nosauktie parametri masīva formātā
  $maršruts->parametri;

  // Saskanēšanas regulārā izteiksme
  $maršruts->regex;

  // Saturs jebkura atsevišķa '*' satura
  $maršruts->splat;

  // Parāda URL ceļu.... ja tiešām to jums vajag
  $maršruts->paraugs;

  // Parāda, kāds starpējais programmatūrpakotnei ir piešķirts
  $maršruts->middleware;

  // Parāda piešķirto aliasu šim maršrutam
  $maršruts->alias;
}, true);

Maršruta Grupēšana

Var būt brīži, kad vēlaties grupēt saistītus maršrutus kopā (piemēram, /api/v1). To var izdarīt, izmantojot group metodi:

Flight::group('/api/v1', function () {
  Flight::route('/lietotāji', function () {
    // Saskanēs ar /api/v1/lietotāji
  });

  Flight::route('/raksti', function () {
    // Saskanēs ar /api/v1/raksti
  });
});

Pat varat iegult grupas grupās:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() iegūst mainīgos, tas nenoteiks maršrutu! Skatiet zemāk esošo objekta kontekstu
    Flight::route('GET /lietotāji', function () {
      // Saskanēs ar GET /api/v1/lietotāji
    });

    Flight::post('/raksti', function () {
      // Saskanēs ar POST /api/v1/raksti
    });

    Flight::put('/raksti/1', function () {
      // Saskanēs ar PUT /api/v1/raksti
    });
  });
  Flight::group('/v2', function () {

    // Flight::get() iegūst mainīgos, tas nenoteiks maršrutu! Skatiet zemāk esošo objekta kontekstu
    Flight::route('GET /lietotāji', function () {
      // Saskanēs ar GET /api/v2/lietotāji
    });
  });
});

Grupēšana ar Objektu Kontekstu

Joprojām varat izmantot maršruta grupēšanu ar Engine objektu sekojošajā veidā:

$app = new \flight\Engine();
$app->group('/api/v1', function (Router $maršrutētājs) {

  // lietojiet $maršrutētājs mainīgo
  $maršrutētājs->get('/lietotāji', function () {
    // Saskanēs ar GET /api/v1/lietotāji
  });

  $maršrutētājs->post('/raksti', function () {
    // Saskanēs ar POST /api/v1/raksti
  });
});

Translācija

Tagad varat straumēt atbildes klientam, izmantojot streamWithHeaders() metodi. Tas ir noderīgi lielo failu sūtīšanai, ilgstošiem procesiem vai lielo atbilžu ģenerēšanai. Maršrutēt straumēšana tiek## Route Grouping

There may be times when you want to group related routes together (such as /api/v1). You can do this by using the group method:

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

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

You can even nest groups of groups:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() iegūst mainīgos, tas nenoteiks 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 nenoteiks maršrutu! Skatiet objekta kontekstu zemāk
    Flight::route('GET /users', function () {
      // Atbilst GET /api/v2/users
    });
  });
});

Grouping with Object Context

You can still use route grouping with the Engine object in the following way:

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

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

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

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

• Symfony ir milzīga ekosistēma ar attīstītājiem un moduļiem, kas var tikt izmantoti, lai atrisinātu kopējas problēmas.
• Symfony ir pilnībā iekļauts ORM (Doctrine), kas var tikt izmantots, lai mijiedarbotos ar jūsu datubāzi.
• Symfony ir liels daudzums dokumentācijas un pamācību, kas var tikt izmantotas, lai iemācītos ietvaru.
• Symfony piedāvā podkāstus, konferences, sapulces, video un citus resursus, kas var tikt izmantoti, lai iemācītos ietvaru.
• Symfony ir vērsts uz pieredzējušu izstrādātāju, kurš vēlas izveidot pilnīgi iekļaujošu uzņēmumu tīmekļa lietojumprogrammu.

Mīnusi salīdzinājumā ar Flight

• Symfony zem kapuces darbojas daudz vairāk nekā Flight. Tas nāk ar dramatisku veiktspējas cenu. Skatiet TechEmpower salīdzinājumus lai iegūtu vairāk informācijas.
• Flight ir vērsts uz izstrādātāju, kurš vēlas izveidot vieglu, ātru un viegli lietojamu tīmekļa lietojumprogrammu.
• Flight ir vērsts uz vienkāršību un lietojamību.
• Viena no Flight pamata funkcijām ir tā, ka tā labākais darīs, lai uzturētu atpakaļējo saderību.
• Flight nav atkarīgs no citiem komponentiem, kamēr Symfony ir daudz atkarību
• Flight ir domāts izstrādātājiem, kuri iegrimst ietvaru jomā pirmo reizi.
• Flight arī var veidot uzņēmējdarbības līmeņa lietojumprogrammas, bet tam nav tik daudz piemēru un pamācību kā Symfony. Tas prasīs arī vairāk disciplīnas no izstrādātāja puses, lai saglabātu lietas kārtībā un labi strukturētu.
• Flight dod izstrādātājam lielāku kontroli pār lietojumprogrammu, kamēr Symfony var slēpties aiz kameru un veikt kaut kādus brīnumus.

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 funkcijas tiek izpildītas secībā, kā tās tiek pievienotas maršrutam. Izpildes process ir līdzīgs tam, kā Slim Framework izturas pret to.
  • Pirmskonsultācijas tiek izpildītas pievienošanas secībā, un Pēckonsultācijas tiek izpildītas apgrieztā secībā.
• Ja jūsu starpējā funkcija atgriež false, visi izpildes procesi tiek apturēti, un tiek izraisīta kļūda 403 Aizliegts. Visticamāk, jūs vēlēsities to apstrādāt eleganti, izmantojot Flight::redirect() vai kaut ko līdzīgu.
• Ja jums ir nepieciešami parametri no jūsu maršruta, tie tiks padoti vienā masīvā jūsu starpējāi funkcijai. (function($params) { ... } vai public function before($params) {}). Iemesls tam ir tāds, ka jūs varat strukturēt savus parametrus grupās un dažādās šajās grupās parametri var parādīties citā secībā, kas izjauktu starpējo funkciju, atsaucoties uz nepareizo parametru. Šādā veidā jūs varat piekļūt tiem pēc nosaukuma nevis pēc pozīcijas.
• Ja ievadīsit tikai starpējās funkcijas nosaukumu, tā automātiski tiks izpildīta, izmantojot atkarību injekcijas konteineru, un starpējais kodols tiks izpildīts ar nepieciešamajiem parametriem. Ja jums nav reģistrēta atkarību injekcijas konteiners, tā nodos flight\Engine gadījumu iekšā __construct().

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:

• body - Neapstrādātais HTTP pieprasījuma ķermenis
• url - Pieprasītā URL
• base - URL vecāku apakšdirektorija
• method - Pieprasījuma metode (GET, POST, PUT, DELETE)
• referrer - Atsauces URL
• ip - Klienta IP adrese
• ajax - Vai pieprasījums ir AJAX pieprasījums
• scheme - Servera protokols (http, https)
• user_agent - Pārlūka informācija
• type - Satura tips
• length - Satura garums
• query - Vaicājuma virknes parametri
• data - POST dati vai JSON dati
• cookies - Sīkdatņu dati
• files - Augšupielādēti faili
• secure - Vai savienojums ir drošs
• accept - HTTP pieņemšanas parametri
• proxy_ip - Klienta prokša IP adrese. Skatās $_SERVER masīvā HTTP_CLIENT_IP, HTTP_X_FORWARDED_FOR, HTTP_X_FORWARDED, HTTP_X_CLUSTER_CLIENT_IP, HTTP_FORWARDED_FOR, HTTP_FORWARDED tā secībā.
• host - Pieprasījuma saimniekdatora nosaukums

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

Ietvara API Metodes

Flight ir radīts, lai būtu viegli lietojams un saprotams. Zemāk ir pilnīgs metožu kopa ietvarā. Tā sastāv no pamatmetodēm, kas ir regulāras statiskās metodes, un paplašināmām metodēm, kas ir atkarinātas metodes, kas var tikt filtrētas vai pārrakstītas.

Pamatmetodes

Šīs metodes ir pamata ietvarā un tās nevar tikt pārrakstītas.

Flight::map(virkne $name, callable $callback, bool $pass_route = false) // Izveido pielāgotu ietvara metodi.
Flight::register(virkne $name, virkne $class, masīvs $params = [], ?callable $callback = null) // Reģistrē klasi ietvara metodē.
Flight::unregister(virkne $name) // Atceļ klasi no ietvara metodes.
Flight::before(virkne $name, callable $callback) // Pievieno filtru pirms ietvara metodes.
Flight::after(virkne $name, callable $callback) // Pievieno filtru pēc ietvara metodes.
Flight::path(virkne $path) // Pievieno ceļu klasēm automātiskai ielādei.
Flight::get(virkne $key) // Iegūst mainīgo, ko iestatījis Flight::set().
Flight::set(virkne $key, mixed $value) // Iestata mainīgo Flight dzinējā.
Flight::has(virkne $key) // Pārbauda, vai mainīgais ir iestatīts.
Flight::clear(masīvs|virkne $key = []) // Notīra mainīgo.
Flight::init() // Inicializē ietvaru uz tās noklusējuma iestatījumiem.
Flight::app() // Iegūst pieteikumu 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āmas metodes

Flight::start() // Sāk ietvaru.
Flight::stop() // Aptur ietvaru un nosūta atbildi.
Flight::halt(int $code = 200, virkne $message = '') // Aptur ietvaru ar neobligātu statusa kodu un ziņojumu.
Flight::route(virkne $pattern, callable $callback, bool $pass_route = false, virkne $alias = '') // Atkarina URL modeli uz atgriezšanu.
Flight::post(virkne $pattern, callable $callback, bool $pass_route = false, virkne $alias = '') // Atkarina POST pieprasījuma URL modeli uz atgriezšanu.
Flight::put(virkne $pattern, callable $callback, bool $pass_route = false, virkne $alias = '') // Atkarina PUT pieprasījuma URL modeli uz atgriezšanu.
Flight::patch(virkne $pattern, callable $callback, bool $pass_route = false, virkne $alias = '') // Atkarina PATCH pieprasījuma URL modeli uz atgriezšanu.
Flight::delete(virkne $pattern, callable $callback, bool $pass_route = false, virkne $alias = '') // Atkarina DELETE pieprasījuma URL modeli uz atgriezšanu.
Flight::group(virkne $pattern, callable $callback) // Izveido grupu URL, modelim jābūt teksta virknei.
Flight::getUrl(virkne $name, masīvs $params = []) // Ģenerē URL, pamatojoties uz maršruta aliasu.
Flight::redirect(virkne $url, int $code) // Novirza uz citu URL.
Flight::download(virkne $filePath) // Lejupielādē failu.
Flight::render(virkne $file, masīvs $data, ?string $key = null) // Renderē veidni failam.
Flight::error(Throwable $error) // Nosūta HTTP 500 atbildi.
Flight::notFound() // Nosūta HTTP 404 atbildi.
Flight::etag(virkne $id, virkne $type = 'string') // Veic ETag HTTP kešatmiņu.
Flight::lastModified(int $time) // Veic pēdējo modificēto HTTP kešošanu.
Flight::json(mixed $data, int $code = 200, bool $encode = true, virkne $charset = 'utf8', int $option) // Nosūta JSON atbildi.
Flight::jsonp(mixed $data, virkne $param = 'jsonp', int $code = 200, bool $encode = true, virkne $charset = 'utf8', int $option) // Nosūta JSONP atbildi.
Flight::jsonHalt(mixed $data, int $code = 200, bool $encode = true, virkne $charset = 'utf8', int $option) // Nosūta JSON atbildi un aptur ietvaru.

Jebkuras pielāgotas metodes, kas pievienotas ar map un register, var tikt filtrētas. Piemēru par to, kā atkarināt šīs metodes, skatīt Paplašinot Flight rokasgrāmatā.

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:

• Ātrā attīstība: Ietvari nodrošina daudz funkcionalitātes no paša sākuma. Tas nozīmē, ka jūs varat ātrāk veidot tīmekļa lietojumprogrammas. Jums nav jāraksta tik daudz koda, jo ietvars nodrošina lielu daļu funkcionalitātes, kas jums nepieciešama.
• Konzistence: Ietvari nodrošina vienotu veidu, kā darīt lietas. Tas padara vieglāku saprast, kā kods darbojas un atvieglo citiem izstrādātājiem saprast jūsu kodu. Ja jums ir skripti pēc skripta, varat zaudēt konsekvenci starp skriptiem, īpaši, ja strādājat ar izstrādātāju komandu.
• Drošība: Ietvari nodrošina drošības funkcijas, kas palīdz aizsargāt jūsu tīmekļa lietojumprogrammas no bieži sastopamām drošības draudiem. Tas nozīmē, ka jums nav jāuztraucas tik daudz par drošību, jo ietvars daudzās jomās rūpējas par to.
• Kopiena: Ietvariem ir lieli izstrādātāju kopienas, kas dod ieguldījumus ietvarā. Tas nozīmē, ka jūs varat saņemt palīdzību no citiem izstrādātājiem, kad jums ir jautājumi vai problēmas. Tas arī nozīmē, ka ir daudz resursu, kas palīdz jums apgūt, kā izmantot ietvaru.
• Labās prakses: Ietvari tiek izstrādāti, izmantojot labās prakses. Tas nozīmē, ka jūs varat mācīties no ietvara un izmantot tās pašas labās prakses savā kodā. Tas var palīdzēt jums kļūt par labāku programmētāju. Dažreiz jums nav zināšanu par to, ko nezināt, un tas jums visbeidzot var likt sasistas.
• Pievienojamība: Ietvari ir izstrādāti, lai tos varētu paplašināt. Tas nozīmē, ka varat pievienot savu funkcionalitāti ietvaram. Tas ļauj jums veidot tīmekļa lietojumprogrammas, kas pielāgotas jūsu konkrētajām vajadzībām.

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:

• Lietotājs dodas uz jūsu pārlūkprogrammu un ieraksta http://piemērs.com/lietotājs/1234.
• Serveris saņem pieprasījumu un skatās URL, nododot to jūsu Flight lietojumprogrammas kodam.
• Iedomāsimies, ka jūsu Flight kodā ir kaut kas tāds kā Flight::route('/lietotājs/@id', ['LietotājuKontrolieris', 'skatītLietotājaProfila']);. Jūsu Flight lietojumprogrammas kods apskata URL un redz, ka tas atbilst jums definētajam maršrutam, un tad izpilda kodu, ko esat definējis šim maršrutam.
• Flight maršrutētājs pēc tam palaiž un izsauc skatītLietotājaProfila($id) metodi LietotājuKontrolieris klasē, padodot 1234 kā $id argumentu šajā metodē.
• Koda jūsu skatītLietotājaProfila() metode pēc tam darbosies un darīs to, ko esat tai pateicis. Jūs varat beigt ar ātras lietotāja profila sākuma HTML atspoguļošanu, vai ja tas ir RESTful API, jūs varat atspoguļot JSON atbildi ar lietotāja informāciju.
• Flight ietina to skaisti, ģenerē atbildes galvenes un nosūta to atpakaļ uz lietotāja pārlūku.
• Lietotājs ir piepildīts ar prieku un dod sev siltu apskāvi!

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:

• Centralizēta Maršrutēšana: Jūs varat turēt visus savus maršrutus vienuviet. Tas padara vieglāk redzēt, kādus maršrutus jums ir un ko tie dara. Tas arī atvieglo tos mainīt, ja ir nepieciešams.
• Maršruta Parametri: Jūs varat izmantot maršruta parametrus, lai padotu datus savām maršruta metodēm. Tas ir lielisks veids, kā saglabāt kodu tīru un organizētu.
• Maršrutu Grupēšana: Jūs varat grupēt maršrutus kopā. Tas ir lielisks veids, kā organizēt kodu un piemērot starpniekprogrammatūru maršrutu grupai.
• Maršruta Aliasing: Jūs varat piešķirt aliasu maršrutam, lai vēlāk dinamiski varētu ģenerēt URL savā kodā (piemēram, šablona gadījumā). Piemēram, tajā vietā, lai ciet kodētu /lietotājs/1234 savā kodā, jūs varētu atsauce vietā lietot lietotājs_skatīt un padot id kā parametru. Tas padara to brīnišķīgu gadījumā, ja nolēmīsiet to vēlāk mainīt uz /administrators/lietotājs/1234. Jums nebūs jāmaina visi jūsu cietkodētās URL, vienkārši URL, kas pievienots maršrutam.
• Maršruta Starpniekprogrammatūra: Jūs varat pievienot starpniekprogrammatūru savām maršrutām. Starpniekprogrammatūra ir ārkārtīgi spēcīga, pievienojot konkrētas darbības jūsu lietojumprogrammai, piemēram, autentificējot !{a} lietotāju piekļuvi maršrutai vai maršrutu grupai.

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:

• Ātrā attīstība: Ietvari nodrošina daudz funkcionalitātes no paša sākuma. Tas nozīmē, ka jūs varat ātrāk veidot tīmekļa lietojumprogrammas. Jums nav jāraksta tik daudz koda, jo ietvars nodrošina lielu daļu funkcionalitātes, kas jums nepieciešama.
• Konzistence: Ietvari nodrošina vienotu veidu, kā darīt lietas. Tas padara vieglāku saprast, kā kods darbojas un atvieglo citiem izstrādātājiem saprast jūsu kodu. Ja jums ir skripti pēc skripta, varat zaudēt konsekvenci starp skriptiem, īpaši, ja strādājat ar izstrādātāju komandu.
• Drošība: Ietvari nodrošina drošības funkcijas, kas palīdz aizsargāt jūsu tīmekļa lietojumprogrammas no bieži sastopamām drošības draudiem. Tas nozīmē, ka jums nav jāuztraucas tik daudz par drošību, jo ietvars daudzās jomās rūpējas par to.
• Kopiena: Ietvariem ir lieli izstrādātāju kopienas, kas dod ieguldījumus ietvarā. Tas nozīmē, ka jūs varat saņemt palīdzību no citiem izstrādātājiem, kad jums ir jautājumi vai problēmas. Tas arī nozīmē, ka ir daudz resursu, kas palīdz jums apgūt, kā izmantot ietvaru.
• Labās prakses: Ietvari tiek izstrādāti, izmantojot labās prakses. Tas nozīmē, ka jūs varat mācīties no ietvara un izmantot tās pašas labās prakses savā kodā. Tas var palīdzēt jums kļūt par labāku programmētāju. Dažreiz jums nav zināšanu par to, ko nezināt, un tas jums visbeidzot var likt sasistas.
• Pievienojamība: Ietvari ir izstrādīti, lai tos varētu paplašināt. Tas nozīmē, ka varat pievienot savu funkcionalitāti ietvaram. Tas ļauj jums veidot tīmekļa lietojumprogrammas, kas pielāgotas jūsu konkrētajām vajadzībām.

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 jums ģenerēt daļu no atbildes galvenēm, bet lielāko daļu kontroles par to, ko nosūtat atpakaļ lietotājam, jūs turat. Dažreiz varat piekļūt Atbilde objektam tieši, bet lielāko laiku izmantosiet Flight piemēru, lai nosūtītu atbildi.

Nosūtīt pamata atbildi

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

// Tas nosūtīs "Sveika, pasaule!" uz lietotāja pārlūku
Flight::route('/', function() {
    echo "Sveika, pasaule!";
});

// HTTP/1.1 200 OK
// Content-Type: text/html
//
// Sveika, pasaule!

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

// Tas nosūtīs "Sveika, pasaule!" uz lietotāja pārlūku
Flight::route('/', function() {
    // Ilgi, bet darbojas dažreiz, kad jums tas ir nepieciešams
    Flight::response()->write("Sveika, pasaule!");

    // ja vēlaties iegūt ķermeni, ko esat iestatījuši šajā punktā
    // 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 "Sveika, pasaule!";
    } else {
        Flight::response()->status(403);
        echo "Aizliegts";
    }
});

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

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

Iestatīt atbildes ķermeni

Jūs varat iestatīt atbildes ķermeni, izmantojot write metodi; tomēr, ja jūs izmantojat echo vai print jebko, tiks iegūts un nosūtīts atpakaļ kā atbildes ķermens, izmantojot izvades buferēšanu.

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

// tas pats kā

Flight::route('/', function() {
    echo "Sveika, pasaule!";
});

Notīrīt atbildes ķermeni

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

Flight::route('/', function() {
    if($kādaNosacījums) {
        Flight::response()->write("Sveika, pasaule!");
    } else {
        Flight::response()->clearBody();
    }
});

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/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 Skati un Sagataves

Flight nodrošina pamata sagatavošanas funkcionalitāti pēc noklusējuma.

Ja jums ir nepieciešama sarežģītāka sagatavošanas vajadzība, skatiet Smarty un Latte piemērus sadaļā Pielāgoti skati.

Noklusētais skata dzinējs

Lai parādītu skata sagatavi, izsauciet render metodi ar sagataves faila nosaukumu un neobligātu sagataves datu:

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

Sagataves dati, ko jūs padodat, automātiski tiek ievietoti sagatavē un var tikt atsaukti kā lokāla mainīgā. Sagataves faili vienkārši ir PHP faili. Ja hello.php sagataves faila saturs ir:

Sveiki, <?= $name ?>!

Izvade būs:

Sveiki, Bob!

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

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

Tagad mainīgais name ir pieejams visos jūsu skatos. Tādējādi jūs vienkārši varat izdarīt:

Flight::render('hello');

Jāpiebilst, ka, norādot sagataves nosaukumu render metodē, jūs varat izlaist .php paplašinājumu.

Pēc noklusējuma Flight meklē views direktoriju sagatavošanas failiem. Jūs varat iestatīt alternatīvu ceļu savām sagatavēm, iestatot sekojošo konfigurāciju:

Flight::set('flight.views.path', '/ceļš/uz/skatiem');

Izkārtojumi

Ir parasts, ka tīmekļa vietnēm ir viens izkārtojuma sagataves fails ar mainīgu saturu. Lai atveidotu saturu, kas tiks izmantots izkārtojumā, varat padot neobligātu parametru render metodē.

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

Tad jūsu skatās būs saglabāti mainīgie ar nosaukumiem headerContent un bodyContent. Jūs varat atveidot savu izkārtojumu, darot:

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

Ja sagataves 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 skata dzinēji

Flight ļauj jums vienkārši nomainīt noklusēto skata dzinēju, vienkārši reģistrējot savu skata klasi.

Smarty

Šeit ir kā jūs varētu izmantot Smarty sagatavošanas dzinēju savos skatos:

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

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

// Piešķirt sagataves datus
Flight::view()->assign('name', 'Bob');

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

Lai būtu pilnīgas, jums vajadzētu pārrakstīt arī Flight noklusēto 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 varētu izmantot Latte sagatavošanas dzinēju savos skatos:

// Reģistrēt Latte kā skata klasi
// Tāpat nododot atsauces funkciju, lai konfigurētu Latte ielādes laikā
Flight::register('view', Latte\Engine::class, [], function (Latte\Engine $latte) {
  // Šeit Latte saglabās jūsu sagataves, lai paātrinātu lietas
  // Viens īpaši labs Latte aspekts ir tas, ka tas automātiski atjauno jūsu
  // kešatmiņu, kad jūs veicat izmaiņas savās sagatavēs!
  $latte->setTempDirectory(__DIR__ . '/../cache/');

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

// Un iesaiņojiet to, lai jūs varētu pareizi izmantot Flight::render()
Flight::map('render', function(string $template, array $data): void {
  // Tas ir kā $latte_engine->render($template, $data);
  echo Flight::view()->render($template, $data);
});

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

• Fat-Free ir nedaudz vairāk zvaigžņu GitHub nekā Lidojumam.
• Fat-Free ir dažas labas dokumentācijas daļas, bet tai trūkst skaidrības dažos aspektos.
• Fat-Free ir daži ierobežoti resursi, piemēram, YouTube pamācības un tiešsaistes raksti, kas var būt izmantoti, lai iemācītos karkasu.
• Fat-Free ir iebūvēti daži noderīgi spraudņi kas dažreiz ir noderīgi.
• Fat-Free ir iebūvēts ORM, ko sauc par Kartētāju, ko var izmantot, lai sazinātos ar jūsu datu bāzi. Lidojumam ir aktīvais-ieraksts.
• Fat-Free ir sesijas, kešatmiņu un lokalizāciju iekļaušana. Lidojumam ir jāizmanto trešo pušu bibliotēkas, bet tas ir aprakstīts dokumentācijā.
• Fat-Free ir neliela grupa no kopienā radītu spraudņi kas var izmantoti, lai paplašinātu karkasu. Lidojumam ir daži aprakstīti dokumentācijā un piemēru lapās.
• Fat-Free, tāpat kā Lidojums, nav atkarīgs no citiem pakotņu komplektiem.
• Fat-Free, tāpat kā Lidojums, ir vērsts uz to, lai izstrādātājam dotu kontroli pār viņu lietojumprogrammu un vienkāršu izstrādātāja pieredzi.
• Fat-Free saglabā atpakaļējo saderību tāpat kā Lidojums (daļēji tāpēc, ka atjauninājumi kļūst retāki).
• Fat-Free, tāpat kā Lidojums, ir paredzēts izstrādātājiem, kuri ienirst iet karkasu zemē pirmo reizi.
• Fat-Free ir iebūvēta veidne dzinējs, kas ir izturīgāks nekā Lidojuma veidne dzinējs. Lidojums iesaka Latte lai to sasniegtu.
• Fat-Free ir unikāla CLI veida "marsruta" komanda, kurā jūs varat izveidot CLI lietotnes Fat-Free ietvaros un to apsaukt tāpat kā GET pieprasījumu. Lidojums to sasniedz ar skrejceli.

Mīnusi salīdzinājumā ar Lidojumu

• Fat-Free ir dažas īstenošanas pārbaudes un pat ir savs pārbaude klase, kas ir ļoti pamata. Tomēr tas nav 100% vienību pārbaudīts kā Lidojums.
• Lai faktiski meklētu dokumentācijas vietni, jums jāizmanto meklētājmotoru, piemēram, Google.
• Lidojumam ir tumšais režīms to dokumentācijas vietnē. (mikrofons ietriecienās)
• Fat-Free ir dažas moduļi, kas pamatīgi nav uzturēti.
• Lidojumam ir vienkāršs PdoAvalku kas ir mazliet vienkāršāks nekā Fat-Free iebūvētā DB\SQL klase.
• Lidojumam ir atļauju spraudnis kas var tikt izmantots, lai nodrošinātu jūsu lietojumprogrammu. Slaids prasa jums izmantot trešo pušu bibliotēku.
• Lidojumam ir ORM saukts aktivs-ieraksts kas jūtas kā ORM nekā Fat-Free Kartētājs. Pievienotā priekšrocība ar aktivs-ieraksts ir tāda, ka jūs varat definēt attiecības starp ierakstiem automātiskajiem savienojumiem, kur Fat-Free Kartētājam nepieciešams izveidot SQL skatus.
• Pārsteidzoši, Fat-Free nesatur saknes vardnīcu. Lidojums ir apakšvietāts visu laiku, lai nekolidētu ar jūsu pašu kodu. Kešatmiņa klase ir lielākais pārkāpējs šeit.
• Fat-Free nav starpniekprogrammatūra. Tā vietā ir pirmsmājas un pēcmājas kauli, kurus var izmantot, lai filtrētu pieprasījumus un atbildes kontrolieros.
• Fat-Free nevar grupēt maršrutus.
• Fat-Free ir atkarības injekcijas konteineru vadītājs, bet dokumentācija ir ļoti vērā ņemama par to, kā to izmantot.
• Labošana var kļūt mazliet sarežģīta, jo būtībā viss tiek glabāts tā sauktajā HIVE.

Learn/extending

Paplašināšana

Flight ir izstrādāts kā paplašināms ietvars. Ietvars ir aprīkots ar iebūvētām metodēm un komponentēm, bet tas ļauj jums pievienot savas metodes, reģistrēt savas klases vai pat pārrakstīt esošās klases un metodes.

Ja jums ir nepieciešams DIC (Dependency Injection Container), apmeklējiet Dependency Injection Container lapu.

Kartēšanas Metodes

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

// Norādiet savu metodi
Flight::map('hello', function (string $name) {
  echo "sveiki $name!";
});

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

Lai izveidotu vienkāršas pielāgotas metodes, ir iespējams veidot standarta funkcijas PHP. Tā ir ieteicamā prakse, jo tajā ir automātiskā pabeigšana IDE vidēs un ir vieglāk lasāma. Tas būtu ekvivalents augstāk redzamajam kodam:

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

hello('Bobs');

Šis tiek izmantots vairāk, kad jums ir nepieciešams nodot mainīgos savai metodē, lai iegūtu paredzamo vērtību. Izvietojot metodi register() kā zemāk, tas ir vairāk paredzēts, lai nodotu konfigurāciju un pēc tam izsauktu jūsu iepriekš konfigurēto klasi.

Reģistrēšanas Klases

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

// Reģistrējiet savu klasi
Flight::register('lietotājs', Lietotājs::class);

// Iegūstiet sava objekta piemēru
$manslietotājs = Flight::lietotājs();

Reģistrēšanas metode ļauj jums arī nodot parametrus jūsu klases konstruktoram. Tādējādi, ielādējot savu pielāgoto klasi, tā tiks iepriekš inicializēta. Konstruktoram varat definēt parametrus, padodot papildu masīvu. Šeit ir piemērs, kā ielādēt datu bāzes savienojumu:

// Reģistrējiet klasi ar konstruktoram paredzētiem parametriem
Flight::register('db', PDO::class, ['mysql:host=localhosts;dbname=test', 'lietotājs', 'parole']);

// Iegūstiet sava objekta piemēru
// Tas izveidos objektu ar definētajiem parametriem
//
// new PDO('mysql:host=localhosts;dbname=test','lietotājs','parole');
//
$db = Flight::db();

// un ja vēlēsities to vēlāk izmantot savā kodā, vienkārši atkal izsauciet to pašu metodi
class KādsKontrolieris {
  public function __construct() {
    $this->db = Flight::db();
  }
}

Ja nododat papildu atsauksmes parametru, tas tiks izpildīts nekavējoties pēc klases izveides. Tas ļauj veikt jebkādas iestatīšanas procedūras jaunajam objektam. Atsauksmes funkcija ņem vienu parametru, jauna objekta piemēru.

// Objekts, kas tika izveidots, tiks nodots atsauksmei
Flight::register(
  'db',
  PDO::class,
  ['mysql:host=localhost;dbname=test', 'lietotājs', 'parole'],
  function (PDO $db) {
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  }
);

Pēc noklusējuma katru reizi, kad ielādējat savu klasi, jums tiks nodots koplietotā instance. Lai iegūtu jaunu klases piemēru, vienkārši nododiet false kā parametru:

// Klases koplietotais piemērs
$koplietots = Flight::db();

// Jauns klases piemērs
$jauns = Flight::db(false);

Netaisni, ka kartētām metodēm ir priekšrocība pār reģistrētajām klasēm. Ja deklarējat abas, izmantojot to pašu nosaukumu, tiks izsaukta tikai kartētā metode.

Pārrakstīšanas Ietvara Metodes

Flight ļauj jums pārrakstīt tās noklusētās funkcijas, lai piemērotu tās saviem mērķiem, neiemodificējot nekādu kodu. Jūs varat aplūkot visas metodes, ko varat pārrakstīt šeit.

Piemēram, kad Flight nevar sakrist URL ar maršrutu, tā izsauc metodi notFound, kas nosūta vispārīgu HTTP 404 atbildi. Šo uzvedību var pārrakstīt, izmantojot metodi map:

Flight::map('notFound', function() {
  // Parādiet pielāgoto 404 lapu
  iekļaut 'kļūdas/404.html';
});

Flight arī ļauj jums aizstāt ietvara pamata sastāvdaļas. Piemēram, jūs varat aizstāt noklusējuma maršrutētāja klasi ar savu pielāgoto klasi:

// Reģistrējiet savu pielāgoto klasi
Flight::register('maršrutētājs', ManaMaršrutētāja::class);

// Kad Flight ielādē Maršrutētāja piemēru, tas ielādēs jūsu klasi
$manamaršrutētājs = Flight::maršrutētājs();

Taču ietvara metodes, piemēram, map un register, nevar tikt pārrakstītas. Ja mēģināsit to izdarīt, saņemsiet kļūdu.

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

• Slīmam ir lielāka attīstītāju kopiena, kas savukārt izveido noderīgas moduļus, lai palīdzētu jums neuzgriezt riteni.
• Slīms seko daudziem interfeisiem un standartiem, kas ir kopīgi PHP kopienā, palielinot savstarpējo saderību.
• Slīmam ir pieņemama dokumentācija un pamācības, kas var tikt izmantotas, lai iemācītos pamatus (nekas salīdzinot ar Laravel vai Symfony tomēr).
• Slīmam ir dažādi resursi, piemēram YouTube pamācības un tiešsaistes raksti, kas var tikt izmantoti, lai iemācītos pamatus.
• Slīms ļauj jums izmantot jebkurus komponentus, ko vēlaties, lai apstrādātu galvenās maršrutēšanas funkcijas, jo tas atbilst PSR-7.

Mīnusi salīdzinot ar lidojumu

• Pārsteidzoši, Slīms nav tik ātrs, cik varētu domāt par mikrostruktūru. Skatiet   TechEmpower pārbaudes   plašākai informācijai.
• Lidojums ir orientēts uz izstrādātāju, kas vēlas izveidot vieglu, ātru un viegli lietojamu tīmekļa lietojumprogrammu.
• Lidojumam nav atkarību, bet Slimam ir dažas atkarības, kas jāinstalē.
• Lidojums ir orientēts uz vienkāršību un lietojamību.
• Viena no Lidojuma pamatfunkcijām ir tā, ka tas cenšas labāk uzturēt atpakaļējo saderību. Slīma no v3 līdz v4 bija pārtraucošs pārmaiņas.
• Lidojums paredzēts izstrādātājiem, kuri ienāk ietvaros pirmo reizi.
• Lidojumam ir iespējamas lielas mēroga programmas, bet tam nav tik daudz piemēru un pamācību kā Slīmam.   Tas prasīs arī vairāk disciplīnas no izstrādātāja puses, lai saglabātu lietas kārtībā un labi strukturētu.
• Lidojums ļauj izstrādātājam vairāk kontroles pār lietojumprogrammu, turpretī Slīms var slīpt aizkulises kāds maģija.
• Lidojumam ir vienkāršs PdoWrapper, kas var tikt izmantots, lai mijiedarbotos ar jūsu datu bāzi. Slīmam ir jāizmanto   trešās puses bibliotēka.
• Lidojumu var izmantot atļauju spraudnis](/awesome-plugins/permissions), lai nodrošinātu lietojumprogrammu. Slīmam ir nepieciešams izmantot   trešās puses bibliotēka.
• Lidojumam ir ORM, kas saucas active-record, kas var tikt izmantots, lai mijiedarbotos ar jūsu datu bāzi. Slīmam ir jāizmanto   trešās puses bibliotēka.
• Lidojumam ir CLI lietojumprogramma, kas saucas runway, kas var tikt izmantota, lai palaistu jūsu lietojumprogrammu no komandrindas. Slīmam nav.

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();

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 ātra, vienkārša, paplašināmais ietvars PHP programmēšanas valodai. Tas ir diezgan daudzpusīgs un var tikt izmantots, lai izveidotu jebkura veida tīmekļa lietojumprogrammu. Tas ir izveidots, ņemot vērā vienkāršību, un uzrakstīts tā, lai būtu viegli saprotams un izmantojams.

Flight ir lielisks ietvars iesācējiem tiem, kuri ir jauni PHP valodā un vēlas uzzināt, kā veidot tīmekļa lietojumprogrammas. Tas ir arī lielisks ietvars pieredzējušiem izstrādātājiem, kuri vēlas labāku kontroli pār savām tīmekļa lietojumprogrammām. Tas ir izstrādāts, lai viegli izveidotu RESTful API, vienkāršu tīmekļa lietojumprogrammu vai sarežģītu tīmekļa lietojumprogrammu.

Ātrā sākšana

<?php

// ja ir instalēts ar komponistu
require 'vendor/autoload.php';
// vai arī ja instalēts manuāli ar zip failu
// require 'flight/Flight.php';

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

Flight::route('/json', function() {
  Flight::json(['sveiki' => 'pasaule']);
});

Flight::start();

Pietiekami vienkārši, vai ne? Uzzini vairāk par Flight dokumentācijā!

Struktūras/Pamata lietotne

Ir piemēra lietotne, kas var palīdzēt jums sākt strādāt ar Flight ietvaru. Dodieties uz flightphp/skeleton, lai iegūtu norādes par to, kā sākt! Jūs varat arī apmeklēt examples lapu, lai iedvesmotos par dažādām lietām, ko varat darīt ar Flight.

Kopiena

Mēs esam Matrix tērzēšanā ar mums pievienojieties pie #flight-php-framework:matrix.org.

Ieguldīt

Ir divi veidi, kā jūs varat ieguldīt Flight:

1. Jūs varat ieguldīt pamatstruktūrā, apmeklējot core repository.
2. Jūs varat ieguldīt dokumentācijā. Šīs dokumentācijas vietne ir uzglabāta vietnē Github. Ja pamanāt kļūdu vai vēlaties kaut ko uzlabot, jūs droši varat labot un iesniegt pieprasījumu "pull request"! Mēs cenšamies būt atjaunināti, bet jauninājumi un valodas tulkojumi ir laipni gaidīti.

Prasības

Flight prasa PHP 7.4 vai jaunāku.

Piezīme: Tiek atbalstīts PHP 7.4, jo rakstīšanas pašreizējā laikā (2024) PHP 7.4 ir noklusējuma versija dažiem LTS Linux distribūcijām. Pāreja uz PHP >8 rada daudz nespējas šiem lietotājiem. Ietvars arī atbalsta PHP >8.

Licence

Flight izlaižas zem MIT licences.

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

Wruczek/PHP-File-Cache

Viegla, vienkārša un neatkarīga PHP iekšējās kešatmiņas klase

Priekšrocības

• Viegla, neatkarīga un vienkārša
• Viss kods vienā failā - bezjēdzīgu draiveru nav.
• Drošs - katram ģenerētajam kešatmiņas failam ir php galvenes fails ar die, padarot tiešu piekļuvi neiespējamu pat tad, ja kādam ir zināms ceļš un jūsu serveris nav konfigurēts pareizi
• Labi dokumentēts un pārbaudīts
• Pareizi apstrādā vienlaicību ,izmantojot flock
• Atbalsta PHP 5.4.0 - 7.1+
• Bezmaksas saskaņā ar MIT licences noteikumiem

Noklikšķiniet šeit, lai aplūkotu kodu.

Instalācija

Uzstādiet, izmantojot komponistu:

composer require wruczek/php-file-cache

Lietošana

Lietošana ir diezgan vienkārša.

use Wruczek\PhpFileCache\PhpFileCache;

$app = Flight::app();

// Jūs nododat direktoriju, kurā kešatmiņa tiks saglabāta, konstruktorā
$app->register('cache', PhpFileCache::class, [ __DIR__ . '/../cache/' ], function(PhpFileCache $cache) {

    // Tas nodrošina, ka kešatmiņa tiek izmantota tikai tad, ja esat produktīvā režīmā
    // ENVIRONMENT ir konstante, kas ir iestatīta jūsu sākotnējā failā vai citur jūsu lietotnē
    $cache->setDevMode(ENVIRONMENT === 'development');
});

Tad jūs varat to izmantot savā kodā šādi:

// Saņemt kešatmiņas instanci
$cache = Flight::cache();
$data = $cache->refreshIfExpired('simple-cache-test', function () {
    return date("H:i:s"); // atgriezt dati, kas tiks saglabāti
}, 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/Wruczek/PHP-File-Cache pilnai dokumentācijai un pārliecinieties, ka apskatāt piemērus mapes.

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/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.

• Wruczek/PHP-File-Cache - Gaiša, vienkārša un neatkarīga PHP faila kešošanas klase

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.

• tracy/tracy - Tā ir pilna funkcionāla kļūdu apstrāde, kas var tikt izmantota ar Flight. Tā disponē ar daudzām paneļu, kas var palīdzēt jums novērst jūsu lietojumprogrammas kļūdas. To ir arī ļoti viegli paplašināt un pievienot savus paneļus.
• flightphp/tracy-extensions - Lietots ar Tracy kļūdu apstrādātāju, šis spraudnis pievieno dažus papildu paneļus, lai palīdzētu ar dīversijas konkrēti Flight projektos.

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.

• flightphp/core PdoWrapper - Oficiālais Flight PDO apvalks, kas ir daļa no kodola. Šis ir vienkāršs apvalks, lai palīdzētu vienkāršot vaicājumu rakstīšanas un izpildes procesu. Tas nav ORM.
• flightphp/active-record - Oficiālais Flight ActiveRecord ORM/Mapper. Lieliska maza bibliotēka, lai viegli atgūtu un saglabātu datus jūsu datubāzē.

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.

• Ghostff/Session - PHP sesiju pārvaldītājs (nebloķējošs, flash, segments, sesijas šifrēšana). Izmanto PHP open_ssl sesiju datu izvēlēti šifrēt/šifrēt.

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.

• flightphp/core View - Tas ir ļoti pamata templēšanas dzinējs, kas ir daļa no kodola. Nav ieteicams izmantot to, ja jūsu projektā ir vairāk nekā dažas lapas.
• latte/latte - Latte ir pilna funkcionāla templēšanas dzinējs, kas ir ļoti viegli lietojams un jūtas tuvāks PHP sintaksei nekā Twig vai Smarty. To ir arī ļoti viegli paplašināt un pievienot savus filtrus un funkcijas.

Contributing

Vai jums ir spraudnis, ko vēlaties koplietot? Iesniedziet pieprasījumu pull, lai to pievienotu sarakstam!

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/session

Ghostff/Session

PHP sesiju pārvaldnieks (nevibloķējošs, zibatmiņa, segmenta, sesijas šifrēšana). Izmanto PHP open_ssl opciju datu šifrēšanai/atšifrēšanai. Atbalsta Failu, MySQL, Redis un Memcached.

Noklikšķiniet šeit, lai aplūkotu kodu.

Instalācija

Instalēt ar komponistu.

composer require ghostff/session

Pamata konfigurācija

Jums nav nepieciešams nodot neko, lai izmantotu noklusējuma iestatienus savai sesijai. Jūs varat lasīt par vairākiem iestatījumiem Github Readme.

lietojiet Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

// viena lieta, ko atcerēties, ir tā, ka ir jāsaglabā savu sesiju katru lapas ielādi
// pretējā gadījumā jums būs jāpalaiž auto_commit savā konfigurācijā.

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 Extensions

=====

Tas ir komplekts paplašinājumu, kas padara darbu ar Flight nedaudz bagātāku.

• Flight - Analizēt visus Flight mainīgos.
• Database - Analizēt visus pieprasījumus, kas ir izpildīti lapā (ja pareizi inicializējat datu bāzes savienojumu)
• Request - Analizēt visus $_SERVER mainīgos un izpētīt visus globālos dati ($_GET, $_POST, $_FILES)
• Session - Analizēt visus $_SESSION mainīgos, ja sesijas ir aktīvas.

Šī ir panelis

Un katrs panelis rāda ļoti noderīgu informāciju par jūsu lietojumprogrammu!

Noklikšķiniet šeit, lai skatītu kodu.

Instalācija

Izpildiet composer require flightphp/tracy-extensions --dev un jūs esat gatavs!

Konfigurācija

Lai sāktu izmantot šo, jums ir nepieciešama ļoti maza konfigurācija. Jums būs jāinicializē Tracy atkļūdošana pirms šī sākuma https://tracy.nette.org/en/guide:

<?php

use Tracy\Debugger;
use flight\debug\tracy\TracyExtensionLoader;

// palaižamā kods
require __DIR__ . '/vendor/autoload.php';

Debugger::enable();
// Varat būt nepieciešams norādīt savu vidi, izmantojot Debugger::enable(Debugger::DEVELOPMENT)

// ja lietojat datu bāzes savienojumus savā lietojumprogrammā, ir
// nepieciešams PDO iesaiņotājs LIETOŠANAI TIKAI IZSTRĀDEI (lūdzu, neizmantojiet ražošanā!)
// Tā ir tāda pati parametru kopums kā parasts PDO savienojums
$pdo = new PdoQueryCapture('sqlite:test.db', 'user', 'pass');
// vai ja to pievienojat Flight struktūrai
Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'user', 'pass']);
// tagad, kad veicat vaicājumu, tas saglabās laiku, vaicājumu un parametrus

// Tas savieno punktus
if(Debugger::$showBar === true) {
    // Tas jābūt viltus, vai arī Tracy faktiski nevar atveidot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

// vairāk koda

Flight::start();

Papildu konfigurācija

Sesiju dati

Ja jums ir pielāgots sesiju 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 nododat ar session_data atslēgu TracyExtensionLoader konstruktorā otro parametru.

use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

$app->register('session', Session::class);

if(Debugger::$showBar === true) {
    // Tas jābūt viltus, vai arī Tracy faktiski nevar atveidot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]);
}

// maršruti un citi lielumi...

Flight::start();

Latte

Ja jums ir Latte instalēts jūsu projektā, jūs varat izmantot Latte paneli, lai analizētu savus veidnes. Jūs varat nodot Latte instanci TracyExtensionLoader konstruktorā ar atslēgu latte otro 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 Paneļu Tracy
    $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension);
});

if(Debugger::$showBar === true) {
    // Tas jābūt viltus, vai arī Tracy faktiski nevar atveidot :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app());
}

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.

• bdump($var) - Tas izmetīs mainīgo uz Tracy joslas atsevišķajā panelī.
• dumpe($var) - Tas izmetīs mainīgo un tad nekavējoties nomirs.

Awesome-plugins/active_record

Flight Active Record

Aktīvais ieraksts ir datubāzes vienības atspoguļojums PHP objektā. Vienkārši izsakoties, ja jums ir lietotāju tabula datubāzē, jūs varat "pārvērst" rindu šajā tabulā par User klasi un $user objektu jūsu koda bāzē. Skatiet pamata piemēru.

Spied šeit, lai iegūtu repozitoriju GitHub vietnē.

Pamata Piemērs

Pieņemsim, ka jums ir šāda tabula:

CREATE TABLE users (
    id INTEGER PRIMARY KEY, 
    name TEXT, 
    password TEXT 
);

Tagad jūs varat izveidot jaunu klasi, lai pārstāvētu šo tabulu:

/**
 * ActiveRecord klase parasti ir vienatnē
 * 
 * Iespējams, ir 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($datubāzes_savienojums)
    {
        // jūs varat iestatīt to šādi
        parent::__construct($datubāzes_savienojums, 'lietotāji');
        // vai šādi
        parent::__construct($datubāzes_savienojums, null, [ 'table' => 'lietotāji']);
    }
}

Tagad skatieties, kas notiek!

// SQLite gadījumā
$datubāzes_savienojums = new PDO('sqlite:test.db'); // tas ir tikai piemērs; jūs, visticamāk, izmantotu reālu datubāzes savienojumu

// MySQL gadījumā
$datubāzes_savienojums = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'lietotājvārds', 'parole');

// vai mysqli
$datubāzes_savienojums = new mysqli('localhost', 'lietotājvārds', 'parole', 'test_db');
// vai mysqli ar neobjekta pamatotu izveidi
$datubāzes_savienojums = mysqli_connect('localhost', 'lietotājvārds', 'parole', 'test_db');

$user = new User($datubāzes_savienojums);
$user->name = 'Bobby Tabulas';
$user->password = password_hash('kāda forša parole');
$user->insert();
// vai $user->save();

echo $user->id; // 1

$user->name = 'Joseph Tava Mamma';
$user->password = password_hash('kāda ļoti forša parole vēlreiz!!!');
$user->insert();
// šeit nevar izmantot $user->save(), jo tas uzskatīs, ka tas ir atjauninājums!

echo $user->id; // 2

Un tik ātri tika pievienots jauns lietotājs! Tagad, kad datu bāzē ir lietotāja rinda, kā to izvilkt?

$user->find(1); // atrod id = 1 datu bāzē un atgriež to.
echo $user->name; // 'Bobby Tabulas'

Un ja vēlaties atrast visus lietotājus?

$lietotāji = $user->findAll();

Kas notiks ar noteiktu nosacījumu?

$lietotāji = $user->like('name', '%mamma%')->findAll();

Redziet, cik jautri tas ir? Uzstādiet to un sāciet!

Instalēšana

Vienkārši instalējiet ar Composer

composer require flightphp/active-record 

Lietošana

To var izmantot kā neatkarīgu bibliotēku vai ar Flight PHP ietvaru. Pilnīgi atkarīgs no jums.

Neatkarīgi

Vienkārši pārliecinieties, ka nododat PDO savienojumu konstruktoram.

$pdo_savienojums = new PDO('sqlite:test.db'); // tas ir tikai piemērs; jūs, visticamāk, izmantotu reālu datubāzes savienojumu

$Lietotājs = new User($pdo_savienojums);

Piezīme: Ja negribat vienmēr iestatīt savienojumu ar datubāzi konstruktorā, skatiet Datubāzes Savienojuma Pārvaldība citus ieteikumus!

Reģistrēt kā metodi Flight

Ja izmantojat Flight PHP ietvaru, varat reģistrēt ActiveRecord klasi kā pakalpojumu, bet, lai godīgi būtu, jums to nevajag.

Flight::register('lietotājs', 'Lietotājs', [ $pdo_savienojums ]);

// tad to varat izmantot tādā veidā kontrolierī, funkcijā, utt.

Flight::user()->find(1);

runway Metodes

runway ir Flight CLI rīks, kam ir pielāgots komandu šim bibliotēkai.

# Lietošana
php runway make:record datubāzes_tabulas_vārds [klases_vārds]

# Piemērs
php runway make:record lietotāji

Tas izveidos jaunu klasi UserRecord.php direktorijā app/records/ ar šādu saturu:

<?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 $lietotājvārds
 * @property string $e-pasts
 * @property string $paroles_hash
 * @property string $izveides_dt
 */
class UserRecord extends \flight\ActiveRecord
{
    /**
     * @var array $attiecības Uzstādiet attiecības modeļiem
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $attiecības = [
        // 'attiecības_vārds' => [ self::HAS_MANY, 'SaistītāKlase', 'ārējais_atslēgas_lauks' ],
    ];

    /**
     * Konstruktors
     * @param mixed $datubāzesSavienojums Savienojums ar datubāzi
     */
    public function __construct($datubāzesSavienojums)
    {
        parent::__construct($datubāzesSavienojums, 'lietotāji');
    }
}

CRUD funkcijas

find($id = null) : boolean|ActiveRecord

Atrast vienu ierakstu un piešķirt to pašreizējam objektam. Ja padodat kādu $id, tas veiks meklēšanu pēc primārās atslēgas ar šo vērtību. Ja netiek padots nekas, tā vienkārši atradīs pirmo ierakstu tabulā.

Papildus varat padot citus palīglīdzekļus, lai vaicātu jūsu tabulu.

// atrast ierakstu ar priekšnosacījumiem
$user->notNull('password')->orderBy('id DESC')->find();

// atrast ierakstu ar konkrētu id
$id = 123;
$user->find($id);

findAll(): array<int,ActiveRecord>

Atrast visus ierakstus tabulā, ko norādījāt.

$user->findAll();

isHydrated(): boolean (v0.4.0)

Atgriež true, ja pašreizējais ieraksts ir uzpildīts (paņemts no datubāzes).

$user->find(1);
// ja ieraksts tika atrasts ar datiem...
$user->isHydrated(); // true

insert(): boolean|ActiveRecord

Ievieto pašreizējo ierakstu datubāzē.

$user = new User($pdo_savienojums);
$user->name = 'demo';
$user->password = md5('demo');
$user->insert();

Teksta Bāzēta Primārās Atslēgas

Ja jums ir teksta bāzēta primārā atslēga (piemēram, UUID), jūs varat iestatīt primāro atslēgu vērtību pirms ievietošanas kādā no diviem veidiem.

$user = new User($pdo_savienojums, [ 'primaryKey' => 'uuid' ]);
$user->uuid = 'kāds-uuid';
$user->name = 'demo';
$user->password = md5('demo');
$user->insert(); // vai $user->save();

vai varat ļaut primāro atslēgu automātiski ģenerēties, izmantojot notikumus.

class User extends flight\ActiveRecord {
    public function __construct($datubāzes_savienojums)
    {
        parent::__construct($datubāzes_savienojums, 'lietotāji', [ 'primaryKey' => 'uuid' ]);
        // varat arī iestatīt primāro atslēgu šādi, nevis iepriekš definētajā masīvā.
        $this->primaryKey = 'uuid';
    }

    protected function beforeInsert(self $self) {
        $self->uuid = uniqid(); // vai kā jums vajag ģenerēt savus unikālos identifikatorus
    }
}

Ja nepiesakāt primāro atslēgu pirms ievietošanas, tā tiks iestatīta uz rowid, un datubāze to ģenerēs jums, bet tas nesanāks, jo šis lauks varētu nepastāvēt jūsu tabulā. Tāpēc ir ieteicams izmantot notikumu, lai automātiski šo apstrādātu.

update(): boolean|ActiveRecord

Atjaunina pašreizējo ierakstu datubāzē.

$user->gt('id', 0)->orderBy('id desc')->find();
$user->email = 'tests@piemērs.com';
$user->update();

save(): boolean|ActiveRecord

Ievieto vai atjaunina pašreizējo ierakstu datubāzē. Ja ierakstam ir id, tas tiks atjaunināts, pretējā gadījumā tas tiks ievietots.

$user = new User($pdo_savienojums);
$user->name = 'demo';
$user->password = md5('demo');
$user->save();

Piezīme: Ja klasē ir definētas attiecības, tās tiks šķērsotas, lai atjaunotu arī tās attiecības, ja tās ir definētas, instancētas un ir netīras datu atjaunošanai. (v0.4.0 un jaunāk)

delete(): boolean

Nosaka pašreizējo ierakstu no datubāzes.

$user->gt('id', 0)->orderBy('id desc')->find();
$user->delete();

Varat arī dzēst vairākus ierakstus, pirms izpildāt meklēšanu.

$user->like('name', 'Boba%')->delete();

dirty(array $dirty = []): ActiveRecord

Netīros dati attiecas uz datiem, kas ir mainīti ierakstā.

$user->gt('id', 0)->orderBy('id desc')->find();

// nekas nav "netīrs" līdz šim.

$user->email = 'tests@piemērs.com'; // tagad e-pasts tiek uzskatīts par "netīru", jo tas ir mainījies.
$user->update();
// tagad nav neviena netīrā datu, jo tā ir atjaunināta un saglabāta datubāzē

$user->password = password_hash()'jaunāparole'); // tagad tas ir netīrs
$user->dirty(); // nosūtot neko tīši notīra visus netīros ierakstus.
$user->update(); // netiks veikts neviens atjaunošana, jo nav sagrābts, ka kaut kas ir netīrs.

$user->dirty([ 'name' => 'kautkas', 'password' => password_hash('atkārtota atšifrēšanas parole') ]);
$user->update(); // abi vārdi un parole tiks atjaunoti.

copyFrom(array $data): ActiveRecord (v0.4.0)

Tas ir sinonīms dirty() metodei. Tas ir mazliet skaidrāk, ko jūs darāt.

$user->copyFrom([ 'name' => 'kautkas', 'password' => password_hash('atkārtota atšifrēšanas parole') ]);
$user->update(); // abi vārdi un parole tiks atjaunoti.

isDirty(): boolean (v0.4.0)

Atgriež true, ja pašreizējais ieraksts ir mainīts.

$user->gt('id', 0)->orderBy('id desc')->find();
$user->email = 'tests@piemērs.com';
$user->isDirty(); // true

reset(bool $include_query_data = true): ActiveRecord

Atiestata pašreizējo ierakstu uz tā sākotnējo stāvokli. Tas ir ļoti noderīgi izmantojot cikliskā tipa uzvedību. Ja padodat true, tas arī atiestatīs vaicājumu datus, kas tika izmantoti, lai atrastu pašreizējo objektu (noklusējuma uzvedība).

$lietotāji = $user->gt('id', 0)->orderBy('id desc')->find();
$user_uzņēmums = new UserCompany($pdo_savienojums);

foreach($lietotāji as $lietotājs) {
    $user_uzņēmums->reset(); // sākt ar tīru plaukta izskatu
    $user_uzņēmums->user_id = $lietotājs->id;
    $user_uzņēmums->company_id = $daudzums_uzņēmuma_id;
    $user_uzņēmums->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 izveidotā SQL un izmantot to, lai atkļūdotu.

SQL Vaicājuma Metodes

select(string $field1 [, string $field2 ... ])

Jūs varat atlasīt tikai dažus tabulas laukus, ja vēlaties (tas ir efektīvāks ļoti plašu tabulu ar daudziem laukiem gadījumā)

$user->select('id', 'name')->find();

from(string $table)

Jūs tehniski varat izvēlēties citu tabulu arī! Kāpēc arī ne?

$user->select('id', 'name')->from('user')->find();

join(string $table_name, string $join_condition)

Jūs varat pat pievienot citai tabulai datubāzē.

$user->join('kontakti', 'kontakti.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 šдика ›куфос ки.а. џањ.у ниурулка и ПНР ђагди.уии реди.хиртми.д та "кумирлк" дни.дируглик" ки њоьуцфук а руйд.джеигабн.у ПНР и $Пкп$ди ща' ПНРПккпеигш. Соади екцидаг екиграли.

Сеыйт хере фор тии репоситоры ин ГитХуб.

Небни Екиграли

Летс аснукуе једи ле поано:

ЦРЕАТЕ ТАБЛЕ Усерс (
    ид ІНТЕГЕР ПРИМАРЫ КЕУ,
    наме ТЕХТ,
    пассворд ТЕХТ 
);

Нос иаир тсеуп а нев чласс то репресент тхис табле:

/**
 * Ан АцтивеРецорд цласс ис усуаллы сингулар
 * 
 * Ит'с хигхлы рецоммендед то адд тхе пропертис оф тхе табле ас комментс хере
 * 
 * @проперты инт    $ид
 * @проперты стринг $наме
 * @проперты стринг $пассворд
 */ 
цласс Усер екстендс флигхт\АцтивеРецорд {
    публиц фунцтион __цонструкт($датабасе_цоннецтион)
    {
        // јоу цан сет ит тхис ваы
        парент::__цонструкт($датабасе_цоннецтион, 'усерс');
        // ор тхис ваы
        парент::__цонструкт($датабасе_цоннецтион, нулл, [ 'табле' => 'усерс']);
    }
}

Нов ватцх тхе магив ћаппен!

// фор ѕқлите
$датабасе_цоннецтион = неw РДО('сқлите:тест.дб'); // тхис ис јуст фор екампле, уоуд пробаЬлы усе а реал датабасе цоннецтион

// фор мүсқл
$датабасе_цоннецтион = неw РДО('мүсқл:host=localhost;дбнаме=тест_дб&цхарсет=утф8бм4', 'усернаме', 'пассворд');

// ор мйсли
$датабасе_цоннецтион = неw мүсқл('лоцалхост', 'усернаме', 'пассворд', 'тест_дб');
// ор мйсли витх нон-објецт басед цреатион
$датабасе_цоннецтион = мйсли_цоннецт('лоцалхост', 'усернаме', 'пассворд', 'тест_дб');

$усер = неw Усер($датабасе_цоннецтион);
$усер->наме = 'Боббы Таблес';
$усер->пассворд = пассворд_хаш('соме цоол пассворд');
$усер->инсерт();
// ор $усер->саве();

есхо $усер->ид; // 1

$усер->наме = 'Јосепх Мамма';
$усер->пассворд = пассворд_хаш('соме цоол пассворд агаин!!!');
$усер->инсерт();
// цан't усе $усер->саве() хере ор ит вилл тхинк ит's ан упдате!

есхо $усер->ид; // 2

Анд ит вас јуст тхат еасы то адд а нев усер! Нов тхат тхере ис а усер ров ин тхе датабасе, хоу до уоу пулл ит оут?

$усер->финд(1); // финд ид = 1 ин тхе датабасе анд ретурн ит.
есхо $усер->наме; // 'Боббы Таблес'

Анд шат иф уоу вант то финд алл тхе усерс?

$усерс = $усер->финдАлл();

Вхат абоут витх а цертаин цондитион?

$усерс = $усер->лике('наме', '%мамма%')->финдАлл();

Сее хов муцх фун тхис ис? Лет'с инсталл ит анд гет стартед!

Инсталлатион

Симплы инсталл витх Цомпосер

цомпосер рецуире флигхтпхп/ацтиве-рецорд 

Усаге

Тхис цан бе усед ас а стандалоне либрары ор витх тхе Флигхт ПХП Фрамеворк. Цомплетелы уп то уоу.

Стандалоне

Јуст макес шуре уоу пасс а ПДО цоннецтион то тхе констрцтор.

$пдо_цоннецтион = неw ПДО('сқлите:тест.дб'); // тхис ис јуст фор екампле, уоуд пробаЬлы усе а реал датабасе цоннецтион

$Усер = неw Усер($пдо_цоннецтион);

**Дон'т вант то алва

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

Brīnišķīgi spraudņi

Flight ir neaprakstāmi paplašinājams. Ir daudz spraudņu, kas var tikt izmantoti, lai pievienotu funkcionalitāti jūsu Flight lietotnei. Daži ir oficiāli atbalstīti ar "Flight" komandu, bet citi ir mikro/lite bibliotēkas, lai jums palīdzētu sākt.

Autentifikācija/Autorizācija

Autentifikācija un autorizācija ir būtiskas jebkurai lietotnei, kas prasa, lai kontroles būtu par to, kas var piekļūt kādam.

• flightphp/permissions - Oficiālā "Flight" atļauju bibliotēka. Šī bibliotēka ir vienkāršs veids, kā pievienot lietotāju un lietotnes līmeņa atļaujas jūsu lietojumprogrammai.

Kešošana

Kešošana ir lielisks veids, kā paātrināt jūsu lietojumprogrammu. Ir daudz kešošanas bibliotēku, kas var tikt izmantotas ar "Flight".

• Wruczek/PHP-File-Cache - Gaismas, vienkārša un autonomā PHP failu kešošanas klase

CLI

CLI lietojumprogrammas ir lielisks veids, kā mijiedarboties ar jūsu lietojumprogrammu. Jūs varat izmantot tās, lai ģenerētu vadītājus, attēlotu visus maršrutus un daudz vairāk.

• flightphp/runway - "Runway" ir CLI lietojumprogramma, kas palīdz jums pārvaldīt jūsu "Flight" lietojumprogrammas.

Sīkdatnes

Sīkdatnes ir lielisks veids, kā saglabāt nelielas datu daļiņas klienta pusē. To var izmantot, lai saglabātu lietotāja preferences, lietotnes iestatījumus, un daudz vairāk.

• overclokk/cookie - PHP sīkdatne ir PHP bibliotēka, kas nodrošina vienkāršu un efektīvu veidu, kā pārvaldīt sīkdatnes.

Atkļūvošana

Atkļūvošana ir būtiska, kad jūs izstrādājat savā lokālajā vidē. Ir daži spraudņi, kas var uzlabot jūsu atkļūvošanas pieredzi.

• tracy/tracy - Tā ir pilnīga ārkārtas vadība, kas var tikt izmantota ar "Flight". Tai ir vairākas paneļu, kas var palīdzēt jums atkļūvot jūsu lietojumprogrammu. Tas ir arī ļoti viegli paplašināms un pievieno savus paneļus.
• flightphp/tracy-extensions - Lietots ar Tracy kļūdu apstrādātāju, šis spraudnis pievieno vairākus papildu paneļus, lai palīdzētu ar atkļūvošanu īpaši "Flight" projektiem.

Datubāzes

Datubāzes ir pamats lielākajai daļai lietojumprogrammu. Tā ir veids, kā saglabāt un izgūt datus. Dažas datubāzes bibliotēkas ir vienkārši apvalki, lai rakstītu vaicājumus un dažas ir pilnvērtīgas ORM.

• flightphp/core PdoWrapper - Oficiālais "Flight" PDO apvalks, kas ir sastāvdaļa no pamata. Tas ir vienkāršs apvalks, kas palīdz vienkāršot vaicājumu rakstīšanas un to izpildes procesu. Tas nav ORM.
• flightphp/active-record - Oficiālais "Flight" aktīvais ieraksts ORM/Mapētājs. Lieliska maza bibliotēka, lai viegli iegūtu un saglabātu datus jūsu datubāzē.

Šifrēšana

Šifrēšana ir būtiska jebkurai lietojumprogrammai, kas saglabā jutīgus datus. Datus šifrēt un atšifrēt nav ļoti grūti, bet pareizi uzglabāt šifrēšanas atslēgu var būt grūti. Visbūtiskākais ir nekad neuzglabāt savu šifrēšanas atslēgu publiskajā katalogā vai to neievadīt savā kodu repozitorijā.

• defuse/php-encryption - Šī ir bibliotēka, kas var tikt izmantota, lai šifrētu un atšifrētu datus. Sākt darbu ar to ir diezgan vienkārši, lai sāktu šifrēt un atšifrēt datus.

Sesija

Sesijas nav īsti noderīgas API, bet, ja veidojat tīmekļa lietojumprogrammu, sesijas var būt būtiskas, lai uzturētu stāvokli un pieteikšanās informāciju.

• Ghostff/Session - PHP sesiju pārvaldītājs (nenovēršami, ātri, segmenti, sesijas šifrēšana). Izmanto PHP open_ssl, lai iespējotu sesijas datu šifrēšanu/atšifrēšanu.

Veidne

Veidne ir būtiska jebkurai tīmekļa lietojumprogrammai ar UI. Ir daudz veidņu dzinēju, kas var tikt izmantoti ar "Flight".

• flightphp/core View - Tas ir ļoti pamata veidnes dzinējs, kas ir sastāvdaļa no pamata. Nav ieteicams lietot to, ja jums ir vairāk kā pāris lapas jūsu projektā.
• latte/latte - "Latte" ir pilnīgi atbalstīts veidnes dzinējs, kas ir ļoti viegli lietojams un jūtas tuvāk PHP sintaksei nekā Twig vai Smarty. Tas ir arī ļoti viegli paplašināms un pievienot savus filtrus un funkcijas.

Contributing

Vai ir jums spraudni, ko vēlaties kopīgot? Iesniedziet pieprasījumu izvilkt to uz sarakstu!

Media

Mediji

Mēs esam centušies atrast visu, ko varam par dažādiem mediju veidiem internetā ap Flight. Zemāk ir dažādi resursi, kurus varat izmantot, lai uzzinātu vairāk par Flight.

Raksti

• Labākie PHP mikro rāmji 2024. gadam autors n0nag0n (2024)
• RESTful API izveidošana ar Flight Framework autors n0nag0n (2024)
• Vienkārša emuāra veidošana ar Flight 2. daļa autors n0nag0n (2024)
• Vienkārša emuāra veidošana ar Flight 1. daļa autors n0nag0n (2024)
• 🚀 Vienkārša CRUD API izveidošana PHP ar Flight Framework autors soheil-khaledabadi (2024)
• PHP tīmekļa lietojumprogrammas veidošana ar Flight mikro rāmjiem autors Arthur C. Codex (2023)
• Labākie PHP rāmji tīmekļa izstrādē 2024. gadā autors Ravikiran A S (2023)
• Top 12 PHP rāmji: visaptveroša rokasgrāmata 2023. gadam autors marketing kbk (2023)
• 5 PHP rāmji, par kuriem, iespējams, jūs neesat dzirdējuši autors n0nag0n (2022)
• 12 labākie PHP rāmji tīmekļa izstrādātājiem, ņemot vērā 2023. gadā autors Anna Monus (2022)
• Labākie PHP mikro rāmji mākoņa serverī autors Shahzeb Ahmed (2021)
• PHP rāmji: 15 jaudīgas izvēles jūsu tīmekļa izstrādei autors AHT Tech (2020)
• Vienkārša PHP maršrutēšana ar FlightPHP autors Lucas Conceição (2019)
• Jauna PHP rāmja (Flight) izmēģināšana autors Leon (2017)
• FlightPHP iestatīšana darbam ar Backbonejs autors Timothy Tocci (2015)

Video

• PHP Flight Framework vienkāršs ievada video autors n0nag0n (2024)
• Iestatīt HTTP galvenes kodu Flightphp (3 risinājumi!!) autors Roel Van de Paar (2024)
• PHP Flight Framework pamācība. Ļoti viegls API projekts! autors n0nag0n (2022)
• CRUD tīmekļa lietojumprogramma ar php un mysql un bootstrap izmantojot flight autors Devlopteca - Oscar Uh (2021)
• DevOps & SysAdmins: Lighttpd pārveidošanas noteikums Flight PHP mikro rāmjiem autors Roel Van de Paar (2021)
• REST API Flight PHP pamācība #DAĻA2 IEVADĪT TABULAS informāciju #KODS (Tagalog) autors Info Singkat Official (2020)
• REST API Flight PHP pamācība #DAĻA1 informācija #KODS (Tagalog) autors Info Singkat Official (2020)
• Kā izveidot JSON REST API PHP - 2. daļa autors Codewife (2018)
• Kā izveidot JSON REST API PHP - 1. daļa autors Codewife (2018)
• Testēšana mikro rāmji PHP - Flight PHP, Lumen, Slim 3 un Laravel autors Codemarket (2016)
• Pamācība 1 Flight PHP - Instalācija autors absagg (2014)
• Pamācība 2 Flight PHP - Maršruts 1. daļa autors absagg (2014)

Examples

Vai nepieciešams ātri uzsākt?

Jums ir divas iespējas, kā uzsākt darbu ar Flight:

• Vienas faila skeleta pamatne: Viena faila, kas ietver visu, kas nepieciešams, lai palaistu jūsu lietotni vienā vienkāršā failā.
• Pilna skeleta pamatne: Vairāk pilnīga piemēra ar kontrolieriem un skatījumiem.

Vai nepieciešama iedvesma?

Lai arī tie oficiāli nav atbalstīti no Flight komandas, tie var dot jums idejas par to, kā strukturēt savus projektus, kas veidoti ar Flight!

• Flight piemēra blogs - Flight v3 ar Middleware, kontrolieriem, Active Record un Latte.
• Flight CRUD RESTful API - Vienkāršs CRUD API projekts, izmantojot Flight ietvaru, kas nodrošina pamata struktūru jauniem lietotājiem, lai ātri uzstādītu PHP lietotni ar CRUD operācijām un datu bāzes savienojamību. Projekts demonstrē, kā izmantot Flight RESTful API izstrādei, padarot to par ideālu mācību rīku iesācējiem un noderīgu sākuma komplektu pieredzējušākiem izstrādātājiem.
• Flight skolas vadības sistēma - Flight v3
• Paste Bin ar komentāriem - Flight v3
• Pamata skeleta lietotne
• Piemēru Wiki
• IT-Innovator PHP ietvara lietotne
• Mazais izglītojošais CMS (spāņu valodā)
• Itāļu dzelteno lapu API
• Vispārīgs satura pārvaldības sistēma (ar....ļoti maz dokumentācijas)
• Mazs php ietvars, kas balstīts uz Flight un medoo.
• Piemēra MVC lietotne

Vai vēlaties dalīties ar savu piemēru?

Ja jums ir projekts, ko vēlaties dalīties, lūdzu, iesniedziet pieprasījumu par izmaiņām, lai pievienotu to šai 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

• Lai izstrādes vidēs būtu svarīgi konfigurēt PHP iestatījumus atbilstoši jūsu projekta prasībām.
• Nomainot PHP versijas, pārliecinieties, ka visi attiecīgie PHP paplašinājumi ir instalēti attiecīgajai versijai, kuru plānojat izmantot.
• Pēc PHP versiju maiņas vai konfigurāciju atjaunošanas, restartējiet savu tīmekļa serveri (Apache, Nginx, u.c.), lai piemērotu izmaiņas.