Piemērs

<body>
      <h1><?php echo 'Sveiciens!'; ?></h1>
</body>

<body>
      <h1>Sveiciens!</h1>
</body>

Komentāra piemērs

<?php
      // C++ stila vienas rindas komentārs
      echo 'Šis teksts tiek izvadīts'; // bet šo interpretators ignorē
      /* bloka komentārs,
         kas uzrakstīts pa
         vairākām rindām */
?>

Mainīgie

  • Derīgi mainīgo nosaukumi: 
$mainigais
$ShisIr1MainigaisArCiparu
$_mainigais_ar_zemsvitru
  • Nederīgi mainīgo nosaukumi: 
$1mainigais_ar_ciparu_sakuma
$mainigais-ar-neatlautiem-simboliem

Skaitļi

  • integer - vesels skaitlis, kura vērtību var norādīt decimālajā, oktālajā vai heksadecimālajā skaitīšanas sistēmā. 
$a = 1234; // decimāls skaitlis
$a = -123; // a negatīvs skaitlis
$a = 0123; // octāls skaitlis (vienāds ar 83 decimālajā sistēmā)
$a = 0x1A; // hexadecimāls skaitlis (26 – decimālajā sistēmā)

Skaitļi

  • float - decimāldaļskaitlis, kura vērtību var norādīt trīs dažādos pierakstos, kas visi ir decimālajā skaitīšanas sistēmā. 
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;

Iebūvētie aritmētiskie operatori

$summa = 1 + 2;	//mainīgā vērtība: 3
$starpiba = 1 – 2;	//vērtība: -1
$reizinajums = 1 * 2;	//vērtība: 2
$dalijums = 1 / 2;	//vērtība: 0.5
$modulis = 1 % 2;	//vērtība: 1

Apvienota piešķiršana un aritmētikas operācijas

$a++; //palielina $a vērtību par 1
$a--; //samazina $a vērtību par 1
$a += $b;  //dara to pašu ko $a = $a + $b
$a -= $b;  //dara to pašu ko $a = $a - $b
$a *= $b;  //dara to pašu ko $a = $a * $b
$a /= $b;  //dara to pašu ko $a = $a / $b
$a %= $b;  //dara to pašu ko $a = $a % $b

Boolean

Boolean - var saglabāt tikai divas vērtības - patiess un nepatiess 
$navPatiesiba = false;
$navPatiesiba = 0; //nulle ir līdzvērtīga False;
$irPatiesiba = true;
$irPatiesiba = 1; //jebkurš cipars, kas atšķiras no 0, tai skaitā
				  //negatīvs tiek uztverts kā TRUE

Loģiskie operatori

Operators Pielietojums Apraksts
&& $a && $b “un” operators atgriež vērtību true, ja $a un $b abi ir true
|| $a || $b “vai” atgriež true, ja vismaz viens no mainīgajiem ir true
xor $a xor $b “xor” atgriež true, ja tikai viens no mainīgajiem ir true, bet otrs false

Loģiskie operatori

Operators Pielietojums Apraksts
! ! $a “ne” atgriež pretējo vērtību, ja $a ir true, tad ! $a ir false, un otrādi

Loģiskie operatori

$rej = true; //dzīvnieks rej
$njaud = false; //dzīvnieks ņaud

$irMajdzivnieks = $rej || $njaud; //vērtība: true
//Ja dzīvnieks ņaud vai rej, tad tas ir mājdzīvnieks.

$irSuns = $irMajdzivnieks && $rej; //vērtība: true
//Ja dzīvnieks ir majdzivnieks un tas rej, tad tas ir suns.

Loģiskie operatori

$irMezaZvers = ! $irMajdzivnieks; //vērtība: false
//Ja dzīvnieks nav mājdzivnieks, tad tas ir meža zvērs.
//Šajā gadījumā tas ir mājdzīvnieks, tādēļ $mezaZvers ir nepatiess.

$navKluda = $irMezaZvers xor $irMajdzivnieks //vērtība: true
//Dzīvnieks var būt tikai meža vai tikai māju, citādi sistēmā ir
//ieviesusies kļūda.


