3. PHP'in temelleri

3.1. İlk örnek

Aşağıda, PHP'in temel özelliklerini gösteren bir program yer almaktadır.

3.1.1. Program (exemple_01)

<?php

// bu bir yorumdur
// bildirilmeden kullanılan değişken
$nom = "dupont";

// bir ekran görüntüsü
print "nom=$nom\n";

// farklı türde elemanlar içeren bir dizi
$tableau = array("un", "deux", 3, 4);

// eleman sayısı
$n = count($tableau);

// bir döngü
for ($i = 0; $i < $n; $i++)
  print "tableau[$i]=$tableau[$i]\n";

// bir dizinin içeriğiyle 2 değişkenin başlatılması
list($chaine1, $chaine2) = array("chaine1", "chaine2");

// 2 dizgenin birleştirilmesi
$chaine3 = $chaine1 . $chaine2;

// sonucun görüntülenmesi
print "[$chaine1,$chaine2,$chaine3]\n";

// fonksiyon kullanımı
affiche($chaine1);

// bir değişkenin türü bilinebilir
afficheType($n);
afficheType($chaine1);
afficheType($tableau);

// bir değişkenin türü çalışma sırasında değişebilir
$n = "a changé";
afficheType($n);

// bir işlev bir sonuç döndürebilir
$res1 = f1(4);
print "res1=$res1\n";

// bir işlev bir değerler dizisi döndürebilir
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";

// bu değerler bir dizide toplanabilirdi
$t = f2();
for ($i = 0; $i < count($t); $i++)
  print "t[$i]=$t[$i]\n";

// testler
for ($i = 0; $i < count($t); $i++)
// sadece kanalları gösterir
  if (getType($t[$i]) == "string")
    print "t[$i]=$t[$i]\n";

// diğer testler
for ($i = 0; $i < count($t); $i++){
// sadece 10'dan büyük tamsayıları görüntüler
  if (getType($t[$i]) == "integer" and $t[$i] > 10)
    print "t[$i]=$t[$i]\n";
}

// bir while döngüsü
$t = array(8, 5, 0, -2, 3, 4);
$i = 0;
$somme = 0;
while ($i < count($t) and $t[$i] > 0) {
  print "t[$i]=$t[$i]\n";
  $somme+=$t[$i];   //$somme=$somme+$t[$i]
  $i++;             //$i=$i+1
}
print "somme=$somme\n";

// program sonu
exit;

//----------------------------------
function affiche($chaine) {
  // $chaine'i görüntüler
  print "chaine=$chaine\n";
}

//----------------------------------
function afficheType($variable) {
  // $variable türünü göster
  print "type[$variable]=" . getType($variable) . "\n";
}

//----------------------------------
function f1($param) {
  // $param'e 10 ekler
  return $param + 10;
}

//----------------------------------
function f2() {
  // 3 değer döndürür
  return array("un", 0, 100);
}
?>

Sonuçlar:

nom=dupont
tableau[0]=un
tableau[1]=deux
tableau[2]=3
tableau[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=integer
type[chaine1]=string
type[Array]=array
type[a changé]=string
res1=14
(res1,res2,res3)=[un,0,100]
t[0]=un
t[1]=0
t[2]=100
t[0]=un
t[2]=100
t[0]=8
t[1]=5
somme=13

Yorumlar

• 1. satır: PHP'te değişkenlerin türü belirtilmemiştir. Bu değişkenler, zaman içinde değişebilen dinamik bir türe sahiptir
• $nom, nom tanımlayıcı değişkenini temsil eder
• 1. satır: Ekrana yazmak için print komutu veya echo komutu kullanılabilir
• 1. satır: array anahtar sözcüğü, bir dizi tanımlamaya olanak tanır. $nom[$i] değişkeni, $tableau dizisinin $i elemanını temsil eder.
• 1. satır: count($tableau) işlevi, $tableau dizisindeki eleman sayısını verir
• 1. satır: Karakter dizeleri tırnak işaretleri " veya kesme işaretleri ' ile çevrelenir. Tırnak işaretleri içindeki $variable değişkenleri değerlendirilir, ancak kesme işaretleri içindekiler değerlendirilmez.
• 1. satır: list işlevi, değişkenleri bir listede bir araya getirip tek bir atama işlemiyle onlara değer atamaya olanak tanır. Burada $chaine1="dize1" ve $chaine2="dize2" şeklindedir.
• 1. satır: . operatörü, dizeleri birleştirme operatörüdür.
• 1. satır: function anahtar sözcüğü bir işlevi tanımlar. Bir işlevin değer döndürüp döndürmeyeceği, return deyimi ile belirlenir. Çağıran kod, bir işlevin sonuçlarını yok sayabilir veya alabilir. Bir işlev, kodun herhangi bir yerinde tanımlanabilir.
• 1. satır: Önceden tanımlanmış getType($variable) işlevi, $variable türünü temsil eden bir karakter dizisi döndürür. Bu tür zaman içinde değişebilir.
• 1. satır: Önceden tanımlanmış exit işlevi, komut dosyasını durdurur.

3.2. Değişkenlerin kapsamı

3.2.1. Program 1 (exemple_02)

<?php

// değişkenlerin kapsamı

function f1() {
  // $i küresel değişkeni kullanılır
  $i = &$GLOBALS["i"];
  $i++;
  $j = 10;
  print "f1[i,j]=[$i,$j]\n";
}

function f2() {
  // $i küresel değişkeni kullanılıyor
  $i = &$GLOBALS["i"];
  $i++;
  $j = 20;
  print "f2[i,j]=[$i,$j]\n";
}

function f3() {
  // yerel $i değişkeni kullanılıyor
  $i = 4;
  $j = 30;
  print "f3[i,j]=[$i,$j]\n";
}

// testler
$i = 0;
$j = 0;  // bu iki değişken, $GLOBALS dizisi aracılığıyla f fonksiyonu tarafından bilinir
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
?>

Sonuçlar:

f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[4,30]
test[i,j]=[2,0]

Açıklamalar

• 29-30. satırlar: ana programda $i ve $j adlı 2 değişken tanımlar. Bu değişkenler fonksiyonların içinde tanınmaz. Dolayısıyla, 9. satırda, f1 fonksiyonundaki $j değişkeni, f1 fonksiyonuna özgü bir yerel değişkendir ve ana programdaki $j değişkeninden farklıdır. Bir fonksiyon, $GLOBALS adlı küresel değişkenler dizisi aracılığıyla ana programdaki $variable değişkenine erişebilir. 7. satırda, $GLOBALS["i"] notasyonu, ana programın $i küresel değişkenini ifade eder. Şu şekilde yazarsak

$i=$GLOBALS["i"]

$i adlı yerel değişkene, $i adlı küresel değişkenin değeri atanır. Burada iki farklı değişken söz konusudur ve $i adlı yerel değişkeni değiştirmek, $i adlı küresel değişkeni etkilemez. Şu gösterim:

$i=&Globals["i"]

kullanıldığında, yerel $i değişkeni, küresel $i değişkeniyle aynı bellek adresine sahip olur. Dolayısıyla, yerel $i değişkenini değiştirmek, küresel $i değişkenini değiştirmekle aynı anlama gelir.

3.2.2. Program 2 (exemple_03)

<?php

// bir değişkenin kapsamı kod blokları genelindedir
$i = 0; {
  $i = 4;
  $i++;
}
print "i=$i\n";
?>

Sonuçlar:

i=5

Yorumlar

Bazı dillerde, küme parantezleri içinde tanımlanan bir değişkenin kapsamı bu parantezlerle sınırlıdır: bu parantezlerin dışında bu değişken bilinmez. Yukarıdaki sonuçlar, PHP'te durumun böyle olmadığını göstermektedir. 5. satırda küme parantezleri içinde tanımlanan $i değişkeni, küme parantezlerinin dışında 4. ve 8. satırlarda kullanılan değişkenle aynıdır.

3.3. Tablolar

3.3.1. Geleneksel tek boyutlu tablolar (exemple_04)

<?php

// geleneksel diziler
// başlatma
$tab1 = array(0, 1, 2, 3, 4, 5);

// döngü - 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";

// döngü - 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1))
  print "tab1[$clé]=$valeur\n";

// eleman ekleme
$tab1[] = $i++;
$tab1[] = $i++;

// gözden geçirme - 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
  print "tab1[$i]=$élément\n";
  $i++;
}

