[[oktatas:programozás:php|< PHP]]


====== PHP nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2011-2020
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== Bevezetés =====

**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 sajátosságai =====

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.


===== Gyakorlat 001 =====

Válaszoljon a következő kérdésekre:
  - Mi a PHP alkotójának neve?
  - Mikor kezdődött a PHP fejlesztése?
  - Mi volt az első PHP változat neve?
  - Milyen eszköz került a PHP 2.0 végleges verzióba?
  - Mikor jött ki a 3.0 PHP változat?
  - Kis és nagybetűérzékeny-e a PHP nyelv?



===== Helló Világ =====

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

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

</code>

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:
<code php index.php>
<?php
  echo("Helló Világ");

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

===== Megjegyzések =====

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:
<code php>
/* több
   soros
   megjegyzés
 */
</code>

Egysoros:
<code php>
//egysoros megjegyzés
</code>

Másik egysoros:
<code php>
# egysoros megjegyzés
</code>



A megjegyzések, utasítások után is írhatók:
<code php>
<?php
echo 348000*2; //megjegyzés
</code>

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

Megjegyzés beágyazása utasításba:
<code php>
echo(3 * /* köztes megjegyzés */ 6);
</code>


===== Kiíratás =====

<code php>
echo "Szöveg";
</code>

<code php>
print "Szöveg";
</code>

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.
<code php>
echo 45;
print 35;
</code>


Az echo és a print használható zárójellel is. 
<code php>
echo(45);
echo("Helló Világ");
print("45");
</code>

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.

==== Kifejezések ====

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:
<code php>
$eredmeny = $szam;
</code>

De ha vannak körülötte operátorok is, akkor már igen:
<code php>
$eredmeny = ++$szam;
$eredmeny = $szam + 2;
</code>

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.

<code php>
echo 2 * 3;
print 384000 * 4;
</code>


===== Gyakorlat 002 =====
Válaszoljon a következő kérdésekre:
  - Mi a szerepe egy PHP programban a következő öt karakternek: <?php
  - Mi a szerepe egy PHP kódban a következő két karakternek: ?> 
  - 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ő
  - Hogyan lehet egysoros megjegyzést tenni PHP-ban?
  - Hogyan lehet többsoros megjegyzést tenni PHP-ban?
  - Írjon minimum két utasítást, amellyel kiíratás végezhető PHP nyelven.

===== HTML-be ágyazva =====

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.
          
<code html index.php>

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

</code>

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.



===== Escape szekvenciák =====

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. 
<code php>
<?php
echo("merengés");
</code>

Most tegyünk egy "\" karakter az "n" karakter elé:
<code php>
<?php
echo("mere\ngés");
</code>

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:
<code php index.php>
<?php
  echo("Helló<br />Világ");
?>

</code>

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. :
<code php index.php>
<?php
echo("Helló\tVilág");
?>
</code>

^  Escape szekvenciák ^^
^  Szekvencia  ^  Jelentés  ^
|  \n  | új sor (LF vagy 0x0A (10) az ASCII táblában) |
|  \r  | kocsi vissza (CR vagy 0x0D (13) az ASCII táblában) |
|  \t  | vízszintes tabulátor (HT vagy 0x09 (9) az ASCII táblában) |
|  \v  | függőleges tabulátor (VT vagy 0x0B (11) az ASCII táblában) (PHP 5.2.5 verziótól) |
|  \e  | escape (ESC vagy 0x1B (27) az ASCII táblában) (PHP 5.4.0 verziótól) |
|  \f  | lapdobás (FF vagy 0x0C (12) az ASCII táblában) (PHP 5.2.5 verziótól) |
|  <nowiki>\\</nowiki>  | backslash  |
|  \$  | dollárjel |
|  <nowiki>\"</nowiki>  | idézőjel |
|  \[0-7]{1,3}  | megegyezik a szabályos kifejezésekben szereplő oktális jelzéssel |
|  \x[0-9A-Fa-f]{1,2}  | megegyezik a szabályos kifejezésekben szereplő hexadecimális jelzéssel |


