• PHP steht für PHP: Hypertext Preprocessor
  • PHP-Dateien können Text, HTML, JavaScript-Code und PHP-Code enthalten
  • PHP-Code wird auf dem Server ausgeführt, und das Ergebnis wird als reines HTML an den Browser zurückgegeben
  • Die Standard-Dateiendung für PHP-Dateien ist ".php"
PHP 基础知识总结

Was kann PHP tun?

  • PHP kann dynamische Seiteninhalte generieren
  • PHP kann Dateien auf dem Server erstellen, öffnen, lesen, schreiben und schließen
  • PHP kann Formulardaten erfassen
  • PHP kann Cookies senden und empfangen
  • PHP kann Daten in Ihrer Datenbank hinzufügen, löschen und ändern
  • PHP kann Benutzer daran hindern, auf einige Seiten Ihrer Website zuzugreifen
  • PHP kann Daten verschlüsseln

Installation

Wenn Ihr Server PHP nicht unterstützt, müssen Sie:

  1. Einen Webserver installieren
  2. PHP installieren
  3. Eine Datenbank wie MySQL installieren
    Die offizielle PHP-Website (PHP.net) enthält Installationsanweisungen für PHP:http://php.net/manual/en/install.php

Empfohlene integrierte Entwicklungsumgebung: WAMPhttp://www.wampserver.com/

PHP-Grundsyntax

PHP-Skripte können überall in einem Dokument platziert werden.

PHP-Skripte beginnen mit <?php und enden mit ?>:

<!DOCTYPE html>
<html>
<body>

<h1>我的第一个 PHP 页面</h1>

<?php
echo "Hello World!";

// 这是一行注释

/*
这是
多行
注释
*/

?>

</body>
</html>

Jede Codezeile in PHP muss mit einem Semikolon enden

Zwei grundlegende Anweisungen zur Textausgabe im Browser: echo und print.

PHP-Variablen

Variablen beginnen mit dem $-Symbol, gefolgt vom Variablennamen

PHP hat keinen Befehl zum Deklarieren von Variablen.

Eine Variable wird erstellt, wenn Sie ihr zum ersten Mal einen Wert zuweisen:

PHP ist eine schwach typisierte Sprache
PHP konvertiert die Variable automatisch in den korrekten Datentyp, basierend auf ihrem Wert.

In stark typisierten Programmiersprachen müssen wir den Typ und den Namen einer Variablen deklarieren (definieren), bevor wir sie verwenden.

Gültigkeitsbereich von PHP-Variablen

PHP hat vier verschiedene Gültigkeitsbereiche für Variablen:

  • local
  • global
  • static
  • Parameter

Lokaler und globaler Gültigkeitsbereich

Variablen, die außerhalb aller Funktionen definiert werden, haben globalen Gültigkeitsbereich. Auf globale Variablen kann jeder Teil des Skripts außer Funktionen zugreifen. Um innerhalb einer Funktion auf eine globale Variable zuzugreifen, müssen Sie das Schlüsselwort global verwenden.

Variablen, die innerhalb einer PHP-Funktion deklariert werden, sind lokale Variablen, und auf sie kann nur innerhalb der Funktion zugegriffen werden:

<?php
$x=5; // 全局变量

function myTest()
{
    $y=10; // 局部变量
    echo "<p>测试变量在函数内部:<p>";
    echo "变量 x 为: $x";
    echo "<br>";
    echo "变量 y 为: $y";
} 

myTest();

echo "<p>测试变量在函数外部:<p>";
echo "变量 x 为: $x";
echo "<br>";
echo "变量 y 为: $y";
?>

Um von innerhalb einer Funktion auf eine außerhalb einer Funktion definierte globale Variable zuzugreifen, müssen wir der Variablen innerhalb der Funktion das Schlüsselwort global voranstellen:

<?php
$x=5;
$y=10;

function myTest()
{
    global $x,$y;
    $y=$x+$y;
}

myTest();
echo $y; // 输出 15
?>

PHP speichert alle globalen Variablen in einem Array namens $GLOBALS[index]. Der Index enthält den Namen der Variablen. Auf dieses Array kann innerhalb von Funktionen zugegriffen werden, und es kann auch direkt verwendet werden, um globale Variablen zu aktualisieren.

<?php
$x=5;
$y=10;

function myTest()
{
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
} 

myTest();
echo $y;
?>

Ruang Lingkup Statis

Wenn eine Funktion beendet wird, werden normalerweise alle ihre Variablen gelöscht. Manchmal möchten Sie jedoch, dass eine lokale Variable nicht gelöscht wird; Sie können dasstatic-Schlüsselwort verwenden

