Learn

Uzziniet par Flight

Flight ir ātrs, vienkāršs, paplašināms ietvars PHP valodai. Tas ir diezgan universāls un var tikt izmantots, lai izveidotu jebkuru veida tīmekļa lietojumprogrammu. Tas ir izstrādāts, ņemot vērā vienkāršību un uzrakstīts tā, lai būtu viegli saprotams un izmantojams.

Svarīgi Ietvara Jēdzieni

Kāpēc Ietvars?

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

Turklāt @lubiana ir izveidojusi lielisku pamācību. Lai arī tā nenodzīvo Flight konkrēti, šī vadlīnija palīdzēs jums saprast dažus galvenos jēdzienus, kas saistīti ar ietvaru, un kāpēc tos ir izdevīgi izmantot. Jūs varat atrast pamācību šeit.

Pamata Tēmas

Automātiskā Ielāde

Iemācieties, kā automātiski ielādēt savas klases savā lietojumprogrammā.

Maršruta Nosūtīšana

Iemācieties, kā pārvaldīt maršrutus savai tīmekļa lietojumprogrammai. Tas ietver arī maršrutu grupēšanu, maršruta parametrus un starpierobežojumus.

Starpnieklis

Iemācieties, kā izmantot starpnieku, lai filtrētu pieprasījumus un atbildes savā lietojumprogrammā.

Pieprasījumi

Iemācieties, kā apstrādāt pieprasījumus un atbildes savā lietojumprogrammā.

Atbildes

Iemācieties, kā nosūtīt atbildes saviem lietotājiem.

HTML Veidnes

Iemācieties, kā izmantot iebūvēto skatu dzinēju, lai renderētu savas HTML veidnes.

Drošība

Iemācieties, kā nodrošināt savu lietojumprogrammu pret vispārīgiem drošības apdraudējumiem.

Konfigurācija

Iemācieties, kā konfigurēt ietvaru savai lietojumprogrammai.

Paplašinot Flight

Iemācieties, kā paplašināt ietvaru ar savu metožu un klašu pievienošanu.

Notikumi un Filtrēšana

Iemācieties, kā izmantot notikumu sistēmu, lai pievienotu āķus saviem metodēm un iekšējiem ietvaru metodēm.

Atkarību Ievietošanas Konteiners

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

Ietvara API

Uzziniet par ietvaras galvenajām metodēm.

Pāreja uz v3

Atgrieztais savietojamība lielākoties ir saglabāta, bet ir dažas izmaiņas, par kurām jums vajadzētu zināt, pārejot no v2 uz v3.

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

Migrēšana uz v3

Atgriezeniskā saderība lielākoties ir saglabāta, bet ir dažas izmaiņas, par kurām jums jāņem vērā, migrējot no v2 uz v3.

Izvades buferēšanas uzvedība (3.5.0)

Izvades buferēšana ir process, kurā PHP skripta ģenerētā izvade tiek saglabāta buferī (iekšējā PHP) pirms tā tiek nosūtīta klientam. Tas ļauj jums modificēt izvadi pirms tā tiek nosūtīta klientam.

MVC lietojumprogrammā Kļūdu izvadītājs ir "vadītājs" un tas vadīt to, ko skats dara. Izvade, kas tiek ģenerēta ārpus vadītāja (vai dažreiz Fly ietvars gadījumā anonīmā funkcija) pārkāpj MVC modeli. Šī izmaiņa ir veikta, lai iegūtu lielāku saderību ar MVC modeli un padarītu ietvaru paredzamāku un vieglāk lietojamu.

v2, izvades buferēšana tika apstrādāta tā, ka tā konsistenti neatvēra savu izvades buferi, kas padarīja mērvienību testēšanu un straumēšanu sarežģītāku. Lielākajai vairumu lietotāju šī izmaiņa varētu neietekmēt praktiski. Tomēr, ja jūs atgriežat saturu ārpusizsaucamajiem un vadītājiem (piemēram, āķī), iespējams, ka uz jums gaida problēmas. Uzskaitot saturu āķos un pirms ietvara faktiskā izpildes agrāk varēja darboties, bet nedarbosies turpmāk.

Vietas, kur var būt problēmas

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

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

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

Flight::map('hello', 'hello');
Flight::after('hello', function(){
    // tas faktiski būs kārtībā
    echo '<p>Šo Sveika pasaule frazi jums sagādā burti "S"</p>';
});

Flight::before('sākums', function(){
    // lietas, kas izskatās šādi, radīs kļūdu
    echo '<html><head><title>Mana lapa</title></head><body>';
});

Flight::route('/', function(){
    // tas faktiski ir tikai labi
    echo 'Sveika pasaule';

    // Tas arī būtu tikai labi
    Flight::hello();
});

Flight::after('sākums', function(){
    // tas radīs kļūdu
    echo '<div>Jūsu lapa ielādējās '.(microtime(true) - START_TIME).' sekundes</div></body></html>';
});

Ieslēgt v2 izvades buferēšanas uzvedību

Vai joprojām varat paturēt savu veco kodu tāpat kā tas ir, neveicot pārrakstīšanu, lai tas strādātu ar v3? Jā, jūs varat! Jūs varat ieslēgt v2 izvades buferēš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 ietvarā tas tiks noņemts.

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

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

Flight::before('sākums', function(){
    // Tagad tas būs tikai kārtībā
    echo '<html><head><title>Mana lapa</title></head><body>';
});

// vairāk koda 

Dispečera izmaiņas (3.7.0)

Ja jūs tieši esat izsaukdami statiskās metodes Dispatcher, piemēram, Dispatcher::invokeMetode(), Dispečera::execute(), utt., jums būs jāatjaunina savs kods, lai neizsauktu šīs metodes tieši. Dispatcher ir pārveidots, lai būtu vairāk objektu orientēts, tādējādi Atkarību ieviešanas konteineri var tikt izmantoti vieglāk. Ja jums ir nepieciešams izsaukt metodi, līdzīgu tam, kā to darīja Dispečers, jūs varat manuāli izmantot kaut ko līdzīgu $rezultāts = $klase->$metode(...$parametri); vai call_user_func_array() vietā.

Learn/configuration

Konfigurācija

Jūs varat pielāgot noteiktas Flight uzvedības, iestatot konfigurācijas vērtības, izmantojot set metodi.

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

Pieejamie konfigurācijas iestatījumi

Zemāk ir uzskaitīts visi pieejamie konfigurācijas iestatījumi:

Mainīgie

Flight ļauj saglabāt mainīgos, lai tos varētu izmantot jebkur jūsu lietojumprogrammā.

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

// Cits jūsu lietojumprogrammas vietā
$id = Flight::get('id');

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

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

Jūs varat notīrīt mainīgo, darot:

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

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

Flight izmanto mainīgos arī 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 noķerti ar Flight un nodoti error metodē. Noklusējuma uzvedība ir nosūtīt vienkāršu HTTP 500 Internal Server Error atbildi ar dažādu kļūdu 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();
});

Noklusējuma uzvedībā kļūdas netiek reģistrētas tīmekļa serverī. Jūs varat iespējot to, 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 Not Found 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/security

Drošība

Drošība ir liela problēma, runājot par tīmekļa lietotnēm. Jums jānodrošina, lai jūsu lietotne būtu droša un jūsu lietotāju dati būtu drošībā. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt drošību savām tīmekļa lietotnēm.

Galvenes

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

Divas lieliskas vietnes, kurās varat pārbaudīt savu galvenu drošību, ir securityheaders.com un observatory.mozilla.org.

Pievienot manuāli

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

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

// Iestatiet Content-Security-Policy galveni, lai novērstu XSS
// Piezīme: šī galvene var kļūt ļoti sarežģīta, tāpēc jums vajadzēs
// konsultēties ar piemēriem internetā jūsu 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 sniffing
Flight::response()->header('X-Content-Type-Options', 'nosniff');

// Iestatiet Referrer-Policy galveni, lai kontrolētu, cik daudz informācijas tiek nosūtīta par nosūtītāju
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 Permissions-Policy galveni, lai kontrolētu, kādas funkcijas un API varēs izmantot
Flight::response()->header('Permissions-Policy', 'geolocation=()');

Šīs var pievienot virspusē jūsu bootstrap.php vai index.php failos.

Pievienot kā filtru

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

// Pievienot 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ā starpziņu

Jūs tos varat pievienot arī kā starpziņu klasi. Tas ir labs veids, kā saglabāt jūsu kodu tīru un kārtotu.


// app/middleware/SecurityHeadersMiddleware.php

namespace app\middleware;

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

// index.php vai kur jums ir marsruta
// Pamanījums, šis tukšais virknes grupa darbojas kā vispārējā starpziņa visiem maršrutiem. Protams, jūs varētu darīt to pašu un pievienot to tikai konkrētiem maršrutiem.
Flight::group('', function(Router $router) {
    $router->get('/lietotaji', [ 'UserController', 'getUsers' ]);
    // vairāk maršrutu
}, [ new SecurityHeadersMiddleware() ]);

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? Apskatiet "kāpēc izvēlēties ietvaru?" lapu, lai iegūtu detalizētāku skaidrojumu.

Vienkārša maršrutēšana Flight ietvarā tiek veikta, saskaņojot URL paraugu ar atpakaļizsaucējfunkciju vai klases un metodes masīvu.

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

Maršruti tiek saskaņoti tajā secībā, kādā tie ir definēti. Pirmajam maršrutam, kas saskan ar pieprasījumu, tiks izpildīts.

Atpakaļizsaucēji/Funkcijas

Atpakaļizsaucējs var būt jebkura objekta, kas ir izsaukams. 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 sveiki() {
        echo 'sveika pasaule!';
    }
}

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

Vai izveidojot objektu vispirms un tad izsaucot metodi:


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

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

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

Flight::route('/', [ $sveiciens, 'sveiki' ]);
// Jūs varat to darīt arī bez objekta izveidošanas pirmkārt
// Piezīme: Konstruktorā netiks ievietoti argumenti
Flight::route('/', [ 'Sveiciens', 'sveiki' ]);

Atkarību ievietošana, izmantojot DIC (Dependency Injection Container)

Ja vēlaties izmantot atkarību ievietošanu, izmantojot konteineru (PSR-11, PHP-DI, Dice, u.c.), vienīgā veida maršruti, kur tas ir pieejams, ir vai nu tieši izveidot objektu pats un izmantot konteineri, lai izveidotu savu objektu, vai arī varat izmantot virknes, lai definētu klasi un metodi, ko izsaukt. Varat doties uz Atkarību ievietošana lapu, lai iegūtu vairāk informācijas.

Šeit ir ātrs piemērs:


use flight\database\PdoWrapper;

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

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

// index.php

// Iestatiet konteineru ar visiem nepieciešamajiem parametriem
// Skatiet Atkarību ievietošanas lapu, lai iegūtu plašāku informāciju par PSR-11
$dice = new \Dice\Dice();

// Nedrīkst aizmirst pārvietot mainīgo saglabāšanai ar '$dice = '!!!!!
$dice = $dice->addRule('flight\database\PdoWrapper', [
    'shared' => true,
    'constructParams' => [ 
        'mysql:host=localhost;dbname=test', 
        'root',
        'password'
    ]
]);

// Reģistrēt konteineru apstrādes pasūtījumu
Flight::registerContainerHandler(function($class, $params) use ($dice) {
    return $dice->create($class, $params);
});

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

Flight::start();

Metodes Maršrutēšana

Pēc noklusējuma maršruta paraugi tiek saskaņoti pret visiem pieprasījuma metodēm. Jūs varat reaģēt uz konkrētām metodēm, novietojot 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 varat arī pievienot vairākas metodes vienai atpakaļizsaucējfunkcijai, izmantojot | atdalītāju:

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

Turklāt jūs varat iegūt Maršrutētāja objektu, kuram ir dažas palīgmetodes, ko varat izmantot:


$router = Flight::router();

// atkārto visus metodus
$router->map('/', function() {
    echo 'sveika pasaule!';
});

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

Regulārās izteiksmes

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

Flight::route('/lietotajs/[0-9]+', function () {
  // Tas saskanēs ar /lietotajs/1234
});

Kaut arī šī metode ir pieejama, rekomendējams izmantot nosauktos parametrus vai nosauktos parametrus ar regulārām izteiksmēm, jo tie ir lasāmāki un vieglāk uzturami.

Nosauktie Parametri

Jūs varat norādīt nosauktus parametrus savos maršrutos, kas tiks nodoti jūsu atpakaļizsaucējfonkcijai.

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

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

Flight::route('/@vards/@id:[0-9]{3}', function (string $vards, string $id) {
  // Tas saskanēs ar /bobs/123
  // Bet nesaskanēs ar /bobs/12345
});

