Kihagyás

7. fejezet

A fejezet anyaga

Ebben a fejezetben áttekintjük a PHP alapvető nyelvi elemeit.

A PHP nyelvi alapjai

Kommentek

PHP-ban is írhatunk a forráskódba kommenteket (megjegyzéseket):

  • egysoros kommenteket // után vagy # után adhatunk meg
  • többsoros kommenteket /* és */ között írhatunk.
1
2
3
4
5
6
7
<?php
  // ez egy egysoros komment
   # ez szintén egy egysoros komment

  /* ez pedig egy
     többsoros komment */
?>

Kiíratás

A PHP többféle lehetőséget is biztosít adatok kiíratására.

A két legalapvetőbb utasítás, amellyel adatokat írhatunk ki az alapértelmezett kimenetre, az echo és a print. Mindkét utasítás esetén használhatunk a kiírandó kifejezésben HTML markup-ot is (pl. sortörést a <br/> taggel tehetünk).

Az echo és print többnyire hasonlóan viselkednek, csupán néhány apróbb működésbeli különbség van köztük:

  • az echo-nak nincs visszatérési értéke, míg a print-nek van (konstans 1), így a print használható kifejezésekben
  • az echo-nak több paraméter is átadható, míg a print-nek csak egy
  • működését tekintve az echo valamelyest gyorsabb a print-nél.

Megjegyzés

Az echo és print utasításokat zárójelekkel is használhatjuk (echo(), print()).

Tömbök és objektumok részletes kiíratására a print_r() függvényt használjuk. Ez rekurzívan kiírja a paraméterül kapott kifejezés értékét.

A die() és exit() függvényekkel kiléphetünk a programból. Ezeknek opcionálisan átadható paraméterben egy szöveg (hibaüzenet) vagy egy egész szám (kilépési kód). Ha szöveges paramétert adunk át, akkor azt ki is írják a képernyőre.

1
2
3
4
5
6
7
8
9
<?php
  echo "Hello echo! <br/>";
  print "Hello print! <br/>";
  echo "Az ", "élet ", "értelme ", 42, ". <br/>"; // az echo-nak több paramétere is lehet
  // print "Ez ", "nem ", "működik <br/>";        // HIBA: a print-nek csak 1 paramétere lehet!
  print_r(["alma", "banán", "citrom"]);           // tömb kiíratása
  die("<br/>Valamit elszúrtunk...");              // kilépés a programból
  echo "Ez már nem lesz kiírva. <br/>";
?>

A kód kimenete

Hello echo! Hello print! Az élet értelme 42. Array ( [0] => alma [1] => banán [2] => citrom ) Valamit elszúrtunk...

Változók

PHP-ban a változók neve előtt minden esetben dollárjel ($) szerepel. A változónév csak betűket, számokat és alulvonás karaktert tartalmazhat, valamint betűvel vagy alulvonással kell kezdődnie (tehát a változónév nem kezdődhet számmal). A változónév érzékeny a kis- és nagybetűkre (tehát például $nev és $NEV két külön változónak számít).

Egy változónak az = (egyenlőségjel) operátorral adhatunk értéket. A változók értékét legegyszerűbben az echo vagy print utasítások valamelyikével írathatjuk ki.

1
2
3
4
<?php
  $nev = "Gipsz Jakab";               // egy $nev változó létrehozása és értékadás
  echo "Szia! A nevem $nev. <br/>";   // a változó értékének kiíratása
?>

A kód kimenete

Szia! A nevem Gipsz Jakab.

Érték és referencia szerinti értékadás

Amikor PHP-ban egy változónak egy másik változót adunk értékül, akkor alapértelmezett módon érték szerinti értékadás történik (kivéve objektumok esetén, lásd: később). Ekkor az eredeti változó értéke lemásolódik, így az értékadás után a két változó egymástól teljesen függetlenül módosítható.

Az & (és-jel) operátorral lehetőségünk van referencia szerinti értékadásra is. Ekkor nem történik másolás, így mindkét változó ugyanarra az adatra mutat. Ekkor, ha az értékadás után az egyik változó értéke megváltozik, akkor ugyanúgy módosul a másik változó értéke is.

Nézzünk egy példát! Az alábbi kódban érték szerinti értékadás történik ($b = $a). Ekkor az $a és $b változók értéke egymástól teljesen függetlenül módosítható.