$s = 'simbolu virkne';  //vērtība: simbolu virkne
$s = 'satur (\') apostrofu';  //vērtība: satur (') apostrofu
$s = 'ar slīpsvītru\\';  //vērtība: ar slīpsvītru\
$s = 'ar \ slīpsvītru';  //vērtība: ar \ slīpsvītru
$s = 'ar \\ slīpsvītru';  //vērtība: ar \ slīpsvītru
$s = '\\\\ 2 slīpsvītras!'; //vērtība: \\ 2 slīpsvītras
$s = 'kļūda ar slīpsvītru\'; //kļuda: syntax error, unexpected T_STRING
$s = 'kļūda ar ' apostrofu'; //kļuda: syntax error, unexpected T_STRING

Ar pēdiņām

Simboli Apraksts
\n Linefeed (LF) pārnes tekstu jaunā rindā - Unix un Windows OS
\r Carriage return (CR) pārnes tekstu jaunā rindā – Mac un Windows OS
\t Tabulēšanas simbols
\\ Slīpsvītra '\'

Ar pēdiņām

Simboli Apraksts
\$ Dolāra zīme '$'
\" Pēdiņas '"'
\[0-7]{1,3} Oktāls skaitlis, kas norāda attēlojamā simbola kodu (\101 = A)
\x[0-9A-Fa-f]{1,2} Heksadecimāls skaitlis, kas norāda attēlojamā simbola kodu (\x41 = A)

Ar pēdiņām

$a = "pasaule";
$s = "Sveika $a!";  //vērtība: Sveika pasaule!
$s = "100\$";  //vērtība: 100$
$s = "\x41\x42\x43";  //vērtība: ABC

Konkatenācijas operators

  • Teksta mainīgajiem ir tikai viens operators '.', ar kuru var apvienot divas string tipa vērtības. 
$a = "pasaule!";
$s = "Sveika" . $a; //vērtība: Sveika pasaule!

Salīdzināšanas operatori

1 == 1;       //vērtība: true
$a = "abc";   // NAV SALĪDZINĀŠANA!!!
$a == "abc";  //vērtība: true
$a != "abc";  //vērtība: false
3 < 2.9;      //vērtība: false
10 >= 10;     //vērtība: true

Salīdzināšanas operatori

"5" == 5; //vērtība: true
"5abc" == 5 //vērtība: true
//teksta virknes sākumā ir simbols 5 kuru PHP pārveido par skaitli
"4" === 4; //vērtība: false
"3" !== 3; //vērtība: true

Speciālie mainīgie

  • resource - šī tipa mainīgo vērtība ir saite uz ārējiem resursiem, kā atvērtas datnes, pieslēgums datubāzei.
  • Null - 'null' nav gluži mainīgā tips, bet speciāla vērtība, kas norāda, ka mainīgajam nav vērtības. 
$a == null; //vērtība: true
//Mainīgajam $a vēl nav piešķirta vērtība tādēļ $a == null ir patiess
$a == 0;  //vērtība: false
$a = "Labvakar!";  //vērtība: Labvakar!
$a = null;  //no mainīgā $a tika izdzēsta vērtība

Array

  • Sintakse 
array( [atslēga =>] vērtība
      , ...
)
  • Īsā sintakse 
[ [atslēga =>] vērtība
      , ...
]

Array piemērs

//vērtības var pievienot masīvam jau tā izveidošanas brīdī
$arr = array("vards" => "Jānis", 40 => 123); // pilnā sintakse
$arr = ["vards" => "Jānis", 40 => 123]; // īsā sintakse
$a = $arr["vards"]; //vērtība: Jānis
$a = $arr[40]; //vērtība: 123

//var izveidot arī tukšu masīvu un pievienot tam vērtības vēlāk
$arr2 = array(); // pilnā sintakse
$arr2 = []; // īsā sintakse
$arr2["vards"] = "Kaspars";

Array piemērs

//var pievienot jaunu masīvu, kā vērtību
//(veidot 2 un vairāk dimensiju masīvu)
$arr["mans_masivs"] = array("atslega1" => "vertiba1");

//tad vērtībai var piekļūt sekojoši
$a = $arr["mans_masivs"]["atslega1"]; //Rezultāts: vertiba1

Array

  • Ja kādai vērtībai indekss netiks norādīts, tad PHP automātiski izvēlēsies par indeksu lielāko indeksa sarakstā atrodamo veselo skaitli + 1.
  • Pēc noklusējuma indekss sākas ar 0. 
$arr = array("ābols", 4 => "banāns", "apelsīns");
$a = $arr[0];  //vērtība: ābols
$a = $arr[1];  //masīva elementam nav vērtības - $arr[1] == null
$a = $arr[4];  //vērtība: banāns
$a = $arr[5];  //vērtība: apelsīns