// son öğenin silinmesi
array_pop($tab1);

// güzergâh - 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";

// ilk öğeyi silme
array_shift($tab1);

// dolaşım - 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";

// tablonun sonuna ekleme
array_push($tab1, -2);

// dolaşım - 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";

// tablonun başına ekleme
array_unshift($tab1, -1);

// tarama - 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
?>

Sonuçlar:

tab1 a 6 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 8 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=7
tab1 a 7 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 a 6 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 a 7 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 a 8 éléments
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2

Açıklamalar

Yukarıdaki program, bir değer tablosunun işlenmesine ilişkin işlemleri göstermektedir. PHP'te tablolar için iki farklı gösterim biçimi vardır:

$tableau=array("un",2,"trois")
$contraires=array("petit"=>"grand", "beau"=>"laid", "cher"=>"bon marché")

Tablo 1, "tablo" olarak adlandırılırken, tablo 2 ise öğelerin anahtar => değer şeklinde gösterildiği bir "sözlük" olarak adlandırılır. $contraires["beau"] notasyonu, "güzel" anahtarına atanan değeri belirtir. Dolayısıyla burada bu değer "çirkin" dizesidir. Dizi 1, sözlüğün sadece bir çeşididir ve şu şekilde gösterilebilir:

$tableau=array(0=>"un",1=>2,2=>"trois")

Böylece $tableau[2]="üç" olur. Sonuçta, sadece sözlükler vardır. n elemanlı klasik bir dizi durumunda, anahtarlar [0,n-1] aralığındaki tamsayılardır.

• 1. satır: each($tableau) işlevi, bir sözlüğü taramaya olanak tanır. Her çağrıldığında, sözlüğün bir (anahtar, değer) çiftini döndürür.
• 1. satır: reset($dictionnaire) işlevi, each işlevini sözlüğün ilk (anahtar, değer) çifti üzerine konumlandırır.
• 1. satır: while döngüsü, each fonksiyonu sözlüğün sonunda boş bir çift döndürdüğünde sona erer.
• 1. satır: $tableau[]=değer ifadesi, valeur öğesini $tableau dizisinin son öğesi olarak ekler.
• 1. satır: Dizi, bir foreach ile taranır. Bu sözdizimsel öğe, bir sözlüğü, dolayısıyla bir diziyi iki farklı sözdizimi kullanılarak taramaya olanak tanır:

foreach($dictionnaire as $clé=>$valeur)
foreach($tableau as $valeur)

İlk sözdizimi her yinelemede bir çift (clé,valeur) döndürürken, ikinci sözdizimi sözlükten yalnızca valeur öğesini döndürür.

• 1. satır: array_pop($tableau) işlevi, $tableau'in son elemanını siler
• 1. satır: array_shift($tableau) işlevi, $tableau'in ilk elemanını siler
• 1. satır: array_push($tableau,değer) işlevi, valeur'i $tableau'in son elemanı olarak ekler
• 1. satır: array_unshift($tableau,değer) işlevi, valeur'i $tableau'in ilk elemanı olarak ekler

3.3.2. Sözlük (exemple_05)

<?php

// sözlükler
$conjoints = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");

// güzergâh - 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";

// sözlüğü anahtara göre sıralama
ksort($conjoints);

// tarama - 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";

// sözlük anahtarları listesi
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++)
  print "clés[$i]=$clés[$i]\n";

// sözlüğün değer listesi
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++)
  print "valeurs[$i]=$valeurs[$i]\n";

// anahtar arama
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");

// anahtar-değer silme
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
  print "conjoints[$clé]=$valeur\n";
}

// son
exit;

function existe($conjoints, $mari) {
  // $mari anahtarının $conjoints sözlüğünde mevcut olup olmadığını kontrol eder
  if (isset($conjoints[$mari]))
    print "La clé [$mari] existe associée à la valeur [$conjoints[$mari]]\n";
  else
    print "La clé [$mari] n'existe pas\n";
}

?>