===== Gyakorlat 003 =====
Válaszoljon a következő kérdésekre. 
  - Milyen kiterjesztést kap az állomány, ha HTML kódba ágyazzuk a PHP kódot?
  - Mire való a \n escape szekvencia?
  - Mire való a \t escape szekvencia?
  - Mire való a \" escape szekvencia?
  - Mi íródik a böngészőbe weblap szinten a következő utasítás hatására:
    * echo "alma\nkörte";
  - 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";
  - Mi íródik a böngészőbe weblap szinten a következő utasítás hatására:
    * echo "alma<br>körte";
  - 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:
  - A program írja ki egymás alá a következő településneveket: 
    * Miskolc, Szolnok, Szeged, Hatvan


===== HTML oldal generálása =====

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:

<code html index.html>
<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
<title>Cím</title>
</head>
<body>


<p>Helló Világ</p>

</body>
</html>

</code>

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:





<code php 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>";

?>
</code>

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:


<code php 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;

?>

</code>

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 <nowiki><<<EOT</nowiki>" 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!

===== Típusok =====

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:
<code php>
<?php
$szam = 35;
echo gettype($szam);
</code>

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:

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

Ha egy karaktert teszek a $karakter változóba, akkor az string típus lesz:
<code php>
<?php
$kar = 'a';
echo gettype($kar);
</code>

Ha több karaktert teszünk bele az is karakter típus lesz:
<code php>
<?php
$kar = 'alma';
echo gettype($kar);
$kar = "körte";
echo gettype($kar);
</code>

Az $igaz nevű változóba a true értéket téve, boolean típust kapunk:
<code php>
<?php
$igaz = true;
echo gettype($igaz);
</code>

A típus kiíratására használható még a var_dump() függvény:
<code php>
<?php
$adat = 35;
echo(gettype($adat));
echo "<br>";
var_dump($adat);
</code>

==== Egyéb típusok példái ====


A tömb típus:
<code php>
<?php
$tomb[0]=30;
$tomb[1]=35;
echo gettype($tomb);
?>
</code>

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:
<code php>
<?php
class Dolgozo {
    public $nev = 'Névtelen';
    public $kor = 35;
}

$janos = new Dolgozo();

echo gettype($janos);
?>
</code>

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

Erőforrástípus példa:
<code php>
<?php
$img = imagecreatefrompng("kep.png");
echo($img);
</code>

NULL típus:
<code php>
<?php
$adat = NULL;
echo(gettype($adat));
</code>

===== Változók használata =====

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:

<code php>
$szam = 35;
</code>

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.

<code php 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>";


?>

</code>

Szöveg megadása:
<code php>
$nev = "Nagy János";
</code>
vagy:
<code php>
$nev = 'Nagy János';
</code>

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

==== Érvényes változónevek ====
<code php>
$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
</code>

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

<code php>
<?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;
?>
</code>

==== Számok ====

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.


=== Egész számok ===


<code php>
$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)
</code>


===  Valós számok ===

<code php>
$a = 1.234;  //fixpontos szám
$a = 1.2e3;  //lebegőpontos szám
</code>





===== Gyakorlat 004 =====

  * 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.




===== Konstansok =====
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ó.



==== Előre definiált konstansok ====
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.

<code>
__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
</code>

Az előre definiált konstansokat kiírathatjuk a következő paranccsal:
  print_r(get_defined_constants());

==== Saját állandó definiálása ====

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

<code php>
define("MAX", 300);
</code>

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. 


<code php>
const MAX = 300;
</code>


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

===== Gyakorlat 005 =====

==== Gyakorlat ====

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

|  832  |  834  |

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

|  0384  |  038  |

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

|  0xa8  |  0xbc  |

  * 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?


 
 


===== Operátorok használata =====
==== Az operátorokról ====

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ő.


==== Aritmetikai operátorok ====


^  Operator  ^  Név  ^  Leírás  ^  Példa  ^  Visszatérési érték  ^
|  x + y  | Összeadás  |  x és y összege  |  2 + 2  |  4  |
|  x - y  | Különbség  |  x és y különbsége  |  5 - 2  |  3  |
|  x * y  | Szorzat  |  x és y szorzata  |  5 * 2  |  10  |
|  x / y  | Osztás  |  x és y hányadosa  |  15 / 5  |  3  |
|  x % y  | Modulus  |  x és y osztás maradéka |  5 % 2 \\ 10 % 8 \\ 10 % 2  |  1 \\ 2 \\ 0  |
|  - x    | Negáció  | x ellentéte |	- 2  |  |
|  a . b  | Konkatenáció | két sztring összefűzése | "Hi" . "Ha" |  HiHa   |



