Hoe draagt php data over
Werkend aan een MVC framework rijst de vraag hoe PHP data overdraagt.
In de Controller zit een functie: 'view($view, $data = [])'.
De 'class Users extends Controller{' creëert $data en bevat de aanroep:
'$this->view('users/register', $data);'
Deze aanroep vertaalt zich naar het aanroepen van:
require_once (APP_ROOT . '/views/users/register.php');
Mijn vraag is:
Hoe kan register.php bij die $data variabele?
Anders gezegd: Welk mechanisme binnen PHP is hier aan het werk?
Dat gezegd hebbende denk ik dat je op zoek bent naar https://www.php.net/manual/en/function.extract.php ?
Dit lijkt erop, maar erg duidelijk is dat manual (voor mij) niet.
Ik bedoel dit
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<?php
echo 'index.php<br>';
$data =[
'var_1' => 'some value',
];
require_once('page_2.php');[/code]
en dan in page_2 dit:
[code][code]<?php
echo 'page_2.php<br>';
echo $data['var_1'] . '<br>';[/code]
Dat levert als output:
[quote]index.php
page_2.php
some value[/quote]
De vraag is: hoe werkt dat?
In de veronderstelling dat PHP 'stateless' is.
[size=xsmall][i]Toevoeging op 16/10/2021 15:20:20:[/i][/size]
Nou, geweldig is dit niet; ik vertrouw erop dat je eruit komt.
[size=xsmall][i]Toevoeging op 16/10/2021 15:23:40:[/i][/size]
Gewoon waardeloos leesbaar:
In page_1 dit:
[code][code]<?php
echo 'index.php<br>';
$data =[
'var_1' => 'some value',
];
require_once('page_2.php');
[/code]
en in page_2 dit:
[code][code]<?php
echo 'page_2.php<br>';
echo $data['var_1'] . '<br>';
[/code]
en de out put is:
[quote]index.php
page_2.php
some value
[/quote]
De vraag is; hoe werkt dit terwijl PHP 'stateless' is?
echo 'index.php<br>';
$data =[
'var_1' => 'some value',
];
require_once('page_2.php');[/code]
en dan in page_2 dit:
[code][code]<?php
echo 'page_2.php<br>';
echo $data['var_1'] . '<br>';[/code]
Dat levert als output:
[quote]index.php
page_2.php
some value[/quote]
De vraag is: hoe werkt dat?
In de veronderstelling dat PHP 'stateless' is.
[size=xsmall][i]Toevoeging op 16/10/2021 15:20:20:[/i][/size]
Nou, geweldig is dit niet; ik vertrouw erop dat je eruit komt.
[size=xsmall][i]Toevoeging op 16/10/2021 15:23:40:[/i][/size]
Gewoon waardeloos leesbaar:
In page_1 dit:
[code][code]<?php
echo 'index.php<br>';
$data =[
'var_1' => 'some value',
];
require_once('page_2.php');
[/code]
en in page_2 dit:
[code][code]<?php
echo 'page_2.php<br>';
echo $data['var_1'] . '<br>';
[/code]
en de out put is:
[quote]index.php
page_2.php
some value
[/quote]
De vraag is; hoe werkt dit terwijl PHP 'stateless' is?
Gewijzigd op 16/10/2021 15:18:32 door Jan Kila
Uhm PHP is stateless ja. Echter met require(_once) en include(_once) wordt de code samengevoegd voordat deze geparsed wordt.
Stom voorbeeldje:
en in view php staat:
Dan wordt je script dat uitgevoerd wordt hetzelfde als:
Variabelen die je van de ene pagina mee kan nemen naar de andere pagina (waarbij er dus een nieuwe pagina opgevraagd wordt door de browser aan de webserver) zijn er enkel in de vorm van $_SESSION $_COOKIE $_GET en $_POST variabelen.
OK, helder: PHP voegt bij require&include de code samen alvorens te parsen.
Dat zal vast wel ergens in de documentatie staan, maar ik heb het nog niet eerder gezien.
Volgens mij werkt het zo in elke programmeertaal met compilatie tot bytecode: C, C++, Rust, Pascal, en zelfs BASIC. Het zou ook iets moeten zijn wat in elke tutorial staat.
Overigens is PHP code wel degelijk stateful en niet stateless. Vaak wordt PHP ingezet als een soort handler om op de een of andere manier dynamische content te genereren die een webserver via HTTP terug geeft aan een browser, via het HTTP protocol. Het HTTP protocol is wel stateless, maar dat wordt meestal ondervangen met een sessiecookie.
Wanneer je ergens in een PHP bestand een variabele instelt zoals $data, blijft PHP dat onthouden voor de hele levensduur van het PHP-script. En dat kan best lang zijn, bijvoorbeeld als je PHP-code zelf voor webserver speelt (voorbeeld).
Het staat inderdaad luid en duidelijk in de documentatie; mijn dank!
Je opmerking dat het "werkt in elke programmeertaal met compilatie tot bytecode:" stelt me ook gerust dat het geen bijkomstigheid betreft die op zeker moment kan veranderen.
Ik bedoel: de programmatuur die ik thans maak, zal naar verwachting ook in de verre toekomst nog met de hier bedoelde manier van data overdracht blijven werken.
https://www.php.net/supported-versions.php
Er zijn altijd wel plannen voor nieuwe versies, zoals de nieuwe PHP 8.1. Maar dat impliceert ook dat je je code moet blijven aanpassen wil het blijven werken met een ondersteunde PHP versie.
Neem bijvoorbeeld een overstap van een vorige versie van PHP 7 naar 8. Het resultaat van PHP 7 code is niet meer zeker in PHP 8, al was het maar omdat ze de werking van boolean operatoren hebben veranderd:
https://www.php.net/manual/en/migration80.incompatible.php
En zo zijn er bij elke (sub)versie allerlei 'backward incompatible' veranderingen in de programmeertaal.
De reden hiervoor is dat PHP een verzamelbak is van allemaal tooltjes in 'handige' (driedubbele) functies, allemaal uitbreidbaar en leuk en aardig, en lang niet volledig gedocumenteerd. Je kunt er snel programma's mee maken, maar PHP heeft ook nadelen. Een aantal nadelen worden onderkend en wel opgelost met elke nieuwe versie, zoals de boolean operatoren, maar daar heb je als programmeur last van.
Voor mij persoonlijk is het reden genoeg om de ontwikkeling van mijn programma te stoppen met PHP 7, en volledig over te willen naar Rust. Toegegeven, PHP heeft me met mijn programma 13 jaar lang geholpen sinds 2008, maar nu Rust volwassener begint te worden is het een welkome verandering met meer lange termijn in het vizier.
Ad Fundum op 17/10/2021 14:06:11:
Maak je niet te veel illusies over de 'verre' toekomst, PHP wordt op dit moment slechts ondersteund tot 26 november 2023:
https://www.php.net/supported-versions.php
https://www.php.net/supported-versions.php
Een beetje vreemd hoe je met jouw formulering een soort suggestie lijkt te wekken dat PHP na november 2023 ineens niet meer zou bestaan of niet meer naar behoren zou functioneren.
Ad Fundum op 17/10/2021 14:06:11:
Voor mij persoonlijk is het reden genoeg om de ontwikkeling van mijn programma te stoppen met PHP 7, en volledig over te willen naar Rust.
Prima dat je zelf wil overstappen naar een andere programmeertaal. Geen enkel probleem. Maar het is niet nodig om mensen bang te maken dat er straks ineens geen PHP meer is.
PHP bestaat al sinds 1994 en stop echt niet zomaar ineens van de ene op de andere dag. Die support tot november 2023 betreft versie 8. Er komt daarna ongetwijfeld een versie 8.1, 8.2 enzovoorts. En ja, dan kunnen er (zoals in de meeste programmeertalen) tussentijds kleine dingen wijzigen op basis van voortschrijdend inzicht. Computers, processors en chips worden ook ieder jaar/maand/week/dag verbeterd. Windows en Android worden continue geüpdatet. Niks in deze wereld is statisch. Alles is onderhevig aan verandering. Zo'n 75 à 80% van alle websites gebruikt PHP. Hier nu een soort illusie creëren dat PHP er na november 2023 niet meer toe doet, is onzinnig.
Dus nogmaals, dat jij persoonlijk kiest voor iets anders is helemaal prima. Maar mensen gaan waarschuwen voor 'de toekomst' van PHP vind ik persoonlijk een onterechte en onnodige weerspiegeling van zaken. Ik zie er het nut niet van in.
Gewijzigd op 17/10/2021 16:43:08 door Ozzie PHP
Toegeven, PHP is af en toe een puinzooi van verzamelde bibliotheken, waar alles op 3 verschillende manieren kan (de oude, de nieuwe, en de exotische), maar dat maakt dat je er wel zo'n beetje *alles* mee kunt. Voor het eindresultaat ligt het er vooral aan wie er "aan de knoppen zit" - maar dat zal bij elke taal zo zijn (uit ervaring weet ik dat er 2 soorten programmeurs zijn: zij die de cursus succesvol afgerond hebben, en zij die het echt snappen).
Het gaat niet meer over mijn vraag.