Umgebungsvariablen in Windows enthalten verschiedene Informationen über Systemeinstellungen und die Umgebung des Benutzers. Es wird zwischen Benutzer-, System- und Prozessumgebungsvariablen unterschieden.

Der einfachste Weg, Inhalte anzuzeigen Umgebungsvariablen in Windows – Systemeigenschaften öffnen ( sysdm.cpl) -> Erweitert -> Umgebungsvariablen. Wie Sie sehen, gibt es in dem sich öffnenden Fenster zwei Abschnitte: Der obere enthält die Umgebungsvariablen des Benutzers und der untere enthält Systemvariablen.

Darüber hinaus werden Umgebungsvariablen in der Systemregistrierung gespeichert. Benutzervariablen werden im gespeichert. System - in HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment.

Sie können die Werte aller Umgebungsvariablen in anzeigen Befehlszeile Windows. Der Befehl ist einfach:

Der Befehl gibt eine Liste aus Umgebungsvariablen und ihre Bedeutung.

In PowerShell können Sie mit dem Befehl alle Umgebungsvariablen anzeigen:

Wenn Sie den Wert nur einer Variablen anzeigen müssen, müssen Sie den Befehl echo verwenden und der Variablenname muss in Prozentzeichen eingeschlossen sein. Zum Beispiel,

Echo %systemroot%

set > c:\tmp\env_var.txt

Umgebungsvariablen für einen bestimmten Prozess können kostenlos abgerufen werden Process Explorer-Dienstprogramme(von Sysinternals). Öffnen Sie einfach die Prozesseigenschaften und gehen Sie zur Registerkarte Umfeld.

Vor 13 Jahren

Ein kleines Problem, auf das Sie achten sollten:

Wenn Sie RegisterGlobals und verwandte Elemente deaktivieren und dann get_defined_vars() verwenden, wird möglicherweise Folgendes angezeigt:

Array
[ GLOBALS ] => Array
[ GLOBALS ] => Array
*REKURSION*
[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()
)

[ _POST ] => Array()
[ _GET ] => Array()
[ _COOKIE ] => Array()
[ _FILES ] => Array()

)
?>

Beachten Sie, dass $_SERVER nicht vorhanden ist. Es scheint, dass PHP den superglobalen $_SERVER nur lädt, wenn er irgendwo verwendet wird.

drucken "

" . htmlspecialchars(print_r(get_defined_vars(), true))."

" . htmlspecialchars (print_r ($_SERVER , true )) . "

Vor 6 Jahren

Da get_defined_vars() die Variablen nur dann abruft, wenn Sie die Funktion aufrufen, gibt es eine einfache Möglichkeit, die im aktuellen Bereich definierten Variablen abzurufen.

// Ganz oben in Ihrem PHP-Skript
$vars = get_definierte_vars();

// Jetzt mach deine Sachen
$foo = "foo" ;
$bar = "bar" ;

// Alle im aktuellen Bereich definierten Variablen abrufen
$vars = array_diff(get_definierte_vars(), $vars);

Echo“

"
;
print_r($vars); 
Echo“

Vor 15 Jahren

Hier ist eine Funktion, die einen Debug-Bericht zur Anzeige oder E-Mail generiert
mit get_definierten_Variablen. Ideal für einen detaillierten Schnappschuss ohne
sich auf Benutzereingaben verlassen.