1
2
3
4
5
6
<?php
  $a = 1;
  $b = $a;    // $a értéke: 1, $b értéke: 1
  $a = 2;     // $a értéke: 2, $b értéke: 1
  $b = 3;     // $a értéke: 2, $b értéke: 3
?>

Nézzük meg, mi történik referencia szerinti értékadás esetén! Az alábbi kódban a $b egy referencia az $a változóra. Ekkor, ha valamelyik (akár az $a, akár a $b) változó értéke megváltozik, akkor a másik értéke is ugyanúgy módosul.

1
2
3
4
5
6
<?php
  $a = 1;
  $b = &$a;   // $a értéke: 1, $b értéke: 1
  $a = 2;     // $a értéke: 2, $b értéke: 2
  $b = 3;     // $a értéke: 3, $b értéke: 3
?>
Gyengén típusosság

A fenti kódokban észrevehettük, hogy a változók létrehozásakor nem írjuk ki expliciten a változótípust. Ennek az az oka, hogy a PHP egy gyengén típusos nyelv, ami azt jelenti, hogy a PHP értelmező automatikusan "ki tudja találni" a változók típusát a bennük tárolt érték alapján.

A gyengén típusosság egyik érdekes következménye, hogy ugyanabban a változóban akár eltérő típusú adatokat is tárolhatunk. Erre láthatunk példát az alábbi kódban.

1
2
3
4
5
<?php
  $val = 42;        // $val típusa: int
  $val = TRUE;      // $val típusa: bool
  $val = "sajt";    // $val típusa: string
?>

Konstansok

PHP-ban létrehozhatunk konstansokat (állandókat) is. Ezeknek a kezdőértéke nem változtatható meg a program futása során, különben szintaktikai hibát kapunk.

A változókkal ellentétben a konstansok neve előtt nem szerepel dollárjel. Konvenció alapján a konstansok nevét csupa nagybetűvel szoktuk írni, és ha a konstansnév több szóból áll, akkor a szavakat alulvonással választjuk el (pl. EZ_EGY_JO_KONSTANSNEV). A konstansok neve érzékeny a kis- és nagybetűkre!

PHP-ban konstansokat a define() függvénnyel definiálhatunk. Ennek első paramétereként megadjuk a konstans nevét (string), második paraméterként pedig a konstans értékét.

1
2
3
4
5
6
<?php
  define("ELET_ERTELME", 42);   // konstans definiálása
  // ELET_ERTELME = 10;         // HIBA: a konstansok értéke nem módosítható
  // echo elet_ertelme;         // HIBA: a konstansok neve kis- és nagybetű érzékeny
  echo "Az élet értelme: " . ELET_ERTELME . "<br/>";
?>

A kód kimenete

Az élet értelme: 42

A PHP biztosít számunkra úgynevezett mágikus konstansokat is. Ezek előre definiált, beépített konstansok, amelyek neve dupla alulvonással kezdődik és végződik. Néhány fontosabb mágikus konstans:

  • __LINE__: a fájl aktuális sorának száma
  • __FILE__: a fájl teljes elérési útvonala és neve
  • __FUNCTION__: a függvény neve
  • __CLASS__: az osztály neve
  • __METHOD__: az osztály metódusának neve
  • __NAMESPACE__: a névtér neve.

Adattípusok

Ebben a részben áttekintjük a PHP nyelv adattípusait és azok fontosabb jellemzőit.

A bool típus

Logikai adattípus. A TRUE (igaz) és FALSE (hamis) logikai értékek valamelyikét veheti fel. PHP-ban ez a két kulcsszó nem érzékeny a kis- és nagybetűkre.

1
2
3
4
<?php
  $logikai1 = FALSE;
  $logikai2 = false;  // a TRUE és FALSE kulcsszavak nem érzékenyek a kis- és nagybetűkre
?>
Az int típus

Az egész számok típusa. PHP-ban az egész számok mindig előjelesek, tehát C-vel ellentétben itt nincs előjeltelen egész típus.

A PHP_INT_MIN és PHP_INT_MAX konstansokkal lekérdezhető az int típussal ábrázolható legkisebb és legnagyobb érték. Ezek a határok architektúrafüggők. Ha egy szám az int típus értelmezési tartományán kívül esik, akkor automatikusan lebegőpontosra lesz konvertálva.

