9 Nützliche PHP-Funktionen und -Funktionen, die Sie kennen müssen

German (Deutsch) translation by Nikol Angelowa (you can also view the original English article)

Zweimal im Monat besuchen wir einige der Lieblingsbeiträge unserer Leser aus der gesamten Geschichte von Nettuts+.

Selbst nachdem wir jahrelang PHP verwendet haben, stoßen wir auf Funktionen und Merkmale, die wir nicht kannten. Einige davon können sehr nützlich sein, werden aber nicht ausreichend genutzt. Vor diesem Hintergrund habe ich eine Liste von neun unglaublich nützlichen PHP-Funktionen und -Funktionen zusammengestellt, mit denen Sie vertraut sein sollten.

1. Funktionen mit beliebiger Anzahl von Argumenten

Möglicherweise wissen Sie bereits, dass Sie mit PHP Funktionen mit optionalen Argumenten definieren können. Es gibt aber auch eine Methode, um eine völlig beliebige Anzahl von Funktionsargumenten zuzulassen.

Hier ist zunächst ein Beispiel mit nur optionalen Argumenten:

// function with 2 optional arguments
function foo($arg1 = '', $arg2 = '') {

	echo "arg1: $arg1\n";
	echo "arg2: $arg2\n";

}


foo('hello','world');
/* prints:
arg1: hello
arg2: world
*/

foo();
/* prints:
arg1:
arg2:
*/

Nun wollen wir sehen, wie wir eine Funktion erstellen können, die eine beliebige Anzahl von Argumenten akzeptiert. Dieses Mal werden wir func_get_args() verwenden:

// yes, the argument list can be empty
function foo() {

	// returns an array of all passed arguments
	$args = func_get_args();

	foreach ($args as $k => $v) {
		echo "arg".($k+1).": $v\n";
	}

}

foo();
/* prints nothing */

foo('hello');
/* prints
arg1: hello
*/

foo('hello', 'world', 'again');
/* prints
arg1: hello
arg2: world
arg3: again
*/

2. Verwenden von Glob() zum Suchen von Dateien

Viele PHP-Funktionen haben lange und beschreibende Namen. Es kann jedoch schwierig sein zu sagen, was eine Funktion namens glob() tut, es sei denn, Sie kennen diesen Begriff bereits von einer anderen Stelle.

Stellen Sie sich das wie eine leistungsfähigere Version der Funktion scandir() vor. Sie können mithilfe von Mustern nach Dateien suchen.

// get all php files
$files = glob('*.php');

print_r($files);
/* output looks like:
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
)
*/

Sie können mehrere Dateitypen so abrufen:

// get all php files AND txt files
$files = glob('*.{php,txt}', GLOB_BRACE);

print_r($files);
/* output looks like:
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
    [4] => log.txt
    [5] => test.txt
)
*/

Beachten Sie, dass die Dateien abhängig von Ihrer Abfrage tatsächlich mit einem Pfad zurückgegeben werden können:

$files = glob('../images/a*.jpg');

print_r($files);
/* output looks like:
Array
(
    [0] => ../images/apple.jpg
    [1] => ../images/art.jpg
)
*/

Wenn Sie den vollständigen Pfad zu jeder Datei erhalten möchten, können Sie einfach die Funktion realpath() für die zurückgegebenen Werte aufrufen:

$files = glob('../images/a*.jpg');

// applies the function to each array element
$files = array_map('realpath',$files);

print_r($files);
/* output looks like:
Array
(
    [0] => C:\wamp\www\images\apple.jpg
    [1] => C:\wamp\www\images\art.jpg
)
*/

3. Informationen zur Speichernutzung

Wenn Sie die Speichernutzung Ihrer Skripte beobachten, können Sie Ihren Code möglicherweise besser optimieren.

PHP hat einen Garbage Collector und einen ziemlich komplexen Speichermanager. Die Menge an Speicher, die von Ihrem Skript verwendet wird. kann während der Ausführung eines Skripts auf und ab gehen. Um die aktuelle Speichernutzung abzurufen, können wir die Funktion memory_get_usage() verwenden. Um die höchste Speichermenge zu erhalten, die zu einem beliebigen Zeitpunkt verwendet wird, können wir die Funktion memory_get_peak_usage() verwenden.

echo "Initial: ".memory_get_usage()." bytes \n";
/* prints
Initial: 361400 bytes
*/

// let's use up some memory
for ($i = 0; $i < 100000; $i++) {
	$array []= md5($i);
}

