Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file ( $ini ) ) {
if ( is_readable ( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "Fatal: $ini nicht lesbar (Rechte?)", E_USER_ERROR );
}
} else {
trigger_error ( "Fatal: $ini existiert nicht", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Dazu noch ein Hinweis: Eigentlich sollte der Ordner /data AUSSERHALB des Document-root liegen, damit er nicht versehentlich ausgeliefert wird und dann z.B: Zugangsdaten zur Datenbank sichtbar werden. Im Beispiel habe ich das anders gemacht, weil manche Billig-Hoster diese Möglichkeit nicht bieten.
In dem Fall sollte (auf einem Apache Webserver) wenigstens eine Datei mit dem Name ".htaccess" existieren (wenn wenigstens das erlaubt ist), [welche den Zugang sperrt](https://httpd.apache.org/docs/2.4/howto/access.html). Minimallösung: Die Dateinamen beginnen mit ".ht".
**Nutzung:**
Obiges Skript wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
configDebug ();
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file ( $ini ) ) {
if ( is_readable ( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "Fatal: $ini nicht lesbar (Rechte?)", E_USER_ERROR );
}
} else {
trigger_error ( "Fatal: $ini existiert nicht", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Dazu noch ein Hinweis: Eigentlich sollte der Ordner /data AUSSERHALB des Document-root liegen, damit er nicht versehentlich ausgeliefert wird und dann z.B: Zugangsdaten zur Datenbank sichtbar werden. Im Beispiel habe ich das anders gemacht, weil manche Billig-Hoster diese Möglichkeit nicht bieten.
In dem Fall sollte (auf einem Apache Webserver) wenigstens eine Datei mit dem Name ".htaccess" existieren (wenn wenigstens das erlaubt ist), [welche den Zugang sperrt](https://httpd.apache.org/docs/2.4/howto/access.html). Minimallösung: Die Dateinamen beginnen mit ".ht".
**Nutzung:**
Obiges Skript wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "Fatal: $ini nicht lesbar (Rechte?)", E_USER_ERROR );
}
} else {
trigger_error ( "Fatal: $ini existiert nicht", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Dazu noch ein Hinweis: Eigentlich sollte der Ordner /data AUSSERHALB des Document-root liegen, damit er nicht versehentlich ausgeliefert wird und dann z.B: Zugangsdaten zur Datenbank sichtbar werden. Im Beispiel habe ich das anders gemacht, weil manche Billig-Hoster diese Möglichkeit nicht bieten.
In dem Fall sollte (auf einem Apache Webserver) wenigstens eine Datei mit dem Name ".htaccess" existieren (wenn wenigstens das erlaubt ist), [welche den Zugang sperrt](https://httpd.apache.org/docs/2.4/howto/access.html). Minimallösung: Die Dateinamen beginnen mit ".ht".
**Nutzung:**
Obiges Skript wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "Fatal: $ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "Fatal: $ini existiert nicht", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Dazu noch ein Hinweis: Eigentlich sollte der Ordner /data AUSSERHALB des Document-root liegen, damit er nicht versehentlich ausgeliefert wird und dann z.B: Zugangsdaten zur Datenbank sichtbar werden. Im Beispiel habe ich das anders gemacht, weil manche Billig-Hoster diese Möglichkeit nicht bieten.
In dem Fall sollte (auf einem Apache Webserver) wenigstens eine Datei mit dem Name ".htaccess" existieren (wenn wenigstens das erlaubt ist), [welche den Zugang sperrt](https://httpd.apache.org/docs/2.4/howto/access.html). Minimallösung: Die Dateinamen beginnen mit ".ht".
**Nutzung:**
Obiges Skript wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Dazu noch ein Hinweis: Eigentlich sollte der Ordner /data AUSSERHALB des Document-root liegen, damit er nicht versehentlich ausgeliefert wird und dann z.B: Zugangsdaten zur Datenbank sichtbar werden. Im Beispiel habe ich das anders gemacht, weil manche Billig-Hoster diese Möglichkeit nicht bieten.
In dem Fall sollte (auf einem Apache Webserver) wenigstens eine Datei mit dem Name ".htaccess" existieren (wenn wenigstens das erlaubt ist), [welche den Zugang sperrt](https://httpd.apache.org/docs/2.4/howto/access.html). Minimallösung: Die Dateinamen beginnen mit ".ht".
**Nutzung:**
Obiges Skript wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini ;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini) . "\n";
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Derlei wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini . "\n";
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini);
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Derlei wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini);
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Derlei wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function configDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~
Verwendung von Server-Variablen
bearbeitet von Regina Schaukrug> >was hindert Dich daran, zu Deinem PHP-Code noch eine Konfigurationsdatei zu speichern, die nicht .htaccess, sondern vielleicht config.xml heißt? Mit simplexml_load_file() kann man das wunderbar auslesen.
> Kann man auch so machen, ist aber mehr Aufwand als Umgebungsvariablen und dadurch gewinnt man nicht viel. Mit simplexml_load_file() bist du ja noch nicht am Ende, du musst ja noch die einzelnen Werte aus dem DOM-Baum holen.
Eben. Für vergleichbar einfache Wertsetzungen gibt es [`parse_ini_file();`](http://php.net/manual/de/function.parse-ini-file.php) und die Schwester [`parse_ini_string();`](http://php.net/manual/de/function.parse-ini-string.php). Den übernommenen Array kann man in ein Objekt übernehmen, es kann auch eine globale Variable sein: (Achte auf die Prüfung, damit Du Fehlermeldungen bekommst.)
~~~php
<?php
# file: myIniRead.php
function myIniRead() {
$iniString '';
$iniFiles = ['/data/server.ini', '/data/site.ini'];
foreach ( $iniFiles as $ini ) {
$ini = $_SERVER['DOCUMENT_ROOT'] . $ini;
if ( is_file( $ini ) ) {
if ( is_readable( $ini ) ) {
$iniString .= file_get_contents ( $ini);
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
} else {
trigger_error ( "$ini nicht lesbar", E_USER_ERROR );
}
}
return parse_ini_string( $ini );
}
$GLOBALS['config'] = myIniRead();
~~~
Derlei wird einfach mit [`require_once()`](http://php.net/manual/de/function.require-once.php) eingebunden:
~~~php
<?php
require_once ( $_SERVER['DOCUMENT_ROOT'] . '/myIniRead.php' );
~~~
Der Zugriff geht dann in Funktionen wie folgt:
~~~php
function iniDebug () {
if ( isset ( $GLOBALS['config'] ) ) {
print "<pre>";
var_dump( $GLOBALS['config'] );
print "</pre>";
} else {
print '<pre>$GLOBALS[config] ist nicht besetzt.</pre>';
}
}
~~~