<?php

function myTest()
{
    static $x=0;
    echo $x;
    $x++;
}

myTest();
myTest();
myTest();

?>

Gültigkeitsbereich von Parametern

Parameter sind lokale Variablen, die Werte erhalten, die vom aufrufenden Code an die Funktion übergeben werden.

Parameter werden in der Parameterliste deklariert, als Teil der Funktionsdeklaration:

<?php

function myTest($x)
{
    echo $x;
}

myTest(5);

?>

PHP echo- und print-Anweisungen

  • echo - kann eine oder mehrere Zeichenketten ausgeben
  • print - erlaubt nur die Ausgabe einer Zeichenkette, und sein Rückgabewert ist immer 1

Tipp: echo gibt schneller aus als print, echo hat keinen Rückgabewert, und print hat einen Rückgabewert von 1.
Sowohl echo als auch print sind Sprachkonstrukte. Bei ihrer Verwendung können Sie die Klammern weglassen oder Klammern hinzufügen: echo oder echo(), print oder print().

<?php
echo "<h2>PHP is fun!</h2>";
echo "Hello world!<br>";
echo "I'm about to learn PHP!<br>";
echo "This", " string", " was", " made", " with multiple parameters.";

print "<h2>PHP is fun!</h2>";
print "Hello world!<br>";
print "I'm about to learn PHP!";

?>

Das folgende Beispiel zeigt, wie man den echo-Befehl verwendet, um Variablen und Strings auszugeben:

<?php
$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

echo $txt1;
echo "<br>";
echo "Study PHP at $txt2"; //php 双引号内部可包含变量
echo "My car is a {$cars[0]}"; //用大括号 显式的指定这是变量

$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

print $txt1;
print "<br>";
print "Study PHP at $txt2";
print "My car is a {$cars[0]}";

?>

PHP5-Datentypen

String, Integer, Float, Boolean, Array, Objekt, NULL (Nullwert).

String
Sie können jeden Text in einfache und doppelte Anführungszeichen setzen:

<?php 
$x = "Hello world!";
echo $x;
echo "<br>"; 
$x = 'Hello world!'; //单引号 包括字符串字面量 双引号包含的字符串 可包含变量
echo $x;
?>

Integer
Im folgenden Beispiel testen wir verschiedene Zahlen. PHPvar_dump()Die Funktion gibt den Datentyp und den Wert einer Variablen zurück:

?php 
$x = 5985;
var_dump($x);
echo "<br>"; 
$x = -345; // 负数 
var_dump($x);
echo "<br>"; 
$x = 0x8C; // 十六进制数
var_dump($x);
echo "<br>";
$x = 047; // 八进制数
var_dump($x);
?>

Float

<?php 
$x = 10.365;
var_dump($x);
echo "<br>"; 
$x = 2.4e3;
var_dump($x);
echo "<br>"; 
$x = 8E-5;
var_dump($x);
?>

Boolean

Boolean kann TRUE oder FALSE sein.

Array

Ein Array kann mehrere Werte in einer Variablen speichern

<?php 
$cars=array("Volvo","BMW","Toyota");
var_dump($cars);
?>

Objekt

In PHP müssen Objekte deklariert werden.

Zuerst müssen Sie ein Klassenobjekt mit dem Schlüsselwort class deklarieren. Eine Klasse ist eine Struktur, die Eigenschaften und Methoden enthalten kann.
Dann definieren wir Datentypen in der Klasse und verwenden dann die Datentypen in der instanziierten Klasse:

<?php
class Car
{
    var $color;
    function Car($color="green") {
      $this->color = $color;
    }
    function what_color() {
      return $this->color;
    }
}

function print_vars($obj) {
   foreach (get_object_vars($obj) as $prop => $val) {
     echo "\t$prop = $val\n";
   }
}

// instantiate one object
$herbie = new Car("white");

// show herbie properties
echo "\herbie: Properties\n";
print_vars($herbie);

?>

NULL-Wert
Der NULL-Wert gibt an, dass eine Variable keinen Wert hat. NULL ist ein Wert mit dem Datentyp NULL.

<?php
$x="Hello world!";
$x=null;
var_dump($x);
?>

Konstanten

Eine Konstante ist ein Bezeichner für einen einfachen Wert. Dieser Wert kann während des Skripts nicht geändert werden. (Ein Konstantenname benötigt keinen $-Modifikator.)

Hinweis: Konstanten können im gesamten Skript verwendet werden.

Um eine Konstante festzulegen, verwenden Sie die Funktion define(), deren Syntax wie folgt lautet:

define(string constant_name, mixed value, case_sensitive = true)
Diese Funktion hat drei Parameter:

  • constant_name: Erforderlicher Parameter, der Name der Konstante, d. h. der Bezeichner.
  • value: Erforderlicher Parameter, der Wert der Konstante.
  • case_sensitive: Optionaler Parameter, gibt an, ob zwischen Groß- und Kleinschreibung unterschieden wird; auf true setzen, um anzugeben, dass die Groß-/Kleinschreibung nicht unterschieden wird.

Das folgende Beispiel erstellt eine Konstante, bei der zwischen Groß- und Kleinschreibung unterschieden wird, mit dem Wert "Welcome to example.com!":

<?php
define("GREETING", "Welcome to example.com!");
echo GREETING;
?>

String-Funktionen und String-Verkettung

<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2; // 字符串连接运算符 .

echo strlen("Hello world!"); //获取字符串长度
echo strpos("Hello world!","world"); //获取子串位置
//字符串中第一个字符的位置是 0
?>

Operatoren

<?php
//其他运算符略..
//逻辑运算符 ! && || and or xor
//数组运算符 合并: + 比较：== != === !==
$x = array("a" => "red", "b" => "green"); 
$y = array("c" => "blue", "d" => "yellow"); 
$z = $x + $y; // $x 和 $y 数组合并
var_dump($z);
var_dump($x == $y);
var_dump($x === $y);
var_dump($x != $y);
var_dump($x <> $y);
var_dump($x !== $y);
?>

Kontrollflussanweisungen, wie in JS

<?php

$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}



$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$t=date("H");
if ($t<"10")
{
    echo "Have a good morning!";
}
else if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$favcolor="red";
switch ($favcolor)
{
    case "red":
    echo "Your favorite color is red!";
    break;
    case "blue":
    echo "Your favorite color is blue!";
    break;
    case "green":
    echo "Your favorite color is green!";
    break;
    default:
    echo "Your favorite color is neither red, blue, or green!";
}

//循环
$i=1;
while($i<=5)
{
    echo "The number is " . $i . "<br>";
    $i++;
}


$i=1;
do
{
    $i++;
    echo "The number is " . $i . "<br>";
}
while ($i<=5);

for ($i=1; $i<=5; $i++)
{
    echo "The number is " . $i . "<br>";
}


$x=array("one","two","three");
foreach ($x as $value)
{
    echo $value . "<br>";
}

?>

Arrays

<?php
$cars=array("Volvo","BMW","Toyota"); //数组定义 数值数组
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . "."; //访问数组元素

//数组长度count()
$cars=array("Volvo","BMW","Toyota");
echo count($cars); //count() 函数用于返回数组的长度

//遍历数值数组
$cars=array("Volvo","BMW","Toyota");
$arrlength=count($cars);