// let's remove half of the array
for ($i = 0; $i < 100000; $i++) {
	unset($array[$i]);
}

echo "Final: ".memory_get_usage()." bytes \n";
/* prints
Final: 885912 bytes
*/

echo "Peak: ".memory_get_peak_usage()." bytes \n";
/* prints
Peak: 13687072 bytes
*/

4. Informationen zur CPU-Auslastung

Dafür verwenden wir die Funktion getrusage(). Beachten Sie, dass dies auf Windows-Plattformen nicht verfügbar ist.

print_r(getrusage());
/* prints
Array
(
    [ru_oublock] => 0
    [ru_inblock] => 0
    [ru_msgsnd] => 2
    [ru_msgrcv] => 3
    [ru_maxrss] => 12692
    [ru_ixrss] => 764
    [ru_idrss] => 3864
    [ru_minflt] => 94
    [ru_majflt] => 0
    [ru_nsignals] => 1
    [ru_nvcsw] => 67
    [ru_nivcsw] => 4
    [ru_nswap] => 0
    [ru_utime.tv_usec] => 0
    [ru_utime.tv_sec] => 0
    [ru_stime.tv_usec] => 6269
    [ru_stime.tv_sec] => 0
)

*/

Das sieht vielleicht etwas kryptisch aus, es sei denn, Sie haben bereits einen Hintergrund in der Systemadministration. Hier ist die Erklärung für jeden Wert (Sie müssen sich diese nicht merken):

ru_oublock: Blockausgabeoperationen
ru_inblock: Blockeingabeoperationen
ru_msgsnd: Nachrichten gesendet
ru_msgrcv: Nachrichten empfangen
ru_maxrss: maximale Größe des residenten Sets
ru_ixrss: Integrierte Größe des gemeinsam genutzten Speichers
ru_idrss: Integrale nicht gemeinsam genutzte Datengröße
ru_minflt: Seite wird zurückgefordert
ru_majflt: Seitenfehler
ru_nsignals: empfangene Signale
ru_nvcsw: freiwillige Kontextwechsel
ru_nivcsw: unfreiwillige Kontextwechsel
ru_nswap: Swaps
ru_utime.tv_usec: Verwendete Benutzerzeit (Mikrosekunden)
ru_utime.tv_sec: Verwendete Benutzerzeit (Sekunden)
ru_stime.tv_usec: Verwendete Systemzeit (Mikrosekunden)
ru_stime.tv_sec: Verwendete Systemzeit (Sekunden)

Um zu sehen, wie viel CPU-Leistung das Skript verbraucht hat, müssen wir uns die Werte für "Benutzerzeit" und "Systemzeit" ansehen. Die Sekunden- und Mikrosekundenabschnitte werden standardmäßig separat bereitgestellt. Sie können den Mikrosekundenwert durch 1 Million teilen und zum Sekundenwert addieren, um die Gesamtsekunde als Dezimalzahl zu erhalten.

Sehen wir uns ein Beispiel an:

// sleep for 3 seconds (non-busy)
sleep(3);

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 0.011552
System time: 0
*/

Obwohl die Ausführung des Skripts etwa 3 Sekunden dauerte, war die CPU-Auslastung sehr, sehr gering. Da das Skript während des Ruhezustands tatsächlich keine CPU-Ressourcen verbraucht. Es gibt viele andere Aufgaben, die möglicherweise in Echtzeit ausgeführt werden, jedoch möglicherweise keine CPU-Zeit benötigen, z. B. das Warten auf Festplattenvorgänge. Wie Sie sehen, sind die CPU-Auslastung und die tatsächliche Laufzeit nicht immer gleich.

Hier ist ein weiteres Beispiel:

// loop 10 million times (busy)
for($i=0;$i<10000000;$i++) {

}

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.424592
System time: 0.004204
*/

Dies dauerte ungefähr 1,4 Sekunden CPU-Zeit, fast die gesamte Benutzerzeit, da keine Systemaufrufe stattfanden.

Systemzeit ist die Zeit, die die CPU damit verbringt, Systemaufrufe für den Kernel im Namen des Programms auszuführen. Hier ist ein Beispiel dafür:

$start = microtime(true);
// keep calling microtime for about 3 seconds
while(microtime(true) - $start < 3) {

}

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.088171
System time: 1.675315
*/

Jetzt haben wir ziemlich viel Systemzeitverbrauch. Dies liegt daran, dass das Skript die Funktion microtime() viele Male aufruft, wodurch über das Betriebssystem eine Anforderung zum Abrufen der Zeit ausgeführt wird.