Sonuçlar:

Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle
clés[0]=Jacques
clés[1]=Jean
clés[2]=Paul
clés[3]=Pierre
valeurs[0]=Lucette
valeurs[1]=
valeurs[2]=Virginie
valeurs[3]=Gisèle
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
conjoints[Jacques]=Lucette
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle

Açıklamalar

Yukarıdaki kod, daha önce basit bir dizi için ele alınan işlemleri bir sözlüğe uygular. Yalnızca yeni unsurları açıklayacağız:

• 1. satır: ksort (anahtar sıralama) işlevi, bir sözlüğü anahtarın doğal sırasına göre sıralamaya olanak tanır.
• 1. satır: array_keys($dictionnaire) işlevi, sözlüğün anahtar listesini tablo biçiminde döndürür
• 1. satır: array_values($dictionnaire) işlevi, sözlüğün değer listesini tablo biçiminde döndürür
• 1. satır: isset($variable) işlevi, $variable değişkeni tanımlanmışsa true, aksi takdirde false değerini döndürür.
• 1. satır: unset($variable) işlevi, $variable değişkenini siler.

3.3.3. Çok boyutlu diziler (exemple_06)

<?php

// klasik çok boyutlu tablolar
// başlatma
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// tarama
for ($i1 = 0; $i1 < count($multi); $i1++)
  for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
    print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
// çok boyutlu sözlükler
// başlatma
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// tarama
foreach ($multi as $clé => $valeur)
  for ($i2 = 0; $i2 < count($valeur); $i2++)
    print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
?>

Sonuçlar:

multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zéro][0]=0
multi[zéro][1]=1
multi[zéro][2]=2
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24

Açıklamalar

• 1. satır: $multi tablosunun elemanları da birer tablodur
• 1. satır: $multi tablosu, her bir valeur'in bir tablo olduğu bir sözlüğe (clé,valeur) dönüşür

3.3.4. Dizeler ve tablolar arasındaki bağlantılar (exemple_07)

<?php

// dizgiyi tabloya dönüştürme
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);

// dizide tarama
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n";

// diziden dizgiye
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";

// boş bir alan ekleyelim
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);

// diziyi tarama
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; // Şu anda 5 elemanımız var, sonuncusu boş
  
// tekrar boş bir alan ekleyelim
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);

// diziyi tarayalım
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; // Şu anda 6 eleman var, son ikisi boş
?>

Sonuçlar:

tab a 4 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
chaine2=1:2:3:4
chaîne=1:2:3:4:
tab a 5 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
chaîne=1:2:3:4::
tab a 6 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

Açıklamalar

• 1. satır: explode($séparateur,$chaine) işlevi, $chaine dosyasındaki alanları $séparateur ile ayrılmış olarak alır. Böylece, explode(":",$chaine) işlevi, ":" karakteriyle ayrılmış $chaine öğelerini bir dizi olarak elde etmeyi sağlar.
• implode($séparateur,$tableau) işlevi ise explode işlevinin tersini gerçekleştirir. Bu işlev, $tableau'in $séparateur ile ayrılmış öğelerinden oluşan bir karakter dizesi döndürür.

3.4. Dizgiler

3.4.1. Notasyon (exemple_08)

<?php

// dizelerin notasyonu
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>

Sonuçlar:

[un,un]

3.4.2. Karşılaştırma (exemple_09)

<?php

// dizgi karşılaştırma testleri
compare("abcd", "abcd");
compare("", "");
compare("1", "");
exit;

function compare($chaine1, $chaine2) {
  // dize1 ile dize2'yi karşılaştır
  if ($chaine1 == $chaine2)
    print "[$chaine1] est égal à [$chaine2]\n";
  else
    print "[$chaine1] est différent de [$chaine2]\n";
}

?>

Sonuçlar:

[abcd] est égal à [abcd]
[] est égal à []
[1] est différent de []

3.5. Düzenli ifadeler (exemple_10)

<?php

// PHP'te düzenli ifadeler
// bir dizgenin farklı alanlarını alma

// şablon: herhangi bir karakterle çevrili bir sayı dizisi
// sadece rakam dizisini almak istiyoruz
$modèle = "/(\d+)/";
// dizgiyi şablonla karşılaştırıyoruz
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");