Funktion genericDebugReport ($method, $defined_vars, $email = "undefiniert" )(
// Funktion zum Erstellen eines Debug-Berichts zur Anzeige oder E-Mail.
// Verwendung: genericDebugReport(method,get_defined_vars(),email);
// Wobei Methode „Browser“ oder „E-Mail“ ist.

// Eine Ignorierliste für von „get_defined_vars“ zurückgegebene Schlüssel erstellen.
// Zum Beispiel HTTP_POST_VARS, HTTP_GET_VARS und andere
// redundant (wie _POST, _GET)
// Fügen Sie auch Variablen hinzu, die aus Sicherheitsgründen ignoriert werden sollen – d. h. PHPSESSID.
$ignorelist =array("HTTP_POST_VARS" , "HTTP_GET_VARS" ,
„HTTP_COOKIE_VARS“, „HTTP_SERVER_VARS“,
„HTTP_ENV_VARS“ , „HTTP_SESSION_VARS“ ,
„_ENV“, „phpsessid“, „sess_dbuser“,
"SESS_DBPASS" , "HTTP_COOKIE" );

$timestamp = date ("m/d/y h:m:s" );
$message = "Debug-Bericht erstellt $timestamp \n" ;

// Zur Sicherheit den letzten SQL-Fehler abrufen, wobei $link der Ressourcenbezeichner ist
// für mysql_connect. Kommentieren Sie Ihre Datenbank- oder Abstraktionseinrichtung aus oder ändern Sie sie.
globaler $link ;
$sql_error = mysql_error($link);
if($sql_error )(
$message .= "\nMysql-Nachrichten:\n" . mysql_error($link);
}
// MySQL beenden

// Könnte hier eine rekursive Funktion verwenden. Du hast es verstanden ;-)
foreach($defined_vars as $key => $val )(
if(is_array ($val ) && ! in_array ($key , $ignorelist ) && count ($val ) > 0 )(
$message .= "\n $key array (key=value):\n" ;
foreach($val as $subkey => $subval )(
if(! in_array ($subkey , $ignorelist ) && ! is_array ($subval ))(
$message .= $subkey . " = " . $subval. "\N" ;
}
elseif(! in_array ($subkey , $ignorelist ) && is_array ($subval ))(
foreach($subval as $subsubkey => $subsubval )(
if(! in_array ($subsubkey, $ignorelist))(
$message .= $subsubkey . " = " . $subsubval . "\N" ;
}
}
}
}
}
elseif(! is_array ($val ) && ! in_array ($key , $ignorelist ) && $val )(
$message .= "\nVariable " . $key . " = " . $val. "\N" ;
}
}

If($method == "browser" )(
echo nl2br($message);
}
elseif($method == "email" )(
if($email == "undefiniert" )(
$email = $_SERVER [ "SERVER_ADMIN" ];
}

$mresult = mail ($email , "Debug-Bericht für " . $_ENV [ "HOSTNAME" ]. "" , $message );
if($mresult == 1 )(
Echo „Debug-Bericht erfolgreich gesendet.\n“;
}
anders(
Echo „Fehler beim Senden des Debug-Berichts.\n“;
}
}
}
?>

Vor 17 Jahren

Einfache Routine zum Konvertieren eines get_defined_vars-Objekts in XML.

Funktion obj2xml ($v, $indent = "" ) (
while (list($key , $val ) = every ($v )) (
if ($key == "__attr" ) continue;
// Auf __attr prüfen
if (is_object ($val -> __attr )) (
while (list($key2 , $val2 ) = every ($val -> __attr )) (
$attr .= " $key2 =\" $val2 \"" ;
}
}
sonst $attr = "" ;
if (is_array ($val ) || is_object ($val )) (
print(" $indent< $key$attr >\N" );
obj2xml($val, $indent. "");
print(" $indent\N" );
}
else print(" $indent< $key$attr >$val\N" );
}
}

//Beispielobjekt
$x -> name -> first = "John" ;
$x -> Name -> last = "Smith" ;
$x -> arr [ "Fruit" ] = "Bannana" ;
$x -> arr [ "Veg" ] = "Karotte" ;
$y -> Kunde = $x ;
$y -> Kunde -> __attr -> id = "176C4" ;

$z = get_definierte_vars();
obj2xml($z["y"]);
?>
wird ausgeben:


John
Schmied


Banane
Karotte

Vor 11 Jahren

Bitte beachten Sie, dass get_defined_vars() keine Reihe von Variablenreferenzen zurückgibt (wie ich gehofft hatte). Zum Beispiel:

// eine Variable definieren
$my_var = "foo" ;

// Holen Sie sich unsere Liste der definierten Variablen
$definierte_vars = get_definierte_vars();

// Versuchen Sie nun, den Wert über das zurückgegebene Array zu ändern
$defined_vars [ "my_var" ] = "bar" ;

echo $my_var , "\n" ;

?>

gibt „foo“ (den ursprünglichen Wert) aus. Es wäre schön, wenn get_defined_vars() ein optionales Argument hätte, um sie als Referenzen zu verwenden, aber ich stelle mir vor, dass es sich um eine eher spezielle Anfrage handelt. Sie können es selbst (weniger bequem) mit etwas tun wie:

$definierte_vars = array();
$var_names = array_keys(get_defined_vars());

foreach ($var_names als $var_name)
{
$definierte_vars [ $var_name ] =& $ $var_name ;
}

?>

Vor 1 Jahr

Ich habe hier bereits darüber gepostet, dass „dies“ in get_definierten_Variablen enthalten ist.

Es stellt sich heraus, dass es nicht immer vorhanden ist, aber in bestimmten Fällen erscheint es aus unerklärlichen Gründen.

PHP -r "
Klassentest(
öffentliche Funktion a() (var_dump(array_keys(get_defined_vars()));$a = 123;)
öffentliche Funktion b() (var_dump(array_keys(get_defined_vars()));$this;)
}
$t = neuer Test();
$t->a();
$t->b();
"

Array()
array("this")

Dies ist in PHP 7.2 nicht der Fall, wird aber in PHP 5.6 passieren.

Vor 1 Jahr

Einige Kommentare hier weisen darauf hin, dass diese Funktion keine Referenzen zurückgibt. Es werden jedoch Namen zurückgegeben, und Namen sind „Referenzen“.

Ich würde die Vorschläge hier, die es in Referenzen umwandeln, nicht empfehlen.

Öffentliche Funktion x($a, $b, $c) (
foreach(array_keys(get_defined_vars()) as $key)
if($key !== "this")
$this->y($($key));
}

Öffentliche Funktion y(&$input) (
$input++;
}

Anstelle von $() können Sie auch $$ verwenden.

Ich habe im Laufe meiner Zeit einige verrückte Dinge getan, um extrem generischen Code zu erstellen, aber ich musste so etwas noch nie tun. Es funktioniert möglicherweise nicht einmal (sollte aber, da es sich nicht von $a[$key] unterscheidet).

Sie könnten auch $$key++ ausführen, aber ich habe noch nie Code wie diesen gesehen, der nicht schrecklich schlecht war (die Verwendung von Dynamik, wo Dynamik keinen Vorteil bringt).

Wenn Sie so etwas tun, sollten Sie es genauer unter die Lupe nehmen.

Sicherlich haben Sie zu Hause einen Schrank oder eine Kommode. Das Prinzip ihrer Verwendung ist einfach: Wir legen dort Dinge ab, die wir im Moment nicht brauchen, aber vielleicht in einer Weile brauchen.

Die Variablen sind genau gleich angeordnet. Sie können ihnen einen gewissen Wert beimessen und sie dort aufbewahren, bis Sie sie benötigen.

Variablen erstellen

Sie können einen Wert wie folgt in eine Variable einfügen:

Im obigen Code haben wir eine Variable $name erstellt und den Wert Ivan eingegeben. Anschließend haben wir eine Variable $age erstellt und ihr den Wert 20 zugewiesen.

Der Name „Variable“ bedeutet, dass sich ihr Wert während der Skriptausführung ändern kann:

In einigen Sprachen muss eine Variable zunächst „deklariert“ und dann verwendet werden. In PHP gibt es keine Deklaration – eine Variable wird in dem Moment erstellt, in dem Sie einen Wert eingeben.
Allerdings sagen PHP-Programmierer oft „eine Variable deklarieren“ statt „eine Variable erstellen“.

Anstelle von „Einen Wert in eine Variable einfügen“ sagt man oft auch „Einen Wert zuweisen“.
Der Grund ist einfach: Das =-Symbol, dank dessen wir einen Wert in einer Variablen speichern, wird „Zuweisungsoperator“ genannt. Daher der Begriff „angemessen“.

Regeln für die Benennung von Variablen

1. Der Variablenname beginnt mit dem $-Symbol.

2. Das zweite Zeichen kann ein Buchstabe oder ein Unterstrich sein _

Bei Variablennamen muss die Groß-/Kleinschreibung beachtet werden. $name und $Name sind unterschiedliche Variablen.

Den Wert einer Variablen auf dem Bildschirm anzeigen

Sie können eine Variable mit dem Echo-Befehl anzeigen, den wir bereits kennen:

Mit dem Echo-Befehl können Sie mehrere Werte gleichzeitig anzeigen:

Beachten Sie, dass wir zwei durch Komma getrennte Werte an echo übergeben haben. Auf diese Weise können wir beliebig viele Werte übergeben. Die folgenden beiden Beispiele führen zum gleichen Ergebnis:

Es gibt auch eine Kurzsyntax zum Anzeigen von Variablen in PHP. Anstatt

Vor PHP 5.4 funktionierte die Kurzschriftsyntax nur, wenn die Direktive short_open_tag in den PHP-Einstellungen aktiviert war, die auch die Verwendung eines verkürzten Eröffnungs-Tags ermöglicht

Überprüfen des Werts einer Variablen

Der Echo-Befehl eignet sich nicht immer zum Überprüfen des aktuellen Werts einer Variablen. Wenn Sie beispielsweise versuchen, die leere Zeichenfolge „“ anzuzeigen, wird auf dem Bildschirm absolut nichts angezeigt. Und es ist nicht klar, was der Grund ist – eine leere Variable oder ein defekter Code.

Um den Wert einer Variablen zu überprüfen, wird daher die Funktion var_dump() verwendet:

Ergebnis der Skriptausführung:

String(5) „Vasya“ string(0) „“

Wie Sie sehen, zeigte PHP nicht nur den Inhalt der Variablen an, sondern auch die Anzahl der Zeichen und sogar den Typ der Variablen (String). In den folgenden Lektionen werden wir uns ausführlich mit Datentypen befassen.

Variablen entfernen

Sie können eine vorhandene Variable mit der Funktion unset() entfernen:

Jetzt ist es an der Zeit, ein wenig zu üben.

Denken Sie daran, dass es für fast jedes PHP-Problem mehrere Lösungen geben kann. Wenn Ihre Lösungen also von denen auf dieser Website abweichen, bedeutet das keineswegs, dass Sie etwas falsch gemacht haben.

Schreiben Sie ein Skript, das:
1. Erstellt Variablen mit den Namen Titel und Inhalt sowie einigen Werten.
2. Zeigt den Wert der Titelvariablen im h1-Tag und den Wert der Inhaltsvariablen im div-Tag an.

Lösung anzeigen

", $title, ""; Echo "

Ich möchte Sie noch einmal darauf aufmerksam machen, dass diese Entscheidung nicht die einzig richtige ist. Der folgende Code führt beispielsweise zum gleichen Ergebnis:

Dieses Tutorial behandelt den Umfang von PHP-Variablen. Erklärt den Unterschied zwischen lokalem und globalem Gültigkeitsbereich, zeigt, wie man innerhalb einer Funktion auf globale Variablen zugreift, wie man mit Superglobals arbeitet und statische Variablen erstellt.

Wenn Sie anfangen, PHP zu lernen und mit Funktionen und Objekten zu arbeiten, ist der Variablenbereich etwas verwirrend. Glücklicherweise sind die diesbezüglichen Regeln von PHP (im Vergleich zu anderen Programmiersprachen) sehr einfach zu verstehen.

Was ist Umfang?

Der Gültigkeitsbereich von Variablen ist der Kontext, in dem die Variable definiert wurde und in dem auf sie zugegriffen werden kann. PHP hat zwei Variablenbereiche:

• Global- Auf Variablen kann überall im Skript zugegriffen werden
• Lokal- Auf Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie definiert wurden

Der Gültigkeitsbereich einer Variablen, insbesondere des lokalen, vereinfacht die Codeverwaltung erheblich. Wenn alle Variablen global wären, könnten sie an einer beliebigen Stelle im Skript geändert werden. Dies würde zu Chaos und großen Skripten führen, da sehr oft verschiedene Teile des Skripts Variablen mit demselben Namen verwenden. Indem Sie den Bereich auf den lokalen Kontext beschränken, definieren Sie die Grenzen des Codes, der auf eine Variable zugreifen kann, wodurch der Code robuster, modularer und einfacher zu debuggen ist.

Variablen mit globalem Gültigkeitsbereich werden als global bezeichnet, und Variablen mit lokalem Gültigkeitsbereich werden als lokal bezeichnet.

Hier ist ein Beispiel dafür, wie globale und lokale Variablen funktionieren.

"; ) sayHello(); echo "Wert von \$globalName: "$globalName"
"; echo "\$localName value: "$localName"
"; ?>