1
2
3
4
5
<?php
  $egesz1 = 42;
  $egesz2 = -123456;
  $egesz3 = PHP_INT_MAX;
?>
A float típus

A lebegőpontos ("valós") számok típusa. PHP-ban nincs külön egyszeres és dupla pontosságú lebegőpontos típus. A float típussal ábrázolható maximális érték architektúrafüggő.

A lebegőpontos számok megadásakor tizedespontot használunk tizedesvessző helyett.

1
2
3
4
5
<?php
  $lebegopontos1 = 3.14;
  // az int értelmezési tartományán kívüli számok automatikusan float-ra konvertálódnak
  $lebegopontos2 = PHP_INT_MAX + 1;
?>
A string típus

Szöveges adattípus. Tetszőleges hosszúságú karaktersorozat megadására használhatjuk.

A stringeket leggyakrabban aposztrófok ('...') vagy idézőjelek ("...") között adjuk meg. A lényegi különbség a két megadási mód között, hogy idézőjeles megadás esetén a változók értékei és az escape-szekvenciák behelyettesítődnek, míg aposztrófos megadás esetén nem.

1
2
3
4
5
<?php
  $szoveg = "Szeretem a Webtervezést!";
  echo '$szoveg értéke: ';        // nem helyettesíti be a változó értékét
  echo "$szoveg <br/>";           // behelyettesíti a változó értékét
?>

A kód kimenete

$szoveg értéke: Szeretem a Webtervezést!

PHP-ban a stringek összefűzésére a . (pont) operátort használjuk.

1
2
3
<?php
  $desszert = "almás" . "pite";   // "almáspite"
?>

Természetesen PHP-ban is van lehetőségünk a stringek karaktereinek indexelésére. Erre a más nyelvekből ismerős szögletes zárójel operátort használhatjuk: $szoveg[index]. Hasonlóképpen, mint C-ben, PHP-ban is 0-tól kezdődően indexeljük a stringek karaktereit.

Egy kis érdekesség, hogy PHP-ban negatív indexeket is megadhatunk. Ekkor a string végétől kezdünk el számolni (tehát az utolsó karakter indexe -1, az utolsó előtti karakteré -2 stb.).

1
2
3
4
5
<?php
  $szoveg = "Hello World";
  echo "A legelső karakter: " . $szoveg[0] . "<br/>";
  echo "Az utolsó karakter: " . $szoveg[-1] . "<br/>";
?>

A kód kimenete

A legelső karakter: H Az utolsó karakter: d

A PHP rengeteg beépített stringkezelő függvényt biztosít számunkra. Ezek közül áttekintünk néhány fontosabbat (a stringkezelő függvények teljes listája elérhető itt).

  • strlen($s): visszaadja az $s string hosszát
  • strtolower($s): csupa kisbetűssé alakítja az $s stringet
  • strtoupper($s): csupa nagybetűssé alakítja az $s stringet
  • substr($s, $start, $length): visszaadja az $s string egy részstringjét, annak $start indexétől kezdődően, $length darab karakteren keresztül
  • strpos($s, $text): visszaadja a $text részstring első előfordulásának kezdőindexét az $s stringben (FALSE-ot ad vissza, ha nem találja)
  • str_replace($old, $new, $s): lecseréli az $s stringben az $old részstring összes előfordulását a $new szövegre
  • explode($delim, $s): feldarabolja az $s stringet $delim karakterek mentén (egy tömbbel tér vissza)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
<?php
  $szoveg = "A Citromos Fagyi A Legjobb Fagyi";

  echo strlen($szoveg) . "<br/>";                       // string hossza
  echo strtolower($szoveg) . "<br/>";                   // kisbetűsítés
  echo strtoupper($szoveg) . "<br/>";                   // nagybetűsítés
  echo substr($szoveg, 0, 8) . "<br/>";                 // az első 8 karakter lekérése
  echo strpos($szoveg, "Citrom") . "<br/>";             // részstring keresése
  echo str_replace("Fagyi", "Süti", $szoveg) . "<br/>"; // részstring lecserélése (az eredeti stringet nem módosítja)
  $szavak = explode(" ", $szoveg);                      // feldarabolás szóköz karakterek mentén
?>

A kód kimenete

32 a citromos fagyi a legjobb fagyi A CITROMOS FAGYI A LEGJOBB FAGYI A Citrom 2 A Citromos Süti A Legjobb Süti

