Differences

This shows you the differences between two versions of the page.

--- programming:php [2023/11/01 07:31] – removed - external edit (Unknown date) 127.0.0.1
+++ programming:php [2023/11/02 07:11] (current) – skipidar
@@ Line 1: / Line 1: @@
+===== PHP =====
+==== Basic Syntax ====
+== $bar= ==
+Normal local variable declaration
+<code>
+function Sum()
+{
+    $locvar = "bla" //scope's local variable
+}
+</code>
+== global ==
+<code>
+$a = 1; //global var
+$a = 2; //global var
+function Sum()
+{
+    global $a, $b;  //reference to the global vars
+    $b = $a + $b;   //produce 3
+}
+</code>
+== => ==
+=> us used to get values in arrays
+<code>
+$creator['Toilet'] = "Crapper";
+$creator = array('Light bulb' => 'Edison',
+'Rotary Engine' => 'Wankel',
+'Toilet' => 'Crapper');
+</code>
+or to retrieve objects values
+<code>
+class Person {
+var $name = "Fred";
+var $age = 35;
+}
+$o = new Person;
+$a = (array) $o;
+print_r($a);
+Array
+(
+[name] => Fred
+[age] => 35
+)
+</code>
+==$$varname==
+The double dollar sign declares that the value of $a should be used as the name of newly defined variable. \\
+For example, the code below creates a variable called $hello and outputs the string “world”
+<code>
+<?php
+$a = 'hello';
+$$a = 'world'
+echo $hello;
+?>
+</code>
+<code>
+<?php
+$a = 'hello';
+$$a = 'world';
+echo "$a ${$a}";  //produces hello world
+echo "$a $hello"; //produces hello world
+?>
+</code>
+== var keyword ==
+Is for declaring class member variables.
+<code>
+class foo {
+    var $x = 'y';
+    function bar() {
+    }
+}
+</code>
+==== GET ====
+Wenn du einen text, einen Dateipfad usw. als URL parameter übergeben musst - nutze vor dem Übergeben die Funktion **rawurlencode**:
+<code>
+$filename    = "bibtexdata1 - Copy.bib";
+$urlfilename = rawurlencode ( $filename );  // bibtexdata1%20-%20Copy.bib
+</code>
+und am anderem Ende
+<code>
+$filename = rawurldecode ( $urlfilename  );
+</code>
+==== OOP Syntax in PHP ====
+// Details about the syntax can be read [[http://reeg.junetz.de/DSP/node28.html|here]] //
+=== Call by reference ===
+Kopier- vs. Referenzsemantik
+Beim Aufruf einer Methode kann man dieser - vorausgesetzt, diese erlaubt das - Parameter übergeben. Ist einer dieser Parameter ein Objekt, genauer: eine Referenz auf ein Objekt, so findet in PHP bei der Übergabe dasselbe Vorgehen statt wie bei gewöhnlichen Primitivtypen (Integer, Boolean, String): Es wird eine Kopie des ursprünglichen Datums, bei Objekten also eine Kopie der Referenz, erzeugt und übergeben. Da eine Referenz auf ein Objekt ja immer nur das Objekt bezeichnet, es aber nicht selbst darstellt, kann folglich keine Methode das ursprüngliche Objekt (z.B. mit NULL) überschreiben. Auch in Java, wo bei Objekten statt der Kopiersemantik die sog. Referenzsemantik zum Einsatz kommt[*], funktioniert dies nicht. Der Unterschied zwischen Java und PHP in der Behandlung von Objekten kommt erst dann zum Tragen, wenn versucht wird, den Wert eines Objekt-Attributes zu ändern. Während Java innerhalb einer aufgerufenen Methode nämlich tatsächlich das Attribut sowohl der übergebenen als auch der ursprünglichen Referenz auf das Objekt ändert, erfolgt dies bei PHP standardmäßig nur auf der Referenzkopie, die lokal in der Methode sichtbar ist.
+Grundsätzlich ist es natürlich immer möglich, mittels einer return-Anweisung die lokale Referenz zurückzugeben und der ursprünglichen Objektvariable zuzuweisen.
+Ausweg aus dem Referenzdilemma
+Wie also kann man sicherstellen, daß eine Referenz auch als solche behandelt wird? In PHP gibt es dafür spezielle Syntax, bei der das Kaufmanns-Und den Referenz-Charakter einer Zuweisung oder einer Variablen-Betrachtung anzeigt:
+<code>
+$a = &$b;
+$c =& $a;
+$c = 42;
+</code>
+Die beiden obigen Zuweisung bewirken gleichermaßen, daß jeweils beide Variablen nicht nur denselben Wert haben, sondern auch eine Wertänderung einer der Variablen automatisch die exakt selbe Wertänderung der anderen Variablen bewirkt. Die letzte Anweisung bewirkt folglich, daß alle drei Variablen den Wert 42 annehmen.
+Auch bei Funktions- und Methodenaufrufen wird normalerweise Kopiersemantik angewandt. Um explizit Referenzsemantik zu fordern, stellt man hierbei bei einer Funktions-/Methodendefinition einer zu referenzierenden Parameter-Variablen ein Kaufmanns-Und voran:
+<code>
+function Plus($var) { $var++; }
+function Minus(&$var) { $var--; }
+$var = 42;
+Plus($var);
+Minus($var);
+echo $var;
+</code>
+Die Ausgabe obigen Codes ist natürlich 41, da nur die Funktion Minus den Wert der Variablen $var ändert. In Java wäre das nicht so offensichtlich, da hier u.U. eine Klassenvariable namens var existieren könnte, die implizit gemeint sein könnte. In PHP müßte man dann aber $this->var schreiben.
+=== Methoden ===
+==static==
+Manchmal ist es nötig, eine Methode einer Klasse aufzurufen, ohne ein Objekt derselben erzeugt zu haben. In diesem Fall kann man einen sogenannten ,,static``-Aufruf machen. Zu beachten ist dabei, daß eine so aufgerufene ,,Klassenmethode`` nirgends auf die Attribute der Klasse, in der sie sich befindet, zugreifen darf, da diese ja nur im Kontext einer Instanz (Objekt) vorhanden sind. Lokale und globale Variablen dürfen dagegen natürlich benutzt werden.
+Ein primitives Beispiel:
+<code>
+class Auto {
+...
+  function Erfinder() {
+    return "Etienne Lenoir, Carl Benz";
+  }
+...
+}
+echo Auto::Erfinder();
+</code>
+==parent==
+Im Falle von Zugriffen auf geerbte, aber überschriebene Methoden sollte man statt des Klassennamens das Schlüsselwort parent benutzen. Dadurch taucht der Name der beerbten Klasse nur hinter extends auf, was das nachträgliche Vornehmen von Änderungen z.T. stark erleichtert. Außerdem wird dadurch auch der Unterschied zwischen ,,static`` (kein Objekt vorhanden) und normalem Instanz-Methodenaufruf deutlich.
+Beispiel: Angenommen, wir hätten in der Klasse DSP_CR die Methode lenke(drehung) der Klasse Auto überschrieben, von der DSP_CR erbt. Will man nun innerhalb von DSP_CR auf die gleichnamige Methode der Basisklasse Auto zugreifen, kommt folgende Syntax zum Einsatz:
+<code>
+...
+  function lenke($drehung) {
+    // Servo aktivieren
+    $drehung = $this->servo($drehung);
+    // Methode der Basisklasse aufrufen
+    parent::lenke($drehung);
+  }
+...
+</code>
+==== Debugging ====
+use the method to echo the variable's content
+<code>
+var_export($VARIABLE);
+$var = var_export($VARIABLE,true);
+</code>
+==== Importing Files  ====
+<sxh php>
+//To import a file and immediately print it - do
+require file.php;
+//To import a file into a variable - do:
+//getting variables by ob_start / ob_get_clean makes php evaluate the php in those files variables
+ob_start();
+include($ROOT.'/templatesubs/zvg/toolbar.php');
+$toolbar = ob_get_clean();
+//To load a file as it is, without filling the variables
+$toolbar = @file_get_contents($ROOT.'/templatesubs/partners/toolbar.php');
+</sxh>
+====INSTALLATION, CONFIGURATION====
+This Page is about tips and fallpits while configurating PHP:
+===Find out, which User Account PHP uses===
+**Problem:** Find out, which User Account PHP uses, e.g. to grant permissions for a Folder.
+<code>
+<?php
+echo 'Name des Benutzers: ' . get_current_user();
+?>
+</code>
+===Install modules===
+<code>
+sudo apt-get install php5-mysql php5-curl php5-gd php5-idn php-pear php5-imagick php5-imap php5-mcrypt php5-memcache php5-mhash php5-ming php5-ps php5-pspell php5-recode php5-snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl php5-json
+</code>
+====Usage====
+===Findout the path to the current directory===
+When including other files, they can't be refered relatively to the current dir. To do so use
+<code>
+define('__ROOT__', dirname(__FILE__));
+$path = (__ROOT__ . '/relative/path.php');
+</code>
+=== Php Script as a cron job ===
+<code>
+*/20 * * * * /usr/bin/php -q -f /home/scripts/humblebundle/index.php > /dev/null
+</code>