Hallo Harry! $globalName-Wert: „Zoe“ $localName-Wert: „“

In diesem Skript haben wir zwei Variablen erstellt:

• $globalName- Das global Variable
• $localName- Das lokal eine Variable, die innerhalb der Funktion sayHello() erstellt wird.

Nach dem Erstellen der Variablen und der Funktion ruft das Skript sayHello() auf, das „Hallo Harry!“ ausgibt. . Das Skript versucht dann, die Werte der beiden Variablen mithilfe der Echo-Funktion auszugeben. Folgendes passiert:

• Weil $globalName außerhalb der Funktion erstellt wurde, ist es überall im Skript verfügbar, daher wird „Zoe“ ausgegeben.
• $localName ist nur innerhalb der Funktion sayHello() verfügbar. Da der Echo-Ausdruck außerhalb der Funktion liegt, bietet PHP keinen Zugriff auf die lokale Variable. Stattdessen erwartet PHP, dass der Code eine neue Variable namens $localName erstellt, die den Standardwert der leeren Zeichenfolge hat. Deshalb gibt der zweite Aufruf von echo den Wert „“ für die Variable $localName aus.

Zugriff auf globale Variablen innerhalb einer Funktion

Um auf eine globale Variable zuzugreifen außer Funktion Es reicht aus, einfach ihren Namen zu schreiben. Sondern um auf eine globale Variable zuzugreifen innerhalb einer Funktion, müssen Sie die Variable zunächst in der Funktion mit dem Schlüsselwort global als global deklarieren:

Funktion myFunction() ( global $globalVariable; // Auf die globale Variable $globalVariable zugreifen)

Wenn Sie dies nicht tun, geht PHP davon aus, dass Sie eine lokale Variable erstellen oder verwenden.

Hier ist ein Beispielskript, das eine globale Variable innerhalb einer Funktion verwendet:

"; global $globalName; echo "Hallo $globalName!
"; ) sayHello(); ?>

Bei der Ausführung gibt das Skript Folgendes aus:

Hallo Harry! Hallo Zoya!

Die Funktion sayHello() verwendet das Schlüsselwort global, um die Variable $globalName als global zu deklarieren. Sie kann dann auf die Variable zugreifen und deren Wert ausgeben („Zoe“).

Was sind Superglobale?

PHP verfügt über einen speziellen Satz vordefinierter globaler Arrays, die verschiedene Informationen enthalten. Solche Arrays werden aufgerufen Superglobale, da sie von überall im Skript aus zugänglich sind, einschließlich des internen Funktionsraums, und nicht mit dem Schlüsselwort global definiert werden müssen.

Hier ist eine Liste der Superglobals, die in PHP Version 5.3 verfügbar sind:

• $GLOBALS – Liste aller globalen Variablen im Skript (außer Superglobals)
• $_GET – enthält eine Liste aller Formularfelder, die vom Browser mithilfe einer GET-Anfrage übermittelt wurden
• $_POST – enthält eine Liste aller Formularfelder, die vom Browser per POST-Anfrage gesendet werden
• $_COOKIE – enthält eine Liste aller vom Browser gesendeten Cookies
• $_REQUEST – enthält alle Schlüssel/Wert-Kombinationen, die in den Arrays $_GET, $_POST, $_COOKIE enthalten sind
• $_FILES – enthält eine Liste aller vom Browser heruntergeladenen Dateien
• $_SESSION – ermöglicht Ihnen das Speichern und Verwenden von Sitzungsvariablen für den aktuellen Browser
• $_SERVER – enthält Informationen über den Server, z. B. den Dateinamen des ausgeführten Skripts und die IP-Adresse des Browsers.
• $_ENV – enthält eine Liste von Umgebungsvariablen, die von PHP übergeben werden, z. B. CGI-Variablen.

Wenn Sie das obige Skript mit der URL http://www.example.com/script.php?yourName=Fred ausführen, wird Folgendes ausgegeben:

Hallo Fred!

Warnung! In einem echten Skript sollte eine solche Datenübertragung aufgrund mangelnder Sicherheit niemals verwendet werden. Sie sollten Daten immer validieren oder filtern.

Das superglobale $GLOBALS ist sehr praktisch zu verwenden, da es Ihnen ermöglicht, den Zugriff auf globale Variablen in einer Funktion zu organisieren, ohne dass das Schlüsselwort global erforderlich ist. Zum Beispiel:

"; ) sayHello(); // Gibt „Hallo, Zoya!“ aus ?>

Statische Variablen: Sie sind irgendwo in der Nähe

Wenn Sie eine lokale Variable innerhalb einer Funktion erstellen, existiert diese nur, während die Funktion ausgeführt wird. Wenn die Funktion abgeschlossen ist, verschwindet die lokale Variable. Bei einem erneuten Aufruf der Funktion wird eine neue lokale Variable erstellt.

In den meisten Fällen funktioniert das hervorragend. Somit sind die Funktionen in sich abgeschlossen und funktionieren bei jedem Aufruf immer gleich.

Es gibt jedoch Situationen, in denen es praktisch wäre, eine lokale Variable zu erstellen, die sich ihren Wert zwischen Funktionsaufrufen „merkt“. Eine solche Variable heißt statisch.

Um eine statische Variable in einer Funktion zu erstellen, müssen Sie das Schlüsselwort static vor dem Variablennamen verwenden und ihm unbedingt einen Anfangswert zuweisen. Zum Beispiel:

Funktion myFunction() ( static $myVariable = 0; )

Betrachten wir eine Situation, in der es praktisch ist, eine statische Variable zu verwenden. Nehmen wir an, Sie erstellen eine Funktion, die beim Aufruf ein Widget erstellt und die Anzahl der bereits erstellten Widgets anzeigt. Sie können versuchen, Code wie diesen mit einer lokalen Variablen zu schreiben:

"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " haben wir bereits erstellt.>
"; ?>

Da die Variable $numWidgets jedoch bei jedem Aufruf der Funktion erstellt wird, erhalten wir das folgende Ergebnis:

Wir erstellen einige Widgets... Wir haben bereits 1 erstellt. Wir haben bereits 1 erstellt. Wir haben bereits 1 erstellt.

Aber durch die Verwendung einer statischen Variablen können wir den Wert von einem Funktionsaufruf zu einem anderen speichern:

"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " >wir haben bereits erstellt.
"; ?>

Jetzt liefert das Skript das erwartete Ergebnis:

Wir erstellen einige Widgets... Wir haben bereits 1 erstellt. Wir haben bereits 2 erstellt. Wir haben bereits 3 erstellt.

Obwohl eine statische Variable ihren Wert zwischen Funktionsaufrufen behält, ist sie nur gültig, während das Skript ausgeführt wird. Sobald die Ausführung des Skripts abgeschlossen ist, werden alle statischen Variablen sowie lokale und globale Variablen zerstört.

Das ist es! Bitte schauen Sie regelmäßig in Ihrer PHP-Dokumentation nach.

Variablen in PHP- Dies ist eine Art Informationscontainer, der verschiedene Datentypen (Text, Zahlen, Arrays usw.) enthalten kann. Im Allgemeinen ermöglichen Variablen das Erstellen, Speichern, Ändern und spätere schnelle Zugreifen auf die darin angegebenen Informationen.

So erstellen Sie eine Variable in PHP

Wie können Sie Variablen benennen:

$var
$variabel
$Jahr1945
$_variable
So benennen Sie Variablen nicht:

$1 – besteht nur aus Zahlen
$1var – Sie können einen Variablennamen nicht mit einer Zahl beginnen
$/var – von den zusätzlichen Zeichen ist nur der Unterstrich erlaubt _
$variable – Kyrillisch ist in der PHP-Dokumentation zulässig, wird jedoch nicht empfohlen
$variable – Leerzeichen können nicht verwendet werden

Jeder Variablen wird ein Wert zugewiesen. Das Vorzeichen dient der Wertzuweisung = (gleich). Während der Skriptverarbeitung kann sich der Wert einer Variablen abhängig von verschiedenen Bedingungen wiederholt ändern.

$city = "Moskau"; // Der Variable $city wurde der Zeichenfolgenwert (in Anführungszeichen) Moskau zugewiesen
$Jahr = 1147; // und der Variablen $year wurde der numerische Wert 1147 zugewiesen
?>

$name = "Alexander";
$Name = "Alexey";
echo „$name, $Name“; // wird „Alexander, Alexey“ drucken
?>

Drucken von PHP-Variablen

// So legen wir die Werte der Variablen fest
$name1 = "Alexey";
$name2 = "Alexander";

// Ausgabevariablen
echo $name2; // Ausgabe: Alexander
echo „name1 ist $name1“; // Name1 ist Alexey

// Bei Verwendung von einfachen Anführungszeichen Ausgabe
// Variablenname, nicht Wert
echo „name1 ist $name1“; // gibt Folgendes aus: name1 ist $name1

// Sie können einfach die Werte der Variablen anzeigen
echo $name1; // Alexey
echo $name1,$name2; // AlexeyAlexander
echo $name1." ".$name2; // Alexey Alexander
echo „$name1, $name2“; // Alexey, Alexander

Echo<<Für die Ausgabe wird die Syntax „Here Document“ verwendet
mehrere Zeilen mit $variable-Variablensubstitution.
ENDE;

Operationen mit PHP-Variablen

-$a(Negation) Ändere das Vorzeichen von $a.
$a + $b(Addition) Die Summe von $a und $b.
$a - $b(Subtraktion) Differenz von $a und $b.
$a * $b(Multiplikation) Produkt von $a und $b.
$a / $b(Division) Der Quotient von $a dividiert durch $b.
$a % $b(Modulo-Division) Der ganzzahlige Rest, wenn $a durch $b geteilt wird.
Schauen wir uns Beispiele an

$a = 2; // Beachten Sie, dass bei Zahlen keine Anführungszeichen verwendet werden
$b = 3; // Beachten Sie, dass bei Zahlen keine Anführungszeichen verwendet werden

$result = $a + $b; // Variablen hinzufügen
echo $result; // gibt 5 aus

$result = $b - $a; // Variablen hinzufügen
echo $result; // gibt 1 aus

Inkrementierungs- und Dekrementierungsoperationen in PHP
Diese Operationen werden vor allem beim Konstruieren von Zyklen nützlich sein, worüber wir etwas später sprechen werden.
Präfix- Operatoren, die VOR der Variablen geschrieben werden ( --$a; +$a). Gibt den Wert der Variablen vor Änderungen zurück.
Postfix- Operatoren, die nach der Variablen geschrieben werden ( $a--; $a--). Gibt den Wert einer Variablen mit Änderungen zurück.
Inkrement- Wertsteigerung.
Dekrementieren- sinkender Wert.

+$a Präfix-Inkrement. Erhöht $a um eins und gibt den Wert von $a zurück.
$a++ Postfix-Inkrement. Gibt den Wert von $a zurück und erhöht dann $a um eins.
--$a Präfixdekrement. Dekrementiert $a um eins und gibt den Wert von $a zurück.
$a-- Postfix-Dekrement. Gibt den Wert von $a zurück und verringert dann $a um eins.
Echo“

Postfix-Inkrement

Echo"

Präfix-Inkrement

Echo"

Postfix-Dekrement

Echo"

Präfix-Dekrement

Zuweisungsoperationen in PHP
Basisoperator sieht aus wie = . Auf den ersten Blick scheint es, dass es sich hierbei um den Gleichheitsoperator handelt. Eigentlich stimmt das nicht. Tatsächlich bedeutet der Zuweisungsoperator, dass der linke Operand den Wert des rechten Ausdrucks annimmt (d. h. durch den resultierenden Wert festgelegt wird). Kombinierte Operatoren- Dies sind Operatoren, mit denen Sie frühere Werte von Variablen für nachfolgende Operationen verwenden können (an eine Zeichenfolgenvariable anhängen (mit Text) oder numerische Werte hinzufügen).

$a = ($b = 2) + 4; // Ergebnis: $a wird auf 6 gesetzt, Variable $b wird 2 zugewiesen.

$a = 2;
$a += 3; // setzt $a auf 5, ähnlich wie beim Schreiben: $a = $a + 3;
$b = "Hallo";
$b .= "Frieden!"; // setzt $b auf die Zeichenfolge „Hello World!“, wie $b = $b . "Dort!";

es gibt auch Vergleichsoperationen Und logisch, aber wir werden in den folgenden Lektionen darüber sprechen. Ich werde versuchen, Sie nicht gleich mit einer großen Menge an Informationen zu erschrecken!)