<code php index.php>
<?php
print 5 * 3;
?>
</code>


==== Értékadó operátorok ====


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:
<code php>
$x = 5;
</code>



^  Értékadás  ^  Jelentése  ^  Leírás  ^
|  x = y  |  x = y       | A baloldali operátor felveszi a jobboldali kifejezés értékét |
|  x += y  |  x = x + y  | Összeadás  |
|  x -= y  |  x = x - y  | Kivonás  |
|  x *= y  |  x = x * y  | Szorzás  |
|  x /= y  |  x = x / y	 | Osztás  |
|  x %= y  |  x = x % y	 | Maradékok |
|  a .= b  |  a = a . b	 | Két karaktersorozat összefűzése |


==== Inkrementáló/Dekrementáló operátorok ====


^  Operátor  ^  Név  ^  Leírás  ^
|  ++ x  | Pre-increment | Előbb növeli x értékét, majd visszaadja x értékét |
|  x ++  | Post-increment | Visszatér x érétkével, majd növeli x-et. |
|  <nowiki>--</nowiki> x  | Pre-decrement  | Csökkenti x értékét eggyel, majd visszatér x-el |
|  x <nowiki>--</nowiki>  | Post-decrement | Visszatér x-el, majd csökkenti x értékét |

==== Összehasonlító operátorok ====

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


^  Operátor  ^  Név  ^  Leírás  ^  Példa  ^
|  x == y  | Equal          | True ha x és y egyenlő | 5==8 false értékkel tér vissza |
|  x === y | Identical      | True ha x és y egyenlő és azonos típusúak | 5==="5" false értékkel tér vissza |
|  x != y  | Not equal      | True ha x és y nem egyenlő | 5!=8 true értékkel tér vissza |
|  x <> y  | Not equal      | True ha x és y nem egyenlő | 5<>8 true értékkel tér vissza |
|  x !== y  | Not identical  | True ha x és y nem egyenlő vagy nem azonos a típusuk | 5!=="5" true értékkel tér vissza |
|  x > y   | Greater than   | True ha x nagyobb mint y | 5>8 false értékkel tér vissza | 
|  x < y   | Less than      | True if x kisebb mint y | 5<8 true értékkel tér vissza  |
|  x >= y  | Greater than vagy equal to | True ha x nagyobb vagy egyenlő mint y | 5>=8 false értékkel tér vissza |
|  x <nowiki><=</nowiki> y  | Less than vagy equal to    | True ha x kisebb vagy egyenlő mint y | 5<=8 true értékkel tér vissza |

==== Logikai operátorok ====



^  Operátor  ^  Név  ^  Leírás  ^  Példa  ^
|  x and y  |  And  | Igaz ha mindkettő, azaz x és y is igaz | x=6  \\  y=3 \\  (x < 10 and y > 1) returns true  |
|  x or y   |  Or   | Igaz ha egyik vagy mindkettő igaz | x=6  \\ y=3  \\ (x==6 or y==5) returns true  |
|  x xor y  |  Xor  | Igaz, ha az egyik x vagy y igaz; de ha mindkettő igaz, az eredmény hamis | x=6 \\ y=3 \\ (x==6 xor y==3) returns false |
|  x && y   |  And  | Igaz ha mindkettő, azza x és y is igaz | x=6  \\  y=3  \\  (x < 10 && y > 1) returns true  |
|  x <nowiki>||</nowiki> y   |  Or   | Igaz ha egyik vagy mindkét, x és y is igaz | x=6 \\ y=3  \\  (x==5 <nowiki>||</nowiki> y==5) returns false  |
|  ! x      |  Not  | Igaz ha x nem igaz | x=6 \\ y=3 \\ !(x==y) returns true |


==== Tömboperátorok ====


^  Operátor  ^  Név  ^  Leírás  ^
|  x + y   |  Unió  | x és y uniója |
|  x == y  |  Equality  | True ha x és y azonos kulcs/érték párral rendelkezik |
|  x === y  |  Identity  | True ha x és y azonos kulcs/érték párral rendelkezik, egyező sorrendben és a típusuk is megegyezik |
|  x != y   |  Inequality  | True ha x nem egyenlő y-l |
|  x <> y   |  Inequality  | True ha x nem egyenlő y-l |
|  x !== y  |  Non-identity  | True ha x nem egyenlő y-l |