Dinamiskie mainīgie

  • PHP pieļauj arī skripta izpildes laikā dinamiski izveidot un izmantot jaunus mainīgos.
  • Pirms mainīgā vārda norādot divas dolāra zīmes '$', par mainīgā vārdu tiek uztverta norādītā mainīgā vērtība (string). 
$a = "Mans mainīgais";
$b = "a";
echo $$b; //Rezultāts: Mans mainīgais

Norādes uz mainīgo

  • Pēc būtības tas ir mainīgais, kura vērtība ir norāde uz cita mainīgā adresi un izsaucot tā vērtību nav nepieciešams likt priekšā vēl vienu '$' zīmi.
  • Jebkura mainīgā adresi var iegūt pirms mainīgā vārda norādot '&' simbolu. 
$a = "Mans mainīgais";
$b = &$a;
echo $b;	//Rezultāts: Mans mainīgais
$a = "Jauna vērtība"; echo $b;	//Rezultāts: Jauna vērtība

If – else

if (nosacījums) {
    komandu_bloks;
}
[ else {
	alternatīvais_komandu_bloks;
} ]

If – else

$a = 2;
$b = 0;
if ($a > $b){
      echo "a ir lielāks par b";
      $a++;
      $b--;
}
//Rezultāts:  a ir lielāks par b

If – else

$a = 5;
if ($a < 10){
      echo "a ir mazāks par 10 \n";
} else {
      echo "a ir lielāks vai vienāds ar 10 \n";
}
//Rezultāts:  a ir mazāks par 10

If – else

$a = 10;
if ($a < 10){
      echo "a ir mazāks par 10 \n";
} else if ($a > 10) {
      echo "a ir lielāks par 10 \n";
} else {
      echo "a ir vienāds ar 10 \n";
}
//Rezultāts: a ir vienāds ar 10

switch

switch(izteiksme){
case vērtība_1:
      komandu_bloks_1;
      break;
case vērtība_2:
      komandu_bloks_2;
      break;
default:
      komandas_ja_izteiksmes_vērtība_nesakrīt_ar_iepriekš_pārbaudītajām;
}

switch

$a = "qwerty";
switch($a){
case "abc":
      echo "Ābece";
      break;
case "vzž":
      echo "Pēdējie alfabēta burti!";
      break;
default:
      echo "Cits teksts";
}
//Rezultāts: Cits teksts

Nosacījuma operators - ?:

  • nosacījums ? vērtība_ja_patiess : vērtība_ja_nepatiess
  • '?:' operators darbojas līdzīgi kā if-else, taču tas nevar izpildīt komandu bloku, bet gan tikai atgriezt vērtību. 
$a = 5;
$b = ( $a>5 ? $a+100 : '$a nav lielāks par 5' );
echo $b;
//Rezultāts: $a nav lielāks par 5

Cikla operatori

  • Cikla operatori ļauj atkārtot kādu programmas daļu.
  • while ir cikla operators.
  • Tā sākumā ir norādīts nosacījums un pēc tam seko komandu bloks, kurš tiek atkārtoti izpildīts tik ilgi kamēr nosacījums ir patiess.
  • Ja nosacījums jau pašā sākumā nav patiess, tad komandu bloks netiek izpildīts vispār.

while

  • Sintakse 
while(nosacījums){
      komandu_bloks;
}
  • Piemērs 
$atzime = 5;
while($atzime < 10) {
    // kamer atzime mazāka par 10 – mācamies
	$a = $a + 1;
}
echo $a;
//Rezultāts: 10

do ... while

  • Sintakse 
do {
      komandu_bloks;
} while (nosacījums);
  • Piemērs 
$a = 1;
do {
      $a++;
} while ($a < 1);
echo $a;
//Rezultāts: 2

for

for (cikla_inicializēšanas_izteiksme; nosacījums; soļa_izteiksme){
      komandu_bloks;
}

for

$pakapienuSkaits = 4;
for($pakapiens = 0; $pakapiens < $pakapienuSkaits; $pakapiens++){
      echo "Esmu uz $pakapiens pakāpiena 
\n";
}
echo "Esmu augšā! Tagad lekšu ik pa 2 pakāpieniem lejā!
\n";
for($pakapiens = $pakapienuSkaits; $pakapiens > 0; $pakapiens -= 2){
      echo "Esmu uz $pakapiens pakāpiena 
\n";
}