Piezīme: Nesavienojam atbilstošos regex grupas () ar nosauktajiem parametriem. :'(

Neobligātie Parametri

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

Flight::route(
  '/blogs(/@gads(/@menesis(/@diena)))',
  function(?string $gads, ?string $menesis, ?string $diena) {
    // Tas saskanēs ar šādiem URL:
    // /blogs/2012/12/10
    // /blogs/2012/12
    // /blogs/2012
    // /blogs
  }
);

Jebkuri neobligāti parametri, kas nesaskan, tiks nodoti kā NULL.

Aizstādītāji

Saskanēšana tiek veikta tikai individuāliem URL segmentiem. Ja vēlaties saskanēt ar vairākiem segmentiem, varat izmantot * aizstādītāju.

Flight::route('/blogs/*', function () {
  // Tas saskanēs ar /blogs/2000/02/01
});

Lai saskanētu visas pieprasījumus ar vienu atpakaļizsaucējfonkciju, varat:

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

Pāreja

Jūs varat nodot izpildi nākamajam saskanētajam maršrutam, atgriežot true no jūsu atpakaļizsaucējfunkcijas.

Flight::route('/lietotajs/@vards', function (string $vards) {
  // Pārbaudiet nosacījumu
  if ($vards !== "Jānis") {
    // Turpiniet uz nākamo maršrutu
    return true;
  }
});

Flight::route('/lietotajs/*', function () {
  // Tas tiks izsaukts
});

Maršrutu Piešķiršana

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

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

// vēlāk jūsu kodā
Flight::getUrl('lietotaja_skats', [ 'id' => 5 ]); // atgriezīs '/lietotaji/5'

Tas ir īpaši noderīgi, ja jūsu URL mainās. Šajā piemērā, lecam uz gadījumu, ka lietotāji tiek pārvietots uz /admin/lietotaji/@id vietā. Ar aliāšu izmantošanu jūs nevajadzēs mainīt vietu, kur atsauces alianses, jo alianse tagad atgriezīs /admin/lietotaji/5 kā minēts iepriekšējā piemērā.

Maršruta aliāse darbojas arī grupās:

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

// vēlāk jūsu kodā
Flight::getUrl('lietotaja_skats', [ 'id' => 5 ]); // atgriezīs '/lietotaji/5'

Maršruta Informācija

Ja vēlaties pārbaudīt saskanēto maršruta informāciju, jūs varat pieprasīt, lai maršrutas objekts tiktu nodots jūsu atpakaļizsaucējfunkcijai, padodot true kā trešo parametru maršruta metodē. Maršruta objekts vienmēr tiks nodots kā pēdējais parametrs jūsu atpakaļizsaucējfunkcijai.

Flight::route('/', function(\flight\net\Route $maršruts) {
  // Masīvs ar saskaņotajām HTTP metodēm
  $maršruts->metodes;

  // Masīvs ar nosauktajiem parametriem
  $maršruts->parametri;

  // Saskaņošanas regulārā izteiksme
  $maršruts->regex;

  // Iekļauj jebkurus '*' izmantotos URL paraugā
  $maršruts->lāpne;

  // Parāda URL ceļu....ja jums patiešām tas ir nepieciešams
  $maršruts->paraugs;

  // Parāda, kāds starpprogrammatūru ir piešķirts
  $maršruts->starpprogrammatūra;

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

Maršruta Grupēšana

Var gadīties, ka 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('/lietotaji', function () {
    // Saskanēs /api/v1/lietotaji
  });

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

Pat varat ieienišanas grupas grupas:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() saņem mainīgos, tas neatrod maršrutu! Skatiet objekta kontekstu zemāk
    Flight::route('GET /lietotaji', function () {
      // Saskan ar GET /api/v1/lietotaji
    });

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

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

    // Flight::get() saņem mainīgos, tas neatrod maršrutu! Skatiet objekta kontekstu zemāk
    Flight::route('GET /lietotaji', function () {
      // Saskan ar GET /api/v2/lietotaji
    });
  });
});

Grupēšana ar Objekta Kontekstu

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

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

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

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

Strīmošana

Tagad jūs varat strādāt ar atbildēm klientam, izmantojot streamWithHeaders() metodi. Tas ir noderīgi lielu failu sūtīšanai, ilgstošiem procesiem vai lielu atbildes ģenerēšanai. Maršruta strīmošana tiek apstrādāta nedaudz atšķirīgi nekā parasts maršruts.

Piezīme: Strīmošanas atbildes ir pieejamas tikai tad, ja jums ir flight.v2.output_buffering iestatīts uz false.

Flight::route('/strimo-lietotājus# Maršrutēšana

> **Piezīme:** Vai vēlaties uzzināt vairāk par maršrutēšanu? Apskatiet ["kāpēc izvēlēties ietvaru?"](/learn/why-frameworks) lapu, lai iegūtu detalizētāku skaidrojumu.

Vienkārša maršrutēšana Flight ietvarā tiek veikta, saskaņojot URL paraugu ar atpakaļizsaucējfunkciju vai klases un metodes masīvu.

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

Maršruti tiek saskaņoti tajā secībā, kādā tie ir definēti. Pirmajam maršrutam, kas saskan ar pieprasījumu, tiks izpildīts.

Atpakaļizsaucēji/Funkcijas

Atpakaļizsaucējs var būt jebkura objekta, kas ir izsaukams. 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 sveiki() {
        echo 'sveika pasaule!';
    }
}

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

Vai izveidojot objektu vispirms un tad izsaucot metodi:


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

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

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

Flight::route('/', [ $sveiciens, 'sveiki' ]);
// Jūs varat to darīt arī bez objekta izveidošanas pirmkārt
// Piezīme: Konstruktorā netiks ievietoti argumenti
Flight::route('/', [ 'Sveiciens', 'sveiki' ]);

Atkarību ievietošana, izmantojot DIC (Dependency Injection Container)

Ja vēlaties izmantot atkarību ievietošanu, izmantojot konteineru (PSR-11, PHP-DI, Dice, u.c.), vienīgā veida maršruti, kur tas ir pieejams, ir vai nu tieši izveidot objektu pats un izmantot konteineri, lai izveidotu savu objektu vai varat izmantot virknes, lai definētu klasi un metodi, ko izsaukt. Varat doties uz Atkarību ievietošana lapu, lai iegūtu vairāk informācijas.

Šeit ir ātrs piemērs:


use flight\database\PdoWrapper;

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

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

// index.php

// Iestatiet konteineru ar visiem nepieciešamajiem parametriem
// Skatiet Atkarību ievietošanas lapu, lai iegūtu plašāku informāciju par PSR-11
$dice = new \Dice\Dice();

// Nedrīkst aizmirst pārvietot mainīgo saglabāšanai ar '$dice = '!!!!!
$dice = $dice->addRule('flight\database\PdoWrapper', [
    'shared' => true,
    'constructParams' => [ 
        'mysql:host=localhost;dbname=test', 
        'root',
        'password'
    ]
]);

// Reģistrēt konteineru apstrādes pasūtījumu
Flight::registerContainerHandler(function($class, $params) use ($dice) {
    return $dice->create($class, $params);
});

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

Flight::start();

Metodes Maršrutēšana

Pēc noklusējuma maršruta paraugi tiek saskaņoti pret visiem pieprasījuma metodēm. Jūs varat reaģēt uz konkrētām metodēm, novietojot 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 varat arī pievienot vairākas metodes vienai atpakaļizsaucējfunkcijai, izmantojot | atdalītāju:

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

Turklāt jūs varat iegūt Maršrutētāja objektu, kuram ir dažas palīgmetodes, ko varat izmantot:


$router = Flight::router();

// atkārto visus metodus
$router->map('/', function() {
    echo 'sveika pasaule!';
});

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

Regulārās izteiksmes

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

Flight::route('/lietotajs/[0-9]+', function () {
  // Tas saskanēs ar /lietotajs/1234
});

Kaut arī šī metode ir pieejama, rekomendējams izmantot nosauktos parametrus vai nosauktos parametrus ar regulārām izteiksmēm, jo tie ir lasāmāki un vieglāk uzturami.

Nosauktie Parametri

Jūs varat norādīt nosauktus parametrus savos maršrutos, kas tiks nodoti jūsu atpakaļizsaucējfonkcijai.

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

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

Flight::route('/@vards/@id:[0-9]{3}', function (string $vards, string $id) {
  // Tas saskanēs ar /bob/123
  // Bet nesaskanēs ar /bob/12345
});

Piezīme: Nesavienojam atbilstošos regex grupas () ar nosauktajiem parametriem. :'(

Neobligātie Parametri

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

Flight::route(
  '/blog(/@gads(/@menesis(/@diena)))',
  function(?string $gads, ?string $menesis, ?string $diena) {
    // Tas saskanēs ar šādiem URL:
    // /blog/2012/12/10
    // /blog/2012/12
    // /blog/2012
    // /blog
  }
);

Jebkuri neobligāti parametri, kas nesaskan, tiks nodoti kā NULL.

Aizstādītāji

Saskanēšana tiek veikta tikai individuāliem URL segmentiem. Ja vēlaties saskanēt ar vairākiem segmentiem, varat izmantot * aizstādītāju.

Flight::route('/blog/*', function () {
  // Tas saskanēs ar /blog/2000/02/01
});

Lai saskanētu visas pieprasījumus ar vienu atpakaļizsaucējfonkciju, varat:

Flight::route('*', function () {
  // Do something
});

Pāreja

Jūs varat nodot izpildi nākamajam saskanētajam maršrutam, atgriežot true no jūsu atpakaļizsaucējfunkcijas.

Flight::route('/lietotajs/@vards', function (string $vards) {
  // Pārbaudiet nosacījumu
  if ($vards !== "Bob") {
    // Turpiniet uz nākamo maršrutu
    return true;
  }
});

Flight::route('/lietotajs/*', function () {
  // This will get called
});

Maršruta Aliasing

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

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

// later in code somewhere
Flight::getUrl('user_view', [ 'id' => 5 ]); // will return '/users/5'

This is especially helpful if your URL happens to change. In the above example, lets say that users was moved to /admin/users/@id instead. With aliasing in place, you don't have to change anywhere you reference the alias because the alias will now return /admin/users/5 like in the example above.

Route aliasing still works in groups as well:

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

// later in code somewhere
Flight::getUrl('user_view', [ 'id' => 5 ]); // will return '/users/5'

Route Info

If you want to inspect the matching route information, you can request for the route object to be passed to your callback by passing in true as the third parameter in the route method. The route object will always be the last parameter passed to your callback function.

Flight::route('/', function(\flight\net\Route $route) {
  // Array of HTTP methods matched against
  $route->methods;

  // Array of named parameters
  $route->params;

  // Matching regular expression
  $route->regex;

  // Contains the contents of any '*' used in the URL pattern
  $route->splat;

  // Shows the url path....if you really need it
  $route->pattern;

  // Shows what middleware is assigned to this
  $route->middleware;

  // Shows the alias assigned to this route
  $route->alias;
}, true);

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 () {
    // Matches /api/v1/users
  });

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

You can even nest groups of groups:

