• Szerző: Sallai András
• Copyright © Sallai András, 2011-2020
• Licenc: CC Attribution-Share Alike 4.0 International
• Web: https://szit.hu

Rasmus Lerdorf (kanadai programozó) Perl nyelven alkalmazást ír 1994-ben, hogy megtudja kik látogatják az önéletrajzát. A gép, ahol a weblap volt, lassú volt, ezért úgy gondolta C nyelven újra írja. Mások is szerették volna használni. Később más eszközöket is létrehozott, és a sikerét látva programcsomagot állított össze belőle. Ekkor adta első nevét:

• Personal Home Page Tools

Rövidesen újabb nevet adott neki.

• Personal Home Page Construction Kit

Készített egy másik csomagot, amely SQL adatbázisból tudott lekérdezni. Ennek neve:

• Form Interpreter

Mindkét eszközt alaposan átírta és egyesítette 1997 végére a neve ekkor:

• PHP/FI 2.0

A végleges 2.0 változatban bekerült a regex támogatás is.

1998-ban kiadták a 3.0-ás változatot, már Zeev Suraski (izraeli prog.) és Andi Gutmans (izraeli prog.) közreműködésével. A neve ekkor lett „PHP Hypertext Preprocessor”

• PHP 3.0

Ekkor a PHP csak CGI-ként futtatható programok halmaza.

A PHP 4.0 változatát az apache már a mai formájában támogatta. Más webszervereken ekkor csak CGI formában futtatható.

A PHP nyelv kis- és nagybetűérzékeny. Vannak utasítások amelyek nyelvi elemként vannak megvalósítva, és vannak amelyek függvényként. A függvényként megvalósított utasítások esetén mindig kötelező a zárójel. A függvények használhatók változóként meghívva.

Válaszoljon a következő kérdésekre:

1. Mi a PHP alkotójának neve?
2. Mikor kezdődött a PHP fejlesztése?
3. Mi volt az első PHP változat neve?
4. Milyen eszköz került a PHP 2.0 végleges verzióba?
5. Mikor jött ki a 3.0 PHP változat?
6. Kis és nagybetűérzékeny-e a PHP nyelv?

Alaphelyzet, hogy készítünk egy .php kiterjesztésű állományt, amelyben leírjuk a PHP programunkat.

index.php

<?php
  echo("Helló Világ");
?>

A PHP programot <?php karaktersorozattal indítjuk, és ?> karakterekkel fejezzük be. A kettő közzé kerülnek a kódjaink. Lentebb látni fogjuk, hogy egy .html kiterjesztésű fájlba is beágyazható a php kód.

Ha csak PHP kódot írunk (nem HTML-be ágyazott PHP), akkor megengedett a záró rész elhagyása:

index.php

<?php
  echo("Helló Világ");

Ezt megoldást sokak alapszabálynak tekintik, mások vitatják, merthogy mindent le kell zárni.

A programkódunkba megjegyzéseket tehetünk magunknak vagy más programozóknak. Ezeket a PHP értelmező nem dolgozza fel. A megjegyzések lehetnek egy vagy több sorosak.

Több soros:

/* több
   soros
   megjegyzés
 */

Egysoros:

//egysoros megjegyzés

Másik egysoros:

# egysoros megjegyzés

A megjegyzések, utasítások után is írhatók:

<?php
echo 348000*2; //megjegyzés

<?php
echo 348000*2; /* megjegyzés */

Megjegyzés beágyazása utasításba:

echo(3 * /* köztes megjegyzés */ 6);

echo "Szöveg";

print "Szöveg";

Ha idézőjelek, vagy aposztrófok nélkül írunk számokat az echo vagy a print után, az gond nélkül kiírathatók.

echo 45;
print 35;

Az echo és a print használható zárójellel is.

echo(45);
echo("Helló Világ");
print("45");

Az echo és print ugyanúgy működik, a különbség még az, hogy amíg az echo utasításnak nincs visszatérési értéke, a print utasításnak van.

Minden kifejezés amit leírsz. Pontosabban: valami, aminek értéke van.

Ha van egy változónk önmagában (mint az alábbi példában az egyenlőség jel jobb oldalán), akkor persze nem szoktuk kifejezésként említeni:

$eredmeny = $szam;

De ha vannak körülötte operátorok is, akkor már igen:

$eredmeny = ++$szam;
$eredmeny = $szam + 2;

Azt mondhatjuk az egyenlőség jobb oldalán egy kifejezés áll.

Az echo, vagy a print után írt kifejezések kiértékelésre kerülnek, majd az eredményt íródik a képernyőre.

echo 2 * 3;
print 384000 * 4;

Válaszoljon a következő kérdésekre:

1. Mi a szerepe egy PHP programban a következő öt karakternek: <?php
2. Mi a szerepe egy PHP kódban a következő két karakternek: ?>
3. Van e olyan sor a következő kódok közöt, ami kihagyható egy PHP kódban?
   • <?php
   • ?>
   • mindkettő kötelező
   • egyik sem kötelező
4. Hogyan lehet egysoros megjegyzést tenni PHP-ban?
5. Hogyan lehet többsoros megjegyzést tenni PHP-ban?
6. Írjon minimum két utasítást, amellyel kiíratás végezhető PHP nyelven.

Az alábbi példában HTML-be ágyazva látjuk a PHP kódunkat. A nyitó és záró karaktersorozat megegyezik a fentiekkel, csak a <body> tegek közzé ágyaztuk azokat.

index.php

<html>
  <head>
    <title>Példa</title>
  </head>
  <body>
    <?php
    echo "Helló, vagyok!";
    ?>
  </body>
</html>

Vegyük észre, hogy a fájl kiterjesztése .php továbbra is. A fájlban viszont HTML oldalt írunk, annak csak egy kis része tartalmaz PHP kódot.

A PHP nyelven is használhatunk Escape szekvenciákat. Ezek a generált HTML oldal forráskódjában fognak megjelenni. A legjellemzőbben használt ilyen szekvencia a \n, amellyel egy újsor jelet írunk a HTML forrásban. Az alábbi táblázatban láthatjuk a többi escape szekvenciát.

Ha kiíratom, hogy „merengés”, minden egyes karakter a böngészőben megjelenik.

<?php
echo("merengés");

Most tegyünk egy „\” karakter az „n” karakter elé:

<?php
echo("mere\ngés");

Az „n” karakter, most nem íródik a képernyőre, helyette egy sortörés jelenik meg, forráskód szinten.

Nézzük meg az eredményt böngészőben. A „gés” szó nem nincs új sorban. Most nézzük meg a forráskódot a böngészőben. Ekkor, felfedezhetjük a sortörést.

Ne felejtsük el, hogy mi állandóan HTML oldalakat generálunk. A HTML oldal forrásában szereplő sortörést szolgálhatja az átláthatóságot, de megjelenített HTML oldalon az nem jelenik meg. Ha a HTML oldalon szeretnénk sortörést, azt a <br /> tag HTML forrásba írásával érhetjük el.

Az alábbi példában a HTML oldalon szeretnénk a „Világ” szót új sorban látni:

index.php

<?php
  echo("Helló<br />Világ");
?>

Létezik még egy másik gyakran használt escape szekvencia a „\t”. Ez egy tabulátorjelet ír a HTML kód forrásába. :

index.php

<?php
echo("Helló\tVilág");
?>

Válaszoljon a következő kérdésekre.

1. Milyen kiterjesztést kap az állomány, ha HTML kódba ágyazzuk a PHP kódot?
2. Mire való a \n escape szekvencia?
3. Mire való a \t escape szekvencia?
4. Mire való a \„ escape szekvencia?
5. Mi íródik a böngészőbe weblap szinten a következő utasítás hatására:
   • echo „alma\nkörte”;