Möglicherweise stellen Sie auch fest, dass sich die Zahlen nicht ganz auf 3 Sekunden summieren. Dies liegt daran, dass wahrscheinlich auch andere Prozesse auf dem Server vorhanden waren und das Skript während der gesamten Dauer der 3 Sekunden keine 100% ige CPU verwendete.

5. Magische Konstanten

PHP bietet nützliche magische Konstanten zum Abrufen der aktuellen Zeilennummer (__LINE__), des Dateipfads (__FILE__), des Verzeichnispfads (__DIR__), des Funktionsnamens (__FUNCTION__), des Klassennamens (__CLASS__), des Methodennamens (__METHOD__) und des Namespace (__NAMESPACE__).

Wir werden nicht jeden dieser Punkte in diesem Artikel behandeln, aber ich werde Ihnen einige Anwendungsfälle zeigen.

Wenn Sie andere Skripte einfügen, empfiehlt es sich, die Konstante __FILE__ (oder auch __DIR__ ab PHP 5.3) zu verwenden:

// this is relative to the loaded script's path
// it may cause problems when running scripts from different directories
require_once('config/database.php');

// this is always relative to this file's path
// no matter where it was included from
require_once(dirname(__FILE__) . '/config/database.php');

Die Verwendung von __LINE__ erleichtert das Debuggen. Sie können die Zeilennummern aufspüren:

// some code
// ...
my_debug("some debug message", __LINE__);
/* prints
Line 4: some debug message
*/

// some more code
// ...
my_debug("another debug message", __LINE__);
/* prints
Line 11: another debug message
*/

function my_debug($msg, $line) {
	echo "Line $line: $msg\n";
}

6. Generieren eindeutiger IDs

Es kann Situationen geben, in denen Sie eine eindeutige Zeichenfolge generieren müssen. Ich habe viele Leute gesehen, die die Funktion md5() dafür verwenden, obwohl sie nicht genau für diesen Zweck gedacht ist:

1	// generate unique string
2	echo md5(time() . mt_rand(1,1000000));

Es gibt tatsächlich eine PHP-Funktion namens uniqid(), die dafür verwendet werden soll.

// generate unique string
echo uniqid();
/* prints
4bd67c947233e
*/

// generate another unique string
echo uniqid();
/* prints
4bd67c9472340
*/

Möglicherweise stellen Sie fest, dass die Zeichenfolgen zwar eindeutig sind, für die ersten Zeichen jedoch ähnlich erscheinen. Dies liegt daran, dass die generierte Zeichenfolge mit der Serverzeit zusammenhängt. Dies hat tatsächlich einen schönen Nebeneffekt, da jede neu generierte ID später in alphabetischer Reihenfolge angezeigt wird, sodass sie sortiert werden können.

Um die Wahrscheinlichkeit eines Duplikats zu verringern, können Sie ein Präfix oder den zweiten Parameter übergeben, um die Entropie zu erhöhen:

// with prefix
echo uniqid('foo_');
/* prints
foo_4bd67d6cd8b8f
*/

// with more entropy
echo uniqid('',true);
/* prints
4bd67d6cd8b926.12135106
*/

// both
echo uniqid('bar_',true);
/* prints
bar_4bd67da367b650.43684647
*/

Diese Funktion generiert kürzere Zeichenfolgen als md5(), wodurch Sie auch Platz sparen.

7. Serialisierung

Mussten Sie jemals eine komplexe Variable in einer Datenbank oder einer Textdatei speichern? Sie müssen keine ausgefallene Lösung finden, um Ihre Arrays oder Objekte in formatierte Zeichenfolgen zu konvertieren, da PHP bereits über Funktionen für diesen Zweck verfügt.

Es gibt zwei beliebte Methoden zum Serialisieren von Variablen. Hier ist ein Beispiel, das serialize() und unserialize() verwendet:

// a complex array
$myvar = array(
	'hello',
	42,
	array(1,'two'),
	'apple'
);

// convert to a string
$string = serialize($myvar);

echo $string;
/* prints
a:4:{i:0;s:5:"hello";i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:"two";}i:3;s:5:"apple";}
*/

// you can reproduce the original variable
$newvar = unserialize($string);

print_r($newvar);
/* prints
Array
(
    [0] => hello
    [1] => 42
    [2] => Array
        (
            [0] => 1
            [1] => two
        )

    [3] => apple
)
*/