Flight::group('/api', function () {
  Flight::group('/v1', function () {
    // Flight::get() gets variables, it doesn't set a route! See object context below
    Flight::route('GET /users', function () {
      // Matches GET /api/v1/users
    });

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

    Flight::put('/posts/1', function () {
      // Matches PUT /api/v1/posts
    });
  });
  Flight::group('/v2', function () {

    // Flight::get() gets variables, it doesn't set a route! See object context below
    Flight::route('GET /users', function () {
      // Matches 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) {

  // user the $router variable
  $router->get('/users', function () {
    // Matches GET /api/v1/users
  });

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

Streaming

You can now stream responses to the client using the streamWithHeaders() method. This is useful for sending large files, long running processes, or generating large responses. Streaming a route is handled a little differently than a regular route.

Note: Streaming responses is only available if you have flight.v2.output_buffering set to false.

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

    // If you have additional headers to set here after the route has executed
    // you must define them before anything is echoed out.
    // They must all be a raw call to the header() function or 
    // a call to Flight::response()->setRealHeader()
    header('Content-Disposition: attachment; filename="users.json"');
    // or
    Flight::response()->setRealHeader('Content-Disposition', 'attachment; filename="users.json"');

    // however you pull your data, just as an example...
    $users_stmt = Flight::db()->query("SELECT id, first_name, last_name FROM users");

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

        // This is required to send the data to the client
        ob_flush();
    }
    echo '}';

// This is how you'll set the headers before you start streaming.
})->streamWithHeaders([
    'Content-Type' => 'application/json',
    // optional status code, defaults to 200
    'status' => 200
]);

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 ievietošanas konteiners

Ievads

Atkarību ievietošanas 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. Daži piemēri DIC bibliotēkas ir: Dice, Pimple, PHP-DI un league/container.

DIC ir izteiksmīgs veids, kā teikt, ka tas ļauj jums izveidot un pārvaldīt savas klases vienkāršotā vietā. Tas ir noderīgi, kad jums ir nepieciešams padot vienādu objektu vairākām klasēm (piemēram, jūsu vadītājiem). Vienkāršs piemērs varētu palīdzēt labāk saprast.

Pamata piemērs

Vecākā darbības veida varbūt izskatītos šā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', 'user', 'pass'));
Flight::route('/user/@id', [ $UserController, 'view' ]);

Flight::start();

Var redzēt no iepriekšējās koda daļas, ka mēs izveidojam jaunu PDO objektu un nododam to mūsu UserController klasei. Tas ir labi mazai lietojumprogrammai, bet, kad jūsu lietojumprogramma izaug, jūs secināsiet, ka izveidojat to pašu PDO objektu vairākās vietās. Šeit noder DIC.

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


require 'vendor/autoload.php';

// tāda pati klase kā iepriekš. Nav mainījies nekas
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 pārdefinēt to pašu sev kā zemāk!
$container = $container->addRule('PDO', [
    // shared nozīmē, ka katru reizi tiks atgriezts tas pats objekts
    'shared' => true,
    'constructParams' => ['mysql:host=localhost;dbname=test', 'user', 'pass' ]
]);

// Tas reģistrē konteineru apstrādātāju, tāpēc Flight zina, kā 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('/user/@id', [ 'UserController', 'view' ]);
// vai arī alternatīvi varat definēt maršrutu šādi
Flight::route('/user/@id', 'UserController->view');
// vai
Flight::route('/user/@id', 'UserController::view');

Flight::start();

Es uzskatu, ka jūs varētu domāt, ka pie piemēra tika pievienots daudz papildu koda. Burvība rodas tad, kad jums ir cita kontroliera, kuram nepieciešams PDO objekts.


// Ja visiem jūsu kontrolieriem ir konstruktors, kuram nepieciešams PDO objekts
// katram zemāk esošajam maršrutam automātiski tiks veikta injekcija!!!
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');

Papildu bonusa ieguvums, izmantojot DIC, ir tas, ka vienības tests kļūst daudz vienkāršāks. Jūs varat izveidot modeli objektu un to nodot savai klasei. Tas ir liels ieguvums, kad jūs veicat testus savai lietotnei!

PSR-11

Flight arī var izmantot jebkuru PSR-11 saderīgu konteineri. Tas nozīmē, ka jūs varat izmantot jebkuru konteineri, kas īsteno PSR-11 interfeisu. Šeit ir piemērs, izmantojot League 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('user')
    ->addArgument('pass');
Flight::registerContainerHandler($container);

Flight::route('/user', [ 'UserController', 'view' ]);

Flight::start();

Lai arī tas var būt nedaudz izsmeļošāks nekā iepriekšējais Dice piemērs, tas tomēr paveic uzdevumu 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 vēlaties izmantot, kas nav PSR-11 (Dice). Apskatiet pamata piemēru, lai noskaidrotu, 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 instance

Ja jūs izmantojat Engine instanci savos vadītājos/starpposmos, šeit ir kā jūs to konfigurētu:


// Kurš mūsu sākumfailā
$engine = Flight::app();

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

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

// Tagad jūs varat izmantot Engine instanci savos vadītājos/starpposmos

class MansKontrolieris {
    public function __construct(Engine $app) {
        $this->app = $app;
    }

    public function index() {
        $this->app->render('index');
    }
}

Pievienojot citus klases

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


$container = new \Dice\Dice;
// Ja jums nav jāietver kaut kas jūsu klasē
// jums nav nepieciešams neko definēt!
Flight::registerContainerHandler(function($class, $params) use ($container) {
    return $container->create($class, $params);
});

class ManaPielāgotāKlase {
    public function parseThing() {
        return 'thing';
    }
}

class UserController {

    protected MyCustomClass $MyCustomClass;

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

    public function index() {
        echo $this->MyCustomClass->parseThing();
    }
}

Flight::route('/user', 'UserController->index');

Learn/middleware

Ceļa starpnieki

Filma atbalsta ceļa un grupas ceļa starpniekus. Starpnieks ir funkcija, kas tiek izpildīta pirms (vai pēc) ceļa atzvana. Tas ir lielisks veids, kā pievienot API autentifikācijas pārbaudes savā kodā vai pārbaudīt, vai lietotājam ir atļauja piekļūt šim ceļam.

Pamata vidējais

Šeit ir pamata piemērs:

// Ja norādāt tikai anonīmu funkciju, tā tiks izpildīta pirms ceļa atzvana. 
// nav "pēc" starpnieku funkciju, izņemot klases (skatīt zemāk)
Flight::route('/ceļš', function() { echo 'Šeit es esmu!'; })->addMiddleware(function() {
    echo 'Starpposms pirmais!';
});

Flight::start();

// Tas izvadīs "Starpposms pirmais! Šeit es esmu!"

Ir daži ļoti svarīgi punkti par vidējiem, par kuriem jums jāzina, pirms tos lietojat:

Starpnieku klases

Starpniekus var reģistrēt arī kā klasi. Ja jums nepieciešama "pēc" funkcionalitāte, jums izmanto klase.

class ManaVidējā {
    public function before($params) {
        echo 'Starpposms pirmais!';
    }

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

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

Flight::start();

// Šis parādīs "Starpposms pirmais! Šeit es esmu! Starpposms pēdējais!"

Grupveida starpnieki

Jūs varat pievienot ceļa grupu, un tad katram ceļam šajā grupā būs vienādi starpnieki. Tas ir noderīgi, ja ir nepieciešams grupēt daudzus ceļus ar, piemēram, Autentifikācijas starpnieku, lai pārbaudītu API atslēgu galvenē.


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

    // Šis "tukšais" izskatās tips parastsceļš patiesībā sakrīt /api
    Flight::route('', function() { echo 'api'; }, false, 'api');
    Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotāji');
    Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotājs_skatīt');
}, [ jauns ApiAuthMiddleware() ]);

Ja vēlaties piemērot globālu vidējo visiem savām ceļiem, varat pievienot "tukšu" grupu:


// pievienots grupas metodes beigās
Flight::group('', function() {
    Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotāji');
    Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotājs_skatīt');
}, [ jauns 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 ietver HTTP pieprasījumu vienā objektā, kuram var piekļūt, veicot:

$request = Flight::request();

Pieprasījuma objekts nodrošina šādas īpašības:

Jūs varat piekļūt query, data, cookies un files īpašībām kā masīviem vai objektiem.

Tātad, lai iegūtu pieprasījuma virknes parametru, jūs varat izdarīt:

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

Vai arī varat izdarīt:

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

NEAPSTRĀDĀTS Pieprasījuma ķermenis

Lai iegūtu neapstrādātu HTTP pieprasījuma ķermeni, piemēram, darbojoties ar PUT pieprasījumiem, jūs varat izdarīt:

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

JSON Ievade

Ja nosūtāt pieprasījumu ar tipu application/json un datiem {"id": 123} tas būs pieejams no data īpašības:

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

Piekļuve $_SERVER

Ir ātrgaita pieejama, lai piekļūtu $_SERVER masīvam, izmantojot getVar() metodi:


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

Pieprasījuma galvenumu piekļuve

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


// Varbūt jums nepieciešams Autentifikācijas galvenums
$host = Flight::request()->getHeader('Authorization');

// Ja vēlaties iegūt visus galvenumus
$headers = Flight::request()->getHeaders();

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

Struktūras API Metodes

Flight ir izstrādāts, lai būtu viegli lietojams un saprotams. Zemāk ir pilns struktūras metožu kopums. Tas sastāv no pamatmetodēm, kas ir parastas statiskas metodes, un paplašināmajām metodēm, kas ir pievienotas metodes, kuras var filtrēt vai pārrakstīt.

Pamatmetodes

Šīs metodes ir būtiskas struktūrai un tās nevar pārrakstīt.

Flight::map(virkne $name, izsaukums $callback, booleāns $pass_route = false) // Izveido pielāgotu struktūras metodi.
Flight::register(virkne $name, virkne $class, masīvs $params = [], ?izsaukums $callback = null) // Reģistrē klasi struktūras metodē.
Flight::unregister(virkne $name) // Atceļ klasi no struktūras metodes.
Flight::before(virkne $name, izsaukums $callback) // Pievieno filtru pirms struktūras metodes.
Flight::after(virkne $name, izsaukums $callback) // Pievieno filtru pēc struktūras metodes.
Flight::path(virkne $path) // Pievieno ceļu, lai automātiski ielādētu klases.
Flight::get(virkne $key) // Iegūst mainīgo vērtību.
Flight::set(virkne $key, mixed $value) // Iestata mainīgo vērtību.
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ē struktūru pēc noklusējuma iestatījumiem.
Flight::app() // Iegūst lietojumprogrammas objekta instanci.
Flight::request() // Iegūst pieprasījuma objekta instanci.
Flight::response() // Iegūst atbildes objekta instanci.
Flight::router() // Iegūst maršrutētāja objekta instanci.
Flight::view() // Iegūst skata objekta instanci.

Paplašināmās Metodes

Flight::start() // Sāk struktūru.
Flight::stop() // Aptur struktūru un nosūta atbildi.
Flight::halt(int $code = 200, virkne $message = '') // Aptur struktūru ar iespējamo statusa kodu un ziņojumu.
Flight::route(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē URL paraugu pieprasījumam.
Flight::post(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē POST pieprasījuma URL paraugu pieprasījumam.
Flight::put(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē PUT pieprasījuma URL paraugu pieprasījumam.
Flight::patch(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē PATCH pieprasījuma URL paraugu pieprasījumam.
Flight::delete(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē DELETE pieprasījuma URL paraugu pieprasījumam.
Flight::group(virkne $pattern, izsaukums $callback) // Izveido grupēšanu URL adresēm, paraugam jābūt virknei.
Flight::getUrl(virkne $name, masīvs $params = []) // Ģenerē URL, balstoties uz maršruta aliasu.
Flight::redirect(virkne $url, int $code) // Novirza uz citu URL adresi.
Flight::render(virkne $file, masīvs $data, ?virkne $key = null) // Atveido veidni failā.
Flight::error(Throwable $error) // Sūta HTTP 500 atbildi.
Flight::notFound() // Sūta HTTP 404 atbildi.
Flight::etag(virkne $id, virkne $type = 'string') // Veic ETag HTTP kešošanu.
Flight::lastModified(int $time) // Veic pēdējo modificēto HTTP kešošanu.
Flight::json(mixed $data, int $code = 200, booleāns $encode = true, virkne $charset = 'utf8', int $option) // Sūta JSON atbildi.
Flight::jsonp(mixed $data, virkne $param = 'jsonp', int $code = 200, booleāns $encode = true, virkne $charset = 'utf8', int $option) // Sūta JSONP atbildi.

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

Learn/why_frameworks

Kāpēc ietvars?

Daudzi programmētāji kategoriski iebilst pret ietvariem. Viņi argumentē, ka ietvari ir pūderīgi, lēni un grūti saprotami. Viņi saka, ka ietvari nav nepieciešami un ka jūs varat rakstīt labāku kodu bez tiem. Noteikti var izvirzīt dažus pamatotus iebildumus par ietvaru izmantošanas trūkumiem. Tomēr ir arī daudzas priekšrocības, izmantojot ietvarus.

Iemesli Izmantot Ietvaru

Šeit ir daži iemesli, kāpēc varētu ņemt vērā ietvaru izmantošanu:

<<<<<<< Updated upstream Flight ir mikroietvars. Tas nozīmē, ka tas ir mazs un viegls. Tas nenodrošina tik daudz funkcionalitātes kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina daudz no funkcionalitātes, kas jums nepieciešama, lai izveidotu tīmekļa lietojumprogrammas. Tas ir arī viegli mācīties un lietot. Tas padara to par labu izvēli, lai ātri un viegli izveidotu tīmekļa lietojumprogrammas. Ja jums ir jauni ietvaru, Flight ir lielisks sākuma ietvars iesācējam. Tas palīdzēs jums uzzināt par ietvaru izmantošanas priekšrocībām, neapburdot jūs ar pārāk lielu sarežģītību. Kad jums ir kāda pieredze ar Flight, būs vieglāk pāriet uz sarežģītākiem ietvariem, piemēram, Laravel vai Symfony, tomēr Flight joprojām var veiksmīgi izveidot izturīgu pieteikumu.

======= Flight ir mikroietvars. Tas nozīmē, ka tas ir neliels un viegls. Tas nenodrošina tik daudz funkcionalitātes kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina daudz no funkcionalitātes, kas jums nepieciešama, lai izveidotu tīmekļa lietojumprogrammas. Tas ir arī viegli mācīties un lietot. Tas padara to par labu izvēli, lai ātri un viegli izveidotu tīmekļa lietojumprogrammas. Ja jums ir jauni ietvaru, Flight ir lielisks sākuma ietvars iesācējam. Tas palīdzēs jums uzzināt par ietvaru izmantošanas priekšrocībām, neapburdot jūs ar pārāk lielu sarežģītību. Kad jums ir kāda pieredze ar Flight, būs vieglāk pāriet uz sarežģītākiem ietvariem, piemēram, Laravel vai Symfony, tomēr Flight joprojām var veiksmīgi izveidot izturīgu pieteikumu.

Stashed changes

Kas ir Maršrutēšana?

Maršrutēšana ir Flight ietvara pamats, bet kas tieši tas ir? Maršrutēšana ir procesa, kurā tiek ņemta URL un tiek atrasta atbilstoša funkcija jūsu kodā. Tie ir veidi, kā panākt to, lai jūsu tīmekļa vietne darītu dažādas lietas, atkarībā no pieprasītās URL. Piemēram, jūs varētu vēlēties rādīt lietotāja profilu, kad viņi apmeklē /lietotājs/1234, bet rādīt visu lietotāju sarakstu, kad tie apmeklē /lietotāji. Tas viss tiek darīts, pateicoties maršrutēšanai.

Tam varētu izskatīties kaut kas šāds:

Un Kāpēc Tas ir Svarīgi?

Proper centralizētam maršrutētājam faktiski var dramatiski atvieglot jūsu dzīvi! Tas var būt grūti saprast no paša sākuma. Šeit ir daži iemesli, kāpēc:

Noteikti jums ir pazīstams veids, kā izveidot tīmekļa vietni skriptu pa skriptam. Jums varētu būt fails ar nosaukumu index.php, kurā ir daudz if izteikumu, lai pārbaudītu URL un pēc tam izpildītu konkrētu funkciju, atkarībā no URL. Tas ir veids, kā maršrutēšana, bet tas nav pārāk organizēts un tas ātri var ārprātīgi. Flight maršruta sistēma ir daudz labāk organizēta un spēcīgāka veida, kā apstrādāt maršrutēšanu.

Tas?


// /lietotājs/skats_profils.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    skatsLietotājaProfils($id);
}

// /lietotājs/labot_profils.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    rediģētLietotājaProfils($id);
}

// utt...

Vai tas?


// index.php
Flight::route('/lietotājs/@id', [ 'LietotājaKontrolieris', 'skatsLietotājaProfils' ]);
Flight::route('/lietotājs/@id/labot', [ 'LietotājaKontrolieris', 'rediģētLietotājaProfils' ]);

// Visticamāk jūsu app/controllers/UserController.php
class UserController {
    public function skatsLietotājaProfils($id) {
        // dariet kaut ko
    }

    public function rediģētLietotājaProfils($id) {
        // dariet kaut ko
    }
}

Jūsu varat sākt saprast ienesīguma būtību, izmantojot centralizētu maršrutēšanas sistēmu. Tā ir daudz vieglāk pārvaldāma un saprotamā ilgtermiņā!

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 ietvara būtība. Tas paņem pieprasījumu no lietotāja pārlūkprogrammas, apstrādā to, un pēc tam atsūta atbildi. Tas ir veids, kā var izveidot tīmekļa lietojumprogrammas, kas var darīt lietas, piemēram, rādīt lietotāja profilu, ļaut lietotājam pierakstīties vai publicēt jaunu bloga ierakstu.

Pieprasījumi

Pieprasījums ir tas, ko lietotāja pārlūkprogramma nosū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, uz kuru URL lietotājs vēlas apmeklēt, kādus datus lietotājs vēlas nosūtīt uz jūsu serveri vai kāda veida datus lietotājs vēlas saņemt no jūsu servera. Svarīgi zināt, ka pieprasījums ir tikai lasīšana. Jūs nevarat mainīt pieprasījumu, bet to varat lasīt.

Flight nodrošina vienkāršu veidu, kā piekļūt informācijai par pieprasījumu. Jūs varat piekļūt pieprasījuma informācijai, izmantojot Flight::request() metodi. Šī metode atgriež Request 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 atsūta atpakaļ uz lietotāja pārlūkprogrammu, 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, tajā var b# Kāpēc ietvars?

Daudzi programmētāji kategoriski iebilst pret ietvariem. Viņi argumentē, ka ietvari ir pūderīgi, lēni un grūti saprotami. Viņi saka, ka ietvari nav nepieciešami un ka jūs varat rakstīt labāku kodu bez tiem. Noteikti var izvirzīt dažus pamatotus iebildumus par ietvaru izmantošanas trūkumiem. Tomēr ir arī daudzas priekšrocības, izmantojot ietvarus.

Iemesli Izmantot Ietvaru

Šeit ir daži iemesli, kāpēc varētu ņemt vērā ietvaru izmantošanu:

Flight ir mikroietvars. Tas nozīmē, ka tas ir neliels un viegls. Tas nenodrošina tik daudz funkcionalitātes kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina daudz no funkcionalitātes, kas jums nepieciešama, lai izveidotu tīmekļa lietojumprogrammas. Tas ir arī viegli mācīties un lietot. Tas padara to par labu izvēli, lai ātri un viegli izveidotu tīmekļa lietojumprogrammas. Ja jums ir jauni ietvaru, Flight ir lielisks sākuma ietvars iesācējam. Tas palīdzēs jums uzzināt par ietvaru izmantošanas priekšrocībām, neapburdot jūs ar pārāk lielu sarežģītību. Kad jums ir kāda pieredze ar Flight, būs vieglāk pāriet uz sarežģītākiem ietvariem, piemēram, Laravel vai Symfony, tomēr Flight joprojām var veiksmīgi izveidot izturīgu pieteikumu.

Kas ir Maršrutēšana?

Maršrutēšana ir Flight ietvara pamats, bet kas tieši tas ir? Maršrutēšana ir procesa, kurā tiek ņemta URL un tiek atrasta atbilstoša funkcija jūsu kodā. Tie ir veidi, kā panākt to, lai jūsu tīmekļa vietne darītu dažādas lietas, atkarībā no pieprasītās URL. Piemēram, jūs varētu vēlēties rādīt lietotāja profilu, kad viņi apmeklē /lietotājs/1234, bet rādīt visu lietotāju sarakstu, kad tie apmeklē /lietotāji. Tas viss tiek darīts, pateicoties maršrutēšanai.

Tam varētu izskatīties kaut kas šāds:

Un Kāpēc Tas ir Svarīgi?

Proper centralizētam maršrutētājam faktiski var dramatiski atvieglot jūsu dzīvi! Tas var būt grūti saprast no paša sākuma. Šeit ir daži iemesli, kāpēc:

Noteikti jums ir pazīstams veids, kā izveidot tīmekļa vietni skriptu pa skriptam. Jums varētu būt fails ar nosaukumu index.php, kurā ir daudz if izteikumu, lai pārbaudītu URL un pēc tam izpildītu konkrētu funkciju, atkarībā no URL. Tas ir veids, kā maršrutēšana, bet tas nav pārāk organizēts un tas ātri var ārprātīgi. Flight maršruta sistēma ir daudz labāk organizēta un spēcīgāka veida, kā apstrādāt maršrutēšanu.

Tas?


// /lietotājs/skats_profils.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    skatsLietotājaProfils($id);
}

// /lietotājs/labot_profils.php?id=1234
if ($_GET['id']) {
    $id = $_GET['id'];
    rediģētLietotājaProfils($id);
}

// utt...

Vai tas?


// index.php
Flight::route('/lietotājs/@id', [ 'LietotājaKontrolieris', 'skatsLietotājaProfils' ]);
Flight::route('/lietotājs/@id/labot', [ 'LietotājaKontrolieris', 'rediģētLietotājaProfils' ]);

// Visticamāk jūsu app/controllers/UserController.php
class UserController {
    public function skatsLietotājaProfils($id) {
        // dariet kaut ko
    }

    public function rediģētLietotājaProfils($id) {
        // dariet kaut ko
    }
}

Jūsu varat sākt saprast ienesīguma būtību, izmantojot centralizētu maršrutēšanas sistēmu. Tā ir daudz vieglāk pārvaldāma un saprotamā ilgtermiņā!

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 ietvara būtība. Tas paņem pieprasījumu no lietotāja pārlūkprogrammas, apstrādā to, un pēc tam atsūta atbildi. Tas ir veids, kā var izveidot tīmekļa lietojumprogrammas, kas var darīt lietas, piemēram, rādīt lietotāja profilu, ļaut lietotājam pierakstīties vai publicēt jaunu bloga ierakstu.

Pieprasījumi

Pieprasījums ir tas, ko lietotāja pārlūkprogramma nosū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, uz kuru URL lietotājs vēlas apmeklēt, kādus datus lietotājs vēlas nosūtīt uz jūsu serveri vai kāda veida datus lietotājs vēlas saņemt no jūsu servera. Svarīgi zināt, ka pieprasījums ir tikai lasīšana. Jūs nevarat mainīt pieprasījumu, bet to varat lasīt.

Flight nodrošina vienkāršu veidu, kā piekļūt informācijai par pieprasījumu. Jūs varat piekļūt pieprasījuma informācijai, izmantojot Flight::request() metodi. Šī metode atgriež Request 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 atsūta atpakaļ uz lietotāja pārlūkprogrammu, 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, tajā var būt informācija par to, kādu veidu datus jūsu serveris vēlas nosūtīt lietotājam, kādu veidu datus jūsu serveris vēlas saņemt no lietotāja vai kādu veidu 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ūkprogrammu. Jūs varat nosūtīt atbildi, izmantojot Flight::response() metodi. Šī metode ņem Response objektu kā argumentu un nosūta atbildi uz lietotāja pārlūkprogrammu. Jūs varat izmantot šo objektu, lai nosūtītu atbildi uz lietotāja pārlūkprogramma, piemēram, HTML, JSON vai failu. Flight palīdz jums automātiski ģenerēt daļu no atbildes, lai atvieglotu lietas, bet visbeidzot jums ir kontrole par to, ko atsūtāt atpakaļ lietotājam.

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 jums lielākoties ir kontrole pār to, ko nosūtāt lietotājam atpakaļ. Dažreiz jūs varat tieši piekļūt Response objektam, bet lielāko daļu laika jūs izmantosiet Flight gadījumu, lai nosūtītu atbildi.

Nosūtīt pamata atbildi

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


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

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

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


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

    // ja vēlaties iegūt satura, ko esat iestatījis šajā punktā
    // to varat 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

Iestatot atbildes galveni

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


// Tas nosūtīs "Sveika, pasaule!" lietotāja pārlūkam vienkāršā teksta formātā
Flight::route('/', function() {
    Flight::response()->header('Content-Type', 'text/plain');
    echo "Sveika, pasaule!";
});

JSON

Flight piedāvā atbalstu JSON un JSONP atbilžu nosūtīšanai. Lai nosūtītu JSON atbildi jūs padodat datus, kas jāpārvērš par JSON:

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

JSONP

JSONP pieprasījumiem, jūs varat pēc izvēles padot vaicājuma parametra nosaukumu kurš tiek izmantots, lai definētu jūsu 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 jūs nepadodat vaicājuma parametra nosaukumu, tas pēc noklusējuma būs jsonp.

Pāradresēt uz citu URL

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

Flight::redirect('/jauns/atrašanās_vieta');

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

Flight::redirect('/jauns/atrašanās_vieta', 401);

Apturēšana

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

Flight::halt();

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

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

Izsaukšana halt iznīcinās jebkuru atbildes saturu līdz tam punktam. Ja vēlaties apturēt pamata struktūru un izvadīt pašreizējo atbildi, izmantojiet stop metodi:

Flight::stop();

HTTP kešošana

Flight iebūvēti atbalsta HTTP līmeņa kešošanai. Ja tiek izpildīta kešošanas nosacījums Flight atgriezīs HTTP 304 Nav modificēts atbildi. Nākamajā reizē, kad klients pieprasa to pašu resursu, viņi tiks aicināti izmantot vietējo saglabāto versiju.

Ceļa līmeņa kešošana

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


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

// Kā alternatīvu, jūs varat izmantot tekstu, ko padodat
// funkcijai strtotime()
Flight::route('/jaunumi', function () {
  Flight::response()->cache('+5 minutes');
  echo 'Šis saturs tiks kešots.';
});

Pēdējais mainījums

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

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

ETag

ETag kešošana ir līdzīga Pēdējais modificējums, izņemot to, ka jūs varat norādīt jebkuru id vienību ko vēlaties resursam:

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

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

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

# Skati

Flight pēc noklusējuma nodrošina dažas pamata veidnes funkcijas.

Ja jums ir nepieciešamas sarežģītākas veidņu prasības, skatiet Smarty un Latte piemērus sadaļā [Pielāgoti skati](#custom-views).

Lai parādītu skata veidni, izsauciet `render` metodi ar veidnes faila nosaukumu un neobligātu veidnes datu:

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

Veidnes dati, ko jūs nododat, tiek automātiski injicēti veidnē un var tikt atsaukti kā lokāla mainīgā. Veidnes faili vienkārši ir PHP faili. Ja hello.php veidnes faila saturs ir:

Sveiki, <?= $name ?>!

Izvade būs:

Sveiki, Bob!

Jūs arī varat 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āpēc jūs vienkārši varat:

Flight::render('hello');

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

Pēc noklusējuma Flight meklē views katalogu veidņu failiem. Jūs varat norādīt alternatīvu ceļu savām veidnēm, iestatot sekojošo konfigurāciju:

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

Izkārtojumi

Ir parasts, ka vietnēm ir viens izkārtojuma veidne ar mainīgu saturu. Lai renderētu saturu, kas tiks izmantots izkārtojumā, jūs varat nodot neobligātu parametru render metodē.

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

Tad jūsu skatījumā būs saglabāti mainīgie, ko sauc par headerContent un bodyContent. Tad jūs varēsiet renderēt savu izkārtojumu, darot:

Flight::render('layout', ['title' => 'Sākumlapa']);

Ja veidne 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ūs:

<html>
  <head>
    <title>Sākumlapa</title>
  </head>
  <body>
    <h1>Sveiki</h1>
    <div>Pasaule</div>
  </body>
</html>

Pielāgoti Skati

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

Smarty

Šeit ir, kā jūs varētu izmantot Smarty veidnes 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 veidnes datus
Flight::view()->assign('name', 'Bob');

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

Pilnīgumam, jums arī vajadzētu pārkārtot Flight noklusējuma render metodi:

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

Latte

Šeit ir, kā jūs varētu izmantot Latte veidnes 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 veidnes, lai paātrinātu procesu
  // Viena lieliska lieta par Latte ir tā, ka tas automātiski atsvaidzinās jūsu
  // kešatmiņu, kad jūs veicat izmaiņas šablonos!
  $latte->setTempDirectory(__DIR__ . '/../cache/');

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

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

Learn/extending

Paplašināšana

Flight ir izstrādāts, lai būtu paplašināms ietvars. Ietvars tiek piegādāts ar kopu pēc noklusējuma metodēm un komponentiem, bet tas ļauj jums atspoguļot savas metodes, reģistrēt savas klases vai pat pārrakstīt esošās klases un metodes.

Ja meklējat DIC (Atkarību ievades konteineris), apmeklējiet Dependency Injection Container lapu.

Metodes kartēšana

Lai atspoguļotu savu vienkāršo pielāgoto metodi, izmantojiet map funkciju:

// Atspoguļojiet savu metodi
Flight::map('hello', function (string $name) {
  echo "sveiki $name!";
});

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

Tas tiek izmantots vairāk, kad jums ir jāpadod mainīgie savā metodē, lai iegūtu paredzēto vērtību. Lai nodotu konfigurāciju un pēc tam izsauktu jūsu iepriekš konfigurēto klasi, ir vairāk ieteicams izmantot register() metodi.

Klases reģistrēšana

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

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

// Iegūstiet savas klases eksemplāru
$user = Flight::user();

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

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

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

// un ja vēlāk vajadzētu to savā kodā, vienkārši atkārtoti izsauciet to pašu metodi
class DažasKontrolieris {
  public function __construct() {
    $this->db = Flight::db();
  }
}

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

// Atsauces parametram tiks nodots izveidots objekts
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, jūs saņemsit koplietojumu. Lai iegūtu jaunu klases eksemplāru, vienkārši nododiet false kā parametru:

// Koplietots šīs klases eksemplārs
$shared = Flight::db();

// Jauns šīs klases eksemplārs
$new = Flight::db(false);

Ņemiet vērā, ka atspoguļotām metodēm ir prioritāte pār reģistrētajām klasēm. Ja jūs deklarējat abas, izmantojot to pašu nosaukumu, tiks izsaukta tikai atspoguļotā metode.

Esošo ietvara metožu pārrakstīšana

Flight ļauj jums pārrakstīt tās noklusējuma funkcionalitāti, lai piemērotu jūsu pašu vajadzībām, neizmainot nevienu kodu.

Piemēram, ja Flight nevar atbilst URL ar maršrutu, tā izsauc notFound metodi, kas nosūta vispārēju HTTP 404 atbildi. Jūs varat pārrakstīt šo uzvedību izmantojot map metodi:

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

Flight arī ļauj jums aizstāt ietvāra pamata 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', ManaisRouteris::class);

// Kad Flight ielādē Router eksemplāru, tas ielādēs jūsu klasi
$manaisrouteris = Flight::router();

Tomēr ietvara metodes, piemēram map un register, nevar būt pārrakstītas. Jums radīsies kļūda, ja mēģināsit to izdarīt.

Learn/json

JSON

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

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

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

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

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

my_func({"id":123});

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

Learn/autoloading

Automātiska ielāde

Automātiskā ielāde ir koncepts PHP, kurā norādat direktoriju vai direktorijas, no kurām jāielādē klases. Tas ir daudz izdevīgāk nekā izmantot require vai include, lai ielādētu klases. Tas ir arī prasība, lai izmantotu Composer paketes.

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

Pamata piemērs

Aplūkojam, ka mums ir direktoriju koks tāds kā zemāk:

# Piemēra ceļš
/home/lietotājs/projekts/mans-flight-projekts/
├── app
│   ├── kešatmiņa
│   ├── konfigurācija
│   ├── vadītāji - satur šī projekta vadītājus
│   ├── tulkojumi
│   ├── UTILS - satur klases tikai šim lietojumprogrammai (tas ir ar lielajiem burtiem apzināti, kā piemēramā vēlāk)
│   └── skati
└── publisks
    └── css
    └── js
    └── index.php

Varbūt pievērsāties uzmanību, ka tas ir vienādas failu struktūras kā šī dokumentācijas vietne.

Jūs varat norādīt katru direktoriju, no kuras jāielādē, šādi:


/**
 * publisks/index.php
 */

// Pievienot ceļu automātiskajam ielādētājam
Flight::path(__DIR__.'/../app/vadītāji/');
Flight::path(__DIR__.'/../app/utils/');

/**
 * app/vadītāji/MyController.php
 */

// nav obligāta nosaukumu telpošana

// Visas automātiski ielādētās klases tiek ieteiktas būt Pascal Case (katrs vārds lielajiem burtiem, bez atstarpēm)
// Ir prasība, ka jūs nevarat izmantot pasvītrojumus savās klases nosaukumā
class MyController {

    public function index() {
        // kaut ko
    }
}

Nosaukumtelpas

Ja jums ir nosaukumtelpas, ir ļoti viegli to ieviest. Jums vajadzētu izmantot Flight::path() metodi, lai norādītu aplikācijas saknes direktoriju (nevis dokumentu sakni vai publisks/ mapes).


/**
 * publisks/index.php
 */

// Pievienot ceļu automātiskajam ielādētājam
Flight::path(__DIR__.'/../');

Tagad šāda izskatās jūsu vadītāja varētu izskatīties. Apskatiet zemāk esošo piemēru, bet pievērsiet uzmanību komentāriem, lai iegūtu svarīgu informāciju.

/**
 * app/vadītāji/MyController.php
 */

// nosaukumtelpas ir obligātas
// nosaukumtelpas ir vienādas ar direktoriju struktūru
// nosaukumtelpām jāseko tādai pašai lietotnei kā direktoriju struktūrai
// nosaukumtelpās un direktorijās nevar būt nekādu pasvītrojumu
namespace app\vadītāji;

// Visas automātiski ielādētās klases tiek ieteiktas būt Pascal Case (katrs vārds lielajiem burtiem, bez atstarpēm)
// Ir prasība, ka jūs nevarat izmantot pasvītrojumus savās klases nosaukumā
class MyController {

    public function index() {
        // kaut ko
    }
}

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


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

// nosaukumtelpai jāsakrīt ar direktoriju struktūru un režīmu (Ņemiet vērā, ka UTILS direktorijā ir visi burti ar lielajiem burtiem
//     kā failu koks augšā)
namespace app\UTILS;

class ArrayHelperUtil {

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

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 License (MIT)
=================

Autortiesības © `2023` `@mikecao, @n0nag0n`

Atļauja tiek piešķirta bez maksas jebkurai personai,
kas iegūst šīs programmatūras kopiju un saistītos
dokumentus (turpmāk - “Programmatūra”), lai varētu
izmantot Programmatūru bez ierobežojumiem, ieskaitot,
bet neaprobežojoties ar, tiesības izmantot, kopēt,
modificēt, apvienot, publicēt, izplatīt, sublicencēt
un/vai pārdot Programmatūras kopijas, kā arī atļaut
personām, kurām Programmatūra tiek nodrošināta, to darīt,
ievērojot sekojošos nosacījumus:

Piemērotie autortiesību paziņojumi un šī atļauja
paziņojums obligāti jāiekļauj visos kopiju vai
īpaši lielos Programmatūras daļās.

Programmatūra tiek nodrošināta “kā ir”, bez
jebkādām garantijām, izteiktām vai pieļaujamām,
ieskaitot, bet neaprobežojoties ar, komerciālo
kvalitāti, piemērotību konkrētai vajadzībai un
nepārkāpšanu. Autori vai autortiesību turētāji
nav atbildīgi par nekādiem prasījumiem, zaudējumiem
vai citiem pienākumiem, vai nu, līgumtiesiski,
deliktiski vai citādi, ko rada, izriet no vai saistīti
ar Programmatūru vai tās izmantošanu vai citiem darījumiem
ar Programmatūru.

About

Kas ir Flight?

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

Flight ir lielisks iesācējiem paredzēts ietvars tiem, kuriem PHP ir jaunums un kuri 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 vairāk kontroles pār savām tīmekļa lietojumprogrammām. Tas ir izstrādāts tā, lai viegli varētu izveidot RESTful API, vienkāršu tīmekļa lietojumprogrammu vai sarežģītu tīmekļa lietojumprogrammu.

Ātrā sākšana

<?php

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

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

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

Flight::start();

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

Ķermeņa struktūra/uzgrieznis lietojumprogramma

Ir piemēra lietojumprogramma, kas var palīdzēt jums sākt darbu ar Flight ietvaru. Dodieties uz flightphp/skeleton, lai saņemtu instrukcijas, kā sākt darbu! Vai arī apmeklējiet piemēru lapu, lai iedvesmotu jūs par dažām lietām, ko varat darīt ar Flight.

Kopiena

Mēs esam Matrix! Sarunājieties ar mums vietnē #flight-php-framework:matrix.org.

Piedalīšanās

Ir divi veidi, kā jūs varat piedalīties projektā Flight:

  1. Jūs varat piedalīties pamata ietvara izstrādē, apmeklējot pamata izstrādes krātuvi.
  2. Jūs varat piedalīties dokumentācijā. Šī dokumentācijas vietne tiek uzturēta Github. Ja pamanāt kādu kļūdu vai vēlaties labāk izstrādāt kādu lietu, droši labojiet to un iesniedziet “pull request”! Mēs cenšamies turēties līdzi lietām, bet atjauninājumi un valodas tulkojumi tiek uzņemti ar prieku.

Prasības

Flight prasa PHP 7.4 vai jaunāku versiju.

Piezīme: PHP 7.4 tiek atbalstīts, jo rakstīšanas brīdī (2024. gadā) PHP 7.4 ir noklusējuma versija dažiem LTS Linux izplatījumiem. Pāreja uz PHP >8 liktu lielu galvassāpi šo lietotāju. Ietvars atbalsta arī PHP >8.

Licences līgums

Flight ir izdotss pēc 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 autonomas PHP faila kešatmiņas klase

Izdevības

Uzstādīšana

Uzstādīt, 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 padodat katalogu, 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 tā ir produktīvā režīmā
    // ENVIRONMENT ir konstante, kas iestatīta jūsu ielādes failā vai citur jūsu lietotnē
    $cache->setDevMode(ENVIRONMENT === 'development');
});

Tad to varat izmantot savā kodā šādi:


// Iegūt kešatmiņas instanci
$cache = Flight::cache();
$data = $cache->refreshIfExpired('simple-cache-test', function () {
    return date("H:i:s"); // atgriezt dati, kas jākešo
}, 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 redzat examples mapi.

Awesome-plugins/index

Lieliskie spraudņi

Flight ir ļoti paplašināms. Ir daudz spraudņu, kas var tikt izmantoti, lai pievienotu funkcionalitāti jūsu Flight lietojumprogrammai. Daži no tiem oficiāli tiek atbalstīti no Flight komandas, savukārt citi ir mikro/lite bibliotēkas, lai palīdzētu jums sākt.

Kešošana

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

Dīversija

Dīversija ir būtiska, kad jūs izstrādājat savā lokālajā vide. Ir daži spraudņi, kas var uzlabot jūsu dīversijas pieredzi.

Datubāzes

Datubāzes ir vairumam lietojumprogrammu pamats. Tā ir veids, kā saglabāt un atgūt datus. Dažas datubāzu bibliotēkas vienkārši ir wrapperi, lai rakstītu vaicājumus, bet dažas ir pilnvērtīgi ORM.

Sesija

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

Templēšana

Templēšana ir būtiska jebkurai tīmekļa lietojumprogrammai ar lietotāja saskarni. Ir daudz templēšanas dzinēju, kas var tikt izmantoti ar Flight.

Contributing

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

Awesome-plugins/pdo_wrapper

PdoWrapper PDO Palīgklase

Flight tiek nodrošināts ar palīgklasi priekš PDO. Tas ļauj jums viegli piekļūt datubāzei ar visu sagatavoto/izpildīto/pēcņemto() apjukumu. Tas ļoti vienkāršo to, kā jūs varat piekļūt datubāzei. Katrs rindiņas rezultāts tiek atgriezts kā Flight kolekcijas klase, kas ļauj jums piekļūt saviem datiem, izmantojot masīva sintaksi vai objekta sintaksi.

Reģistrējot PDO Palīgklasi

// Reģistrēt 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 parasti pieejamie PDO metodēs ir pieejami. Lai piekļūtu datubāzei, ir pievienotas sekojošas metodes, lai atvieglotu vaicājumu veikšanu:

runQuery(string $sql, array $params = []): PDOStatement

Izmanto šo funkciju IESNIEGUMIEM, ATJAUNINĀJUMIEM, vai ja plāno lietot IZVĒLES teikumu cilpā

$db = Flight::db();
$statement = $db->runQuery("SELECT * FROM table WHERE something = ?", [ $something ]);
while($row = $statement->fetch()) {
    // ...
}

// Vai ierakstīt 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 visas 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 ar IN() sintaksi

Šim ir noderīgs apvalks IN() teikumiem. Viens vienkāršs jautājuma zīme kā aizstājvietu IN() un tad masīvs 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 varētu izmantot šo apvalku
Flight::route('/users', function () {
    // Saņemt visus lietotājus
    $users = Flight::db()->fetchAll('SELECT * FROM users');

    // Straumēt visus lietotājus
    $statement = Flight::db()->runQuery('SELECT * FROM users');
    while ($user = $statement->fetch()) {
        echo $user['name'];
        // vai echo $user->name;
    }

    // Saņemt vienu lietotāju
    $user = Flight::db()->fetchRow('SELECT * FROM users WHERE id = ?', [123]);

    // Saņemt vienu vērtību
    $count = Flight::db()->fetchField('SELECT COUNT(*) FROM users');

    // Īpašais IN() sintakse palīdzēt (pārliecinieties, ka IN ir lieliem burtiem)
    $users = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [[1,2,3,4,5]]);
    // Jūs varētu arī izdarī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]);

    // Saņemt 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 (nepiemērots bloķēšanai, flash, segmenta, sesijas šifrēšanai). Izmanto PHP open_ssl sesijas datu opcionālai šifrēšanai/atšifrēšanai. Atbalsta Failu, MySQL, Redis un Memcached.

Instalācija

Instalēt ar composer.

composer require ghostff/session

Pamata konfigurācija

Jums nav nepieciešams nekas padot, lai izmantotu noklusējuma iestatījumus ar savu sesiju. Varat lasīt par vairāk iestatījumiem Github Readme.


use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

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

// viens lieta, ko atcerēties, ir tā, ka jums jāapsolībina savu sesiju katrā lapas ielādes laikā
// vai jums būs jāpalaiž auto_commit savā konfigurācijā.

Vienkāršs piemērs

Šeit ir vienkāršs piemērs, kā jūs varētu to izmantot.

Flight::route('POST /login', function() {
    $session = Flight::session();

    // veiciet savu ielogošanās loģiku šeit
    // pārbaudiet paroli, uc.

    // ja ielogošanās ir veiksmīga
    $session->set('is_logged_in', true);
    $session->set('user', $user);

    // jebkurā laikā, kad rakstāt sesijā, jums jāapsolībina to apzināti.
    $session->commit();
});

// Šī pārbaude varētu būt ierobežotās lapas loģikā vai ietīta ar starpnieku.
Flight::route('/some-restricted-page', function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }

    // veiciet savu ierobežotās lapas loģiku šeit
});

// starpnieku versija
Flight::route('/some-restricted-page', function() {
    // regulāra lapas loģika
})->addMiddleware(function() {
    $session = Flight::session();

    if(!$session->get('is_logged_in')) {
        Flight::redirect('/login');
    }
});

Vēl sarežģītāks piemērs

Šeit ir vēl sarežģītāks piemērs, kā jūs varētu to izmantot.


use Ghostff\Session\Session;

require 'vendor/autoload.php';

$app = Flight::app();

// iestatiet pielāgotu ceļu uz jūsu sesijas konfigurācijas failu un piešķiriet tai nejaušu virkni sesijas id
$app->register('session', Session::class, [ 'ceļš/uz/sesijas_konfigurācijas.php', bin2hex(random_bytes(32)) ], function(Session $session) {
        // vai arī manuāli varat pārrakstīt konfigurācijas opcijas
        $session->updateConfiguration([
            // ja vēlaties glabāt sesijas datus datubāzē (labi, ja vēlaties kaut ko tādu kā "izlogot mani no visiem ierīces" funkciju)
            Session::CONFIG_DRIVER        => Ghostff\Session\Drivers\MySql::class,
            Session::CONFIG_ENCRYPT_DATA  => true,
            Session::CONFIG_SALT_KEY      => hash('sha256', 'mans-super-S3CR3T-solis'), // lūdzu, izmainiet to uz kaut ko citu
            Session::CONFIG_AUTO_COMMIT   => true, // dariet to tikai tad, ja tas ir nepieciešams un/vai ir grūti apņemt() savu sesiju.
                                                // papildus varētu darīt Flight::after('start', function() { Flight::session()->commit(); });
            Session::CONFIG_MYSQL_DS         => [
                'driver'    => 'mysql',             # Datubāzes draiveris priekš PDO dns piemērs (mysql:host=...;dbname=...)
                'host'      => '127.0.0.1',         # Datubāzes resursdators
                'db_name'   => 'mana_lietotne_datubāze',   # Datubāzes nosaukums
                'db_table'  => 'sesijas',          # Datubāzes tabula
                'db_user'   => 'root',              # Datubāzes lietotājvārds
                'db_pass'   => '',                  # Datubāzes parole
                'persistent_conn'=> false,          # Izmantojiet pastāvīgu savienojumu, lai izvairītos no jauna savienojuma izmaksām katru reizi, kad skripts ir jārunā ar datubāzi, rezultātā ātrākas tīmekļa lietojumprogrammas. MEKLĒJAT AIZMUGURI PAŠI
            ]
        ]);
    }
);

Dokumentācija

Apmeklēt Github Readme pilnu dokumentāciju. Konfigurācijas opcijas ir labi dokumentētas default_config.php failā pati. Kods ir viegli saprotams, ja jūs vēlaties paši izpētīt šo paketi.

Awesome-plugins/tracy_extensions

Tracy Flight Panel Extensions

=====

Šis ir paplašinājumu kopums, lai darbs ar Flight būtu nedaudz bagātīgāks.

Šis ir paneļa

Flight Bar

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

Flight Data Flight Database Flight Request

Instalēšana

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

Konfigurācija

Jums ir jāveic ļoti maz konfigurācijas, lai sāktu darbu ar to. Jums būs jāiniciē Traci dubugeri pirms šī lietojuma izmantošanas https://tracy.nette.org/en/guide:

<?php

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

// palaišanas kods
require __DIR__ . '/vendor/autoload.php';

Debugger::enable();
// Jums var būt nepieciešams norādīt savu vidi ar Debugger::enable(Debugger::DEVELOPMENT)

// ja jūs lietojat datubāzes savienojumus savā lietojumprogrammā, ir 
// nepieciešams PDO apvalks lietošanai TIKAI IZSTRĀDĒ (lūdzu, neizmantojiet produkcijā!)
// Tas ir ar pašiem parametriem kā parasts PDO savienojums
$pdo = new PdoQueryCapture('sqlite:test.db', 'lietotājs', 'parole');
// vai, ja pievienojat to Flight ietvarā
Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'lietotājs', 'parole']);
// tagad katru reizi, kad veicat vaicājumu, tas fiksēs laiku, vaicājumu un parametrus

// Tas savieno punktus
if(Debugger::$showBar === true) {
    // Tas ir jābūt false, lai Tracy faktiski varētu renderēt :(
    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 padot jebkuru sesiju datu masīvu Tracy, un tas automātiski to izvadīs jums. Jūs to padodat 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 ir jābūt false, lai Tracy faktiski varētu renderēt :(
    Flight::set('flight.content_length', false);
    new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]);
}

// maršruti un citi...

Flight::start();

Latte

Ja jums ir Latte instalēts jūsu projektā, jūs varat izmantot Latte paneļa, lai analizētu savus veidnes. Jūs varat padot Latte instanci TracyExtensionLoader konstruktorā ar latte atslēgu otrajā parametrā.



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 Panel pie Tracy
    $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension);
});