6. Mi íródik a böngészőbe a weblap forrásának szintjén a következő utasítás hatására:
   • echo „alma\nkörte”;
7. Mi íródik a böngészőbe weblap szinten a következő utasítás hatására:
   • echo „alma<br>körte”;
8. Mi íródik a böngészőbe a weblap forrásának szintjén a következő utasítás hatására:
   • echo „alma<br>körte”;

Készítsen PHP programot:

1. A program írja ki egymás alá a következő településneveket:
   • Miskolc, Szolnok, Szeged, Hatvan

Az eddig PHP kódjaink nagyon siralmas HTML oldalakat generáltak, azok semmilyen HTML szabványnak nem feleltek meg. Egy HTML5-ös verzióban írt szabályos HTML oldal a következő minimális tartalommal rendelkezik:

index.html

<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
<title>Cím</title>
</head>
<body>
 
 
<p>Helló Világ</p>
 
</body>
</html>

Ha az eddig generált HTML oldal forrását megnézzük, akkor ezeket a tageket sehol nem látjuk. Generáljunk szabályos html odalakat. Ez azt jelenti, hogy minden egyes sor ki kell íratni echo vagy print utasítással:

index.php

<?php
print "<!doctype html>";
print "<html>";
print "<head>";
print "<meta charset=\"UTF-8\" />";
print "<title>Cím</title>";
print "</head>";
print "<body>";
 
 
print "<p>Helló Világ</p>";
 
print "</body>";
print "</html>";
 
?>

Vegyük észre a karakterkódolás beállításainál az escape szekvenciákat. Mivel az idézőjelnek külön szerepe van a PHP-ban, ha ilyen karaktert szeretnénk generálni egy HTML oldalon, akkor az csak escape szekvenciával tehetjük meg.

Később látni fogjuk, hogy van egy heredoc nevű szintaxis, amely segítségével egyetlen print utasítás is elég a HTML generálásához:

index.php

<?php
 
print <<<EOT
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
<title>Cím</title>
</head>
<body>
 
 
<p>Helló Világ</p>
 
</body>
</html>
EOT;
 
?>

Ha ezt használjuk nincs szükség escape szekvenciákra, a HTML forrásban is ugyanígy jelennek meg a tagek és a tartalom.

Gyakori hiba a „print <<<EOT” után tett egy vagy több szóköz vagy más nem látható karakter. Az „EOT” után csak a sortörés legyen!

A PHP nyelvben négy egyszerű típus használatos:

• string
• integer
• double
• boolean

Összetett típusok kettő:

• array
• object

Speciális típus:

• resource
• NULL

Kiegészítő típusok:

• number
• mxed_R
• callback

Ha egy változóba a 35 értéket teszem, akkor az integer típusú lesz:

<?php
$szam = 35;
echo gettype($szam);

A gettype() függvény kiírja a változó típusát.

Ha 35.123 értéket teszem a $szam változóba, akkor az double típusú lesz:

<?php
$szam = 35.123;
echo gettype($szam);

Ha egy karaktert teszek a $karakter változóba, akkor az string típus lesz:

<?php
$kar = 'a';
echo gettype($kar);

Ha több karaktert teszünk bele az is karakter típus lesz:

<?php
$kar = 'alma';
echo gettype($kar);
$kar = "körte";
echo gettype($kar);

Az $igaz nevű változóba a true értéket téve, boolean típust kapunk:

<?php
$igaz = true;
echo gettype($igaz);

A típus kiíratására használható még a var_dump() függvény:

<?php
$adat = 35;
echo(gettype($adat));
echo "<br>";
var_dump($adat);

A tömb típus:

<?php
$tomb[0]=30;
$tomb[1]=35;
echo gettype($tomb);
?>

A tömbökről később a Tömbök fejezetben lesz szó részletesen.

Egy objektum létrehozása és ellenőrzése:

<?php
class Dolgozo {
    public $nev = 'Névtelen';
    public $kor = 35;
}
 
$janos = new Dolgozo();
 
echo gettype($janos);
?>

Az objektumokról részletesen az Objektum Orientált fejezetben lesz szó.

Erőforrástípus példa:

<?php
$img = imagecreatefrompng("kep.png");
echo($img);

NULL típus:

<?php
$adat = NULL;
echo(gettype($adat));

A PHP nyelvben a változókat használatuk előtt nem kell deklarálni. Azok típusa fordítási időben dől el. A változónevek elé mindig egy „$” karaktert teszünk, amely nem tartozik a változó nevéhez. A változókat úgy hozzuk létre, hogy értéket adunk neki:

$szam = 35;

A fentiekben egy „szam” nevű változót hoztunk létre, amelyben a 35-ös egész számot tároltuk el. A „szam” karakter sorozat egy változót azonosít, ezért néha az ilyen azonosítóként említjük a munkánk során.

index.php

<?php
 
print <<<EOT
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
<title>Cím</title>
</head>
<body>
 
 
<p>Helló Világ</p>
 
EOT;
 
$szam = 35;
 
print $szam * 2;
 
print "</body>\n</html>";
 
 
?>

Szöveg megadása:

$nev = "Nagy János";

vagy:

$nev = 'Nagy János';

Ebből is láthatjuk, hogy karaktersorozatot idézőjellel, vagy aposztróffal adhatunk meg.

$4site      = 'ez nem jó'; // nem érvényes, mert számmal kezdődik
 
$_4site      = 'ez ok';    // érvényes, aláhúzással kezdődik
$täyte       = 'mansikka'; // érvényes, az 'ä' az ASCII 228-as karaktere
$tükörfúrógép = "árvíztűrő"; // érvényes, ellenőrizheted egy ASCII táblában

Változók cím szerinti átadása

<?php
$foo = 'Bob';         // 'Bob' hozzárendelése $foo-hoz
$bar = &$foo;         // Hivatkozás $foo-ra $bar-ban.
$bar = "Nevem $bar";  // $bar megváltoztatása...
echo $foo;            // $foo is megváltozik.
echo $bar;
?>

A matematikából tudjuk, hogy vannak egész és valós számok. A programozás során mindkét számmal dolgozunk, a kétféle szám között különbséget teszünk.

$a = 1234; // decimális szám
$a = -123; // egy negatív szám
$a = 0123; // oktális szám (egyenértékű 83 decimálissal)
$a = 0x12; // hexadecimális szám (egyenértékű 18 decimálissal)

$a = 1.234;  //fixpontos szám
$a = 1.2e3;  //lebegőpontos szám

• Készítse el az előző két fejezetben szereplő egyszerű PHP programot
• Válaszoljon a következő kérdésre:
  • Milyen karakterrel vezetjük be a változóneveket.

Konstans, azaz állandó. A programozó azt vállalja, hogy ezen a memóriaterületen elhelyezett értéket a program további részében nem változtatjuk meg. Egyszóval, olyan mint a változó, de később ez nem módosítható.

A PHP nyelv tartalmaz jó-néhány előre meghatározott konstanst. A LINE konstans például az éppen olvasott fájlról ad információt.

Lássunk néhány előre definiált állandót a teljesség igénye nélkül.

__FILE__   Az aktuális fájl útvonal, neve, kiterjesztése egyben.
__LINE__   Az aktuális fájlban hányadik sorban vagyunk (ahol hivatkozunk erre a változóra /PHP forráskódban/)
PHP_VERSION
PHP_OS
TRUE        Értéke 1
FALSE       Nincs értéke
E_ERROR     Nem feldolgozás során bekövetkezett hiba
E_WARNING   Valami nincs rendben ("Ez nem biztos, hogy jó lesz így")
E_PARSE     Szintaktikai hiba
E_NOTICE    Lehet, hogy hiba, lehet nem
E_ALL       Minden E_* formátumú hiba
DIRECTORY_SEPARATOR   Könyvtárszeparátor