for

Esmu uz 0 pakāpiena 

Esmu uz 1 pakāpiena 

Esmu uz 2 pakāpiena 

Esmu uz 3 pakāpiena 

Esmu augšā! Tagad lekšu ik pa 2 pakāpieniem lejā!

Esmu uz 4 pakāpiena 

Esmu uz 2 pakāpiena

foreach

  • Ir cikla operators, kas ļauj izpildīt operācijas uz katru masīvā esošu elementu.
  • Tas var būt īpaši noderīgs, ja masīva elemenu indeksam ir izmantotas string vērtības. 
foreach (masiva_mainigais as indeksa_mainigais => vertibas_mainigais) {
      komandu_bloks;
}

foreach

$atzimes = array(
      "Jānis" => 6,
      "Ilze" => 7,
      "Pēteris" => 8,
      "Anna" => 9
);
foreach ($atzimes as $students => $atzime){
      $atzimes[$students] = $atzime+1;
      echo "Palielināju atzīmi par viens studentam ".$students."
\n";
}
echo $atzimes["Jānis"]."
\n";

foreach

Palielināju atzīmi par viens studentam Jānis

Palielināju atzīmi par viens studentam Ilze

Palielināju atzīmi par viens studentam Pēteris

Palielināju atzīmi par viens studentam Anna

Cikla pārtraukšanas operatori

  • break - pārtrauc cikla izpildi un turpina programmas koda izpildi, kas seko aiz cikla. 
$skaititajs = 0;
while (true) { // šis mūžīgais cikls, jo nosacījums vienmēr ir patiess
	if ($skaititajs > 9) {
		break;
	} else {
		$skaititajs++;
	}
}
echo $skaititajs; //Rezultats: 10

Cikla pārtraukšanas operatori

  • continue - nepārtrauc ciklu pilnībā, bet gan aptur konkrētās darbības. 
for ($i = 0; $i < 10; $i++) {
	// Ja $i vertiba ir nepara skaitlis, izlaižam soli
	if ($i % 2 == 1) {
		continue;
	}
	// Nākamā rinda tiek izpildīta tikai tad ja $i ir pāra vērtība
	echo $i." ";
}
// Rezultāts: 0 2 4 6 8

Funkcijas

function funkcijas_nosaukums([arguments [, arguments ...]]) {
	komandu_bloks;
}

Funkcijas

// funkcijas definēšana
function sveiki() {
	echo "Sveika pasaule!
\n";
}

// funkcijas izmantošana
sveiki();
sveiki();

/*Rezultāts:
Sveika pasaule!

Sveika pasaule!

*/

Funkcijas

function kvadrats($x) {
	return $x * $x;
}
$divi_kvadraataa = kvadrats(2);
echo $divi_kvadraataa;
// Rezultāts: 4

Funkcijas

// Funkcija strādā korekti, ja kāpinātājs ir vesels, nenegatīvs skaitlis
function pakape($baze, $kapinatajs) {
	$pakape = 1;
	for ($i = 0; $i<$kapinatajs; $i++) {
		$pakape *= $baze;
	}
	return $pakape;
}
echo pakape(2,3);
// Rezultāts: 8

Mainīgie funkcijās

$g = 5; // globāls mainīgais
function f() {
	global $g;  // globālais mainīgais tiek ieimportēts funkcijā
	$l = $g;  // lokālajam mainīgam $l piešķir $g vērtību
	$g++;
}
echo $g; // Rezultāts: 5
f();
echo $g; //Rezultāts: 6

Mainīgie funkcijās

  • Piemērs – nepareizs lietojums: 
$g = 5
function fKluda() {
	echo $g;
}
fKluda(); // netiek izvadīts nekas, jo nav ieimportēts $g;

Dinamiski izsaukta funkcija

function dinSveiks() {
	echo "Dinamisks sveiciens pasaulei!";
}
function dinSveiks2($txt) {
	echo "Saku pasaulei: $txt !";
}
$manaFunc = "dinSveiks";
$manaFunc(); // Rezultāts: Dinamisks sveiciens pasaulei!
$manaFunc = "dinSveiks2";
$manaFunc("Čau"); // Rezultāts: Saku pasaulei: Čau !

Klases un objekti

class klases_nosaukums{
	[atribūti]
	[konstruktors un/vai destruktors]
	[funkcijas]
}