if(Debugger::$showBar === true) {
    // Tas ir jābūt false, lai Tracy faktiski varētu renderēt :(
    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.

Awesome-plugins/active_record

Flight Active Record

Aktīvā ieraksta mērķis ir attēlot datu bāzes vienību kā PHP objektu. Vienkārši runājot, ja jums ir lietotāji tabula jūsu datu bāzē, jūs varat "tulko" rindu no šīs tabulas uz User klasi un $user objektu jūsu koda bāzē. Skatiet pamata piemēru.

Pamata Piemērs

Iedomāsimies, ka jums ir šāda tabula:

CREATE TABLE lietotāji (
    id INTEGER PRIMARY KEY, 
    vārds TEKSTS, 
    parole TEKSTS 
);

Tagad jūs varat izveidot jaunu klasi, lai attēlotu šo tabulu:

/**
 * ActiveRecord klase parasti ir vienaskaitļa formā
 * 
 * Lielākā mērā ieteicams pievienot tabulas īpašības kā komentārus šeit
 * 
 * @property int    $id
 * @property string $name
 * @property string $password
 */ 
class User extends flight\ActiveRecord {
    public function __construct($database_connection)
    {
        // varat iestatīt šādi
        parent::__construct($database_connection, 'lietotāji');
        // vai arī šādi
        parent::__construct($database_connection, null, [ 'table' => 'lietotāji']);
    }
}

Tagad vērojiet maģiju notiekam!

// sqlite
$database_connection = new PDO('sqlite:test.db'); // ​​tikai piemēram, visticamāk, jūs izmantotu reālu datu bāzes savienojumu

// mysql
$database_connection = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'lietotājvārds', 'parole');