===== Gyakorlat 006 =====

  * 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?


===== Szintaxis =====

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.


===== Formázott kivitel =====

==== printf függvény ====

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

Szintaxis:
<code php>
int printf ( string $format [, mixed $args [, mixed $... ]] )
</code>



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");


==== Formátumkarakterek ====

|  %%  | Százalékjelet ír |
|  %b  | Bináris szám |
|  %c  | Egy ASCII érték karakter megfelelője |
|  %d  | Előjeles decimális szám |
|  %e  | Tudományos alak (pl.: 1.2e+2) |
|  %u  | Előjel nélküli decimális szám |
|  %f  | Lebegőpontos szám (a helyi beállításokat figyelembe veszi) |
|  %F  | Lebegőpontos szám (a helyi beállításokat nem veszi figyelembe) |
|  %o  | Oktális szám |
|  %s  | String |
|  %x  | Hexadecimális szám (kisbetűs) |
|  %X  | Hexadecimális szám (nagybetűs) |


==== Egyéb módosítók ====
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:

|  +  | Számok előtt a plusz jel kiíratása |
|  '  | Mit használjunk kitöltőnek A %'x20s például az "x" karakterrel tölt ki |
|  -  | Balra igazítás |
|  [0-9] | A kiíratás szélessége |
|  .[0-9]  | A tizedesjegyek száma |


==== Példák ====

Példa1:
<code php>
$str = "Helló";
$szam = 123;
printf("%s Világ. A nap száma: %u", $str, $szam);
</code>

Kimenet:
<code>
Helló Világ. A nap száma: 123 
</code>



Példa2:
<code php>
$number = 123;
printf("%f",$number);
</code>

Kimenet:
<code>
123.000000 
</code>

===== Gyakorlat 007 =====

  * 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.

===== Matematikai függvények =====

==== abs() ====
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:
<code php>
$absErtek = abs(-54);
echo "$absErtek\n";
</code>



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

Példa:

<code php>
echo ceil(4.1) . "\n";
</code>

Eredmény:
  5


==== cos() ====

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

  float cos ( float $arg )


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




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

<code php>
$szog = 30;
$rad = deg2rad($szog);
echo sin($rad) . "\n";
</code>


==== exp() ====
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. 
<code php>
echo exp(8) . "\n";
</code>



==== floor() ====

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


Példa:
<code php>
$a = 4.9;
print floor($a);
</code>

Eredmény:
  4




==== log10() ====

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



Példa:
<code php>
echo log10(3);
</code>

==== log() ====

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 ] )


<code php>
echo log(3);
</code>

==== max() ====

A legnagyobb érték kiválasztása:
  max ( array $values ) : mixed

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


<code php>
$tomb = array(3, 9, 4, 5);
echo max($tomb) . "\n";
</code>


<code php>
$a1 = 35;
$a2 = 72;
$a3 = 18;
$a4 = 29;

echo max($a1, $a2, $a3, $a4) . "\n";
</code>

==== min() ====

A legkisebb érték kiválasztása
  mixed min ( array $values )

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


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

  float pi ( void )

Használata, például:

<code php>
$szog = 30;
$rad = $szog * pi() / 180;
</code>


==== pow() ====

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. 
<code php>
echo pow(2, 8) . "\n";
</code>


==== rad2deg() ====


  float rad2deg ( float $number )

==== round() ====

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:


|  val  | A kerekítendő érték |
|  precision  | Opcionálisan megadható precizitás |
|  mode  | A következő közül egy: PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN vagy PHP_ROUND_HALF_ODD |


Példa:
<code php>
$szam1 = 3.4;
$szam2 = 3.6;

echo round($szam1);
echo "<br>";
echo round($szam2);
</code>

Pontosság megadására példa:
<code php>
$szam1 = 3.12345;
echo round($szam1, 3);
</code>
Eredmény:
  3.123


==== sin() ====
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:
<code php>
$szog = 1;
$rad = $szog * pi() / 180;
echo sin($rad);
</code>



==== sqrt() ====

Gyökvonás.

  float sqrt ( float $arg )

<code php>
echo sqrt(9) . "\n";
</code>


==== tan() ====

Egy szám tangensét adja. Paraméterként radiánt kell megadni. Szintaxisa:
  float tan ( float $arg )



