PHP - () + {}

EDIT: ich merke gerade wieder, dass ich mit dem neuen Forumeditor nicht klar komme.

Die Klammen () beeinflussen die Reihenfolge von Statements.

Ablauf an Deinem Bsp $ergebnis = ($a + $b) - $c * $d

Info: PHP verarbeitet Statements von rechts nach links.

- zu erst wird c * d ausgeführt

- das Zwischenergebnis daraus soll von links subtrahiert werden aber -

- durch die () Klammen wird als nächstes a + v ausgeführt

- zum Schluss wird rechts von links subtrahiert.

Zum $_POST -Bsp:

in dem Bsp sind die Klammern fehlerhaft.

Fixed:

if(     (         !isset($_POST['test']) && strlen($_POST['test']) === 0
    )     || empty($_POST['test'])
){
    echo "Testing";
}

empty() macht hier keinen Sinn, irgendwie. Man will ja, dass es gesetzt ist, und länger als 0.

Also if ( isset($_POST['test']) && strlen($_POST['test']) > 0 ) {}

Die {} Klammern kann ich nicht erklären. Mir fällt da gerade echt nicht ein, wie man das erklärt

Genutzt werden die jedenfalls oft in Ausgaben - zB HTML.

$person = array();
$person['name'] = 'cottton';
echo "In doppelten Anführungszeichen wird Code ausgefürt. Deshalb kann ich meinen Namen einfügen: {$person['name']}";

Ohne Klammern würde PHP das ganze nicht verstehen.

Wichtiger werden die Klammern aber bei variablen variablen (http://php.net/manual/de/language.variables.variable.php)

Oder zB bei Methodenaufruf per variable:

class MyClass {
    public function myFuntion() {
        return 123;
    }
}

$array = [ 
    'method' => 'myFunction',
];

$object = new MyClass()
$result = $object->{$array['method']}(); 
echo $result;

Zitat von Stef

Warum würde ohne die {} PHP es nicht verstehen ? Verstehe ich nicht.

Ohne {} bekommst Du einen syntax error.

Zitat von Stef

Warum ist es da denn wichtig ?

class MyClass {
    public function myFunction() {
        return 123;
    }
}
$array = [
    'method' => 'myFunction',
];
$object = new MyClass();
$result = $object->{$array['method']}(); // OK
$result = $object->$array['method'](); // Fatal error: Uncaught Meets\Service\Error\ErrorException: Array to string conversion

"Array to string", da $object->$array ausgeführt werden würde.

Durch die {} wird zuerst die value aus dem array geholt.

BTW: wähle mal auf PHP.net http://php.net/manual/en/language.variables.variable.php die Sprache "english" aus. Da gibts oft mehr Beispiele.

Zitat von Stef

Warum kommt denn da die Fehlermeldung ? Man greift doch auf den wert vom key method zu. Verstehe ich nicht.

Weil der syntax nicht stimmt. Bei arrays müssen eben die Klammern genutzt werden

echo "\$b value: '{$b}'\r\n";

Output: $b value: 'test'

$$b (besser lesbar ${$b}) bedeutet also $test

und $test ist nicht definiert.

Im Grunde sagst Du

$ ich will eine variable

deren Name in $b steck.

Das hier sieht irre aus, ist aber eigtl ganz einfach:

$b = "test";
$c = "test1";
$f = "test2";
$test = 123;

echo "\$b value: '{$b}'\r\n";

echo "\${\$b} value: {${$b}}";

die $ sind mit Backslash maskiert, um sie ausgeben zu können.

Du könntest das mit array vergleichen:

// ein array mit einem offset ansprechen, welches aus einer variable kommt
$array = [
    'auto' => 'VW',
];
$offset = 'auto';
echo $array[$offset]; // VW


// eine variable mit einem NAMEN ansprechen, welcher aus einer variable kommt
$auto = 'VW';
$varName = 'auto';
echo ${$varName}; // VW

Ist jetzt nicht wirklich das gleiche, aber zeigen, dass es halt nur um die value geht, die in der Variable steckt.

Zitat von Stef

Wenn man diese um die variable schreibt, wird zuerst der Wert in der Variable geladen

Ja, so kann man es sehen.

Klammern sollte man immer verwenden. Liest sich besser und Fehler werden vermieden.

Bsp:

// wir wollen von der var $auto die value "VW" lesen
$auto = 'VW';

// wir wissen aber den namen der variable $auto nicht.
// den gibt und eine klasse/methode:
class MyClass
{
    public function getVarName()
    {
        // würde hier irgendwo her den namen beziehen
        return 'auto';
    }
}


$myClass = new MyClass();

echo $$myClass->getVarName(); // Fatal error: Uncaught Meets\Service\Error\ErrorException: Object of class MyClass could not be converted to string

echo ${$myClass->getVarName()}; // VW

echo ${$myClass->getVarName()}; holt erst den Namen aus der Klassenmethode, und erstellt dann die variable.

Und da geht noch mehr: Bedingungen

$auto = 'VW';
$varName = null;
echo ${isset($varName) ? $varName : 'auto'}; // VW

$varName ist nicht gesetzt (NULL).

Wir wollen eine Variable ausgeben.

Der Name der Var steckt endweder in $varName, oder es wird "auto" genutzt.

Man muss das nicht verwenden. Sollte es mal gesehen haben.

Ich persönlich nutze es öfter mal zB bei Schleifen.

Bsp

$array = [
    'firstname' => 'Hans',
    'lastname'  => 'Wienerschnitzel',
    'street'    => 'Hauptstr. 34',
    //... 
];

// ich will (aus welchem grund auch immer) alle offsets und deren values in variablen packen
// also aus $array['firstname'] soll eine variable $firstname werden
foreach ($array as $key => $value) {
    ${$key} = $value;
}

// test ausgabe
echo $firstname; // Hans
echo $lastname; // Wienerschnitzel
echo $street; // Hauptstr. 34

$ baucht hier einen String. Aber ohne Klammern bekommt $ die Klasse $myClass.

Und die Klasse kann nicht als String verwendet werden.

Mit Klammern wird erst das Ergebnis aus $myClass->getVarName() geholt - was ja dann auto ist.

Daraus entsteht $auto.

Zitat von Stef

Aber warum denn das, wenn zwei $$ davor stehen

Du siehtst das wahrscheinlich immernoch falsch

$$ ist keine einzelne Anweisung o.ä.

Das sind 2 Sachen die hier passieren:

erste $ -- hier wird es um eine Variable gehen

zweite $ -- hier wird es wieder um eine Variable gehen

Mir ist gerade das Konstanten Bsp eingefallen - hier wird es glaub ich deutlicher:

$auto = 'VW';
define('VAR_NAME', 'auto');
echo $VAR_NAME; // Undefined variable: VAR_NAME
echo ${VAR_NAME}; // VW

Wie bisher wollen wir die Value von $auto. Der Name der Variable kommt dieses Mal aus der Konstante VAR_NAME.

Und hier zeigt sich, wie wichtig Klammern sind:

ohne Klammern geben wir fälschlicher Weise an, eine Variable $VAR_NAME aufzurufen.

Mit Klammern wird erst die Value aus der Konstante geholt.

Keine 2 x $$. Das existiert eigentlich gar nicht.