// vai arī mysqli
$database_connection = new mysqli('localhost', 'lietotājvārds', 'parole', 'test_db');
// vai arī mysqli ar neobjekta pamatotu izveidošanu
$database_connection = mysqli_connect('localhost', 'lietotājvārds', 'parole', 'test_db');

$user = new User($database_connection);
$user->name = 'Bobby Tables';
$user->password = password_hash('daža jauka parole');
$user->insert();
// vai arī $user->save();

echo $user->id; // 1

$user->name = 'Joseph Mamma';
$user->password = password_hash('atkal daža jauka parole!!!');
$user->insert();
// šeit nevar izmantot $user->save(), jo tas domās, ka tas ir atjaunināšana!

echo $user->id; // 2

Un tā bija tikai tik viegli pievienot jaunu lietotāju! Tagad, kad datu bāzē ir lietotāja rinda, kā to iegūt?

$user->find(1); // atrast id = 1 datu bāzē un atgriezt to.
echo $user->name; // 'Bobby Tables'

Un kas, ja jūs vēlaties atrast visus lietotājus?

$users = $user->findAll();

Kā būtu ar noteiktu nosacījumu?

$users = $user->like('name', '%mamma%')->findAll();

Vai redzat, cik liela šī ir izklaide? Uzstādiet to un sāciet!