Az array típus

Tömb adattípus. Több elem tárolására alkalmas adatszerkezet. C-vel ellentétben a PHP-beli tömbök dinamikus méretűek, és nem feltétlenül csak azonos típusú elemek tárolhatók bennük.

PHP-ban kétféle szintaxissal hozhatunk létre tömböket:

  • az array() konstrukció segítségével
  • a tömbelemek szögletes zárójelek közötti felsorolásával.

Ebben a jegyzetben szinte mindig a szögletes zárójeles megadási módot fogjuk használni tömbök létrehozására.

1
2
3
4
5
6
<?php
  // tömbök létrehozása
  $tomb1 = array(10, 20, 30);   // 1. módszer: array()
  $tomb2 = [10, 20, 30];        // 2. módszer: szögletes zárójeles szintaxis
  $tomb3 = [];                  // egy üres tömb
?>

PHP-ban a tömb adattípus valójában egy rendezett leképezést valósít meg, ugyanis kulcs-érték párokat tartalmaz. Az ilyen tömböket asszociatív tömböknek is nevezzük.

A fenti kódpéldában a tömbök létrehozásakor csak értékeket soroltunk fel, ekkor a kulcsok alapértemezés szerint a tömbindexek lesznek (0-tól kezdődően). A tömbök létrehozásakor a kulcs-érték párokat expliciten is megadhatjuk a kulcs => érték szintaxissal. A kulcsok csak stringek vagy egész számok lehetnek, az értékek típusára nincs megkötés.

A tömbök indexelése a kulcs alapján történik: $tomb[kulcs].

1
2
3
4
5
6
7
<?php
  $lottoszamok = [56, 42, 12, 81, 25];     // itt a kulcsok a tömbindexek lesznek
  $arak = ["szendvics" => 220, "tea" => 70, "csoki" => 150];

  echo $lottoszamok[0] . "<br/>";         // 56
  echo $arak["szendvics"] . "<br/>";      // 220
?>

A $tomb[kulcs] = ertek szintaxissal beszúrhatunk egy új kulcs-érték párt a tömb végére.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<?php
  $lottoszamok = [56, 42, 12, 81, 25];
  $arak = ["szendvics" => 220, "tea" => 70, "csoki" => 150]; 
  $lottoszamok[] = 5;         // itt a kulcs (tömbindex) automatikusan kerül megállapításra
  $arak["hamburger"] = 800;   // felvesszük a "hamburger" => 800 kulcs-érték párt

  print_r($lottoszamok);  // Array ([0] => 56 [1] => 42 [2] => 12 [3] => 81 [4] => 25 [5] => 5)
  echo "<br/>";           
  print_r($arak);         // Array ([szendvics] => 220 [tea] => 70 [csoki] => 150 [hamburger] => 800)
?>

A tömbök kezelérése számos beépített függvény létezik PHP-ban. Néhány fontosabb ezek közül (teljes lista itt):

  • count($t): visszaadja a $t tömb hosszát
  • sort($t): rendezi a $t tömb értékeit
  • in_array($e, $t): visszaadja, hogy $e szepel-e a $t tömb értékei között
  • array_key_exists($k, $t): visszaadja, hogy $k szerepel-e a $t tömb kulcsai között
  • array_pop($t): törli a $t tömb utolsó elemét
  • array_push($t, $a, $b, ...): beszúrja az $a, $b, ... elemeket a $t tömb végére
  • array_shift($t): törli a $t tömb első elemét
  • array_unshift($t, $a, $b, ...): beszúrja az $a, $b, ... elemekt a $t tömb elejére
  • implode($delim, $t): egy stringgé egyesíti a $t tömb elemeit, $delim karakterek mentén.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
<?php
  $fagyi_tomb = ["vanília", "csokoládé", "szamóca", "citrom"];

  echo count($fagyi_tomb) . "<br/>";          // tömb hossza
  array_pop($fagyi_tomb);                     // törlés a végéről
  array_push($fagyi_tomb, "sztracsatella");   // beszúrás a végére
  array_shift($fagyi_tomb);                   // törlés az elejéről
  array_unshift($fagyi_tomb, "málna");        // beszúrás az elejére
  if (in_array("málna", $fagyi_tomb)) {       // keresés az értékek között
    echo "Hurrá, van málna fagyi! <br/>";
  }
  sort($fagyi_tomb);                          // rendezés (itt: ábécé sorrend)
  $fagyi_string = implode(", ", $fagyi_tomb); // egyesítés stringgé
  echo "A kedvenc fagyi ízeink: $fagyi_string. <br/>";