Példa:
<code php>
$szog = 1;
$rad = $szog * pi() / 180;
echo tan($rad);
</code>

===== Gyakorlat 008 =====

  * Í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. 




===== Véletlen szám =====
==== Prototípusok ====

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 )


==== Véletlen szám generálás példa  ====

<code php>
$kocka = rand(1, 6);
</code>

<code php>
$lottoszam1 = rand(1, 90);
</code>

<code php>
srand(mktime());
$a = rand(1, 6);
print $a;
</code>

Eredmény:
<php>
srand(mktime());
$a = rand(1, 6);
print $a;
</php>
===== Gyakorlat 010 =====

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

===== Konverzió =====

==== string egésszé ====

A string típussal is tudunk számolni:

<code php>
$szamStr = "35";
echo $szamStr * 2;
</code>

Ha szeretnénk tényleges egésszé konvertálni:
<code php>
$szamStr = "35";
$szam = intval($szamStr);
echo gettype($szam);
</code>


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

<code php>
$szamStr = "35.123";
$szam = floatval($szamStr);
echo gettype($szam);
</code>

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

==== Szám sztringgé ====

Az strval() függvény egy értéket sztring típussá alakít.
<code php>
$szam = 35;
$szamStr = strval($szam);
echo gettype($szamStr);
</code>

==== decbin() ====

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

<code php>
echo decbin("8");
</code>

Kimenet:
  1000

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

Példa:
<code php>
echo dechex("11");
</code>

Kimenet:
  b



==== decoct() ====
A decoct() egy decimális számot oktálissá alakít. Szintaxisa:
  string decoct ( int $number )


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


==== octdec() ====

  number octdec ( string $octal_string )






===== Bekérés =====
==== Egyetlen script ====

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.

<code php index.php>
$szam = $_GET['szam'];
print "Ezt irtad: $szam";
</code>

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. 

==== Két PHP script ====

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:

<code php 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;
</code>

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. 
==== GET metódus példák ====
=== Példa 01 ===
Í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.

<code php sum.php>
<?php
$szam1 = $_GET['szam1'];
$szam2 = $_GET['szam2'];

$osszeg = $szam1 + $szam2;

echo "Összeg: $osszeg";
</code>

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




=== Példa 02 ===

Í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.

<code php 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;


</code>


<code php szorzas.php>
<?php

$szam1 = $_GET['szam1'];
$szam2 = $_GET['szam2'];

$szorzat = $szam1 * $szam2;

echo "Szorzat: $szorzat";


</code>

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/

==== POST metódus ====

É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. 



==== POST metódus példák ====

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

<code php 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;
</code>


<code php szorzas.php>
<?php

$szam1 = $_POST['szam1'];
$szam2 = $_POST['szam2'];

$szorzat = $szam1 * $szam2;

echo "Szorzat: $szorzat";

</code>

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


<code php>
// 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);
</code>

==== Gyakorlás 011 ====

  * Í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
===== Szelekció =====

==== Szelekció egyszerűen ====

Az if szelekció szintaxisa:

<code php>
if (feltétel)
     utasítás;
</code>

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. 

<code php>
if (feltétel) {
     utasítás1;
     utasítás2;
}
</code>

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.

<code php index.php>
$elso = 45;
$masodik = 35;
if($elso > $masodik) {
    echo "Az első nagyobb";
}
</code>



==== Ellenben használata ====
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.

<code php>
if (feltétel)
     utasítás;
else
     utasítás;
</code>


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

<code php>
if (feltétel) {
     utasítás1;
     utasítás2;
     
     utasításn;
} else {
     utasítás1;
     utasítás2;
     
     utasításn;
}
</code>


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";


<code php>
$szam1 = 30;
$szam2 = 35;

if ($szam1 > $szam2) {
     echo "Az első nagyobb";
} else {
     echo "Egyenlő vagy kisebb";
}
</code>

==== Szelekció példa ====

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

<code php 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;

</code>


<code php 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;


</code>
==== Többágú szelekció (if) ====


<code php>
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;
}
</code>

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".


<code php fel.php>

$szam = $_GET['szam'];

if ($szam > 0) {
    echo "Pozitív";
}
elseif ($szam < 0) {
    echo "Negatív";
}else {
    echo "Nulla";
}
</code>



==== Több ágú szelekció (switch) ====


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


<code php 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";
?>

</code>

===== Gyakorlás 012 =====

  * Í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