Instalācija

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 jūsu izvēle.

Neatkarīgi

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

$pdo_savienojums = new PDO('sqlite:test.db'); // ​​tikai piemēram, visticamāk, jūs izmantotu reālu datu bāzes savienojumu

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

Flight PHP ietvars

Ja izmantojat Flight PHP ietvaru, jūs varat reģistrēt ActiveRecord klasi kā pakalpojumu (bet, godīgi sakot, jums to nav nepieciešams).

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

// tad varat to izmantot iekš kontrolera, funkcijas, utt.

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

CRUD funkcijas

find($id = null) : boolean|ActiveRecord

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

Papildus tam jūs varat tam pievienot citus palīgmetodus, lai vaicātu tabulu.

// atrast ierakstu ar dažiem iepriekšējiem nosacījumiem
$user->notNull('password')->orderBy('id DESC')->find();

// atrast ierakstu pēc konkrēta id
$id = 123;
$user->find($id);

findAll(): array<int,ActiveRecord>

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

$user->findAll();

isHydrated(): boolean (v0.4.0)

Atgriež True, ja pašreizējais ieraksts ir iestatīts (atpauzdināts no datu bāzes).

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

insert(): boolean|ActiveRecord

Ievieto pašreizējo ierakstu datu bāzē.

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

update(): boolean|ActiveRecord