?>

A kód kimenete

4 Hurrá, van málna fagyi! A kedvenc fagyi ízeink: csokoládé, málna, szamóca, sztracsatella.

PHP-ban létrehozhatunk többdimenziós tömböket is. Ezek tulajdonképpen olyan tömbök lesznek, amelyek elemei szintén tömbök. Az alábbi példában egy kétdimenziós tömb látható.

1
2
3
4
5
6
7
8
<?php
  $felhasznalok = [
    [ "felhasznalonev" => "admin", "jelszo" => "SomeSecurePassword123" ],
    [ "felhasznalonev" => "guest", "jelszo" => "guest01" ]
  ];

  $felhasznalonev1 = $felhasznalok[0]["felhasznalonev"];  // "admin"
?>
Az object típus

Osztályból példányosított objektumok adattípusa. Az objektumokkal részletesebben a 11. fejezetben fogunk foglalkozni.

1
2
3
4
<?php
  class Macska { /* ide kerül az osztály törzse... */ }
  $macskaObjektum = new Macska();               // osztály példányosítása
?>
A resource típus

Erőforrás típus. Jellemzően egy fájlra vagy egy adatbázis-kapcsolatra mutató referenciát jelöl.

1
2
3
4
<?php
  $eroforras = fopen("valami.txt", "r");  // a megnyitott fájlok resource típusúak
  fclose($eroforras);
?>
A null típus

Olyan adattípus, amelynek egyetlen lehetésges értéke a NULL speciális érték. A NULL kulcsszó nem érzékeny a kis- és nagybetűkre.

A NULL egy olyan változót jelöl, ami nem tárol értéket. Például az inicializálás nélkül létrehozott változók értéke és típusa automatikusan NULL lesz. Ezen kívül a NULL értéket expliciten is értékül adhatjuk egy változónak.

1
2
3
4
<?php
  $valami1;         // az inicializálatlan változók értéke automatikusan NULL lesz
  $valami2 = NULL;
?>

Típusinformációk

Mivel a PHP egy gyengén típusos nyelv, ezért előfordulhat, hogy egy változó nem olyan típusú értéket tárol, mint amire számítunk. Emiatt felmerülhet az igény arra, hogy lekérdezhessük a változókhoz tartozó típusinformációkat.

A var_dump() függvény segítségével rekurzívan kiírathatjuk a paraméterül kapott kifejezés típusát és értékét.

Az is_ kezdetű beépített függvényekkel típusellenőrzést végezhetünk: lekérdezhetjük, hogy a függvény paramétere adott típusú-e. A fontosabb függvények típusellenőrzésre: is_bool(), is_int(), is_float(), is_string(), is_array(), is_object(), is_resource(), is_null().

1
2
3
4
5
6
7
8
9
<?php
  $szoveg = "sajt";
  $tomb = [10, 20, 30];

  var_dump($szoveg); echo "<br/>";        // típusinformációk a változók értékéről
  var_dump($tomb); echo "<br/>";
  var_dump(is_string($szoveg)); echo "<br/>"; // string-e a $szoveg változó értéke?
  var_dump(is_string($tomb)); echo "<br/>";   // string-e a $tomb változó értéke?
?>

A kód kimenete

string(4) "sajt" array(3) { [0]=> int(10) [1]=> int(20) [2]=> int(30) } bool(true) bool(false)

Típuskonverzió

PHP-ban az adattípusok közötti konverzió automatikusan történik. Két egyszerű példa automatikus típuskonverzióra:

  • Ha a string összefűzésre használatos . (pont) operátor valamely operandusa nem szöveges típusú, akkor automatikusan stringre lesz konvertálva.
  • Ha egy matematikai művelet valamely operandusa nem egy szám, akkor automatikusan valamely numerikus típusra próbálja konvertálni (ha a másik operandus lebegőpontos, akkor lebegőpontosra, egyébként pedig egészre).