// şablon: herhangi bir karakterle çevrili bir sayı dizisi
// sayı dizisinin yanı sıra öncesindeki ve sonrasındaki alanları da almak istiyoruz
$modèle = "/^(.*?)(\d+)(.*?)$/";
// dizgiyi şablonla karşılaştırıyoruz
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");

// şablon - gg/aa/yy formatında bir tarih
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
compare($modèle, "10/05/97");
compare($modèle, "  04/04/01  ");
compare($modèle, "5/1/01");

// şablon - ondalık sayı
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
compare($modèle, "187.8");
compare($modèle, "-0.6");
compare($modèle, "4");
compare($modèle, ".6");
compare($modèle, "4.");
compare($modèle, " + 4");

// son
exit;

// --------------------------------------------------------------------------
function compare($modèle, $chaîne) {
  // $chaîne dizesini $modèle şablonuyla karşılaştırır
  // dizeyi şablonla karşılaştırır
  $correspond = preg_match($modèle, $chaîne, $champs);
  // sonuçların görüntülenmesi
  print "\nRésultats($modèle,$chaîne)\n";
  if ($correspond) {
    for ($i = 0; $i < count($champs); $i++)
      print "champs[$i]=$champs[$i]\n";
  } else
    print "La chaîne [$chaîne] ne correspond pas au modèle [$modèle]\n";
}
?>

Sonuçlar:

Résultats(/(\d+)/,xyz1234abcd)
champs[0]=1234
champs[1]=1234

Résultats(/(\d+)/,12 34)
champs[0]=12
champs[1]=12

Résultats(/(\d+)/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/(\d+)/]