Atjauno pašreizējo ierakstu datu bāzē.

$user->lielāksKā('id', 0)->orderBy('id desc')->find();
$user->email = 'tests@example.com';
$user->update();

save(): boolean|ActiveRecord

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

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

Piezīme: Ja ir attiecības, kas ir definētas klasē, tas rekurzīvi saglabās arī šīs attiecības, ja tās ir definētas, instancētas un ir netīras datu atjaunošanai. (v0.4.0 un vēlāk)

delete(): boolean

Dzēst pašreizējo ierakstu no datu bāzes.

$user->lielāksKā('id', 0)->orderBy('id desc')->find();
$user->delete();

Jūs varat dzēst arī vairākus ierakstus, izpildot meklēšanu iepriekš.

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

dirty(array $dirty = []): ActiveRecord

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

$user->lielāksKā('id', 0)->orderBy('id desc')->find();

// šajā brīdī nekas nav "netīrs".

$user->email = 'tests@example.com'; // tagad email tiek uzskatīts par "netīro", jo tas ir mainīts.
$user->update();
// tagad nav nevienam netīrama dati, jo tie tika atjaunoti un saglabāti datu bāzē

$user->password = md5('jauna parole'); // tagad šī ir netīra
$user->dirty(); // nepārtraucot neko aktualizēt, jo nav nekas uzkrāts kā netīrs.

$user->dirty([ 'name' => 'kas', 'password' => md5('atkārtota parole') ]);
$user->update(); // tiek atjaunots gan vārds, gan parole.

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

Tas ir aizstājējdarbība dirty() metodei. Šī ir skaidrāka par to, ko jūs darāt.

$user->copyFrom([ 'name' => 'kas', 'password' => md5('atkārtota parole') ]);
$user->update(); // gan vārds, gan parole tiek atjaunoti

isDirty(): boolean (v0.4.0)

Atgriež True, ja pašreizējais ieraksts ir mainījies.

$user->lielāksKā('id', 0)->orderBy('id desc')->find();
$user->email = 'tests@e-pasts.com';
$user->isDirty(); // True

reset(bool $include_query_data = true): ActiveRecord

Atiestata pašreizējo ierakstu uz sākotnējo stāvokli. Tas ir ļoti noderīgi, lietojot saraksta veida darbības. Ja jūs nododat true, tas arī atiestatīs vaicājuma datus, kuri tika izmantoti pašreizējā objekta atrašanai (noklusējuma uzvedība).

$lietotāji = $user->lielāksKā('id', 0)->orderBy('id desc')->find();
$lietotājs_uzņēmums = new LietotājsUzņēmums($pdo_savienojums);

foreach($lietotāji as $lietotājs) {
    $lietotājs_uzņēmums->reset(); // sākt ar tīru iztērēšu
    $lietotājs_uzņēmums->lietotājs_id = $lietotājs->id;
    $lietotājs_uzņēmums->uzņēmuma_id = $dažs_uzņēmuma_id;
    $lietotājs_uzņēmums->insert();
}

getBuiltSql(): string (v0.4.1)

Kad jūs izpildāt find(), findAll(), insert(), update() vai save() metodi, jūs varat iegūt SQL, kas tika izveidots, un to izmantot, lai veiktu kļūdu novēršanas nolūkos.

SQL vaicājuma metodes

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

Varat izvēlēties tikai dažus tabulas stabiņus, ja vēlaties (tas ir efektīvāk ar ļoti plānām tabulām ar daudz stabiņiem)

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

from(string $table)

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

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

join(string $table_name, string $join_condition)

Jūs pat varat pievienoties pie citas tabulas datu bāzē.

$user->join('kontakti', 'kontakti.lietotāja_id = lietotāji.id')->find();

where(string $where_conditions)

Jūs varat iestatīt dažas pielāgotas where argumentus (šajā where izteiksmē nevarat iestatīt parametrus)

$user->where('id=1 AND name="piemērs"')->find();

Drošības piezīme - Jūs varat būt piespiests darīt kaut ko līdzīgu $user->where("id = '{$id}' AND name = '{$vārds}'")->find();. LŪDZAM NEDARIET TO!!! Tas ir uzņēmīgs pret SQL injekcijas uzbrukumiem. Ir daudz rakstu tiešsaistē, lūdzu, meklējiet Google "sql inekcijas uzbrukumi php" un jūs atradīsiet daudz rakstu par šo tēmu. Pareizais veids, kā to apstrādāt ar šo bibliotēku, ir tā vietā, lai izmantotu šo where() metodi, jūs varētu darīt kaut ko līdzīgu $user->eq('id', $id)->eq('name', $vārds)->find();. Ja jums absulūti tas jādara, tad PDO bibliotēkā ir $pdo->quote($mainīgo) lai izvairītos no šāda koda pirms tā izmantošanas where() izteiksmē.

group(string $group_by_statement)/groupBy(string $group_by_statement)

Savienojiet rezultātus pēc konkrēta nosacījuma.

$user->select('COUNT(*) as count')->groupBy('name')->findAll();

order(string $order_by_statement)/orderBy(string $order_by_statement)

Sakārto atgriezto vaicājumu noteiktā veidā.

$user->orderBy('name DESC')->find();

limit(string $limit)/limit(int $offset, int $limit)

Ierobežojiet atgriezto ierakstu daudzumu. Ja otrā vienība ir dotā, tā būs nobīde, limits tikpat kā SQL.

$user->orderBy('name DESC')->limit(0, 10)->findAll();

WHERE nosacījumi

equal(string $field, mixed $value) / eq(string $field, mixed $value)

Kur field = $value

$user->eq('id', 1)->find();

notEqual(string $field, mixed $value) / ne(string $field, mixed $value)

Kur field <> $value

$user->ne('id', 1)->find();

isNull(string $field)

Kur field IS NULL

$user->isNull('id')->find();

isNotNull(string $field) / notNull(string $field)

Kur field IS NOT NULL

$user->isNotNull('id')->find();

greaterThan(string $field, mixed $value) / gt(string $field, mixed $value)

Kur field > $value

$user->gt('id', 1)->find();

lessThan(string $field, mixed $value) / lt(string $field, mixed $value)

Kur field < $value

$user->lt('id', 1)->find();

greaterThanOrEqual(string $field, mixed $value) / ge(string $field, mixed $value) / gte(string $field, mixed $value)

Kur field >= $value

$user->ge('id', 1)->find();

lessThanOrEqual(string $field, mixed $value) / le(string $field, mixed $value) / lte(string $field, mixed $value)

Kur field <= $value

$user->le('id', 1)->find();

like(string $field, mixed $value) / notLike(string $field, mixed $value)

Kur field LIKE $value vai field NOT LIKE $value

$user->like('name', 'de')->find();

$user->in(string $field, array $values) / notIn(string $field, array $values)

Kur field IN($value) vai field NOT IN($value)

$user->in('id', [1, 2])->find();

$user->between(string $field, array $values)

Kur field BETWEEN $value AND $value1

$user->between('id', [1, 2])->find();

Attiecības

Šajā bibliotēkā varat iestatīt vairākus attiecību veidus. Jūs varat iestatīt viens -> daudz un viens -> viens attiecības starp tabulām. Tam ir nepieciešama neliela papildu iestatīšana klasē iepriekš.

$relations masīva iestatīšana nav sarežģīta, bet pareiza sintakse var būt neskaidra.

aizsargāts masīvs $attiecības = [
    // jūs varat nosaukt atslēgu pēc vēlmes. Galvenā ActiveRecord nosaukums, iespējams, ir labs. Piemēram, lietotājs, kontakts, klients
    'user' => [
        // obligāts
        // self::HAS_MANY, self::HAS_ONE, self::BELONGS_TO
        self::HAS_ONE, // šis ir attiecību tips

        // obligāts
        'Daža_Klase', // tas ir "citais" ActiveRecord klase, kas būs atsauce

        // obligāts
        // atkarībā no attiecību veida
        // self::HAS_ONE = ārējais atslēga, kas norāda pievienošanu
        // self::HAS_MANY = ārējais atslēga, kas norāda pievienošanu
        // self::BELONGS_TO = lokālais atslēga, kas norāda pievienošanu
        'lokāls_vai_ārējais_atslēga',
        // tikai no žetona, tas pievienojas tikai primārās atslēgas atslēgai "cita" modelī

        // nav obligāti
        [ 'eq' => [ 'clients_id', 5 ], 'select' => 'COUNT(*) as count', 'limit' => 5 ], // papildu nosacījumi, ko vēlaties, lai pievienotu attiecības
        // $record->eq('clients_id', 5)->select('COUNT(*) as count')->limit(5))

        // nav obligāti
        'atpakaļ_komandas_vārds' // tas ir, ja jūs vēlaties atpakaļpagriezt šo attiecību sev. Piemēram: $lietotājs->kontakts->lietotājs;
    ];
]
class User extends ActiveRecord{
    aizsargāts masīvs $attiecības = [
        'kontakti' => [ self::HAS_MANY, Kontakt::class, 'lietotāja_id' ],
        'kontakts' => [ self::HAS_ONE, Kontakt::class, 'lietotāja_id' ],
    ];

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }
}

klase Kontakts atvasinās no ActiveRecord{
    aizsargāts masīvs $attiecības = [
        'lietotājs' => [ self::BELONGS_TO, Lietotājs::class, 'lietotāja_id' ],
        'lietotājs_ar_atpakaļatnosi' => [ self::BELONGS_TO, Lietotājs::class, 'lietotāja_id', [], 'kontakts' ],
    ];
    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'kontakti');
    }
}

Tagad mums ir iestatītas atsauces, tās ir ļoti viegli izmantot!

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

// atrodiet jaunāko lietotāju.
$user->notNull('id')->orderBy('id desc')->find();

// iegūstiet kontaktus, izmantojot attiecību:
katrs($user->kontakti kā $kontakts) {
    echo $kontakts->id;
}

// vai arī varam iet otras puses.
$kontakts = new Kontakts();

// atrast vienu kontaktu
$kontakts->find();

// iegūstiet lietotāju, izmantojot attiecību:
echo $kontakts->lietotājs->vārds; // tas ir lietotāja vārds

Diezgan forši vai ne?

Norādīt pielāgotus datus

Dažreiz var būt nepieciešams pievienot kaut ko unikālu jūsu ActiveRecord, piemēram, pielāgotu aprēķinu, kas varētu būt vieglāk vienkārši pievienot objektam, kas tiks nodots, teiksim, veidlapai.

setCustomData(string $field, mixed $value)

Jūs pievienojat pielāgoto datus ar setCustomData() metodi.

$user->setCustomData('lapas_skatījumu_skaitītājs', $lapas_skatījumu_skaitītājs);

Un tad jūs vienkārši to atsaukaties kā parastu objekta īpašību.

echo $user->lapas_skatījumu_skaitītājs;