1
2
3
4
5
6
<?php
  $a = 5 . "7";             // "5" . "7" = "57"
  $b = 5 + "7";             // 5 + 7 = 12
  $c = "5" + 7.5;           // 5.0 + 7.5 = 12.5
  $d = 5 + "7 törpe";       // 5 + 7 = 12, de figyelmeztetést kapunk ("non well formed numeric value")
?>

Az automatikus típuskonverzió mellett természetesen lehetőségünk van arra is, hogy egy kifejezést manuálisan egy másik típusra konvertáljunk. Ezt nevezzük típuskényszerítésnek, avagy typecasting-nak. A typecasting szintaxisa ugyanúgy néz ki, mint C-ben: (céltípus)érték.

1
2
3
4
5
<?php
  $a = (int)FALSE;          // 0
  $b = (int)3.14;           // 3
  $c = (string)42;          // "42"
?>

Fontosabb operátorok

A PHP fontosabb operátorai:

Kategória Operátorok
Aritmetikai operátorok +, -, *, /, %, **
Hozzárendelő operátorok =, +=, -=, *=, /=
Inkrementáló, dekrementáló operátorok ++, --
Összehasonlító operátorok ==, ===, !=, !==, <, <=, >, >=
Logikai operátorok &&, ||, !

A legtöbb operátor a C-ben tanultakkal megegyező módon viselkedik, viszont van néhány különbség is, amit érdemes kiemelni.

Az egyik ilyen különbség az osztás operátor működése. PHP-ban ugyanis a / operátor minden esetben lebegőpontos osztást végez, még akkor is, ha az operandusai egész számok. Ha egészosztást szeretnénk végezni, akkor ezt PHP-ban az intdiv() függvénnyel tehetjük meg.

A ** (dupla csillag) operátor újdonság lehet számunkra. Ez a hatványozást jelenti.

1
2
3
4
5
<?php
  $a = 5 / 2;           // 2.5 (lebegőpontos osztás)
  $b = intdiv(5, 2);    // 2 (egészosztás)
  $c = 2 ** 10;         // 1024 (hatványozás)
?>

Külön érdemes beszélni még a == (dupla egyenlő) és === (tripla egyenlő) operátorokról. Mindkettőt kifejezések összehasonlítására használjuk, viszont van egy lényegi különbség a két operátor működésében:

  • A == operátor pontosan akkor ad vissza igazat, ha a két operandusának értéke megegyezik
  • A === operátor pontosan akkor ad vissza igazat, ha a két operandusának értéke és típusa egyaránt megegyezik.

Nézzünk egy példát arra, amikor a két operátor eltérően működik!

1
2
3
4
<?php
  var_dump(0 == FALSE); echo "<br/>"; 
  var_dump(0 === FALSE); echo "<br/>";
?>

A kód kimenete

bool(true) bool(false)

Mi is történik itt? Mivel egy egész számot akarunk egy bool értékkel összehasonlítani, ezért a PHP automatikus típuskonverziót végez. A konverzió után a két változó értéke megegyezik (hiszen a FALSE logikai érték pont a 0 int értéknek felel meg), ezért a == operátor igazat ad vissza. Viszont mivel a 0 egy int, a FALSE pedig egy bool típusú adat, ezért a === operátor visszatérési értéke hamis lesz.

A == operátor tagadása a szokásos módon a != (ez pontosan akkor ad vissza igazat, ha a két operandus eltérő értékű), míg a === operátort a !== segítségével tagadhatjuk (ez pontosan akkor ad vissza igazat, ha a két operandus eltérő értékű vagy típusú).

Tipp

Az összehasonlításoknál célszerű mindig a === (tripla egyenlő) operátort használni.

Vezérlési szerkezetek

Szelekciós vezérlés

A szelekciós vezérlés megvalósítására az if, else, else if és switch utasításokat használjuk. Ezek szintaxisa és működése megegyezik a C-ben tanultakkal. PHP-ban az else if utasítás egybe is írható: elseif.

A feltételek megadására a korábban tanult feltételes és logikai operátorokat használjuk.

Példa: Egy program, amely az $eletkor változó értékének függvényében ír ki adatot a képernyőre

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
<?php
  $eletkor = 12;  

  if ($eletkor < 18) {
    echo "Kiskorú vagy. <br/>";
    echo "Még " . (18 - $eletkor) . " év, és nagykorú leszel.";
  } elseif ($eletkor >= 20 && $eletkor <= 29) {
    echo "Huszonéves vagy.";
  } else {
    echo "Nagykorú vagy.";
  }