Résultats(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
champs[0]=xyz1234abcd
champs[1]=xyz
champs[2]=1234
champs[3]=abcd

Résultats(/^(.*?)(\d+)(.*?)$/,12 34)
champs[0]=12 34
champs[1]=
champs[2]=12
champs[3]= 34

Résultats(/^(.*?)(\d+)(.*?)$/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/^(.*?)(\d+)(.*?)$/]

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
champs[0]=10/05/97
champs[1]=10
champs[2]=05
champs[3]=97

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
champs[0]=  04/04/01  
champs[1]=04
champs[2]=04
champs[3]=01

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
La chaîne [5/1/01] ne correspond pas au modèle [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
champs[0]=187.8
champs[1]=
champs[2]=187.8

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
champs[0]=-0.6
champs[1]=-
champs[2]=0.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
champs[0]=4
champs[1]=
champs[2]=4

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
champs[0]=.6
champs[1]=
champs[2]=.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
champs[0]=4.
champs[1]=
champs[2]=4.

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
champs[0]= + 4
champs[1]=+
champs[2]=4

Açıklamalar

• 3-4. satırlar: Burada, bir karakter dizisindeki çeşitli alanları almak için düzenli ifadeler kullanıyoruz. Düzenli ifadeler, implode işlevinin sınırlarını aşmamızı sağlar. Buradaki prensip, preg_match işlevini kullanarak bir karakter dizisini modèle adlı başka bir karakter dizisiyle karşılaştırmaktır:

$correspond = preg_match($modèle, $chaîne, $champs);

preg_match işlevi, modèle'in chaîne içinde bulunup bulunmadığını boole değeri olarak döndürür. Eğer öyleyse, $champs[0], şablona karşılık gelen alt dizgiyi temsil eder. Ayrıca, model parantez içinde alt modeller içeriyorsa, $champs[1], $chaîne'in ilk alt modele karşılık gelen kısmıdır; $champs[2] ise $chaîne'in 2. alt modele karşılık gelen parçasıdır, vb...

İlk örneği ele alalım. Şablon 8. satırda tanımlanmıştır: bu, bir dizede herhangi bir yerde bulunan bir veya daha fazla (+) rakam (\d) dizisini belirtir. Ayrıca, şablon parantezlerle çevrili bir alt şablon tanımlar.

• 10. satır: /(\d+)/ modeli (dizginin herhangi bir yerinde bulunan bir veya daha fazla rakam dizisi), "xyz1234abcd" dizgisiyle karşılaştırılır. 1234 alt dizgisinin modele uyduğu görülür. Dolayısıyla $champs[0], "1234" ile eşleşir. Ayrıca, kalıbın parantez içinde alt kalıpları da bulunmaktadır. Dolayısıyla $champs[1], "1234" ile eşleşir.
• 1. satır: /(\d+)/ kalıbı, "12 34" dizesiyle karşılaştırılır. 12 ve 34 alt dizelerinin kalıba uyduğu görülür. Karşılaştırma, kalıba uyan ilk alt dizeyle sona erer. Dolayısıyla, $champs[0]=12 ve $champs[1]=12 sonuçları elde edilir.
• 1. satır: /(\d+)/ kalıbı "abcd" dizesiyle karşılaştırılır. Herhangi bir eşleşme bulunmaz.

Kodun geri kalanında kullanılan kalıpları açıklayalım:

$modèle = "/^(.*?)(\d+)(.*?)$/";

dizenin başlangıcı (^), ardından 0 veya daha fazla (*) herhangi bir karakter (.), ardından 1 veya daha fazla (+) rakam, ardından yine 0 veya daha fazla (*) herhangi bir karakter (.). (*) kalıbı, 0 veya daha fazla rastgele karakteri belirtir. Böyle bir kalıp, herhangi bir dizeyle eşleşecektir. Dolayısıyla /^(.*)(\d+)(.*)$/ kalıbı hiçbir zaman bulunmayacaktır, çünkü ilk alt kalıp (.*) tüm dizeyi kapsayacaktır. (.*?)(\d+) kalıbı ise, bir sonraki alt kalıba (?) kadar (burada \d+) 0 veya daha fazla rastgele karakteri belirtir. Dolayısıyla rakamlar artık (.*) kalıbı tarafından yutulmaz. Yukarıdaki kalıp, [début de chaîne (^), une suite de caractères quelconques (.*?), une suite d'un ou plusieurs chiffres (\d+), une suite de caractères quelconques (.*?), la fin de la chaîne ($)] dizisine karşılık gelir.

$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

[début de chaîne (^), 2 chiffres (\d\d), le caractère / (\/), 2 chiffres, /, 2 chiffres, une suite de 0 ou plusieurs espaces (\s*), la fin de chaîne ($)]'e karşılık gelir

$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";

[début de chaîne (^), 0 ou plusieurs espaces (\s*), un signe + ou - [+|-] présent 0 ou 1 fois (?), une suite de 0 ou plusieurs espaces (\s*), 1 ou plusieurs chiffres suivis d'un point décimal suivi de zéro ou plusieurs chiffres (\d+\.\d*) ou (|) un point décimal (\.) suivi d'un ou plusieurs chiffres (\d+) ou (|) un ou plusieurs chiffres (\d+), une suite de 0 ou plusieurs espaces (\s*)].

3.6. İşlev parametrelerinin aktarım şekli (exemple_11)

<?php

// parametre aktarım yöntemi

function f(&$i, $j) {
  // $i referans yoluyla elde edilecektir
  // $j değer yoluyla elde edilecektir
  $i++;
  $j++;
  print "f[i,j]=[$i,$j]\n";
}

// ----------------------------------------testler
$i = 0;
$j = 0;
// $i ve $j değer olarak aktarılır
f($i, $j);
print "test[i,j]=[$i,$j]\n";
?>

Sonuçlar:

f[i,j]=[1,1]
test[i,j]=[1,0]

Açıklamalar

Yukarıdaki kod, bir fonksiyona parametre aktarımının iki yöntemini göstermektedir. Şu örneği ele alalım:

function f(&$a,$b){
…
}

// ana program
$i=10; $j=20;
f($i,$j);

• 1. satır: f fonksiyonunun $a ve $b formal parametrelerini tanımlar. Bu fonksiyon, bu iki formal parametreyi işler ve bir sonuç döndürür.
• 1. satır: f fonksiyonu, $i ve $j adlı iki gerçek parametre ile çağrılır. Biçimsel parametreler ($a, $b) ile gerçek parametreler ($i, $j) arasındaki ilişkiler 7. satırda tanımlanmıştır
• &$a: & işareti, biçimsel parametre $a'in değerinin, etkin parametre $i'in adresi olacağını belirtir. Başka bir deyişle, $a ve $i, aynı bellek konumuna yapılan iki referanstır. Biçimsel parametre $a üzerinde işlem yapmak, fiili parametre $i üzerinde işlem yapmakla aynı anlama gelir. Kodun çalıştırılması da bunu göstermektedir. Bu aktarım yöntemi, çıktı parametreleri ve diziler ile sözlükler gibi büyük veriler için uygundur. Bu aktarım yöntemine "referansla aktarım" denir.
• $b: $b biçimsel parametresinin değeri, $j gerçek parametresinin değerini alacaktır. Bu, değer aktarımdır. Biçimsel ve gerçek parametreler iki farklı değişkendir. Biçimsel parametre $b üzerinde yapılan işlemler, gerçek parametre $j'i etkilemez. Kodun çalıştırılması bunu göstermektedir. Bu aktarım türü, giriş parametreleri için uygundur.
• échange fonksiyonunu ele alalım; bu fonksiyon, $a ve $b adlı iki biçimsel parametre kabul eder. İşlev, bu iki parametrenin değerlerini değiştirir. Dolayısıyla, bir değişim çağrısı ($i,$j) sırasında, çağıran kod, iki etkin parametrenin değerlerinin değiştirilmesini bekler. Dolayısıyla bunlar çıkış parametreleridir (değiştirilirler). Bu nedenle şöyle yazacağız:

function échange(&$a,&$b){....}

3.7. Bir işlev tarafından döndürülen sonuçlar (exemple_12)

<?php

// bir işlev tarafından döndürülen sonuçlar
// bir işlev bir dizide birden fazla değer döndürebilir
list($res1, $res2, $res3) = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++)
  print "res[$i]=$res[$i]\n";

// bir işlev bir sözde nesne döndürebilir
$res = f2(10);
print "[$res->res1,$res->res2,$res->res3]\n";

// son
exit;

// f1 fonksiyonu
function f1($valeur) {
  // bir dizi döndürür ($valeur+1,$aleur+2,$baleur+3)
  return array($valeur + 1, $valeur + 2, $valeur + 3);
}

// f2 işlevi
function f2($valeur) {
  // bir sözde nesne döndürür ($valeur+1,$aleur+2,$baleur+3)
  $res->res1 = $valeur + 1;
  ;
  $res->res2 = $valeur + 2;
  $res->res3 = $valeur + 3;
  // nesneyi döndürür
  return $res;
}

?>

Sonuçlar

[11,12,13]
res[0]=11
res[1]=12
res[2]=13
[11,12,13]

Yorumlar

• Yukarıdaki program, PHP işlevinin tek bir sonuç yerine bir dizi sonuç verebileceğini ve bu sonuçların bir dizi veya nesne biçiminde olabileceğini göstermektedir. Nesne kavramı biraz ileride daha ayrıntılı olarak açıklanmaktadır
• 19-22. satırlar: f1 işlevi, bir dizi biçiminde birden fazla değer döndürür
• 25-33. satırlar: f2 işlevi, bir nesne biçiminde birden fazla değer döndürür

3.8. Metin dosyaları (exemple_13)

<?php

// bir metin dosyasının sıralı olarak işlenmesini sağlar
// bu, login:pwd:uid:gid:infos:dir:shell biçiminde bir dizi satırdır
// her satır, login => uid:gid:infos:dir:shell biçiminde bir sözlüğe eklenir

// dosya adı belirlenir
$INFOS = "infos.txt";

// dosya, yeni oluşturulacak şekilde açılır
if (!$fic = fopen($INFOS, "w")) {
  print "Erreur d'ouverture du fichier $INFOS en écriture\n";
  exit;
}

// İsteğe bağlı bir içerik oluşturulur
for ($i = 0; $i < 100; $i++)
  fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
// dosya kapatılır
fclose($fic);

// sistemi istismar ediyoruz - fgets satır sonu işaretini korur
// bu, boş bir satır okunurken boş bir dize alınmamasını sağlar
// dosya yazma modunda açılır
if (!$fic = fopen($INFOS, "r")) {
  print "Erreur d'ouverture du fichier $INFOS en lecture\n";
  exit;
}
while ($ligne = fgets($fic, 1000)) {
  // varsa satır sonu işaretini siliyoruz
  $ligne = cutNewLineChar($ligne);
  // satırı bir diziye eklenir
  $infos = explode(":", $ligne);
  // kullanıcı adını alır
  $login = array_shift($infos);
  // şifre göz ardı edilir
  array_shift($infos);
  // sözlüğe bir giriş oluşturulur
  $dico[$login] = $infos;
}
// kapatıyoruz
fclose($fic);

// sözlüğü kullanıyoruz
afficheInfos($dico, "login10");
afficheInfos($dico, "X");

// son
exit;

// --------------------------------------------------------------------------
function afficheInfos($dico, $clé) {
  // sözlükte anahtara karşılık gelen değeri görüntüler $dico eğer varsa
  if (isset($dico[$clé])) {
    // değer mevcut - bu bir dizi mi?
    $valeur = $dico[$clé];
    if (is_array($valeur)) {
      print "[$clé," . join(":", $valeur) . "]\n";
    } else {
      // $valeur bir dizi değildir
      print "[$clé,$valeur]\n";
    }
  } else {
    // $clé, $dico sözlüğünde bir anahtar değildir
    print "la clé [$clé] n'existe pas\n";
  }
}

// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
  // $ligne'in satır sonu işaretini varsa silinir
  $L = strlen($ligne);  // satır uzunluğu
  while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
    $ligne = substr($ligne, 0, $L - 1);
    $L--;
  }
  // son
  return($ligne);
}