Pasākumi

Vēl viena lieliska funkcija šajā bibliotēkā ir par notikumiem. Pasākumi tiek izsaukti noteiktos laikos, pamatojoties uz noteiktiem izsaukumiem. Tie ir ļoti, ļoti noderīgi, lai iestatītu datus jums automātiski.

onConstruct(ActiveRecord $ActiveRecord, array &config)

Šis ir ļoti noderīgi, ja jums nepieciešams iestatīt noklusējuma savienojumu vai kaut ko tādu.

// index.php vai bootstrap.php
Flight::register('db', 'PDO', [ 'sqlite:test.db' ]);

//
//
//

// Lietotājs.php
class Lietotājs extends flight\ActiveRecord {

    protected function onConstruct(self $self, array &$config) { // neaizmirstiet & atsauci
        // jūs varētu to izdarīt, lai automātiski iestatītu savienojumu
        $config['savienojums'] = Flight::db();
        // vai arī šo
        $self->pārveidotUnSaglabātSavienojumu(Flight::db());

        // Jūs varat arī iestatīt tabulas nosaukumu šādi.
        $config['tabula'] = 'lietotāji';
    } 
}

beforeFind(ActiveRecord $ActiveRecord)

Šis ir vēlējies, tikai ja jums nepieciešama vaicājuma manipulācija katru reizi.

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function beforeFind(self $self) {
        // vienmēr palaist id > = 0, ja tas ir jūsu dziesma
        $self->gte('id', 0); 
    } 
}

afterFind(ActiveRecord $ActiveRecord)

Tas visticamāk ir noderīgāk, ja jums vienmēr ir jāizpilda kāda loģika, kad šis ieraksts tiek atsaitēts. Vai jums ir nepieciešams dekodēt kaut ko? Vai jums ir nepieciešams vienmēr palaidīt kādu pielāgotu skaitītāju vaicājumu (neefektīvi, bet tāpat)?

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function afterFind(self $self) {
        // dekodēšana
        $self->noslēpums = jūsuAtšifrēšanasFunkcija($self->noslēpums, $dažs_atslēga);

        // iespējams, saglabāt kaut ko pielāgotu kā vaicājumu???
        $self->iestatītPielāgotoDatu('apmeklējumu_skaitītājs', $self->select('COUNT(*) skaits')->no('lietotāju_apmeklējumi')->eq('lietotāja_id', $self->id)['skaits']; 
    } 
}

beforeFindAll(ActiveRecord $ActiveRecord)

Tas visticamāk ir noderīgi tikai, ja jums ir jāmanipulē vaicājumi katru reizi.

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function beforeFindAll(self $self) {
        // vienmēr palaist id >= 0, ja tas ir jūsu dziesma
        $self->gte('id', 0); 
    } 
}

afterFindAll(array<int,ActiveRecord> $results)

Līdzīgi kā afterFind(), bet jums tas jādara visiem ierakstiem!

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function afterFindAll(array $results) {

        katra($results kā $self) {
            // darīt kaut ko foršu kā pēcFind()
        }
    } 
}

beforeInsert(ActiveRecord $ActiveRecord)

Tiešām noderīgi, ja jums ir jāiestata noklusējuma vērtības katru reizi.

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function beforeInsert(self $self) {
        // uzstādiet dažas uzskaitīšanas noklusējuma vērtības
        if(!$self->izveidots_datums) {
            $self->izveidots_datums = gmdate('Y-m-d');
        }

        if(!$self->parole) {
            $self->parole = md5((string) microtime(true));
        }
    } 
}

afterInsert(ActiveRecord $ActiveRecord)

Iespējams, jums ir lietotāja gadījums datu mainīšanai pēc ievietošanas?

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function afterInsert(self $self) {
        // jūs dariet jūs
        Flight::kešatmiņa()->ievietot('pēdējo_ievietoto_id', $self->id);
        // vai kaut kas cits....
    } 
}

beforeUpdate(ActiveRecord $ActiveRecord)

Tiešām noderīgi, ja jums ir jāiestata noklusējuma vērtības katru reizi, kad tiek atjaunināts.

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function beforeInsert(self $self) {
        // uzstādiet dažas uzskaitīšanas noklusējuma vērtības
        if(!$self->atjaunināt_datumu) {
            $self->atjaunināt_datumu = gmdate('Y-m-d');
        }
    } 
}

afterUpdate(ActiveRecord $ActiveRecord)

Iespējams, jums ir lietotāja gadījums datu mainīšanai pēc atjaunināšanas?

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function afterInsert(self $self) {
        // jūs dariet jūs
        Flight::kešatmiņa()->ievietot('pēdējo_atjaunināto_lietotāja_id', $self->id);
        // vai kaut kas cits....
    } 
}

beforeSave(ActiveRecord $ActiveRecord)/afterSave(ActiveRecord $ActiveRecord)

Tas ir noderīgi, ja vēlaties, lai notikumi notiktu gan tad, kad notiktu ievietošana, gan atjaunināšana. Es jums ietaupīšu garu izskaidrojumu, bet esmu pārliecināts, ka spējat minēt, kas tas ir.

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_bāzes_savienojums)
    {
        parent::__construct($datu_bāzes_savienojums, 'lietotāji');
    }

    protected function beforeSave(self $self) {
        $self->pēdējais_atjaunināts = gmdate('Y-m-d H:i:s');
    } 
}

beforeDelete(ActiveRecord $ActiveRecord)/afterDelete(ActiveRecord $ActiveRecord)

Neesmu pārliecināts, ko jūs šeit vēlaties darīt, bet šeit nav sprieduma! Dodieties uz to!

class Lietotājs atvasinās no flight\ActiveRecord {

    publiskā funkcija __construct($datu_savienojums)
    {
        parent::__construct($datu_savienojums, 'lietotāji');
    }

    protected function beforeDelete(self $self) {
        echo 'Viņš bija drosmīgs kareivis... :aizvēršanās:'';
    } 
}

Datu bāzes savienojuma pārvaldība

Kad lietojat šo bibliotēku, datu bāzes savienojumu varat iestatīt dažādos veidos. Jūs varat iestatīt savienojumu konstruktorā, varat iestatīt to, izmantojot konfigurācijas mainīgo $config['savienojums'] vai arī to varat iestatīt, izmantojot setDatabaseConnection() (v0.4.1).

$pdo_savienojums = new PDO('sqlite:test.db'); // piemēram
$user = new User($pdo_savienojums);
// vai
$user = new User(null, [ 'savienojums' => $pdo_savienojums ]);
// vai$user = new User();
$user->setDatabaseConnection($pdo_savienojums);

Ja ir nepieciešams atsvaidzināt datu bāzes savienojumu, piemēram, ja izpildāt ilglaicīgu CLI skriptu un ir nepieciešams savienojumu atkārtoti atsvaidzināt, jūs varat atkārtoti iestatīt savienojumu ar $jūsu_ieraksts->setDatabaseConnection($pdo_savienojums).

Piedalīšanās

Lūdzu dariet to. :D

Iestatīšana

Kad jūs piedalāties, pārliecinieties, ka palaiziet composer test-pārklājums, lai saglabātu 100% testu pārklājumu (tas nav īsta testu pārklājuma vienība, vairāk kā integrācijas testēšana).

Pārliecinieties arī, ka izpildāt composer skaistums un composer phpcs, lai labotu jebkādas formatēšanas kļūdas.

Licences

MIT

Awesome-plugins/latte

Kafija

Kafija ir pilnībā funkciju bagātota veidne, kas ir ļoti viegli lietojama un jūtas tuvāka PHP sintaksei nekā Twig vai Smarty. Turklāt to ir ļoti viegli paplašināt un pievienot savus filtrus un funkcijas.

Instalācija

Instalējiet ar komponistu.

composer require latte/latte

Pamata konfigurācija

Ir dažas pamata konfigurācijas opcijas, lai sāktu darbu. Par tām variet lasīt vairāk 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 ātrinātu lietošanu
    // Viena jauka lieta par Kafiju ir tā, ka tā automātiski atjaunina jūsu
    // kešatmiņu, kad veicat izmaiņas veidnēs!
    $latte->setTempDirectory(__DIR__ . '/../cache/');

    // Paziņojiet Kafijai, kur būs jūsu skatu saknes direktorija.
    $latte->setLoader(new \Latte\Loaders\FileLoader($app->get('flight.views.path')));
});

Vienkārša izkārtojuma piemērs

Šeit ir vienkāršs piemērs izkārtojuma failam. Šis fails tiks izmantots, lai iesaiņotu visus pārējos skatus.

<!-- app/views/layout.latte -->
<!doctype html>
<html lang="lv">
    <head>
        <title>{$title ? $title . ' - '}Mana Viedokļu Uzstādība</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 atveidots iekšējā šī satura blokā:

<!-- app/views/home.latte -->
<!-- Tas paziņo Kafijai, ka šis fails ir "iekšpus" layout.latte faila -->
{extends layout.latte}

<!-- Šis ir saturs, kas tiks atveidots izkārtojumā iekšienē satura blokā -->
{block content}
    <h1>Mājas Lapaspuse</h1>
    <p>Sveicināti manā aplikācijā!</p>
{/block}

Tad, kad jūs dodies atveidot to iekš savas funkcijas vai kontrolierā, jūs darītu kaut ko līdzīgu tam:

// vienkāršs maršruts
Flight::route('/', function () {
    Flight::latte()->render('home.latte', [
        'title' => 'Mājas Lapaspuse'
    ]);
});

// vai, ja izmantojat kontroleri
Flight::route('/', [HomeController::class, 'index']);

// HomeController.php
class HomeController
{
    public function index()
    {
        Flight::latte()->render('home.latte', [
            'title' => 'Mājas Lapaspuse'
        ]);
    }
}

Skatiet vairāk informācijas par to, kā izmantot Kafiju tā pilnīgākai potenciāla izmantošanai Kafijas Dokumentācijā!

Awesome-plugins/awesome_plugins

Izcili Spraudņi

Flight ir neaprakstāmi paplašināms. Ir vairāki spraudņi, ko var izmantot, lai pievienotu funkcionalitāti saviem Flight lietojumiem. Daži oficiāli atbalstīti ar Flight komandu, citi ir mikro/lite bibliotēkas, kas palīdzēs jums sākt.

Kešatmiņa

Kešatmiņa ir lielisks veids, kā paātrināt jūsu lietojumu. Ir vairākas kešatmiņas bibliotēkas, ko var izmantot ar Flight.

Sīkdatnes

Sīkdatnes ir lielisks veids, kā saglabāt mazus datu gabaliņus klienta pusē. Tās var tikt izmantotas, lai saglabātu lietotāja preferences, lietojumprogrammas iestatījumus un citus.

Kļūdu novēršana

Kļūdu novēršana ir būtiska, kad jūs attīstāties savā lokālajā vidē. Ir daži spraudņi, kas var uzlabot jūsu kļūdu novēršanas pieredzi.

Datu bāzes

Datu bāzes ir pamats lielākajai daļai lietojumu. Tā ir veids, kā saglabāt un atgūt datus. Dažas datu bāzes bibliotēkas ir vienkārši apvalki, lai rakstītu vaicājumus, un dažas ir pilntiesīgi ORM.

Šifrēšana

Šifrēšana ir būtiska jebkuram lietojumprogrammai, kas saglabā jutīgus datus. Datus šifrēt un dešifrēt nav ļoti grūti, bet pareizi uzglabāt šifrēšanas atslēgu var būt grūti. Visnozīmīgākais ir nekad neuzglabāt savu šifrēšanas atslēgu publiskajā direktorijā vai iekļaut to koda atjaunojumos.

Sesija

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

Veidnes

Veidnes ir būtiskas jebkurai tīmekļa lietojumprogrammai ar lietotāja interfeisu. Ir daudz veidņu dzinēju, ko var izmantot ar Flight.

Ieguldījumi

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

Examples

Vai vēlaties ātri sākt?

Dodieties uz flightphp/skeleton repo, lai sāktu! Šis ir projekts, kas ietver vienas lapas failu, kurā ir iekļauts viss nepieciešamais, lai palaistu savu lietotni. Tas arī ietver piemēru ar kontrolieriem un skatiem.

Vai Nepieciešama Iedvesma?

Lai arī šie nav oficiāli atbalstīti no Flight komandas puses, tie varētu sniegt jums idejas, kā strukturēt savus projektus, kas izveidoti ar Flight!

Vai Vēlaties Koplietot Savu Paša Piemēru?

Ja jums ir projekts, kuru vēlaties koplietot, lūdzu iesniedziet "pull request", lai to pievienotu šajā sarakstā!