===== Iteráció =====
==== Növekményes ciklus ====


<code php>
for (indulóérték; feltétel; növekedés) {

}
</code>


Példa:
<code php>
for($i=0; $i<5; $i++) {
	print "alma<br>";
}
</code>


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

<code php>
while(feltétel) {
    utasítás1;
    utasítás2;
    utasítás3;
}
</code>


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.

<code php>

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

</code>


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

<code php>
do {
    utasítás1;
    utasítás2;
    ...
    utasításn;
} while (feltétel);
</code>

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



<code php>

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


==== Iterátor ====

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.

<code php>
foreach ($tomb as $elem){
    echo $elem;
}
</code>




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

<code php>
$jarmu[0]="Kia";
$jarmu[1]="Volvo";
$jarmu[2]="Opel";
$jarmu[3]="Toyota";
</code>


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


<code php>

$tomb[] = "alma";
$tomb[] = "szilva";
$tomb[] = "körte";
$tomb[] = "barack";
</code>


A tömb összes elemet kiírathatjuk a print_r() függvénnyel.
<code php>
print_r($tomb);

</code>

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

==== Asszociatív tömbök ====

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

Általánosan:
<code>
array(  kulcs =>  érték
     , ...
     )
</code>

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


==== Az array() függvény ====

<code php>      
<?php

$tomb = array("nev" => "Joska", 2 => true);

echo $tomb["nev"];
echo $tomb[2];
?>
</code>

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

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


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


==== Többdimenziós tömbök ====

<code php>
$csaladok = array(
      "Nagy"=>array
      (
          "Páter",
          "Laci",
          "Magdi"
      ),
      "Kiss"=>array
      (
          "Gábor"
      ),
      "Barna"=>array
      (
          "Tamás",
          "Lori",
          "István"
      )
);

echo $csaladok['Barna'][2];

</code>


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

Bejárás:
<code php>
foreach($termekek as list($termek, $ar, $mennyiseg)) {
	echo "$termek $ar $mennyiseg<br>";
	
}
</code>


<code php>
$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'];
</code>

==== end() ====

A tömb utolsó elemét adja

  $tomb = array(3, 9, 4, 5);
  print end($tomb);
Eredmény:
  5


==== sort() ====
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 ) 

==== asort() ====
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 )



==== count() ====

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

==== array_push() ====

  array_push(array,value1,value2...)

<code php>
$tomb = array();
array_push($tomb, $valtozo);
</code>

<code php>
$tomb = array();
array_push($tomb, 45);
array_push($tomb, 28);
array_push($tomb, 87, 23, 21);
</code>

<code php>
$tomb = array("alma", "körte");
array_push($tomb, "barack", "szilva");
</code>

  * 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);


<code php>
<?php

$tomb = array(3, 4, 8);
array_push($tomb, 45);
$elem = array_pop($tomb);

echo "Elem: $elem\n"; //45
</code>


==== list() ====

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

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

</code>

===== Karakterek =====

==== chr ====


Adott kódú karaktert add vissza
<code php>
print chr(97);
</code>
Eredmény:
  a

==== ord ====
<code php>
print ord("a");
</code>
A futtatás eredménye:
  97



==== Whitespace karakterek levágása ====

chop, rtrim

Whitespace vagy más karaktert levág
<code php>
$ujsz = chop($sz);
$ujsz = chop($sz, "\n");
</code>

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


===== Karaktersorozatok a PHP-ban =====

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

Aposztróffal:
<code php>
$a = 'lorem ipsum dolorest amet';
</code>

Idézőjel:
<code php>
$a = "lorem ipsum dolorest amet";
</code>



Heredoc szintaxissal:
<code php>
$s = <<<EOT
első sor
második sor ...
EOT;
</code>


Nowdoc szintaxissal:
<code php>
$str = <<<'EOD'
első sor
második sor ...
EOD;
</code>
Ez utóbbi esetben a változók nem kerülnek behelyettesítésre.

==== Heredoc és nowdoc szintaxisról ====

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

<code php>
echo <<<EOT
első sor
második sor
harmadik sor
EOT;
</code>

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.

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


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:


<code php>
echo <<<VEGE
első sor
második sor
harmadik sor
VEGE;
</code>

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


<code php>
$szoveg = <<<EOT
első sor
második sor
harmadik sor
EOT;
</code>

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