Az előre definiált konstansokat kiírathatjuk a következő paranccsal:

print_r(get_defined_constants());

A define() függvény globális hatókörben és függvényekben használható:

define("MAX", 300);

Osztály meződefinícióban nem használható.

A const használható osztály meződefiníciójában. Az osztályokkal egyelőre nem foglalkozunk.

const MAX = 300;

const A = 3;	//Definiálunk egy állandót
echo defined("A") . "\n"; //Megvizsgáljuk van-e ilyen

• Készítsen egesz néven projektet
  • Tárolja el a következő számokat, majd írassa ki az értékét

• Készítsen okt néven projektet
  • Tárolja el a következő számokat, majd írassa ki az értékét

• Készítsen hex néven projektet
  • Tárolja el a következő számokat, majd írassa ki az értékét

• Készítsen fnev néven projektet.
  • Írassa ki a forrásfájl nevét.
  • Használjon előre definiált konstanst.
• Készítsen sor néven projektet.
  • Írassa ki a forrásfájl hányadik helyén van a kiírató utasítás.
  • Használjon előre definiált konstanst.
• Írjunk programot, amelyik kiírja a PHP aktuális verzióját.
  • Használja az előzőleg tanult előredefiniált állandókat.
• Válaszold meg a következő kérdést:
  • A define() függvény, használható-e osztály meződefinícióban?

Bármely programozási nyelvben az operátorok csinálnak valamit a változókkal és az állandókkal. Lehet, hogy összeszorozza őket, vagy összeadja, vagy különbséget von, vagy oszt stb. A változókat és az állandókat szokás operandus néven is emlegetni. Ebben a tekintetben azt mondhatjuk, hogy az operátorok az operandusokon csinálnak valamit.

Léteznek egy és két operandusú operátorok. Ha azt mondom: a * b. Az azt jelenti van egy „*” operátor, amely az „a” és „b” operandus szorzatát adja. De vannak olyan operátorok is, amelyeknek csak egy operandusok van. Ilyen például az az operátor amely egy változó értékét eggyel növeli: a++; Az operátor a ”++„. Az operandus az „a”. Az „a” operandus (változó) értéke eggyel nő.

index.php

<?php
print 5 * 3;
?>

Az alapértelmezett értékadó operátor a PHP-ban a ”=„. Baloldalon mindig egy változó áll, jobboldalon pedig egy kifejezés, melynek értékét a változó felveszi.

Például:

$x = 5;

Két értéket hasonlítunk össze.

• Készítsen projektet, szamo néven.
  • Egy egész számot osszon el, egy másik egész számmal.
• Készítsen projektet, valtoz néven.
  • Tároljon változóban két egész számot.
  • Az első változó tartalmát, ossza el a másodikkal.
• Válaszoljon a következő kérdésekre:
  • Mire való a % operátor?
  • Mire való a . (pont) operátor?
  • Mire való a ++ operátor?
  • Mi a különbség a == és az === operátor között?

A programozás elméletből már tudjuk, hogy a szintaxis egy nyelvben a helyesírás. A helyesírást valamilyen formában rögzíteni is szokás. Eddig használtuk a print utasítást, nézzük meg a helyesírását, vagyis a szintaxisát.

A print utasítás szintaktikája:

int print ( string $arg )

Ebből azt látjuk, hogy a print utasításnak egy darab bemenő paramétere lehet, amelynek string típusúnak kell lennie. Ezt a zárójelekben lévő (string $arg) mutatja számunkra. A print előtt van egy „int”. Az int azt jelenti a print előtt, hogy a print egy egész számmal tér vissza, amelynek típusa int.

Amikor fentebb használtuk az print() függvényt, a visszatérési értékkel nem foglalkoztunk, de akár ezt is írhattam volna:

$szam = print("Teszt");

A $szam egy változó, amiben eltárolódik a print() függvény visszatérési értéke. A változó egy memóriaterület.

A fentiekből látjuk, hogy egy függvényt szintaxisában mindig leírjuk mik a bemenő paraméterek, és milyen értékkel tér vissza.

A printf() függvény lehetővé teszi a kimenet formázását.

Szintaxis:

int printf ( string $format [, mixed $args [, mixed $... ]] )

A $format mindig egy karaktersorozat, amely tartalmazhat egy vagy több formátumkódot. A formátumkód mindig egy vagy több argumentumot ír le. Az argumentumok a következők lehetnek:

• literális (egy szám, egy karakter, egy karaktersorozat)
• változó
• egy nevesített állandó
• egy kifejezés

Legyen például egy szám literális, amit formázva szeretnénk kiíratni: 35.

A printf() függvényt, ekkor így használjuk:

printf("%d", 35);

Ha két egész számot szeretnék kiíratni, szóközzel tagolva, akkor:

printf("%d %d", 35, 40);

Vegyük észre két ilyen egységet írtam: %d. A %d a formátumkód. A formátumkód mindig egy % jel karakterrel kezdődik és egy valamilyen formátumkarakterrel végződik. Egész számok esetén a formátumkarakter, a „d” betű, mint a példáinkban is látszik.

Valós számokat, az f formátumkarakterrel íratjuk ki. Legyen a példa kedvéért egy 832.83434 valós szám. Írassuk ki:

printf("%f", 832.83434);

Egy karaktert, a c formátumkarakterrel írathatunk ki. Legyen egy 'b' karakter, amit szertnénk kiíratni.

printf("%c", 65);

Karaktersorozat kiíratása:

printf("%s", "alma");

Ezek a módosítók a % jel és a formátum karakter között helyezhetők el:

Például:

%.2f

• A % jel jelzi, hogy formátumkód következik.
• Az f betű azt jelenti, valós számot szeretnék kiíratni
• A % és az f között a .2, azt jelentése:
  • a számot kettő tizedesjegy pontossággal szeretném kiírni

A .2 karakterek módosítók. Módosítják a kiírás formáját. A következő táblázat bemutatja, még milyen módosítók használhatók:

Példa1:

$str = "Helló";
$szam = 123;
printf("%s Világ. A nap száma: %u", $str, $szam);

Kimenet:

Helló Világ. A nap száma: 123 

Példa2:

$number = 123;
printf("%f",$number);

Kimenet:

123.000000 

• Válaszoljon a következő kérdésekre:
  • Egész számot, milyen formátumkarakterrel kell kiíratni?
    • Válasszon: f, d, c, s
  • Valós számot, milyen formátumkarakterrel kell kiíratni?
    • Válasszon: f, d, c, s
  • Karakter formátumban számot, milyen formátumkarakterrel kell kiíratni?
    • Válasszon: f, d, c, s
  • Karaktersorozatot, milyen formátumkarakterrel kell kiíratni?
    • Válasszon: f, d, c, s
• Írjon programot, fegesz néven.
  • A program tárolja egy változóban a 457 számot.
  • Írass ki a számot 8 szélességben, vezető nullákkal.
• Írjon programot, fvalos néven.
  • A program tárolja egy változóban a 834.5834 számot.
  • Írass ki a számot:
    • 20 szélességben
    • vezető nullákkal
    • 2 tizedesjegy pontossággal
• Írjon programot, fkar néven.
  • A program tárolja egy változóban a 68-s számot.
  • Írass ki a karakterként.
• Írjon programot, fstr néven.
  • Tárolja változóban a „víz” szót.
  • Írassa ki a 10 szélességben.

Az abs() függvény segítségével egy szám abszolút értékét kérhetjük. Szintaxisa:

number abs ( mixed $number )