?>

infos.txt dosyası:

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Sonuçlar:

[login10,uid10:gid10:infos10:dir10:shell10]
la clé [X] n'existe pas

Yorumlar

• 1. satır: fopen(nom_fichier,"w") komutu, nom_fichier dosyasını yazma modunda açar (w=write). Dosya yoksa oluşturulur. Varsa, içeriği silinir. Oluşturma işlemi başarısız olursa, fopen, false değerini döndürür. if (!$fic = fopen($INFOS, "w")) {…} ifadesinde iki ardışık işlem vardır: 1) $fic = fopen(..) 2) if( ! $fic) {...}
• 1. satır: fputs($fic, $chaîne) komutu, chaîne dosyasını $fic dosyasına yazar.
• 1. satır: fclose($fic) komutu, $fic dosyasını kapatır.
• 1. satır: fopen(nom_fichier,"r") komutu, nom_fichier dosyasını okuma modunda açar (r=read). Açma işlemi başarısız olursa (dosya yoksa), fopen, false değerini döndürür.
• 1. satır: fgets($fic,1000) komutu, dosyadan bir sonraki satırı 1000 karakterlik sınır içinde okur. while ($ligne = fgets($fic, 1000)) {…} ifadesinde iki ardışık işlem vardır: 1) $ligne = fgets(...) 2) while ( ! $ligne). Dosyanın son karakteri okunduktan sonra, fgets işlevi dizgiyi boş hale getirir ve while döngüsü sona erer.
• 31. satır: fgets işlevi, satır sonu karakteri de dahil olmak üzere bir metin satırını okur. 70-79. satırlardaki cutNewLineChar işlevi, varsa satır sonu karakterini kaldırır.
• 72. satır: strlen($chaîne) işlevi, $chaîne'in karakter sayısını verir.
• 73. satır: substr($ligne, $position, $taille) işlevi, $ligne dizisinden $taille karakterini döndürür; bu karakterler, 0 numaralı ilk karakterden başlayarak $position numaralı karakterden itibaren alınır. Windows sistemlerinde satır sonu işareti "\r\n" şeklindedir. Unix sistemlerinde ise "\n" dizesidir.
• 35. satır: array_shift($tableau) işlevi, $tableau'in ilk elemanını çıkarır ve bunu sonuç olarak döndürür.
• 37. satır: array_shift($tableau) işlevi kullanılır, ancak sonucu göz ardı edilir
• 57. satır: is_array($variable) işlevi, $variable bir dizi ise true'i, aksi takdirde false'i döndürür.
• 58. satır: join işlevi, daha önce karşılaştığımız implode işleviyle aynı işlevi görür