<code php>
$nev = "Nagy János";
$kor = 35;
$telepules = "Szolnok";

echo <<<EOT
Név: $nev<br>
Életkor: $kor<br>
Település: $telepules<br>
EOT;
</code>

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.

<code php>
echo <<<'EOT'
első sor
második sor
harmadik sor
EOT;
</code>


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.
===== Sztring műveletek =====

==== Összefűzés ====

<code php>
$a = "Para ";
$b = $a . "Para";
$a = "Dárdarázó ";
$a .= "Villmos";
</code>

==== Karaktersorozat változók ====


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

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



==== Sztringkezelő függvények ====

| int strlen ( string $string ) | A $string hosszát adja |
| int strpos ( string $tarolo , mixed $keresett [, int $eltolas = 0 ] ) | Egy karaktersorozat első előfordulását keresi egy másik karaktersorozatban |

<code php>
$str = 'almafa';
$meret = strlen($str);
</code>

==== substr ====

A sztring egy részével tér vissza
<code php index.php>
<?php

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

</code>


=== Negatív start ===

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


==== Karaktersorozat darabolása ====

=== preg_split ===


Sztringet darabol fel reguláris kifejezésre illeszkedő részei mentén
<code php>
$sz =”joska:titok”;
$szavak = preg_split('/:/', $sz);
print $szavak[0];
print $szavak[1];
</code>

=== explode ===


<code php>
<?php

$userData = "janos:titok";

$tomb = explode(":", $userData);

echo "Felhasználó: $tomb[0]\n";

</code>

==== Vissza-perjel hozzáadása ====

<code php>
<?php
$str = "I'm a bird";

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

Vagy Who's Nagy Péter? Stb.

==== Karakterek keverés ====

<code php>
$str = 'abcdef';
echo str_shuffle($str);
</code>

<php>
$str = 'abcdef';
echo str_shuffle($str);
</php>

==== Tömb karaktersorozattá ====

<code php>
<?php

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

</code>
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.


==== Karaktersorozat bejárása ====

<code php>
<?php

$str = "alma";

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

</code>

<code php>
<?php

$str = "alma";
$tomb = str_split($str);

foreach($tomb as $elem) {
    echo "$elem\n";
}

</code>


==== Szövegcsere ====

  str_replace(mit; mire; miben);

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


===== Fájlkezelés =====

==== Megnyitás ====

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
<code php>
  $fkezelo = fopen("filenev.txt", "r");
</code>


Megnyitás módjai
^ Mód ^ Leírás ^
|  r  | csak olvasás, mutató fájl elején  |
|  r+  | olvasás/írás, mutató fájl elején  |
|  w  | csak írás, mutató fájl elején, törli a fájl tartalmát, ha nem létezik, létrehozza  |
|  w+  | olvasás/írás, mutató fájl elején, törli a fájl tartalmát, ha nem létezik, létrehozza  |
|  a  | csak írás, mutató a fájl végén, ha nem létezik, létrehozza  |
|  a+  | olvasás/írás, mutató a fájl végén, ha nem létezik létrehozza  |
|  x  | csak írás, mutató a fájl elején, ha a fájl már létezik, az fopen sikertelen (FALSE)  |
|  x+  | olvasás/írás, mutató a fájl elején, ha a fájl már létezik, az fopen sikertelen (FALSE)  |


==== Fájl bezárása ====
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:
<code php>
fclose($fkezelo);
</code>



==== Fájl végének vizsgálata ====


Az feof() függvény használata:
<code php>
while (!feof($fkezelo)) {
  // a ciklus törzse
}
</code>


==== Olvasás fájlból ====


Az fgets függvény használata
  $sor = fgets($fkezelo);

==== Olvasás fájlból másként ====

<code php>
$filename = "adat.txt";
$fp = fopen($filename, "r");

$content = fread($fp, filesize($filename));
$lines = explode("\n", $content);
print_r($lines);

fclose($fp);
</code>
==== Fájl megnyitása írásra ====


A "w" mód használata:
<code php>
$fkezelo = fopen(”filenev.kit”, ”w”);
</code>

==== Hozzáfűzés fájlhoz ====

Fájl megnyitása hozzáfűzésre a "a" mód megadásával lehetséges.
<code php>
$fkezelo = fopen(”filenev.kit”, ”a”);
</code>



==== Írás a fájlba ====

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. 