Példa:

$absErtek = abs(-54);
echo "$absErtek\n";

A ceil() függvény egy számot felfelé kerekít. Szintaxisa:

ceil ( float $value ) : float

Példa:

echo ceil(4.1) . "\n";

Eredmény:

5

A cos() függvény egy szám koszinuszát adja. Paraméterként radiánt kell megadni. Szintaxisa:

float cos ( float $arg )

$szog = 30;
$rad = $szog * pi() / 180;
echo cos($rad) . "\n";

A deg2rad() függvény fokból, radiánba számol át egy értéket.

float deg2rad ( float $number )

$szog = 30;
$rad = deg2rad($szog);
echo sin($rad) . "\n";

Az e valamilyen hatványának számítása, e^x. Az e, a természetes logaritmus alapja, körülbelül: 2,718282.

exp ( float $arg ) : float

Az e a nyolcadik hatványon.

echo exp(8) . "\n";

A floor() függvény egy számot lefelé kerekít. Szintaxis:

float floor ( float $value )

Példa:

$a = 4.9;
print floor($a);

Eredmény:

4

A log10() függvény egy szám tízes alapú logaritmusát adja. Szintaxis:

float log10 ( float $arg )

Példa:

echo log10(3);

Ha a base paraméter meg van adva, akkor visszatér ezen alapú logaritmussal, egyébként természetes alapú logaritmussal tér vissza. Szintaxis:

float log ( float $arg [, float $base = M_E ] )

echo log(3);

A legnagyobb érték kiválasztása:

max ( array $values ) : mixed

max ( mixed $value1 [, mixed $... ] ) : mixed

$tomb = array(3, 9, 4, 5);
echo max($tomb) . "\n";

$a1 = 35;
$a2 = 72;
$a3 = 18;
$a4 = 29;
 
echo max($a1, $a2, $a3, $a4) . "\n";

A legkisebb érték kiválasztása

mixed min ( array $values )

mixed min ( mixed $value1 , mixed $value2 [, mixed $value3... ] )

A PHP nyelvben a PI értékét egy függvény adja:

float pi ( void )

Használata, például:

$szog = 30;
$rad = $szog * pi() / 180;

A pow() függvénnyel, egy szám hatványát számíthatjuk ki.

number pow ( number $base , number $exp )

Például 2, a nyolcadik hatványon.

echo pow(2, 8) . "\n";

float rad2deg ( float $number )

szintaxis:

float round ( float $val [, int $precision = 0 [, int $mode = PHP_ROUND_HALF_UP ]] )

Visszatér egy kerekített értékkel. Állítható a precizitás és a mód:

Példa:

$szam1 = 3.4;
$szam2 = 3.6;
 
echo round($szam1);
echo "<br>";
echo round($szam2);

Pontosság megadására példa:

$szam1 = 3.12345;
echo round($szam1, 3);

Eredmény:

3.123

A sin() függvény egy szám szinuszát adja. Paraméterként radiánt kell megadni. Szintaxisa:

float sin ( float $arg )

Példa:

$szog = 1;
$rad = $szog * pi() / 180;
echo sin($rad);

Gyökvonás.

float sqrt ( float $arg )

echo sqrt(9) . "\n";

Egy szám tangensét adja. Paraméterként radiánt kell megadni. Szintaxisa:

float tan ( float $arg )

Példa:

$szog = 1;
$rad = $szog * pi() / 180;
echo tan($rad);

• Írjon programot, patrol néven.
  • A program, számolja ki, 43-nak az 5.-dik hatványát.
• Írjon programot, tengi néven.
  • A program, számolja ki 35 foknak a szinuszát.
• Írjon programot, kosz néven.
  • A program, számolja ki 37 foknak a koszinuszát.
• Írjon programot, negyi néven.
  • A program, számolja ki 49-nek a gyökét.

A rand() függvény egy véletlen számot generál. Szintaxisa:

int rand ( void )

int rand ( int $min , int $max )

Az srand() függvény előkészíti a véletlen szám generátort. Szintaxisa:

void srand ([ int $seed ] )

Az mt_getrandmax() függvény visszaadja a legnagyobb generálható véletlen számot.

int mt_getrandmax ( void )

$kocka = rand(1, 6);

$lottoszam1 = rand(1, 90);

srand(mktime());
$a = rand(1, 6);
print $a;

Eredmény: 1

• Írjon programot, amely megadja az ötös lottó egyik számát.
  • A szám 1-90 között szám.

A string típussal is tudunk számolni:

$szamStr = "35";
echo $szamStr * 2;

Ha szeretnénk tényleges egésszé konvertálni:

$szamStr = "35";
$szam = intval($szamStr);
echo gettype($szam);

A string valós számmá alakítása a floatval() függvénnyel lehetséges.

$szamStr = "35.123";
$szam = floatval($szamStr);
echo gettype($szam);

A doubleval() függvény a floatval() más néven.

Az strval() függvény egy értéket sztring típussá alakít.

$szam = 35;
$szamStr = strval($szam);
echo gettype($szamStr);

A decbin() függvény a decimális számokat binárissá alakítja. Szintaxisa:

string decbin ( int $number )

echo decbin("8");

Kimenet:

1000

A dechex() függvény a decimális számokat hexadecimális számokká alakítja. Szintaxisa:

string dechex ( int $number )

Példa:

echo dechex("11");

Kimenet:

b

A decoct() egy decimális számot oktálissá alakít. Szintaxisa:

string decoct ( int $number )

A hexdec() függvény egy hexadecimális számot decimálissá alakít. Szintaxisa:

number hexdec ( string $hex_string )

number octdec ( string $octal_string )

Jó kérdés, hogy böngészőben bekérés esetén hol adjuk meg az adatot. Beírhatjuk paraméterként, és akkor egy $_GET[] tömbben tudunk rá hivatkozni.

De bekérhetjük egy HTML oldalon is, amiből meghívhatjuk a feldolgozó PHP scriptet.

A példa kedvéért írjunk egy PHP scriptet, ami egyetlen adatot vesz át a címsorból. Egy számot fogunk átvenni, a számot eltároljuk a $szam változóban, majd kiíratjuk.

index.php

$szam = $_GET['szam'];
print "Ezt irtad: $szam";

A végrehajtáshoz ezt írjuk a böngészőbe:

http://server/gyakorlas/index.php?szam=40

Itt adjuk át a 40 értéket paraméterként, a szam néven tudunk majd rá hivatkozni. Az index.php után egy ”?„ (kérdőjel) karakter áll. Ezzel mondjuk meg, hogy az index.php számára paraméter fogunk átadni. A paraméter a szam=40.

A feladathoz egyetlen PHP scriptet írtunk.

Most ugyanezt fogjuk megtenni, csak két PHP scriptet használunk. Az első PHP script csak egy űrlap lesz. A másik PHP script pedig feldolgozza az űrlapot.

Legyen egy beker.php script, ami generálja az űrlapot:

beker.php

<?php
 
 
print <<<EOT
 
<meta charset="utf-8">
<form action="fel.php" method="get">
szám: <input type="text" name="szam"><br>
<input type="submit"><br>
</form>
 
EOT;

Létrehozunk egy űrlapot, ahova a felhasználó beírhatja a kért számot. A böngésző meghívja a fel.php scriptet.

A generált HTML kód, nem egy érvényes weboldal, de a kipróbáláshoz megfelel.

Az űrlapot, mindig <form> elemek közzé tesszük. A form elemnek két attribútumot adunk meg: action és method. Az action mondja, meg mi lesz a feldolgozó PHP script. A method mondja meg, milyen metódussal küldjük át az űrlap adatait. Két módon szoktuk átküldeni az adatokat:

• get
• post

Mi a példánkban get metódust használunk.

Írjon egy sum.php scriptet, amely két számot fogad paraméterként. A script összeadja a bekért számokat, majd kiírja az összeget.

sum.php

<?php
$szam1 = $_GET['szam1'];
$szam2 = $_GET['szam2'];
 
$osszeg = $szam1 + $szam2;
 
echo "Összeg: $osszeg";

Feltételezzük, hogy a munkáját egy php könyvtáron belül, azon belül egy sum könyvtáron belül hozta létre. A sum könyvtárban egy sum.php fájlba írja a scriptet.

Ekkor a böngészőbe ezt írja:

http://localhost/php/sum/sum.php?szam1=30&szam2=35

Írjon PHP scriptet szorzas.php néven, amely két számot fogad, megy összeszorozza azok értékét, az eredményt a képernyőre írja. Az űrlap lehet egy index.php nevű script.

index.php

<?php
 
echo <<<EOT
<meta charset="utf-8">
<form action="szorzas.php" method="get">
 
<label>Szám1</label>
<input type="text" name="szam1">
<br>
 
<label>Szám2</label>
<input type="text" name="szam2">
<br>
 
<button type="submit">Számol</button>
EOT;

szorzas.php

<?php
 
$szam1 = $_GET['szam1'];
$szam2 = $_GET['szam2'];
 
$szorzat = $szam1 * $szam2;
 
echo "Szorzat: $szorzat";

Ha C:\xampp\htdocs\php\szorzas könyvtárban dolgozik, akkor a böngészőbe a következőt írja:

http://localhost/php/szorzas/

Érzékeny adatokat POST metódussal szokás átküldeni.

A feldolgozó scriptben az átvett adatok, ilyenkor egy $_POST[] nevű tömbben találhatók.

Bekérünk két számot. A számokat összeszorozzuk, majd kiírjuk az eredményt.

index.php

<?php
 
echo <<<EOT
<meta charset="utf-8">
<form action="szorzas.php" method="post">
 
<label>Szám1</label>
<input type="text" name="szam1">
<br>
 
<label>Szám2</label>
<input type="text" name="szam2">
<br>
 
<button type="submit">Számol</button>
EOT;

szorzas.php

<?php
 
$szam1 = $_POST['szam1'];
$szam2 = $_POST['szam2'];
 
$szorzat = $szam1 * $szam2;
 
echo "Szorzat: $szorzat";

Ha böngésző helyett parancssorban használjuk a PHP-t, akkor bekérhetünk a szabványos bemenetről:

// egy sor olvasása a szabványos bementről:
$line = trim(fgets(STDIN));
 
// egy szám olvasása a szabványos bementről:
fscanf(STDIN, "%d\n", $number);

• Írjon PHP scriptet, ami bekér két gyümölcsöt.
  • A script fűzze össze a két szót, majd írja a képernyőre.
• Írjon PHP scriptet, ami bekér PIN kódot
  • A PIN kódot fogadja egy fel.php script
  • A PIN kódot írja ki egy dobozba, hatalmas betűkkel, középre igazítva

Az if szelekció szintaxisa:

if (feltétel)
     utasítás;

A zárójelbe írt feltétel egy logikai kifejezés kell legyen. Ha igaz, akkor az utasítás végrehajtódik. Máskülönben nem történik semmi.

Utasításokból egyszerre több is megadható, ekkor kapcsos-zárójelek közé írjuk az utasításokat.

if (feltétel) {
     utasítás1;
     utasítás2;
}

A kapcsos-zárójelek közzé írt utasítások alkotják a szelekció törzsét. Ha feltétel igaz, a szelekció törzsében megadott utasítások végrehajtódnak.

Példa: Legyen két szám. Ha az első nagyobb, akkor írjuk ki, hogy az első nagyobb.

index.php

$elso = 45;
$masodik = 35;
if($elso > $masodik) {
    echo "Az első nagyobb";
}

Az eddigi szelekciókban, ha a feltétel hamis volt, nem csináltunk semmit. Egy else után megadhatunk egy vagy több utasítást, amely akkor hajtódik végre, ha a feltétel hamis.

if (feltétel)
     utasítás;
else
     utasítás;

Itt is használhatunk blokk nyitó és bezáró zárójeleket, így több utasítást megadva:

if (feltétel) {
     utasítás1;
     utasítás2;
 
     utasításn;
} else {
     utasítás1;
     utasítás2;
 
     utasításn;
}

Példa:

Írjunk scriptet, amely tartalmaz két számot. Ha az első nagyobb, írjuk ki: „Az első nagyobb”. Ha az első nem nagyobb, írjuk ki, hogy „Egyenlő vagy kisebb”;

$szam1 = 30;
$szam2 = 35;
 
if ($szam1 > $szam2) {
     echo "Az első nagyobb";
} else {
     echo "Egyenlő vagy kisebb";
}

Készítsünk egy egyszerű azonosítást PHP nyelven.

index.php

<?php
 
echo <<<EOT
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Azonosítás</title>
</head>
<body>
 
<h1>Azonosítás</h1>
 
<form action="auth.php" method="post">
 
<label>Felhasználónév</label>
<input type="text" name="user">
<br>
 
<label>Jelszó</label>
<input type="password" name="pass">
<br>
 
<button type="submit">Bejelentkezés</button>
 
</form>
 
</body>
</html>
EOT;

auth.php

<?php
 
$user = $_POST['user'];
$pass = $_POST['pass'];
 
 
if($user == "janos" && $pass == "titok") {
  $msg = "Sikeres bejelentkezés";
}else {
  $msg = "Hiba! Rossz felhasználónév vagy jelszó!";
}
 
echo <<<EOT
<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Azonosítás</title>
</head>
<body>
 
<h1>Az azonosítás eredménye</h1>
 
<p>
$msg
</p>
 
</body>
</html>
EOT;

if (feltétel1) {
    utasítás ha feltétel1 igaz;
}
elseif (feltétel2) {
    utasítás ha feltétel2 igaz;
}else {
    utasítás ha egyik sem volt igaz;
}

Kérjünk be egy számot. Ha a szám nagyobb mint 0, írjuk ki, hogy „Pozitív”. Ha szám kisebb mint 0, akkor írjuk ki, hogy „Negatív”. Ha egyik sem volt igaz, akkor írjuk ki, hogy „Nulla”.

fel.php

$szam = $_GET['szam'];
 
if ($szam > 0) {
    echo "Pozitív";
}
elseif ($szam < 0) {
    echo "Negatív";
}else {
    echo "Nulla";
}

switch ($valasztott) 
{
    case ”elso”:         print ”Első”; break;
    case ”masodik” :     print ”Második”; break;
    case ”harmadik” : print ”Harmadik”; break;
}

index.php

<?php
 
$gyumolcs = "almaa";
switch($gyumolcs)
{
    case "alma" : print "apple"; break;
    case "barack" : print "peach"; break;
    case "szilva" : print "plum"; break;
    default : print "Más";
}
print "\n";
?>

• Írjon PHP scriptet, ami bekér PIN kódot
  • A PIN kódot fogadja egy fel.php script
  • A fel.php ellenőrizze, hogy helyes-e a PIN kód
  • A PIN kód akkor helyes, ha 4832

for (indulóérték; feltétel; növekedés) {
 
}

Példa:

for($i=0; $i<5; $i++) {
	print "alma<br>";
}

A while ciklus addig fut, amíg feltétel igaz. A feltételt a while után zárójelbe írjuk.

while(feltétel) {
    utasítás1;
    utasítás2;
    utasítás3;
}