for($x=0;$x<$arrlength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");//定义关联数组
echo "Peter is " . $age['Peter'] . " years old.";

//遍历关联数组
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
foreach($age as $x=>$x_value)
{
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
}
?>

Array-Sortierung

PHP - Array-Sortierfunktionen

  • sort() - sortiert ein Array in aufsteigender Reihenfolge
  • rsort() - sortiert ein Array in absteigender Reihenfolge
  • asort() - sortiert ein assoziatives Array in aufsteigender Reihenfolge nach dem Wert
  • ksort() - sortiert ein assoziatives Array in aufsteigender Reihenfolge nach dem Schlüssel
  • arsort() - sortiert ein assoziatives Array in absteigender Reihenfolge nach dem Wert
  • krsort() - sortiert ein assoziatives Array in absteigender Reihenfolge nach dem Schlüssel
//sort()
$cars=array("Volvo","BMW","Toyota");
sort($cars);

$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

//rsort()   
$cars=array("Volvo","BMW","Toyota");
rsort($cars);   

//asort() arsort() 关联数组排序 value
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
asort($age);
arsort($age);

//ksort() krsort() 关联数组排序 key
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
ksort($age);
krsort($age);
?>

Superglobale Variablen

PHP definiert mehrere superglobale Variablen vor, was bedeutet, dass sie in allen Gültigkeitsbereichen innerhalb eines Skripts verfügbar sind.

  • $GLOBALS
  • $_SERVER
  • $_REQUEST
  • $_POST
  • $_GET
  • $_COOKIE
  • $_FILES
  • $_ENV
  • $_SESSION

$GLOBAL ist ein globales kombiniertes Array, das alle Variablen enthält. Die Variablennamen sind die Schlüssel des Arrays.

<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

$_SERVER ist ein Array, das Informationen wie Header, Pfade und Skriptstandorte enthält. Die Elemente in diesem Array werden vom Webserver erstellt. Es gibt keine Garantie, dass jeder Server alle Elemente bereitstellt;

<?php 
echo $_SERVER['PHP_SELF']; // /try/demo_source/demo_global_server.php
echo "<br>";
echo $_SERVER['SERVER_NAME']; // example.com
echo "<br>";
echo $_SERVER['HTTP_HOST']; // www.example.com
echo "<br>";
echo $_SERVER['HTTP_REFERER']; //来由
echo "<br>";
echo $_SERVER['HTTP_USER_AGENT']; //浏览器
echo "<br>";
echo $_SERVER['SCRIPT_NAME']; // /try/demo_source/demo_global_server.php

//另外$_SERVER对象还包括 SERVER_ADDR, SERVER_PROTOCOL ,REQUEST_METHOD..等属性

?>

$_REQUEST wird verwendet, um Daten zu sammeln, die von HTML-Formularen übermittelt werden.

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_REQUEST['fname']; 
echo $name; 
?>

</body>
</html>

$_POST wird häufig verwendet, um Formulardaten zu sammeln. Geben Sie dieses Attribut im HTML-Formular-Tag an: "method="post"

<html>
<body>
<!--页面post给自己-->
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_POST['fname']; 
echo $name; 
?>

</body>
</html>

$_GET wird ebenfalls häufig verwendet, um Formulardaten zu sammeln. Geben Sie dieses Attribut im HTML-Formular-Tag an: "method="get".

Mit $_GET können auch Daten gesammelt werden, die in der URL gesendet werden.

<html>
<body>

<a href="test_get.php.html">Test $GET</a>

</body>
</html>

//test_get.php

<html>
<body>

<?php 
echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
?>

</body>
</html>

PHP-Funktionen

Die wahre Stärke von PHP liegt in seinen Funktionen.

In PHP sind mehr als 1000 integrierte Funktionen verfügbar.

<html>
<body>

<?php
function writeName()
{
    echo "Kai Jim Refsnes";
}

echo "My name is ";
writeName();

//函数传参
function writeName($fname,$punctuation)
{
    echo $fname . " Refsnes" . $punctuation . "<br>";
}

echo "My name is ";
writeName("Kai Jim",".");
echo "My sister's name is ";

//函数返回值
function add($x,$y)
{
    $total=$x+$y;
    return $total;
}

echo "1 + 16 = " . add(1,16);

?>

</body>
</html>

Magische Variablen

Es gibt acht magische Konstanten, deren Werte sich je nach ihrer Position im Code ändern.

  • _LINE__
    Die aktuelle Zeilennummer in der Datei.
  • FILE
    Der vollständige Pfad und Dateiname der Datei. Wenn sie innerhalb einer eingebundenen Datei verwendet wird, wird der Name der eingebundenen Datei zurückgegeben.
  • DIR
    Das Verzeichnis der Datei. Wenn sie in einer eingebundenen Datei verwendet wird, wird das Verzeichnis der eingebundenen Datei zurückgegeben.
  • FUNCTION
    Der Funktionsname (neu in PHP 4.3.0). Ab PHP 5 gibt diese Konstante den Funktionsnamen so zurück, wie er definiert wurde (Groß-/Kleinschreibung wird beachtet). In PHP 4 ist der Wert immer kleingeschrieben.
<?php
function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test();
?>
  • CLASSDer Klassenname (neu in PHP 4.3.0). Ab PHP 5 gibt diese Konstante den Klassennamen so zurück, wie er definiert wurde (Groß-/Kleinschreibung wird beachtet).

In PHP 4 ist der Wert immer kleingeschrieben. Der Klassenname enthält seinen deklarierten Namensraum (z. B. Foo\Bar). Beachten Sie, dass ab PHP 5.4CLASSauch mit Traits funktioniert. Wenn es in einer Trait-Methode verwendet wird,CLASSist es der Name der Klasse, die die Trait-Methode verwendet.

<?php
class test {
    function _print() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new test();
$t->_print();
?>
  • TRAITDer Trait-Name (neu in PHP 5.4.0). Ab PHP 5.4.0 implementiert PHP eine Methode zur Wiederverwendung von Code, die Traits genannt wird.

Der Trait-Name enthält seinen deklarierten Namensraum (z. B. Foo\Bar).

Das geerbte Member aus der Basisklasse wird durch die in den Trait SayWorld eingefügte Methode MyHelloWorld überschrieben. Sein Verhalten ist dasselbe wie das der in der Klasse MyHelloWorld definierten Methode. Die Rangfolge ist, dass Methoden in der aktuellen Klasse Trait-Methoden überschreiben und Trait-Methoden wiederum Methoden in der Basisklasse überschreiben.

<?php
class Base {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'World!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>
  • METHODDer Name der Klassenmethode (neu in PHP 5.0.0). Gibt den Methodennamen so zurück, wie er definiert wurde (Groß-/Kleinschreibung wird beachtet).
<?php
function test() {
    echo  '函数名为：' . __METHOD__ ;
}
test();
?>
  • NAMESPACEDer Name des aktuellen Namensraums (Groß-/Kleinschreibung wird beachtet). Diese Konstante wird zur Kompilierzeit definiert (neu in PHP 5.3.0).
<?php
namespace MyProject;

echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

Namespaces

PHP-Namensräume wurden in PHP 5.3 eingeführt. Wenn Sie C# und Java gelernt haben, sind Namensräume nichts Neues. Allerdings haben sie in PHP weiterhin erhebliche Bedeutung.

PHP-Namespaces können die folgenden zwei Arten von Problemen lösen:

  • Namenskollisionen zwischen Benutzercode und PHP-internen Klassen/Funktionen/Konstanten.
  • Aliasnamen (oder verkürzte Namen) erstellen, wodurch die Lesbarkeit des Quellcodes verbessert wird.

Standardmäßig werden alle Konstanten, Klassen und Funktionsnamen im globalen Namensraum abgelegt, genau wie vor der Unterstützung von Namensräumen durch PHP.
Wenn eine Datei Namespaces enthält, muss die Namespace-Deklaration vor allen anderen Code stehen.

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...  

//也可以在同一个文件中定义不同的命名空间代码
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  

?>

Der einzige zulässige Code vor der Deklaration eines Namespace ist eine declare-Anweisung, die zur Definition der Kodierung der Quelldatei verwendet wird. Jeglicher Nicht-PHP-Code, einschließlich Leerraum, darf nicht vor der Namespace-Deklaration erscheinen.

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace { // 全局代码
    session_start();
    $a = MyProject\connect();
    echo MyProject\Connection::start();
}
?>

Der folgende Code verursacht einen Syntaxfehler:

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

Unter-Namespaces

<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间
//创建了常量 MyProject\Sub\Level\CONNECT_OK，
//类 MyProject\Sub\Level\Connection 
//和函数 MyProject\Sub\Level\Connect.

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

Verwendung von Namespaces
Klassennamen in PHP-Namespaces können auf drei Arten referenziert werden:

  1. Nicht qualifizierte Namen oder Klassennamen ohne Präfix, z. B. $a=new foo(); oder foo::staticmethod();. Wenn der aktuelle Namespace currentnamespace ist, wird foo zu currentnamespace\foo aufgelöst. Wenn der Code, der foo verwendet, global ist, d. h. Code, der in keinem Namespace enthalten ist, wird foo zu foo aufgelöst. Warnung: Wenn eine Funktion oder Konstante in einem Namespace nicht definiert ist, wird der nicht qualifizierte Funktionsname oder Konstantenname zum globalen Funktionsnamen oder Konstantennamen aufgelöst.~~Referenz ohne Namespace-Präfix: sucht standardmäßig im aktuellen Namespace und dann im globalen Namespace.

  2. Qualifizierte Namen oder Namen, die ein Präfix enthalten, z. B. $a = new subnamespace\foo(); oder subnamespace\foo::staticmethod();. Wenn der aktuelle Namespace currentnamespace ist, wird foo zu currentnamespace\subnamespace\foo aufgelöst. Wenn der Code, der foo verwendet, global ist, d. h. Code, der in keinem Namespace enthalten ist, wird foo zu subnamespace\foo aufgelöst.~~Referenz mit einem relativen Namespace-Präfix (ähnlich einem relativen Pfad); stellt automatisch den Namespace des aufrufenden Codes voran.

  3. Vollständig qualifizierte Namen oder Namen, die den globalen Präfixoperator enthalten, z. B. $a = new \currentnamespace\foo(); oder \currentnamespace\foo::staticmethod();. In diesem Fall wird foo immer zum wörtlichen Namen im Code aufgelöst, currentnamespace\foo.~~Referenz mit einem absoluten Namespace-Präfix (ähnlich einem absoluten Pfad). Der Referenzpfad ist explizit und es ist keine Suche erforderlich.

file1.php

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

file2.php

<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为函数 Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod.
echo FOO; // resolves to constant Foo\Bar\FOO

/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
                                  // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
                                  
/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

Zugriff auf globale Klassen, Funktionen und Konstanten aus einem Namespace heraus:

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>

Namespaces und dynamische Sprachmerkmale

PHPs Implementierung von Namespaces wird durch die dynamischen Merkmale der Sprache selbst beeinflusst. Wenn Sie den folgenden Code in Namespaces umwandeln möchten, greifen Sie daher dynamisch auf Elemente zu.

//example.php

<?php
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global
?>
<?php
namespace namespacename;
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "namespaced";

include 'example1.php';//全局命名空间和某个命名空间有相同类 函数 和 常量 分别区别访问

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global

/* note that if using double quotes, "\\namespacename\\classname" must be used */
$a = '\namespacename\classname';
$obj = new $a; // prints namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // also prints namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // prints namespacename\funcname
$b = '\namespacename\funcname';
$b(); // also prints namespacename\funcname
echo constant('\namespacename\constname'), "\n"; // prints namespaced
echo constant('namespacename\constname'), "\n"; // also prints namespaced
?>

namespace-Schlüsselwort und __NAMESPACE__-Konstante

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

Dynamisches Erstellen von Namen mit __NAMESPACE__

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\\' . $classname;
    return new $a;
}
?>

Das namespace-Schlüsselwort kann verwendet werden, um explizit auf Elemente im aktuellen Namespace oder einem Unter-Namespace zuzugreifen. Es entspricht dem self-Operator in Klassen.

<?php
namespace MyProject;

use blah\blah as mine; // see "Using namespaces: importing/aliasing"

blah\mine(); // calls function blah\blah\mine()
namespace\blah\mine(); // calls function MyProject\blah\mine()

namespace\func(); // calls function MyProject\func()
namespace\sub\func(); // calls function MyProject\sub\func()
namespace\cname::method(); // calls static method "method" of class MyProject\cname
$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname
$b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b
?>

In PHP werden Aliase mit dem use-Operator implementiert. Nachfolgend ein Beispiel, das alle drei möglichen Arten des Imports verwendet:

  1. Importieren/Verwenden von Aliasen mit dem use-Operator
<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>
  1. Mehrere use-Anweisungen in einer Zeile
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>
<p>导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。</p>
<ol>
<li>导入和动态名称</li>
</ol>
<pre>
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>
  1. Importieren und dynamische Namen
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

Darüber hinaus wirkt sich der Importvorgang nur auf unqualifizierte und qualifizierte Namen aus. Da vollständig qualifizierte Namen eindeutig sind, werden sie vom Importieren nicht beeinflusst.

  1. Importieren und vollständig qualifizierte Namen
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // instantiates object of class My\Full\Classname
$obj = new \Another; // instantiates object of class Another
$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing
$obj = new \Another\thing; // instantiates object of class Another\thing
?>

Verwendung von Namespaces: Rückgriff auf globale Funktionen/Konstanten

Wenn PHP in einem Namespace auf einen nicht qualifizierten Klassen-, Funktions- oder Konstantennamen stößt, verwendet es unterschiedliche Präzedenzstrategien, um den Namen aufzulösen.

  • Klassennamen werden immer zu Namen im aktuellen Namespace aufgelöst (wird kein Name gefunden, wird ein Fehler ausgelöst).Wenn Sie daher auf interne Systemklassen oder Klassennamen zugreifen, die nicht in einem Namespace enthalten sind, müssen Sie vollständig qualifizierte Namen verwenden.
  • Bei Funktionen und Konstanten greift PHP, wenn die Funktion oder Konstante im aktuellen Namespace nicht existiert, auf die Funktion oder Konstante im globalen Raum zurück.
<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

Globaler Raum
Wenn kein Namespace definiert ist, befinden sich alle Klassen- und Funktionsdefinitionen im globalen Raum, genau wie vor der Einführung des Konzepts der Namespaces in PHP. Das Voranstellen eines Backslashs (\) vor einen Namen gibt an, dass der Name ein Name im globalen Raum ist, selbst wenn sich dieser Name in einem anderen Namespace befindet.

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

Reihenfolge der Namespaces (ausgelassen..)

PHP-Dateibehandlung

Dateien öffnen

$file = fopen($fname, mode) // Dateiname, Öffnungsmodus

  • r Nur Lesen. Beginnt am Anfang der Datei.
  • r+ Lesen/Schreiben. Beginnt am Anfang der Datei.
  • w Nur Schreiben. Öffnet und leert den Dateiinhalt; falls die Datei nicht existiert, wird eine neue Datei erstellt.
  • w+ Lesen/Schreiben. Öffnet und leert den Dateiinhalt; falls die Datei nicht existiert, wird eine neue Datei erstellt.
  • a Anhängen. Öffnet und schreibt an das Ende der Datei; falls die Datei nicht existiert, wird eine neue Datei erstellt.
  • a+ Lesen/Anhängen. Öffnet und schreibt an das Ende der Datei, um den Dateiinhalt zu erhalten.
  • x Nur Schreiben. Erstellt eine neue Datei. Gibt FALSE und einen Fehler zurück, wenn die Datei bereits existiert.
  • x+ Lesen/Schreiben. Erstellt eine neue Datei. Gibt FALSE und einen Fehler zurück, wenn die Datei bereits existiert.

Hinweis: Wenn die Funktion fopen() die angegebene Datei nicht öffnen kann, gibt sie 0 (false) zurück.

<?php
//打开文件
$file = fopen("welcome.txt", "r") or exit("Unable to open file!");
//Output a line of the file until the end is reached

//是否到达文件末尾 
while(!feof($file))
{
    echo fgets($file). "<br>"; //逐行读取文件
    //echo fgetc($file); //逐字符读取

}
//关闭文件
fclose($file);
?>

Dateisystem-Funktionen

  • basename() Gibt den Dateinamen-Teil eines Pfades zurück.
  • chgrp() Ändert die Dateigruppe.
  • chmod() Ändert den Dateimodus.
  • chown() Ändert den Dateieigentümer.
  • clearstatcache() Löscht den Dateistatistik-Cache.
  • copy() Kopiert eine Datei.
  • delete() Siehe unlink() oder unset()
  • dirname() Gibt den Verzeichnisnamen-Teil eines Pfads zurück.
  • disk_free_space() Gibt den verfügbaren Speicherplatz in einem Verzeichnis zurück.
  • disk_total_space() Gibt die gesamte Datenträgerkapazität eines Verzeichnisses zurück.
  • diskfreespace() Alias von disk_free_space().
  • fclose() Schließt eine geöffnete Datei.
  • feof() Prüft, ob sich der Dateizeiger am Ende der Datei befindet.
  • fflush() Schreibt gepufferte Ausgabe in eine geöffnete Datei.
  • fgetc() Gibt ein Zeichen aus einer geöffneten Datei zurück.
  • fgetcsv() Analysiert eine Zeile aus einer geöffneten Datei und prüft auf CSV-Felder.
  • fgets() Gibt eine Zeile aus einer geöffneten Datei zurück.
  • fgetss() Gibt eine Zeile aus einer geöffneten Datei zurück und filtert HTML- und PHP-Tags heraus.
  • file() Liest eine Datei in ein Array ein.
  • file_exists() Prüft, ob eine Datei oder ein Verzeichnis existiert.
  • file_get_contents() Liest eine Datei in einen String ein. ~~Dateiinhalt abrufen
  • file_put_contents() Schreibt einen String in eine Datei. ~~Dateiinhalt schreiben
  • fileatime() Gibt den letzten Zugriffszeitpunkt einer Datei zurück.
  • filectime() Gibt den letzten Änderungszeitpunkt einer Datei zurück.
  • filegroup() Gibt die Gruppen-ID einer Datei zurück.
  • fileinode() Gibt die Inode-Nummer einer Datei zurück.
  • filemtime() Gibt den letzten Änderungszeitpunkt des Inhalts einer Datei zurück.
  • fileowner() Gibt die Benutzer-ID (Eigentümer) einer Datei zurück.
  • fileperms() Gibt die Dateiberechtigungen zurück.
  • filesize() Gibt die Dateigröße zurück.
  • filetype() Gibt den Dateityp zurück.
  • flock() Sperrt eine Datei oder hebt die Sperre auf.
  • fnmatch() Gleicht einen Dateinamen oder eine Zeichenkette mit einem angegebenen Muster ab.
  • fopen() Öffnet eine Datei oder eine URL.
  • fpassthru() Liest Daten aus einer geöffneten Datei bis zum Ende der Datei (EOF) und schreibt das Ergebnis in den Ausgabepuffer.
  • fputcsv() Formatiert eine Zeile als CSV und schreibt sie in eine geöffnete Datei.
  • fputs() Alias von fwrite().
  • fread() Liest eine geöffnete Datei.
  • fscanf() Parst eine Eingabe gemäß einem angegebenen Format.
  • fseek() Positioniert den Dateizeiger in einer geöffneten Datei.
  • fstat() Gibt Informationen über eine geöffnete Datei zurück.
  • ftell() Gibt die aktuelle Position in einer geöffneten Datei zurück.
  • ftruncate() Kürzt eine geöffnete Datei auf eine angegebene Länge.
  • fwrite() Schreibt in eine geöffnete Datei.
  • glob() Gibt ein Array mit Dateinamen/Verzeichnissen zurück, die einem angegebenen Muster entsprechen.
  • is_dir() Prüft, ob eine Datei ein Verzeichnis ist.
  • is_executable() Prüft, ob eine Datei ausführbar ist.
  • is_file() Prüft, ob eine Datei eine reguläre Datei ist.
  • is_link() Prüft, ob eine Datei ein Link ist.
  • is_readable() Prüft, ob eine Datei lesbar ist.
  • is_uploaded_file() Prüft, ob eine Datei über HTTP POST hochgeladen wurde.
  • is_writable() Prüft, ob eine Datei beschreibbar ist.
  • is_writeable() Alias von is_writable().
  • lchgrp() Ändert den Gruppeneigentümer eines symbolischen Links.
  • lchown() Ändert den Benutzereigentümer eines symbolischen Links.
  • link() Erstellt einen Hardlink.
  • linkinfo() Gibt Informationen über einen Hardlink zurück.
  • lstat() Gibt Informationen über eine Datei oder einen symbolischen Link zurück.
  • mkdir() Erstellt ein Verzeichnis.
  • move_uploaded_file() Verschiebt eine hochgeladene Datei an einen neuen Ort.
  • parse_ini_file() Analysiert eine Konfigurationsdatei.
  • parse_ini_string() Analysiert eine Konfigurationszeichenkette.
  • pathinfo() Gibt Informationen über einen Dateipfad zurück.
  • pclose() Schließt einen von popen() geöffneten Prozess.
  • popen() Öffnet einen Prozess.
  • readfile() Liest eine Datei und schreibt sie in den Ausgabepuffer.
  • readlink() Gibt das Ziel eines symbolischen Links zurück.
  • realpath() Gibt den absoluten Pfadnamen zurück.
  • realpath_cache_get() Gibt Cache-Einträge zurück.
  • realpath_cache_size() Gibt die Cache-Größe zurück.
  • rename() Benennt eine Datei oder ein Verzeichnis um.
  • rewind() Setzt die Position eines Dateizeigers zurück.
  • rmdir() Entfernt ein leeres Verzeichnis.
  • set_file_buffer() Legt die Puffergröße einer geöffneten Datei fest.
  • stat() Gibt Informationen über eine Datei zurück.
  • symlink() Erstellt einen symbolischen Link.
  • tempnam() erzeugt eine eindeutige temporäre Datei.
  • tmpfile() erzeugt eine eindeutige temporäre Datei.
  • touch() legt die Zugriffs- und Änderungszeit einer Datei fest.
  • umask() ändert die Dateiberechtigungen.
  • unlink() löscht eine Datei.

PHP JSON

  • json_encode kodiert eine Variable im JSON-Format.
  • json_decode dekodiert eine JSON-formatierte Zeichenfolge und konvertiert sie in eine PHP-Variable.
  • json_last_error gibt den zuletzt aufgetretenen Fehler zurück.

string json_encode ( $value [, $options = 0 ] )
Parameters

value: Der zu kodierende Wert. Diese Funktion funktioniert nur mit UTF-8-kodierten Daten.
options: Eine Bitmaske, die aus den folgenden Konstanten besteht: JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT.

<?php
   $arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);
   echo json_encode($arr);


    class Emp {
       public $name = "";
       public $hobbies  = "";
       public $birthdate = "";
   }
   $e = new Emp();
   $e->name = "sachin";
   $e->hobbies  = "sports";
   $e->birthdate = date('m/d/Y h:i:s a', "8/5/1974 12:20:03 p");
   $e->birthdate = date('m/d/Y h:i:s a', strtotime("8/5/1974 12:20:03"));

   echo json_encode($e);
?>

mixed json_decode ($json [,$assoc = false [, $depth = 512 [, $options = 0 ]]])
Parameters

json_string: Die zu dekodierende JSON-Zeichenkette. Es müssen UTF-8-kodierte Daten sein.

assoc: Wenn dieser Parameter TRUE ist, wird ein Array zurückgegeben; wenn FALSE, wird ein Objekt zurückgegeben.

depth: Ein ganzzahliger Parameter, der die Rekursionstiefe angibt.

options: Eine Bitmaske. Derzeit wird nur JSON_BIGINT_AS_STRING unterstützt.

<?php
   $json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

   var_dump(json_decode($json));
   var_dump(json_decode($json, true));
?>

Weitere Tutorials

Ausführlichere Tutorials finden Sie unter:PHP-Tutorial