?>

Példa: Egy program, amely kiírja az érdemjegynek megfelelő szöveges értékelést

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
<?php
  $erdemjegy = 5; 

  switch ($erdemjegy) {  // az $erdemjegy változó értékét vizsgáljuk
    // különböző eseteket vizsgálunk a változó értékének függvényében
    case 1: echo "Elégtelen"; break;
    case 2: echo "Elégséges"; break;
    case 3: echo "Közepes"; break;
    case 4: echo "Jó"; break;
    case 5: echo "Jeles"; break;
    // ha a fentiek közül egyik esetre sem illeszkedünk, akkor a default ág fut le
    default: echo "Érvénytelen érdemjegy!";
  }
?>

Azokat a feltételeket, amelyek csupán egy if-ágból és egy else-ágból állnak, le is rövidíthetjük a C-ből ismerős ternary operátor segítségével. Ennek a szintaxisa a szokásos: feltétel ? művelet ha igaz : művelet ha hamis.

Példa: Egy szám paritásának vizsgálata

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
  $szam = 42;

  // paritás vizsgálat ternary operátor használata nélkül
  if ($szam % 2 === 0) {
    echo "Páros. <br/>";
  } else {
    echo "Páratlan. <br/>";
  }

  // ugyanez, ternary operátorral
  echo $szam % 2 === 0 ? "Páros. <br/>" : "Páratlan. <br/>";
?>
Ismétléses vezérlés (Ciklusok)

PHP-ban a while, do... while, for és foreach utasításokat használjuk ismétléses vezérlés megvalósítására. Ezek közül az első három ugyanúgy működik, mint C-ben.

Példa: Írassuk ki az egész számokat 1-től 10-ig a while, do... while és for ciklusokkal!

1
2
3
4
5
6
7
<?php
  $i = 1;
  while ($i <= 10) {              // while-ciklus
    echo $i . "<br/>";
    $i++;
  }
?>
1
2
3
4
5
6
7
<?php
  $i = 1;
  do {
    echo $i . "<br/>";            // do...while-ciklus
    $i++;
  } while ($i <= 10);
?>
1
2
3
4
5
<?php
  for ($i = 1; $i <= 10; $i++) {  // for-ciklus
    echo $i . "<br/>";
  }
?>

A foreach utasításról külön érdemes beszélni. Ezt jellemzően tömbök listaszerű bejárására használjuk. Ekkor a ciklusváltozó magukon a tömbelemeken iterál végig (tehát itt nem indexváltozónk van, mint a for esetén).

Példa: A foreach szerkezet használata

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
   $arak = ["szendvics" => 220, "tea" => 70, "csoki" => 150];

   // az $ar változó mindig az aktuális tömbelem értékét tárolja
   foreach ($arak as $ar) {
     echo $ar . "<br/>";
   }

   // az $etel az aktuális kulcs, az $ar pedig a kulcshoz tartozó érték
   foreach ($arak as $etel => $ar) {
     echo "$etel ára: $ar forint <br/>";
   }
?>

A kód kimenete

220 70 150 szendvics ára: 220 forint tea ára: 70 forint csoki ára: 150 forint

Érdemes megjegyezni, hogy a foreach alapértelmezett módon a tömb egy másolatával dolgozik. Ha az eredeti tömbbel szeretnénk dolgozni, akkor referenciát kell átadnunk.

Példa: Csökkentsük az $arak tömbben minden étel és ital árát 10%-kal!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
<?php
  $arak = ["szendvics" => 220, "tea" => 70, "csoki" => 150];

  // HIBÁS MEGOLDÁS: itt egy másolattal dolgozunk, nem az eredeti tömbbel
  foreach ($arak as $ar) {
    $ar = $ar * 0.9;
  }
  print_r($arak); echo "<br/>";

  // HELYES MEGOLDÁS: ha referenciát adunk át, akkor az eredeti tömböt módosítjuk
  foreach ($arak as &$ar) {
    $ar = $ar * 0.9;
  }
  print_r($arak); echo "<br/>";
?>

A kód kimenete

Array ( [szendvics] => 220 [tea] => 70 [csoki] => 150 ) Array ( [szendvics] => 198 [tea] => 63 [csoki] => 135 )


Utolsó frissítés: 2021-03-27 13:17:44