A következő példában kérünk egy véletlen számot, 0 és 4 között-t. Ha 0-t kapunk kilépünk a ciklusból, ha más számot, akkor megint kérünk egy véletlen számot. Minden véletlen számot a képernyőre írunk.

$szam = -1;
while($szam != 0) {
    echo "Szám: $szam<br>";
    $szam = rand(0, 4);
}

A do..while() egy hátul tesztelő ciklus. Az ismétlés addig történik, amíg igaz a feltétel.

do {
    utasítás1;
    utasítás2;
    ...
    utasításn;
} while (feltétel);

Valósítsuk meg a fenti feladatot a do..while() ciklussal.

do {
    $szam = rand(0, 4);
    echo "Szám: $szam<br>";
} while ($szam != 0);

Tömbök bejáráshoz használhatjuk a foreach() utasítást. A $tomb tömb elemeit az $elem változóban kapjuk meg a ciklus törzsében.

foreach ($tomb as $elem){
    echo $elem;
}

A tömbökben hasonló elemeket szoktunk tárolni. Például egész számokat, valós számokat, karaktereket stb.

$jarmu[0]="Kia";
$jarmu[1]="Volvo";
$jarmu[2]="Opel";
$jarmu[3]="Toyota";

A tömb index számát nem kötelező megadni:

$tomb[] = "alma";
$tomb[] = "szilva";
$tomb[] = "körte";
$tomb[] = "barack";

A tömb összes elemet kiírathatjuk a print_r() függvénnyel.

print_r($tomb);

A print_r() függvényt, általában nem éles weboldalakon. A programozó viszont megtekintheti egy tömb elemeit.

A PHP asszociatív tömbjei rendezett leképezések. Az adott elemre index helyett egy kulccsal hivatkozunk.

Általánosan:

array(  kulcs =>  érték
     , ...
     )

A kulcs lehet egész szám vagy karaktersorozat, az érték bármilyen típusú lehet.

<?php
 
$tomb = array("nev" => "Joska", 2 => true);
 
echo $tomb["nev"];
echo $tomb[2];
?>

A var_dump() függvény, egy másik módja a tömb összes elemének kiíratására.

<?php
$tomb = array("alma", "körte", "szilva", "barack");
var_dump($tomb);
?>

array(4) {
  [0]=>
  string(4) "alma"
  [1]=>
  string(6) "körte"
  [2]=>
  string(6) "szilva"
  [3]=>
  string(6) "barack"
}

$csaladok = array(
      "Nagy"=>array
      (
          "Páter",
          "Laci",
          "Magdi"
      ),
      "Kiss"=>array
      (
          "Gábor"
      ),
      "Barna"=>array
      (
          "Tamás",
          "Lori",
          "István"
      )
);
 
echo $csaladok['Barna'][2];

$termekek = array(
		array("alma", 380, 45),
		array("körte", 435, 78),
		array("szilva", 218, 510),
		array("barack", 525, 40)
	);

Bejárás:

foreach($termekek as list($termek, $ar, $mennyiseg)) {
	echo "$termek $ar $mennyiseg<br>";
 
}

$employees = [
    ["id"=>1, "name"=>"Dór Tamás", "city"=>"Szeged", "salary"=>2875000],
    ["id"=>2, "name"=>"Ver Imre", "city"=>"Szolnok", "salary"=>2475000]
];
echo $employees[0]['name'];

A tömb utolsó elemét adja

$tomb = array(3, 9, 4, 5);
print end($tomb);

Eredmény:

5

Egy tömb elemeit sorba rendezi

$tomb = array( 3, 4, 5, 9, 2, 6);
print_r($tomb); print "<br>";
sort($tomb);
print_r($tomb); print "<br>";

Eredmény:

Array ( [0] => 3 [1] => 4 [2] => 5 [3] => 9 [4] => 2 [5] => 6 )
Array ( [0] => 2 [1] => 3 [2] => 4 [3] => 5 [4] => 6 [5] => 9 ) 

Egy tömb elemeit sorba rendezi, úgy hogy a kulcsokat is áthelyezi.

$tomb = array( 3, 4, 5, 9, 2, 6);
print_r($tomb); print "<br>";
asort($tomb);
print_r($tomb); print "<br>";

Eredmény:

Array ( [0] => 3 [1] => 4 [2] => 5 [3] => 9 [4] => 2 [5] => 6 )
Array ( [4] => 2 [0] => 3 [1] => 4 [2] => 5 [5] => 6 [3] => 9 )

$tomb = array(5, 8, 2, 7, 3, 4);
$meret = count($tomb);

array_push(array,value1,value2...)

$tomb = array();
array_push($tomb, $valtozo);

$tomb = array();
array_push($tomb, 45);
array_push($tomb, 28);
array_push($tomb, 87, 23, 21);

$tomb = array("alma", "körte");
array_push($tomb, "barack", "szilva");

• array_pop() - A tömb végéről kiszed egy elemet
• array_shift() - A tömb elejéről kiszed egy elemet
• array_unshift() - Adott számú tömbelem visszaállítása
  • array_unshift($tomb, 1);

<?php
 
$tomb = array(3, 4, 8);
array_push($tomb, 45);
$elem = array_pop($tomb);
 
echo "Elem: $elem\n"; //45

Egy tömb tartalmát, szétválogatjuk külön változókba.

$tomb = array("egy", "kettő", "három");
list($a, $b, $c) = $tomb;
echo "$a<br>$b<br>$c";

Adott kódú karaktert add vissza

print chr(97);

Eredmény:

a

print ord("a");

A futtatás eredménye:

97

chop, rtrim

Whitespace vagy más karaktert levág

$ujsz = chop($sz);
$ujsz = chop($sz, "\n");

Második paraméter nélkül levágja a következőket:

" " (ASCII 32 (0x20))   általános szóköz
"\t" (ASCII 9 (0x09))   tabulátor
"\n" (ASCII 10 (0x0A))  új sor
"\r" (ASCII 13 (0x0D))  kocsi vissza
"\0" (ASCII 0 (0x00))   NULL-byte
"\x0B" (ASCII 11 (0x0B) vertikális tabulátor

• aposztróffal
• idézőjellel
• heredoc szintaxissal
• nowdoc

Aposztróffal:

$a = 'lorem ipsum dolorest amet';

Idézőjel:

$a = "lorem ipsum dolorest amet";

Heredoc szintaxissal:

$s = <<<EOT
első sor
második sor ...
EOT;

Nowdoc szintaxissal:

$str = <<<'EOD'
első sor
második sor ...
EOD;

Ez utóbbi esetben a változók nem kerülnek behelyettesítésre.

A két szintaxis segítségével több sort tehetünk egyszerre egy változóba, vagy írathatunk ki.

echo <<<EOT
első sor
második sor
harmadik sor
EOT;

A példában az echo a következő sorokat addig írja a képernyőre, amíg nem találkozik egy újabb EOT szóval, ami pontosvesszővel van lezárva.

Ügyeljünk arra, hogy a külön sorokba írt szöveg, csak a HTML forráskódjában lesz ilyen formában megtörve. HTML oldalon a sortörést <br> elemmel kell megvalósítani.

echo <<<EOT
első sor<br>
második sor<br>
harmadik sor<br>
EOT;

Az EOT, egyébként a End Of Text szavakból van, általában ezt használjuk. Nem kötelező az EOT használata, tetszőleges szó használható. Megfelel például a VEGE vagy bármi más szó is:

echo <<<VEGE
első sor
második sor
harmadik sor
VEGE;

A heredoc szintaxis nem csak az echo utasítással működik. Egy változó is kaphat így értéket:

$szoveg = <<<EOT
első sor
második sor
harmadik sor
EOT;

A heredoc sorain belül változót is megadhatunk. A változó értéke behelyettesítésre kerül.

$nev = "Nagy János";
$kor = 35;
$telepules = "Szolnok";
 
echo <<<EOT
Név: $nev<br>
Életkor: $kor<br>
Település: $telepules<br>
EOT;

Most nézzük a nowdoc szintaxist. Ugyanazt tudja mint a heredoc szintaxis, egy kivétellel. Ha változót írunk bele, nem az értékét kapjuk, hanem a változó nevét. Nowdoc szintaxisnál a nyitó EOT szót, aposztrófok közzé tesszük. Ettől lesz nowdoc és nem heredoc.

echo <<<'EOT'
első sor
második sor
harmadik sor
EOT;

Hibalehetőség! Heredoc esetén az EOT után, nowdoc esetén a 'EOT' után tilos szóközt vagy tabulátort írni.

A lezáró EOT; után sem szerepelhet szóköz vagy tabulátor.

$a = "Para ";
$b = $a . "Para";
$a = "Dárdarázó ";
$a .= "Villmos";

$var = "Géza";
$Var = "János";
echo "$var, $Var";    // kiírja, hogy "Géza, János"

A nyelv nem kisbetű nagybetű érzékeny, de a változók azok.

$str = 'almafa';
$meret = strlen($str);

A sztring egy részével tér vissza

index.php

<?php
 
$mondat = "szilvás";
$eredmeny = substr($mondat, 2, 3);
echo "$eredmeny\n"; //eredmény: ilv

$eredmeny = substr("abcdef", -1);
    // visszaadja: "f"
$eredmeny = substr("abcdef", -2);
    // visszaadaj "ef"
$eredmeny = substr("abcdef", -3, 1);
    // visszaadja "d"

Sztringet darabol fel reguláris kifejezésre illeszkedő részei mentén

$sz =”joska:titok”;
$szavak = preg_split('/:/', $sz);
print $szavak[0];
print $szavak[1];

<?php
 
$userData = "janos:titok";
 
$tomb = explode(":", $userData);
 
echo "Felhasználó: $tomb[0]\n";

<?php
$str = "I'm a bird";
 
// Kimenet: "I\'m a bird"
echo addslashes($str);
?>

Vagy Who's Nagy Péter? Stb.

$str = 'abcdef';
echo str_shuffle($str);

adecfb

<?php
 
$tomb = array("egy", "kettő", "három", "négy");
$str = implode(":", $tomb);
echo "$str\n";

Az implode() egy tömb elemeit egyetlen sztringbe fűzi össze. A sztringben a tömb elemei közzé azt a karaktert teszi, amit megadunk első paraméterként.

<?php
 
$str = "alma";
 
for($i=0;$i<strlen($str);$i++) {
    echo "$str[$i]\n";
}

<?php
 
$str = "alma";
$tomb = str_split($str);
 
foreach($tomb as $elem) {
    echo "$elem\n";
}

str_replace(mit; mire; miben);

$vmi=45;
$valami = "Eredmény: {{ vmi }}";
$mas = str_replace('{{ vmi }}', $vmi, $valami);
echo $mas; //Eredmény: 45

Fájlok megnyitására az fopen függvényt használjuk. Első paramétere egy megnyitandó fájl neve karaktersorozatként megadva. Második paraméter a megnyitás módja. Megnyitási mód például a írás, olvasás, hozzáfűzés, illetve ezek keveréke. Az fopen mindig visszaad egy fájlmutatót. Ezt el kell tárolnunk, mert a PHP programban ez fogja azonosítani a megnyitott állományt.

Az fopen használata

  $fkezelo = fopen("filenev.txt", "r");

Megnyitás módjai

A megnyitott fájlokat illik bezárni használat után. Erre az fclose() függvény használható.

Az fclose() függvény használata:

fclose($fkezelo);

Az feof() függvény használata:

while (!feof($fkezelo)) {
  // a ciklus törzse
}

Az fgets függvény használata

$sor = fgets($fkezelo);

$filename = "adat.txt";
$fp = fopen($filename, "r");
 
$content = fread($fp, filesize($filename));
$lines = explode("\n", $content);
print_r($lines);
 
fclose($fp);

A „w” mód használata:

$fkezelo = fopen(”filenev.kit”, ”w”);

Fájl megnyitása hozzáfűzésre a „a” mód megadásával lehetséges.

$fkezelo = fopen(”filenev.kit”, ”a”);

A fájlok írására az fwrite() függvény használható, de ennek alias neve fputs is használatos, mert a C nyelvben ez áll rendelkezésre.

fputs($fkezelo, "alma");

$tartalom = file_get_contents('adat.txt');
 
file_put_contents('adat.txt', $adatok);

function fuggnev(vált1, vált2, ... váltn) {
  utasítás1;
  utasítás2;
  ...
  utasításn;
  return(visszatérési_érték);
}

A () zárójel kötelező ha nincs paraméter akkor is

Függvény meghívása

fuggnev(érték1, érték2, ..., értékn);

<?php
  osszead(3, 2);
  function osszead($a, $b)
  {
    $osszeg = $a + $b;
    return($osszeg);
  }
?>

A return() függvényen belül használva azonnal befejezi a végrehajtás alatt lévő függvény futását, és a paramétereként megadott érték szolgáltatja a függvény visszatérési értékét.

<?php
 
function leker() {
    $tomb = array("alma", "körte", "szilva", "barack");
    return $tomb;
}
 
 
$a = leker();
 
var_dump($a);
 
?>

<?php
 
ir(0);
 
function ir($a)
{
    if($a<10)
    {
	print "$a<br>\n";
	ir($a + 1);
    }
}
 
?>

<?php
 
function elso() {
	function masodik() {
		print "Belső függvény\n";
	}
}
 
elso();
 
masodik();
 
?>

A masodik() nevű függvény csak az elso() hívása után hívható meg.

<?php
 
$mehet=true;
 
if($mehet) {
	function fg() {
		print "Függvény\n";
	}
}
 
fg();
 
?>

Az alábbi függvényben, ha mondjuk meg, hogy a $a és $b változó nem a függvényen belül van definiálva, akkor hibát kapunk.

index.php

<?php
$a = 3;
$b = 4;
 
osszead();
echo $b . "\n";
 
function osszead() {
    global $a, $b;
 
    $b = $a + $b;
} 
?>

Így is lehet:

index.php

<?php
$a = 3;
$b = 4;
 
osszead();
echo $b . "\n";
 
function osszead() {
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
 
?>

A hibaszinteket a php.ini fájlban állíthatjuk a szerveren. A linuxos szervereken a php.ini fájlok helye általában a következő:

/etc/php5/apache2/php.ini

A hibaüzenetek alapértelmezésként be vannak kapcsolva. A php.ini fájlban egy „error_reporting” nevű változót kell keresni.

Például:

error_reporting = E_ALL & ~E_NOTICE

Vagy így:

error_reporting = E_ALL

Néha szükség lehet arra, hogy a webmester maga állítson hibaszintet. Ekkor a php kódunkban használhatjuk az error_reporting() függvényt. Az error_reporting() beállítja a hibajelentési szintet.

A következő példában az összes üzenetet szeretnénk viszontlátni:

<?php
error_reporting(E_ALL);
?>

Paraméterként valójában egy egész számot kell megadni, de minden hibaszinthez tartozik egy nevesített állandó.

// minden hibajelzés kikapcsolása
error_reporting(0);

// csak az egyszerű futási hibák kijelzése
error_reporting  (E_ERROR | E_WARNING | E_PARSE);

E_NOTICE:

// E_NOTICE szintű hibák kijelzése ugyancsak
// hasznos
// (inicializálatlan változók kijelzésére,
// vagy változónevek elgépelésének kiszűrésére)
 
error_reporting (E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

Kivétel:

// E_NOTICEn kívül minden hiba kijelzése
// Ez az alapbeállítás a php.ini-ben
error_reporting (E_ALL ^ E_NOTICE);

Minden hiba:

// Minden PHP hiba kijelzése 
//(bitenkénti 63 használható PHP 3-ban)
error_reporting (E_ALL);
 
// ugyanaz, mint fent: error_reporting (E_ALL);
ini_set ('error_reporting', E_ALL);

Hibaszint állandók:

PHP scriptben a init_set() függvény is használható:

ini_set('display_errors', 'Off');
ini_set('display_startup_errors', 'Off');

A ”@„ elöljáróval is elérhető, hogy egy függvénnyel kapcsolatos hiba ne jelenjen meg. Ez természetesen csak helyben az adott függvényre lesz érvényes.

Legyen például egy htmlhead() függvény amit szeretnénk meghívni.

Ha a függvény nem létezik, de nem is szeretnénk látni a hibaüzenetet, amelyet a függvény hiány okoz, akkor így kell meghívni:

@htmlhead("Cím")

A hibaszintek beállíthatók a .htaccess fájlban is. Például:

php_flag display_errors off

A htaccess fájlban még idevonatkozó használható beállítások:

php_flag display_startup_errors on
php_flag display_errors on
php_flag html_errors on
php_flag  log_errors on
php_value error_log  /home/path/public_html/tartomány/PHP_errors.log

ini_set("log_errors", 1);
ini_set("error_log", "php-error.log");
error_log("Itt egy saját hibaüzenet");

Figyelem! Az állomány írható kell legyen!

Esetleg a /tmp könyvtárba:

ini_set("log_errors", 1);
ini_set("error_log", "/tmp/php-error.log");
error_log("Itt egy saját hibaüzenet");

A következő utasítások állnak rendelkezésünkre:

• include
• require
• include_once
• require_once

• include
  • Az include beemeli a fájl amire hivatkozunk, majd értelmezi és fut tovább.
  • Ha a fájl nem létezik, akkor E_WARNING hibaüzenetet generál, de fut tovább.

• require
  • Az require beemeli a fájl amire hivatkozunk, majd értelmezi és fut tovább.
  • Ha a fájl nem létezik, akkor E_FATAL hibaüzenetet generál, de és nem fut tovább.

• include_once és require_once
  • A fájl csak akkor lesz lefuttatva, ha még nem futott le.
  • Akkor érdemes használni, ha kéteszi lefutás hibát generál.

A már sok függvényünk van, akkor azokat más PHP állományokba szoktuk rakni. Ahol pedig használni akarjuk a függvényeinket azokat az „include” vagy „require” utasítással emeljük be:

include fájlnév;

require fájlnév;

Más állományok használata

   include_once fájlnév;
   require_once fájlnév;

a már egyszer beillesztésre került kódot a PHP nem próbálja meg ismét betölteni

Másik fájl konkrétan

<?php
    include ”fg.php”
    kiir();
?>

Ha egy könyvtárral feljebb kell hivatkozni:

<?php
    include dirname(dirname(__FILE__)) . '/fg.php';
 
    kiir();
?>

Az include utasítással beemelt állományokat szokás elnevezni .inc kiterjesztéssel. Van aki ebbe teszi az adatbázis beállításait, vagy az egész webhely beállításait. Persze ezzel van egy kis gond. Ha egy támadó eltalálja egy ilyen fájl nevét, annak tartalmát mint egy szöveges állományt látni fogja, mivel a webszerver ezt nem próbálja meg értelmezni. A webmesternek persze ez volt az eredeti célja, hogy önmagának jelezze, hogy ezt nem kell értelmezni.

Természetesen meg lehet leni .inc kiterjesztés nélküli is. Aki mégis ragaszkodik hozzá, az manapság kettős kiterjesztést használ. valami.inc.php. A PHP értelmező így értelmezi, de egy támadó nem fog belőle látni semmit. A webmester mégis jelezte magának, vagy másnak a fájl nevében, hogy ez csak egy beemelt állomány.

Agy webhely konfigurációs állománya ezek után lehet:

• config.inc - rossz választás!
• config.inc.php
• config.php

Az inc kiterjesztéshez hasonló lehet a tpl. Ezeket sablon (template) állományoknál szokás használni. Például:

valami.tpl.php

<head>
 <meta http-equiv="Content-Type" 
 content="text/html; charset=utf-8">
 <title>
 <?= $fejléc['cím'] .
 ( (isset($fejléc['mottó'])) ? ('|' . $fejléc['mottó']) : '' ) ?>
 </title>
 <link rel="stylesheet" href="style.css">
</head>

A függvényen kívül létrehozott változok globálisak. Ha szeretnénk használni egy függvényen belül, akkor a meg kell adnunk a „global” módosító után a globális változókat. Ha több is van, azt vesszővel szeparáljuk egymástól.

<?php
$a = 1; $b = 2;
function osszead()
{
  global $a, $b;
  $b = $a + $b;
}
ossszead();
echo $b;
?>

A szerveren telepítve kell legyen a php5-gd csomag. Ez Ubuntu és Debian rendszeren egyszerű:

apt-get install php5-gd

Ha Windowson használsz apache webszervert és azt a wamp csomag részeként telepítetted, akkor automatikusan telepítve lesz a gd csomag a PHP-hez.

kep.php

<?php

  header("Content-type: image/gif");
  $kep = imagecreate( 300, 300 );
  $hatter = imagecolorallocate($kep, 220,220,220);
  $kek = imagecolorallocate($kep, 0,0,255 );
  imageline( $kep, 50, 50, 250, 50, $kek );
  imagegif($kep);

?>

Teszünk egy hivatkozást a képre.

index.php

<?php
  print "<img src=\"kep2.php\"";
?>

Megjeleníthetjük png-ként: kep.php

<?php

  header("Content-type: image/png");
  $kep = imagecreate( 300, 300 );
  $hatter = imagecolorallocate($kep, 220,220,220);
  $kek = imagecolorallocate($kep, 0,0,255 );
  imageline( $kep, 50, 50, 250, 50, $kek );
  imagepng($kep);

?>

Téglalap rajzolása és kitöltése:

<?php
  $vaszon = imagecreate( 300, 300 );
  $szurke = imagecolorallocate($vaszon, 220,220,220);
  $kek = imagecolorallocate($vaszon, 0,0,255 );

  imagerectangle($vaszon, 50,100, 250,150,$kek);
  imagefill($vaszon, 51,101, $kek);

  header("Content-type: image/png");
  imagepng($vaszon);
  imagedestroy($vaszon);
?>

<?php
  $adatszam=7;
  $adat = array(170, 250, 200, 120, 140, 20, 130);

  $magassag=400;
  $szelesseg=400;
  $kep=imagecreate($magassag, $szelesseg);
  $hatter=imagecolorallocate($kep, 220, 220, 220);

  $vonalszin=imagecolorallocate($kep, 0, 0, 0);
  $kek = imagecolorallocate($kep, 0, 0, 255);  

  imageline( $kep, 10, $magassag - 20, $szelesseg - 10, $magassag - 20, $kek );

  for ($i=0; $i < $adatszam; $i++)
  {
      imagerectangle($kep, $i * 40 + 15, $magassag - 20, 5 + $i * 40 + 25 , ($magassag - 20) - $adat[$i], $vonalszin);
      imagefill($kep, $i * 40 + 16, $magassag - 21, $kek); 
      imagestring($kep, 3, $i * 40 + 15, $magassag - 18, $adat[$i], $kek);   
  }

  header("Content-type: iamge/png");
  imagepng($kep);
  
?>