<code php>
fputs($fkezelo, "alma");
</code>

==== Beolvasás és kiírás egyetlen utasítással ====

<code php>
$tartalom = file_get_contents('adat.txt');

file_put_contents('adat.txt', $adatok);
</code>









===== Függvény általánosan =====


==== A függvényekről általában ====


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

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);


==== Függvény példa ====


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

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.


==== Tömb visszaadása ====

<code php>
<?php

function leker() {
    $tomb = array("alma", "körte", "szilva", "barack");
    return $tomb;
}


$a = leker();

var_dump($a);

?>

</code>


==== Rekurzió ====

<code php>
<?php

ir(0);

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

?>
</code>

==== Beágyazott függvény ====

<code php>
<?php

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

elso();

masodik();

?>

</code>

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

==== Feltételesen definiált függvény ====

<code php>
<?php

$mehet=true;

if($mehet) {
	function fg() {
		print "Függvény\n";
	}
}

fg();

?>

</code>


==== Változók hatásköre ====
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.

<code php index.php>
<?php
$a = 3;
$b = 4;

osszead();
echo $b . "\n";

function osszead() {
    global $a, $b;

    $b = $a + $b;
} 
?>
</code>


Így is lehet:
<code php index.php>
<?php
$a = 3;
$b = 4;

osszead();
echo $b . "\n";

function osszead() {
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

?>
</code>

===== Hibaszintek =====
==== Rendszer szinten ====

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ő:
<code path>
/etc/php5/apache2/php.ini
</code>

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:
<code php>
error_reporting = E_ALL & ~E_NOTICE
</code>

Vagy így:
<code php>
error_reporting = E_ALL
</code>


==== PHP scriptben ====

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:
<code php>
<?php
error_reporting(E_ALL);
?>
</code>

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



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


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


E_NOTICE:
<code php>
// 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);
</code>

Kivétel:
<code php>
// 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);
</code>


Minden hiba:
<code php>
// 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);
</code>


Hibaszint állandók:
^  érték  ^  konstans  ^
|  1  | E_ERROR |
|  2  | E_WARNING |
|  4  | E_PARSE |
|  8  | E_NOTICE |
|  16  | E_CORE_ERROR |
|  32  | E_CORE_WARNING |
|  64  | E_COMPILE_ERROR |
|  128  | E_COMPILE_WARNING |
|  256  | E_USER_ERROR |
|  512  | E_USER_WARNING |
|  1024  | E_USER_NOTICE |
|  2048  | E_STRICT (PHP5-től)|


==== Az ini_set függvénnyel ====

PHP scriptben a init_set() függvény is használható:
<code php>
ini_set('display_errors', 'Off');
ini_set('display_startup_errors', 'Off');
</code>

==== A "@" elöljáró ====

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:

<code php>
@htmlhead("Cím")
</code>


==== A .htaccess fájlban ====


A hibaszintek beállíthatók a .htaccess fájlban is. Például:
<code htaccess>
php_flag display_errors off
</code>


A htaccess fájlban még idevonatkozó használható beállítások:
<code htaccess>
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
</code>


==== Hiba fájlbaírása ====

<code php>
ini_set("log_errors", 1);
ini_set("error_log", "php-error.log");
error_log("Itt egy saját hibaüzenet");
</code>
Figyelem! Az állomány írható kell legyen!


Esetleg a /tmp könyvtárba:
<code php>
ini_set("log_errors", 1);
ini_set("error_log", "/tmp/php-error.log");
error_log("Itt egy saját hibaüzenet");
</code>

===== Más állományok használata =====
==== Másik állomány beemelése ====

A következő utasítások állnak rendelkezésünkre:
  * include
  * require
  * include_once
  * require_once

==== Különbségek ====


  * 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.


==== Használat ====


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:

<code php>
include fájlnév;
</code>

<code php>
require fájlnév;
</code>


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
<code php>
<?php
    include ”fg.php”
    kiir();
?>
</code>




Ha egy könyvtárral feljebb kell hivatkozni:
<code php>
<?php
    include dirname(dirname(__FILE__)) . '/fg.php';
    
    kiir();
?>
</code>
==== INC fájlok ====

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:
<file php 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>
</file>


===== Globális változók használata =====

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.

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



===== Grafika =====
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);
  ?>




===== Oszlopdiagram =====


  <?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);
    
  ?>