Klases un objekti

class Durvis{
	/* Atribūti nosaka ar kādām īpašām objekts tiks raksturots */
	public $materials;
	public $krasa;
	public $stavoklis;
	// koks, plastmasa, metāls, ...
	// balts, zils, zaļš, ...
	// atvērtas, aizvērtas
	...
}

Klases un objekti

class Durvis{
	...
	/*kontruktors inicializē objekta atribūtus, kad tas tiek veidots */
	public function __construct($materials){
		$this->materials = $materials;
		$this->stavoklis = 'aizvertas';
	}
	...
}
?>

Klases un objekti

class Durvis{
	...
	/* funkcijas apraksta kādas darbības iespējams veikt ar objektu */
	public function krasot($krasa){
		$this->krasa = $krasa;
	}
	...
}

Klases un objekti

class Durvis{
	...
	public function vert(){
		if ($this->stavoklis == 'atvertas'){
			$this->stavoklis = 'aizvertas';
		}else{
			$this->stavoklis = 'atvertas';
		}
	}
	...
}

Klases un objekti

class Durvis{
	...
	public function aprakstit(){
		echo "
Materiāls: $this->materials 
\n";
		echo "Krāsa: $this->krasa 
\n";
		echo "Stāvoklis: $this->stavoklis 
\n";
	}
	...
}

Klases un objekti

class Durvis{

	...

}
// Izveido jaunas durvis (izsauc konstruktoru)
$manasDurvis = new Durvis('metals');
// Veicam darbības ar jaunizveidotajām durvīma
$manasDurvis->krasot('balts');
$manasDurvis->aprakstit();
$manasDurvis->vert();
$manasDurvis->aprakstit();

Klases un objekti

Materiāls: metals 

Krāsa: balts 

Stāvoklis: aizvertas 


Materiāls: metals 

Krāsa: balts 

Stāvoklis: atvertas

Mantošana

class PaplasinataKlase extends ManaKlase{
	//pārdefinējam vecāka klases metodi
	public function izvaditMainigo(){
		parent::izvaditMainigo();
		echo ' no paplašinātās klases';
	}
$mansObjekts = new PaplasinataKlase('vērtība');
$mansObjekts->izvaditMainigo();
//Rezultāts: vērtība no paplašinātās klases
}
Atslēgas vārds parent ļauj izsaukt metodes vai atribūtus no vecāka klases.

Izņēmumi (Exceptions)

function dalijums($skaititajs, $saucejs){
	if($saucejs ==0 ){
		throw new Exception("Dalīt ar 0 nevar!");
	}else{
		return $skaititajs / $saucejs;
	}
}

Izņēmumi (Exceptions)

try{
	$a = dalijums($skait,$sauc);
	echo "$skait / $sauc = $a";
}catch(Exception $e){
	echo $e->getMessage();
}
// Rezultāts: Dalīt ar 0 nevar!

GET pieprasījums

  • Skriptā vaicājuma mainīgie ir pieejami PHP iebūvētā masīvā $_GET, kas satur visus mainīgos, kas tikuši padoti skriptam izmantojot URL. 
//skripts dalijums.php
echo $_GET['skaititajs'] / $_GET['saucejs'];
// Rezultāts: 3

GET pieprasījums

  • PHP ļauj arī vaicājuma daļā definēt masīvus
  • Piemērs: http://localhost/dalijums.php?persona[vards]=Janis&persona[uzvards]=Osis 
echo $_GET['persona']['vards'].' '.$_GET['persona']['uzvards'];
// Rezultāts: Janis Osis

POST pieprasījums (forma)


	Vārds: 

	Uzvārds:

POST pieprasījums

echo '
Jūsu vārds un uzvārds ir: ';
echo $_POST['persona']['vards'].' '.$_POST['persona']['uzvards'].'.';

Datņu iekļaušana

Datņu iekļaušana

  • summetajs.php 
<?php
class Summetajs{
      public $skaitli;
      public function summet(){
            $summa = 0;
            foreach($this->skaitli as $skaitlis){
                  $summa += $skaitlis;
            }
            return $summa;
      }
} ?>

Datņu iekļaušana

  • index.php 
<html><body>

Rezultāts



<?php
      require_once 'summetajs.php';
      $sum = new Summetajs();
      $sum->skaitli = array(1,2,3); // 1+2+3 = 6
      echo $sum->summet();
?>
</p>
</body></html>