Dies war die native PHP-Serialisierungsmethode. Da JSON in den letzten Jahren so populär geworden ist, haben sie beschlossen, Unterstützung für PHP 5.2 hinzuzufügen. Jetzt können Sie auch die Funktionen json_encode() und json_decode() verwenden:

// a complex array
$myvar = array(
	'hello',
	42,
	array(1,'two'),
	'apple'
);

// convert to a string
$string = json_encode($myvar);

echo $string;
/* prints
["hello",42,[1,"two"],"apple"]
*/

// you can reproduce the original variable
$newvar = json_decode($string);

print_r($newvar);
/* prints
Array
(
    [0] => hello
    [1] => 42
    [2] => Array
        (
            [0] => 1
            [1] => two
        )

    [3] => apple
)
*/

Es ist kompakter und am besten mit Javascript und vielen anderen Sprachen kompatibel. Bei komplexen Objekten können jedoch einige Informationen verloren gehen.

8. Komprimieren von Saiten

Wenn wir über Komprimierung sprechen, denken wir normalerweise an Dateien wie ZIP-Archive. Es ist möglich, lange Zeichenfolgen in PHP zu komprimieren, ohne Archivdateien einzubeziehen.

Im folgenden Beispiel werden wir die Funktionen gzcompress() und gzuncompress() verwenden:

$string =
"Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Nunc ut elit id mi ultricies
adipiscing. Nulla facilisi. Praesent pulvinar,
sapien vel feugiat vestibulum, nulla dui pretium orci,
non ultricies elit lacus quis ante. Lorem ipsum dolor
sit amet, consectetur adipiscing elit. Aliquam
pretium ullamcorper urna quis iaculis. Etiam ac massa
sed turpis tempor luctus. Curabitur sed nibh eu elit
mollis congue. Praesent ipsum diam, consectetur vitae
ornare a, aliquam a nunc. In id magna pellentesque
tellus posuere adipiscing. Sed non mi metus, at lacinia
augue. Sed magna nisi, ornare in mollis in, mollis
sed nunc. Etiam at justo in leo congue mollis.
Nullam in neque eget metus hendrerit scelerisque
eu non enim. Ut malesuada lacus eu nulla bibendum
id euismod urna sodales. ";

$compressed = gzcompress($string);

echo "Original size: ". strlen($string)."\n";
/* prints
Original size: 800
*/



echo "Compressed size: ". strlen($compressed)."\n";
/* prints
Compressed size: 418
*/

// getting it back
$original = gzuncompress($compressed);

Wir konnten eine Größenreduzierung von fast 50% erzielen. Auch die Funktionen gzencode() und gzdecode() erzielen ähnliche Ergebnisse, indem sie einen anderen Komprimierungsalgorithmus verwenden.

9. Abschaltfunktion registrieren

Es gibt eine Funktion namens register_shutdown_function(), mit der Sie Code ausführen können, bevor das Skript ausgeführt wird.

Stellen Sie sich vor, Sie möchten am Ende Ihrer Skriptausführung einige Benchmark-Statistiken erfassen, z. B. wie lange die Ausführung gedauert hat:

// capture the start time
$start_time = microtime(true);

// do some stuff
// ...

// display how long the script took
echo "execution took: ".
		(microtime(true) - $start_time).
		" seconds.";

Auf den ersten Blick mag dies trivial erscheinen. Sie fügen den Code einfach ganz unten im Skript hinzu und er wird ausgeführt, bevor er abgeschlossen ist. Wenn Sie jedoch jemals die Funktion exit() aufrufen, wird dieser Code niemals ausgeführt. Wenn ein schwerwiegender Fehler vorliegt oder wenn das Skript vom Benutzer beendet wird (durch Drücken der Stopp-Taste im Browser), wird es möglicherweise erneut nicht ausgeführt.

Wenn Sie register_shutdown_function() verwenden, wird Ihr Code ausgeführt, unabhängig davon, warum das Skript nicht mehr ausgeführt wird:

$start_time = microtime(true);

register_shutdown_function('my_shutdown');

// do some stuff
// ...


function my_shutdown() {
	global $start_time;

	echo "execution took: ".
			(microtime(true) - $start_time).
			" seconds.";
}

Abschluss

Kennen Sie andere PHP-Funktionen, die nicht allgemein bekannt sind, aber sehr nützlich sein können? Bitte teilen Sie uns in den Kommentaren. Und danke fürs Lesen!