3. PHP'in temelleri

3.1. Komut dosyalarının dizin yapısı

3.2. PHP'in yapılandırılması

PHP, [php.ini] adlı bir metin dosyası ile önceden yapılandırılmış olarak gelir. Tüm bu yapılandırmalar programlama yoluyla değiştirilebilir. PHP'in yapılandırması, komut dosyalarının çalışmasını büyük ölçüde etkiler. Bu nedenle, bu yapılandırmayı bilmek önemlidir. Aşağıdaki [phpinfo.php] komut dosyası bunu mümkün kılar:

<?php

phpinfo();

Açıklamalar

• 3. satır: [phpinfo] işlevi, PHP'in yapılandırmasını görüntüler;

Çalıştırma Sonuçları

"C:\myprograms\laragon-lite\bin\php\php-7.2.11-Win32-VC15-x64\php.exe" "C:\Data\st-2019\dev\php7\php5-exemples\exemples\tests\phpinfo.php"
phpinfo()
PHP Version => 7.2.11

System => Windows NT DESKTOP-528I5CU 10.0 build 17134 (Windows 10) AMD64
Build Date => Oct 10 2018 01:57:32
Compiler => MSVC15 (Visual C++ 2017)
Architecture => x64
Configure Command => cscript /nologo configure.js  "--enable-snapshot-build" "--enable-debug-pack" "--with-pdo-oci=c:\php-snap-build\deps_aux\oracle\x64\instantclient_12_1\sdk,shared" "--with-oci8-12c=c:\php-snap-build\deps_aux\oracle\x64\instantclient_12_1\sdk,shared" "--enable-object-out-dir=../obj/" "--enable-com-dotnet=shared" "--without-analyzer" "--with-pgo"
Server API => Command Line Interface
Virtual Directory Support => enabled
Configuration File (php.ini) Path => C:\windows
Loaded Configuration File => C:\myprograms\laragon-lite\bin\php\php-7.2.11-Win32-VC15-x64\php.ini
Scan this dir for additional .ini files => (none)
Additional .ini files parsed => (none)
…
Done.

[phpinfo] işlevi burada 800'den fazla yapılandırma satırı göstermektedir. Bunların çoğunun PHP'in ileri düzey kullanımıyla ilgili olması nedeniyle, bunlar üzerinde durmayacağız. Önemli bir satır, yukarıdaki 13. satırdır: Bu satır, komut dosyalarınızı çalıştırmak için kullanacağınız PHP'i yapılandırmak üzere hangi [php.ini] dosyasının kullanıldığını belirtir. PHP dosyasının çalıştırma yapılandırmasını değiştirmek istiyorsanız, değiştirmeniz gereken dosya budur. Bu dosyada, farklı yapılandırmaların işlevlerini açıklayan çok sayıda açıklama bulunmaktadır.

3.3. İlk örnek

3.3.1. Kod

Aşağıda, PHP'in temel özelliklerini gösteren bir [bases-01.php] programı bulunmaktadır.

<?php

// bu bir yorumdur
// bildirilmeden kullanılan değişken
$nom = "dupont";
// ekran çıktı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", $n);
afficheType("chaine1", $chaine1);
afficheType("tableau", $tableau);
// bir değişkenin türü çalışma sırasında değişebilir
$n = "a changé";
afficheType("n", $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ğerleri bir dizide toplayabilirdik
$t = f2();
for ($i = 0; $i < count($t); $i++) {
  print "t[$i]=$t[$i]\n";
}
// testler
for ($i = 0; $i < count($t); $i++) {
  // sadece dizeleri görüntüler
  if (getType($t[$i]) === "string") {
    print "t[$i]=$t[$i]\n";
  }
}
// == ve === karşılaştırma operatörleri
if("2"==2){
  print "avec l'opérateur ==, la chaîne 2 est égale à l'entier 2\n";
}else{
  print "avec l'opérateur ==, la chaîne 2 n'est pas égale à l'entier 2\n";
}
if("2"===2){
  print "avec l'opérateur ===, la chaîne 2 est égale à l'entier 2\n";
}
else{
  print "avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2\n";
}
// diğer testler
for ($i = 0; $i < count($t); $i++) {
  // sadece >10 olan 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 = [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
}//while
print "somme=$somme\n";

// program sonu
exit;

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

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

//afficheType
//----------------------------------
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[variable $n]=integer
type[variable $chaine1]=string
type[variable $tableau]=array
type[variable $n]=string
res1=14
(res1,res2,res3)=[un,0,100]
t[0]=un
t[1]=0
t[2]=100
t[0]=un
avec l'opérateur ==, la chaîne 2 est égale à l'entier 2
avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2
t[2]=100
t[0]=8
t[1]=5
somme=13

Açıklamalar

• 5. satır: PHP'te değişkenlerin türü belirtilmez. Bu değişkenler, zaman içinde değişebilen dinamik bir türe sahiptir. $nom, "nom" tanımlayıcılı değişkeni temsil eder;
• 7. satır: Ekrana yazmak için print komutu veya echo komutu kullanılabilir;
• 9. 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;
• 11. satır: count($tableau) işlevi, $tableau dizisindeki eleman sayısını verir;
• 13-15. satırlar: bir döngü. Bu döngüde tek bir komut olduğu için küme parantezleri isteğe bağlıdır. Bu belgenin devamında, komut sayısına bakılmaksızın her zaman küme parantezleri kullanacağız;
• satır 14: karakter dizeleri tırnak işaretleri " veya kesme işaretleri ' ile çevrelenir. Tırnak işaretlerinin içinde $variable değişkenleri değerlendirilir, ancak kesme işaretlerinin içinde değerlendirilmez;
• 17. 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";
• 19. satır: . operatörü, dizeleri birleştirme operatörüdür;
• 83-86. satırlar: function anahtar sözcüğü bir işlevi tanımlar. Bir işlev, return deyimi aracılığıyla değer döndürebilir veya döndürmeyebilir. Çağıran kod, bir işlevin sonuçlarını yok sayabilir veya alabilir. Bir işlev, kodun herhangi bir yerinde tanımlanabilir.
• 92. 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;
• 45. satır: === operatörü iki öğeyi katı bir şekilde karşılaştırır: karşılaştırılabilmeleri için aynı türde olmaları gerekir. == operatörü daha esnektir: iki öğe aynı türde olmasa da eşit olabilir. 50-60. satırlardaki komutlar bunu göstermektedir. == operatörü kullanıldığında, karşılaştırma, karşılaştırılan iki öğenin aynı türe dönüştürülmesinden sonra yapılır. Bu durumda örtük dönüştürmeler gerçekleşir. Bu örtük dönüştürmelerin varlığını “unutmak” oldukça kolaydır ve bu da, bir koşulun yanlış olmasını beklerken doğru olduğunu fark etmek gibi beklenmedik sonuçlara yol açabilir. Bu tuzağı önlemek için, sistematik olarak === karşılaştırma operatörünü kullanacağız;
• 64. satır: or ve ! gibi Boole operatörleri de kullanılabilir;
• 69. satır: array() notasyonu yerine, PHP7'ten bir dizi başlatmak için [] notasyonu kullanılabilir;
• satır 80: önceden tanımlanmış exit işlevi, betiğin yürütülmesini durdurur;
• satır 107: ?> etiketi, PHP betiğinin sonunu belirtir. Bu etiket zorunlu değildir. Ayrıca, web ortamında, bu etiketin ardından boşluklar veya satır sonu işaretleri gelirse sorun yaratabilir; bunlar metin düzenleyicide görünmediği için tespit edilmesi zordur. Bu nedenle, belgenin geri kalanında bu etiketi sistematik olarak atlayacağız;

Not: Bu belgede, konsolda metin görüntülemek için [print] anahtar kelimesini kullanacağız. Aynı şeyi yapmak için başka bir yöntem de [echo] anahtar kelimesini kullanmaktır. Bu iki anahtar kelime arasında ince farklar vardır, ancak bu belgenin bağlamında bu farkların hiçbir önemi yoktur. Dolayısıyla, [echo]'i kullanmayı tercih ediyorsanız, kullanabilirsiniz.

3.3.2. NetBeans'in Kullanımı

NetBeans, kontrol etmenizde fayda olan çeşitli uyarılar verir. [bases-01.php] betiğini örnek olarak ele alalım:

1. satırda NetBeans, dosyanın PSR-1 tavsiyesine (PHP Standart Tavsiyeleri No. 1) uymadığına dair bir uyarı verir. PSR, standart bir kod üretmek ve böylece farklı kişiler tarafından yazılan kodların birlikte çalışabilirliğini ve bakımını kolaylaştırmak için hazırlanmış önerilerdir. Örneğin proje ekibinin kendi standartları olduğu için kasıtlı olarak standartları ihlal etmek istiyorsanız, bu uyarılar can sıkıcı olabilir. NetBeans ile nelerin kontrol edilip edilmeyeceği yapılandırılabilir:

• [5]'te, NetBeans ile denetlemek istediğiniz öğeleri bulabilirsiniz;
• [6]'te ise NetBeans tarafından bildirilen hataya atanan ciddiyet seviyesi yer alır;

[7]'te, kodun PSR-0 ve PSR-1 önerilerine uygun olup olmadığının kontrol edilmesi istendiği görülmektedir. Bunların hiçbiri zorunlu değildir. Dili öğrenme aşamasında, NetBeans tarafından sunulan seçeneklerin mümkün olduğunca çoğunu kontrol etmeniz tavsiye edilir. Bu sayede çok şey öğrenilir. Daha sonra bu NetBeans kontrolünü, proje ekibinin kodlama standartlarına uyarlayacağız.

PSR-1 ve [8, 9] kodlama standartlarına bir göz atalım:

Seçenek	Denetim
Sınıf Sabit Bildirimi	Sınıf sabitleri MUST, alt çizgi ayırıcılarla birlikte tamamen büyük harflerle beyan edilmelidir. Örnek: const TAUX_TVA
Yöntem Bildirimi	MUST yöntem adları, camelCase() içinde tanımlanmalıdır. Örnek: public function executeBatchImpots{}
Özellik Adı	SHOULD adlı özellik, $StudlyCaps, $camelCase veya $under_score biçiminde (bir kapsam içinde tutarlı bir şekilde) bildirilmelidir Örnek: public SalaireAnnuel (StudlyCaps), public salaireAnnuel (camelCase), public salaire_annuel (under_score)
Yan Etkiler	SHOULD dosyası yeni semboller bildirir ve başka hiçbir yan etkiye neden olmaz; ya da SHOULD dosyası yan etkileri olan mantığı yürütür; ancak SHOULD ve NOT dosyaları her ikisini de yapar.
Tip Bildirimi	Tür adları MUST içinde StudlyCaps olarak bildirilmelidir (5.2.x ve öncesinde yazılmış kodlarda, tür adlarında Vendor_ öneklerini içeren sözde ad alanı kuralı kullanılır). Her tür kendi başına bir dosyada bulunur ve en az bir seviyeli bir ad alanında yer alır: üst düzey bir satıcı adı. Örnek: class EtudiantBoursier {}

PSR-1 / 4 numaralı öneri, bir PHP dosyasında şunların bulunması gerektiğini belirtir:

• ya bir tür bildirimi (sınıflar, arayüz);
• ya da yeni tür bildirimleri içermeyen çalıştırılabilir kod;

NetBeans tarafından denetlenmeyen başka PHP önerileri de mevcuttur: PSR-3, PSR-4, PSR-6, PSR-7 ve PSR-13.

Kolaylık olması açısından, belgedeki örneklerin tümü PSR-1 tavsiyesini uygulamamaktadır; çünkü bu, sınıf ve arayüz kodlarının ayrı dosyalara dağıtılmasını gerektirir ve bu da temel örnekler için çok zahmetlidir. Bu nedenle, her şeyi tek bir dosyaya yerleştirmek daha kolaydır. Bu belgenin ana teması olarak sunulan uygulama örneğinde, PSR-1 tavsiyesine mümkün olduğunca uymaya çalışılmıştır.

NetBeans’in bazı uyarıları potansiyel bir hataya işaret etmektedir:

[Unitialized Variables] uyarısı, muhtemel bir hatayı, genellikle bir değişken adındaki yazım hatasını bildirir. Aynı durum [Unused Variables] uyarısı için de geçerlidir.

Son olarak, kodun sol kenarındaki bir panel ve sağ kenarındaki sarı bir çizgi ile bildirilen tüm NetBeans uyarılarını kontrol etmeniz önerilir:

3.4. Değişkenlerin kapsamı

3.4.1. Örnek 1

[bases-02.php] komut dosyası şöyledir:

<?php

// değişkenlerin kapsamı

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

function f2() {
  // $i küresel değişkeni kullanılıyor
  global $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, f işlevi tarafından bilinmez
// fonksiyon, global komutuyla açıkça bildirmedikçe
// bu değişkenleri kullanmak istediğini açıkça belirtirse
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]

Yorumlar

• 29-30. satırlar: ana programdaki $i ve $j değişkenlerini tanımlar. Bu değişkenler fonksiyonların içinde tanınmaz. Dolayısıyla, 9. satırda, f1 işlevindeki $j değişkeni, f1 işlevine özgü bir yerel değişkendir ve ana programdaki $j değişkeninden farklıdır. Bir fonksiyon, global anahtar sözcüğü aracılığıyla ana programdaki $variable değişkenine erişebilir;
• 7. satırda, komut ana programın $i küresel değişkenini işaret eder;

3.4.2. Örnek 3

[bases-03.php] komut dosyası şöyledir:

<?php

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

Sonuçlar:

i=5

Açıklamalar

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 tanınmaz. 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.5. Tür değişiklikleri

PHP'teki değişkenlerin sabit bir türü yoktur. Bu tür, değişkene atanan değere bağlı olarak çalışma sırasında değişebilir. Çeşitli türlerdeki verileri içeren işlemlerde, PHP yorumlayıcısı, işlenenleri ortak bir türe dönüştürmek için örtük dönüşümler gerçekleştirir. Bu örtük dönüştürmeler, geliştirici tarafından bilinmiyorsa, tespit edilmesi zor hatalara neden olabilir. Aşağıda, örtük ve açık dönüştürmeleri gösteren bir [bases-04.php] komut dosyası sunulmaktadır:

<?php

// parametre aktarımında katı tipler
declare(strict_types=1);

// örtük tip dönüşümleri
// tür -->bool
print "Conversion vers un booléen------------------------------\n";
showBool("abcd", "abcd");
showBool("", "");
showBool("[1, 2, 3]", [1, 2, 3]);
showBool("[]", []);
showBool("NULL", NULL);
showBool("0.0", 0.0);
showBool("0", 0);
showBool("4.6", 4.6);

function showBool(string $prefixe, $var) : void {
  print "(bool) $prefixe : ";
  // $var'in boole değerine dönüştürülmesi, takip eden testte otomatik olarak gerçekleşir
  if ($var) {
    print "true";
  } else {
    print "false";
  }
  print "\n";
}

Açıklamalar

• 4. satır: Belirtildiğinde, bir fonksiyonun parametrelerinin türünün sıkı bir şekilde doğrulanmasını ister;
• 18. satır: [showBool] işlevi, herhangi bir türdeki bir değerin boole değerine dönüştürülmesi gerektiğinde (21. satır) PHP yorumlayıcısının gerçekleştirdiği örtük (otomatik) dönüşümü göstermeyi amaçlamaktadır;
• satır 18: $var parametresine bir tür atanmamıştır. Dolayısıyla, bu parametre herhangi bir türde olabilir. $prefixe parametresinin ise string türünde olması gerekir. showBool fonksiyonu herhangi bir değer döndürmez (void);
• 21. satır: if($var) ifadesinde, $var'in değeri, if'in değerlendirilmesi için boole değerine dönüştürülmelidir. Şaşırtıcı bir şekilde, PHP yorumlayıcısı, kendisine verilen her tür değer için bir yanıt vermektedir;
• 9-16. satırlar: [showBool] işlevinin parametre değeri sırasıyla şöyle olacaktır:
  • 9. satır: boş olmayan bir dize: TRUE sonucu (büyük/küçük harf fark etmez, TRUE=true);
  • 10. satır: boş bir dize: sonuç FALSE;
  • 11. satır: boş olmayan bir dizi: sonuç TRUE;
  • 12. satır: boş bir dizi: sonuç FALSE;
  • 14. satır: 0 tamsayısı: sonuç FALSE;
  • satır 15: 0 tamsayısı: sonuç FALSE;
  • satır 16: 0'dan farklı bir gerçek sayı (veya tamsayı): sonuç TRUE;

Elde edilen ekran görüntüleri şunu göstermektedir:

Conversion vers un booléen------------------------------
(bool) abcd : true
(bool)  : false
(bool) [1, 2, 3] : true
(bool) [] : false
(bool) NULL : false
(bool) 0.0 : false
(bool) 0 : false
(bool) 4.6 : true

Komut dosyası koduna devam edelim:

//
// string türünden sayısal türe örtük dönüşümler
// dize --> sayı
print "Conversion chaîne vers nombre------------------------------\n";
showNumber("12");
showNumber("45.67");
showNumber("abcd");

function showNumber(string $var) : void {
  $nombre = $var + 1;
  var_dump($nombre);
  print "($var): $nombre\n";
}

Açıklamalar

• 9. satır: [showNumber] işlevi, string türünde bir parametre alır ve sonuç döndürmez (void);
• 10. satır: Bu parametre bir aritmetik işlemde kullanılır; bu da PHP yorumlayıcısını, $var'i sayıya dönüştürmeye zorlar;
  • 5. satır: “12” dizesini 12 tamsayısına dönüştürecektir;
  • 6. satır: “45.67” dizesini 45.67 tamsayısına dönüştürecektir;
  • 7. satır: bir uyarı verecek, ancak yine de “abcd” dizesini 0 sayısına dönüştürecektir;

İşte çalıştırma sonuçları:

Conversion chaîne vers nombre------------------------------
int(13)
(12): 13
float(46.67)
(45.67): 46.67

Warning: A non-numeric value encountered in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_031.php on line 37
int(1)
(abcd): 1

Komut dosyasının koduna devam edelim:

// açıkça belirtilen tür dönüşümleri
// int türüne
showInt("12.45");
showInt(67.8);
showInt(TRUE);
showInt(NULL);

function showInt($var) : void {
  print "paramètre : ";
  var_dump($var);
  print "\n";
  print "résultat de la conversion : ";
  var_dump((int) $var);
  print "\n";
}

Yorumlar

• 21. satır: [showInt] işlevi, herhangi bir türden bir parametre alır ve sonuç döndürmez. Bu işlev, $var parametresini 26. satırda tamsayıya dönüştürmeye çalışır. Genel olarak, bir $var değişkenini T türüne dönüştürmek için (T) $var yazılır; burada T, int, integer, bool, boolean, float, double, real, string, array, object veya unset olabilir;
• 16. satır: “12.45” dizesini 12 tamsayısına dönüştürür;
• 17. satır: 67.8 sayısını 67 tamsayısına dönüştürür;
• 18. satır: TRUE boole değerini 1 tamsayısına dönüştürür (FALSE boole değerini ise 0 tamsayısına);
• satır 19: NULL işaretçisini 0 tamsayısına dönüştürür;

Ekran çıktıları şunu göstermektedir:

paramètre : string(5) "12.45"

résultat de la conversion : int(12)

paramètre : float(67.8)

résultat de la conversion : int(67)

paramètre : bool(true)

résultat de la conversion : int(1)

paramètre : NULL

résultat de la conversion : int(0)

Komut dosyasını incelemeye, değerlerin float türüne açık bir şekilde dönüştürülmesiyle devam ediyoruz:

// float'a
showFloat("12.45");
showFloat(67);
showFloat(TRUE);
showFloat(NULL);

function showFloat($var) : void {
  print "paramètre : ";
  var_dump($var);
  print "\n";
  print "résultat de la conversion : ";
  var_dump((float) $var);
  print "\n";
}

Yorumlar

• 35. satır: [showFloat] işlevi, herhangi bir türde bir parametre alır ve sonuç döndürmez;
• 40. satır: Bu parametrenin değeri açıkça float'e dönüştürülür;
• 30. satır: “12.45” dizesi, 12.45 gerçek sayısına dönüştürülür;
• satır 31: 67 tamsayısı, 67 gerçek sayısına dönüştürülür;
• satır 32: TRUE boole değeri, 1 tamsayısına dönüştürülür (FALSE değeri ise 0 tamsayısına);
• satır 33: NULL işaretçisi, 0 tamsayısına dönüştürülür;

Ekran sonuçları şunu göstermektedir:

paramètre : string(5) "12.45"

résultat de la conversion : float(12.45)

paramètre : int(67)

résultat de la conversion : float(67)

paramètre : bool(true)

résultat de la conversion : float(1)

paramètre : NULL

résultat de la conversion : float(0)

String türüne yapılan dönüşümleri inceleyerek komut dosyasının sunumuna devam ediyoruz:

// string'e
showstring(5);
showString(6.7);
showString(FALSE);
showString(NULL);

function showString($var) : void {
  print "paramètre : ";
  var_dump($var);
  print "\n";
  print "résultat de la conversion : ";
  var_dump((string) $var);
  print "\n";
}

• 49. satır: [showString] işlevi, herhangi bir türde bir parametre alır ve sonuç döndürmez;
• 54. satır: parametrenin değeri string türüne dönüştürülür;
• 44. satır: 5 tamsayısı "5" dizesine dönüştürülecektir;
• satır 45: 6,7 sayısal değeri "6,7" dizesine dönüştürülecektir;
• satır 46: FALSE boole değeri boş bir dizeye dönüştürülecektir;
• 47. satır: NULL işaretçisi boş bir dizeye dönüştürülecektir;

Ekran sonuçları şöyledir:

paramètre : int(5)

résultat de la conversion : string(1) "5"

paramètre : float(6.7)

résultat de la conversion : string(3) "6.7"

paramètre : bool(false)

résultat de la conversion : string(0) ""

paramètre : NULL

résultat de la conversion : string(0) ""

3.6. Tablolar

3.6.1. Tek boyutlu klasik tablolar

[bases-05.php] komut dosyası şu şekildedir:

<?php

// geleneksel diziler
// başlatma
$tab1 = array(0, 1, 2, 3, 4, 5);
// dolaşım - 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// dolaşma - 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1)) {
    print "tab1[$clé]=$valeur\n";
}
// öğelerin eklenmesi
$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

Deprecated: The each() function is deprecated. This message will be suppressed on further calls in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_04.php on line 14
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 bulunmaktadı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 veya ilişkisel tablo olarak adlandırılır. $contraires["beau"] notasyonu, "güzel" anahtarına eşleştirilen 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ç olarak, sadece sözlükler vardır. n elemanlı klasik bir dizi durumunda, anahtarlar [0,n-1] aralığındaki tamsayılardır.

• 14. 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. Sonuçların 10. satırında da görüldüğü gibi, each işlevi artık PHP 7'de kullanımdan kaldırılmıştır;
• 13. satır: reset($dictionnaire) işlevi, each işlevini sözlüğün ilk (anahtar, değer) çifti üzerine yerleştirir.
• 14. satır: while döngüsü, each işlevi sözlüğün sonunda boş bir çift döndürdüğünde sona erer. Burada örtük bir dönüştürme söz konusudur: boş çift, FALSE boole değerine dönüştürülür;
• 18. satır: $tableau[]=değer notasyonu, valeur öğesini $tableau dizisinin son öğesi olarak ekler;
• 23. 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.

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

3.6.2. Sözlük veya ilişkisel dizi

[bases-06.php] komut dosyası şu şekildedir:

<?php

// sözlükler
$conjoints = ["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üğün anahtar 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

Deprecated: The each() function is deprecated. This message will be suppressed on further calls in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_05.php on line 8
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:

• 12. 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;
• 19. satır: array_keys($dictionnaire) işlevi, sözlüğün anahtar listesini dizi biçiminde döndürür;
• 24. satır: array_values($dictionnaire) işlevi, sözlüğün değer listesini tablo biçiminde döndürür;
• 43. satır: isset($variable) işlevi, $variable değişkeni tanımlanmışsa TRUE değerini, aksi takdirde FALSE değerini döndürür;
• 33. satır: unset($variable) işlevi, $variable değişkenini siler.

3.6.3. Çok boyutlu tablolar

[bases-07.php] komut dosyası şu şekildedir:

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

• 5. satır: $multi dizisinin elemanları da kendileri birer dizidir;
• 14. satır: $multi tablosu, her bir valeur'in bir tablo olduğu bir sözlüğe (clé,valeur) dönüşür;

3.7. Karakter dizileri

3.7.1. Notasyon

[bases-08.php] komut dosyası şu şekildedir:

<?php

// dizilerin gösterimi
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>

Sonuçlar:

[un,un]

3.7.2. Karşılaştırma

[bases-09.php] komut dosyası şöyledir:

<?php

// fonksiyon parametrelerinin türüne sıkı uyum
declare(strict_types=1);

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

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

Sonuçlar:

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

Yorumlar

• kodun 9. satırı: === yerine == karşılaştırma operatörü kullanılabilirdi. === operatörü, her iki operandın da aynı türde olmasını gerektirdiği için daha kısıtlayıcıdır. Burada, fonksiyon imzasında her iki parametrenin türü string olarak belirlendiğinden, == operatörü ile değiştirilebilirdi;

3.7.3. Dizgiler ve diziler arasındaki bağlantılar

[bases-10.php] komut dosyası şu şekildedir:

<?php

// dizgiyi diziye dönüştürme
$chaine = "1:2:3:4";
$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";
}
// 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

• 5. satır: explode($séparateur,$chaine) işlevi, $séparateur ile ayrılmış $chaine alanlarını almayı sağlar. Böylece, explode(":",$chaine) işlevi, ":" karakteriyle ayrılmış $chaine öğelerini bir dizi olarak alır;
• 12. satır: implode($séparateur,$tableau) işlevi, explode işlevinin tersini gerçekleştirir. Bu fonksiyon, $tableau öğelerinden oluşan ve $séparateur ile ayrılmış bir karakter dizisi döndürür;

3.7.4. Düzenli ifadeler

[bases-11.php] betiği şu şekildedir:

<?php

// fonksiyon parametreleri için katı tip kontrolü
declare (strict_types=1);

// PHP'de düzenli ifadeler
// bir dizeden farklı alanları almak
// Şablon: herhangi bir karakterle çevrili bir sayı dizisi
// sadece sayı dizisini almak istiyoruz
$modèle = "/(\d+)/";
// dizgiyi şablonla karşılaştırıyoruz
compareModele2Chaine($modèle, "xyz1234abcd");
compareModele2Chaine($modèle, "12 34");
compareModele2Chaine($modèle, "abcd");

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

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

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

// son
exit;

// --------------------------------------------------------------------------
function compareModele2Chaine(string $modèle, string $chaîne): void {
  // $chaîne dizesini $modèle şablonuyla karşılaştırır
  // dizgiyi şablonla karşılaştırır
  $champs = [];
  $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

• Burada, bir karakter dizisindeki çeşitli alanları elde etmek 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 bulunabilmesi durumunda TRUE boole değerini döndürür. Eğer öyleyse, $champs[0], şablona karşılık gelen alt dizgiyi temsil eder. Ayrıca, modèle'te parantez içinde alt modeller varsa, $champs[1], 1. alt modele karşılık gelen $chaîne'in parçası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. Model 10. satırda tanımlanmıştır: bir dizginin herhangi bir yerinde yer alan bir veya daha fazla (+) rakam (\d) dizisini belirtir. Ayrıca, model parantezlerle çevrili bir alt model tanımlar;

• 12. satır: /(\d+)/ kalıbı (dizenin herhangi bir yerinde bir veya daha fazla rakamdan oluşan dizi), "xyz1234abcd" dizesiyle karşılaştırılır. 1234 alt dizesinin bu kalıba 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. $champs[1] = "1234" olacaktır;
• 13. 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 elde edilir;
• 14. 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+)(.*?)$/";

dizgenin başlangıcına (^), ardından 0 veya daha fazla (*) herhangi bir karakter (.), ardından 1 veya daha fazla (+) rakam ve tekrar 0 veya daha fazla (*) herhangi bir karakter (.) ile eşleşir. (*) 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 0 veya daha fazla rastgele karakteri belirtir; burada \d+. 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*/";

dizinin başlangıcına (^), 0 veya daha fazla boşluğa (\s*), 0 veya 1 kez (?) geçen bir + veya - işareti [+|-]'e, 0 veya daha fazla boşluktan (\s*) oluşan bir diziye, 1 veya daha fazla rakamın ardından bir ondalık nokta ve ardından sıfır veya daha fazla rakam (\d+\.\d*) veya (|) bir ondalık nokta (\.) ve ardından bir veya daha fazla rakam (\d+) veya (|) bir veya daha fazla rakam (\d+), 0 veya daha fazla boşluktan oluşan bir dizi (\s*)].

Not: Düzenli ifadelerde [espace] terimi, bir karakter kümesini ifade eder: boşluk, satır sonu \n, sekme \t, satır başı \r, sayfa sonu \f…

3.8. İşlevler

3.8.1. Parametre aktarım yöntemi

[base-12.php] komut dosyası şöyledir:

<?php

// bir fonksiyona parametrelerin aktarılma şekli
// parametre türlerine sıkı sıkıya uyulması
declare(strict_types=1);

function f(int &$i, int $j): void {
  // $i referans yoluyla elde edilecektir
  // $j değer olarak aktarılacaktır
  $i++;
  $j++;
  print "f[i,j]=[$i,$j]\n";
}

// testler
$i = 0;
$j = 0;
// $i ve $j, f işlevine 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;
• 7. 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 1. ve 7. satırlarda 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, etkin 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çimli parametresinin değeri, $j etkin parametresinin değerini alı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){….}

Aşağıdaki [base-13.php] komut dosyası başka örnekler göstermektedir:

<?php

// sıkı modda türler
// declare(strict_types = 1);

// parametre aktarım modu

function f(&$i, $j) {
  // $i referans yoluyla alınacaktır
  // $j değer olarak alınacaktır
  $i++;
  $j++;
  print "f[i,j]=[$i,$j]\n";
}

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

// testler
$i = 0;
$j = 0;
// $i ve $j, f işlevine aktarıldı
f($i, $j);
print "test[i,j]=[$i,$j]\n";
// $i ve $j, g işlevine aktarılır
g($i, $j);
print "test[i,j]=[$i,$j]\n";
// f işlevine yanlış parametreler aktarılıyor
$a=5.3;
$b=6.2;
f($a, $b);
print "test[a,b]=[$a,$b]\n";
// f işlevine yanlış parametreler aktarılıyor
$a=5.3;
$b=6.2;
g($a, $b);
print "test[a,b]=[$a,$b]\n";

Yorumlar

• 8-14. satırlar: Bir önceki paragrafta incelenen f fonksiyonu, ancak parametrelerin türleri belirtilmemiştir;
• satır 16-22: g fonksiyonu, f fonksiyonuyla aynı işi yapar ancak beklenen parametrelerin türü belirtilmiştir – bu bir yeniliktir PHP 7. İki adet int türünde parametre beklenmektedir. Fonksiyona geçirilen gerçek parametrenin, fonksiyonun beklediği türde olmadığı durumda ne olacağını görmek istiyoruz;
• 25-26. satırlar: $i ve $j iki tamsayıdır;
• 28-29. satırlar: f fonksiyonu, beklenen türde parametrelerle çağrılıyor;
• satır 31-32: g fonksiyonunun beklenen türde parametrelerle çağrılması;
• satır 34-35: $a ve $b değişkenleri float türündedir;
• satır 36-37: f fonksiyonunun, beklenen türde olmayan parametrelerle çağrılması;
• satır 41-42: g fonksiyonunun beklenen türde olmayan parametrelerle çağrılması;

Sonuçlar

f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6.3,7.2]
test[a,b]=[6.3,6.2]
g[i,j]=[6,7]
test[a,b]=[6,6.2]

• 5-6. satırlar, f fonksiyonunun her iki float türündeki parametreyi de kabul ettiğini ve bunlarla çalıştığını göstermektedir;
• 7-8. satırlar, g fonksiyonunun her iki float türündeki parametreyi kabul ettiğini, ancak bunları int türüne dönüştürdüğünü göstermektedir (7. satır);

Şimdi 4. satırdaki yorum işaretini kaldıralım:

declare(strict_types = 1);

Bu komut, biçimsel parametrelerin türlerine uyulması gerektiğini belirtir. Aksi takdirde bir hata bildirilir. Yürütme sonuçları şu şekilde olur:

f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6.3,7.2]
test[a,b]=[6.3,6.2]

Fatal error: Uncaught TypeError: Argument 1 passed to g() must be of the type integer, float given, called in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_111.php on line 40 and defined in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_111.php:15
Stack trace:
#0 C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_111.php(40): g(5.3, 6.2)
#1 {main}
  thrown in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_111.php on line 15

• 9-10. satırlar: PHP 7 yorumlayıcısı, g işlevine geçirilen ilk parametrenin doğru türde olmadığını belirtmek için bir istisna oluşturdu. İşlev çağrı hatalarını tespit etmek için, mümkün olduğunca her zaman parametre türleri konusunda katı davranılması önerilir;

3.8.2. Bir işlev tarafından döndürülen sonuçlar

[base-15.php] komut dosyası şöyledir:

<?php

// sıkı modda türler
declare(strict_types=1);

// bir fonksiyonun döndürdüğü sonuçlar
// bir fonksiyon 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 "f1 : res[$i]=$res[$i]\n";
}

// bir işlev bir nesne döndürebilir
$res = f2(10);
print "f2 : [$res->res1,$res->res2,$res->res3]\n";
// ne tür bir nesne?
print "nature de l'objet : ";
var_dump($res);
print "\n";

// f3 fonksiyonuyla da aynı şeyi yapıyoruz
$res = f3(10);
print "f3 : [$res->res1,$res->res2,$res->res3]\n";
// Ne tür bir nesne?
print "nature de l'objet : ";
var_dump($res);
print "\n";

// son
exit;

// f1 işlevi
function f1(int $valeur): array {
  // bir dizi döndürür ($valeur+1,$valeur+2,$valeur+3)
  return array($valeur + 1, $valeur + 2, $valeur + 3);
}

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

// f3 işlevi - f2 işleviyle aynı şeyi yapar
function f3(int $valeur): object {
  // bir nesne döndürür ($valeur+1,$valeur+2,$valeur+3)
  $res = new stdclass();
  $res->res1 = $valeur + 1;
  $res->res2 = $valeur + 2;
  $res->res3 = $valeur + 3;
  // nesneyi döndürür
  return $res;
}

Sonuçlar

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

Warning: Creating default object from empty value in C:\Data\st-2019\dev\php7\php5-exemples\exemples\bases\base-15.php on line 43
f2 : [11,12,13]
nature de l'objet : object(stdClass)#1 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}

f3 : [11,12,13]
nature de l'objet : object(stdClass)#2 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}

Açıklamalar

• Yukarıdaki program, PHP işlevinin tek bir sonuç yerine bir dizi sonuç verebileceğini, bu sonuçların bir dizi veya nesne biçiminde olabileceğini göstermektedir. Nesne kavramı biraz ileride açıklanmaktadır;
• 35-38. satırlar: f1 işlevi, bir dizi (array) biçiminde birden fazla değer döndürür;
• 41-48. satırlar: f2 işlevi, bir nesne (object) biçiminde birden fazla değer döndürür;
• satır 51-59: f3 fonksiyonu, 53. satırda açıkça bir nesne oluşturması dışında f2 fonksiyonuyla aynıdır;
• sonuçların 6. satırında, PHP'in kodun 43. satırında, yani [$res→res1] notasyonu kullanılırken varsayılan bir nesne oluşturmak zorunda kaldığını belirten bir uyarı (warning) verilmektedir. Kodun 20. satırındaki var_dump işlevi, nesnenin türüne ve içeriğine erişim sağlar. Sonuçlarda şunlar görülmektedir:
  • 8. satır: varsayılan olarak oluşturulan nesne stdClass türündedir;
  • 9-10. satırlar: res1 özelliği, entier türündedir ve değeri 11'dir;
  • vb…
  • sonuçların 6. satırındaki uyarıyı önlemek için, f3 fonksiyonunun 53. satırında stdClass türünde bir nesne açıkça oluşturulur;

3.9. Metin dosyaları

[bases-16.php] komut dosyası şu şekildedir:

<?php

// fonksiyon parametrelerinin türüne sıkı bir şekilde uyulur
declare (strict_types=1);

// bir metin dosyasının sıralı olarak işlenmesi
// 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
// dosyayı okuma modunda açıyoruz
if (!$fic = fopen($INFOS, "r")) {
  print "Erreur d'ouverture du fichier $INFOS en lecture\n";
  exit;
}

// satırların uzunluğu 1000 karakterden az
// satır okuma işlemi satır sonu işaretinde durur
// veya dosya sonu işaretinde
while ($ligne = fgets($fic, 1000)) {
  // varsa satır sonu işaretini siler
  $ligne = cutNewLineChar($ligne);
  // satırı bir tabloya yerleştirilir
  $infos = explode(":", $ligne);
  // giriş bilgisini alıyoruz
  $login = array_shift($infos);
  // şifreyi göz ardı ediyoruz
  array_shift($infos);
  // sözlüğe bir giriş oluşturulur
  $dico[$login] = $infos;
}
// sözlüğü kapatıyoruz
fclose($fic);

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

// son
exit;

// --------------------------------------------------------------------------
function afficheInfos(array $dico, string $clé): void {
  // 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(string $ligne): string {
  // $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

• 12. 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, birbirini izleyen iki işlem vardır: 1) $fic = fopen(..) 2) if( ! $fic) {…} ;
• 18. satır: fputs($fic,$chaîne) komutu, chaîne değerini $fic dosyasına yazar. $chaine, arkasına \n satır sonu işareti eklenerek yazılır;
• 21. satır: fclose($fic) komutu, $fic dosyasını kapatır;
• 26. 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 (örneğin dosya yoksa), fopen false değerini döndürür;
• 34. satır: fgets($fic,1000) komutu, dosyadan bir sonraki satırı 1000 karakter sınırı dahilinde okur. while ($ligne = fgets($fic, 1000)) {…} ifadesinde, birbirini izleyen iki işlem vardır: 1) $ligne = fgets(…) 2) while ( ! $ligne). Dosyanın son karakteri okunduktan sonra, fgets işlevi false değerini döndürür ve while döngüsü sona erer. fgets işlevi burada en fazla 1000 karakter okumaya çalışır, ancak bir satır sonu işaretiyle karşılaşır karşılaşmaz durur. Burada tüm satırlar 1000 karakterden kısa olduğundan, [fgets] işlevi satır sonu karakteri de dahil olmak üzere bir satır metin okur. 75-84. satırlardaki cutNewLineChar işlevi, olası satır sonu karakterlerini ortadan kaldırır;
• 77. satır: strlen($chaîne) işlevi, $chaîne'in karakter sayısını verir;
• 78. satır: substr($ligne, $position, $taille) işlevi, $ligne dizisinden $taille karakterlik bir parçayı, $position numaralı karakterden başlayarak alır; burada ilk karakterin numarası 0'dır. Windows sistemlerinde satır sonu işareti "\r\n" şeklindedir. Unix sistemlerinde ise "\n" dizesidir;
• 40. satır: array_shift($tableau) işlevi, $tableau'in ilk elemanını çıkarır ve bunu sonuç olarak döndürür. Burada array_shift tarafından döndürülen sonuç göz ardı edilir;
• 62. satır: is_array($variable) işlevi, $variable bir dizi ise true'i, aksi takdirde false'i döndürür;
• 63. satır: join işlevi, daha önce karşılaştığımız implode işleviyle aynı işlevi görür;

3.10. Kodlama / kod çözme jSON

jSON kodlama / kod çözme (JavaScript Nesne Notasyonu), bu belgenin ana temasını oluşturan alıştırmada yoğun olarak kullanacağımız bir konudur. [json-01.php, json-02.php, json-03.php] komut dosyaları, ilerleyen bölümler için bilinmesi gerekenleri açıklamaktadır.

[json-01.php] betiği şu şekildedir:

<?php

$array1 = ["nom" => "séléné", "prénom" => "bénédicte", "âge" => 34];
// array1 dizisinin, Unicode karakterleri kaçış karakterleriyle kodlanmış json biçimi
print "encodage json du tableau array1 avec caractères Unicode échappés\n";
$json1 = json_encode($array1);
print "json1=$json1\n";
// array1 dizisinin, Unicode karakterleri kaçış karakterleri olmadan json olarak kodlanması
print "encodage json du tableau array1 avec caractères Unicode non échappés\n";
$json2 = json_encode($array1, JSON_UNESCAPED_UNICODE);
print "json2=$json2\n";
// jSON'in ilişkisel diziye kod çözülmesi
print "décodage jSON de json2 dans tableau associatif\n";
$array2 = json_decode($json2, true);
var_dump($array2);
foreach ($array2 as $key => $value) {
  print "$key:$value\n";
}
// jSON'in nesneye kodunun çözülmesi
print "décodage jSON de json2 dans objet stdClass\n";
$array2 = json_decode($json2);
var_dump($array2);
print "prénom=$array2->prénom\n";
print "nom=$array2->nom\n";
print "âge=$array2->âge\n";

Sonuçlar

encodage json du tableau array1 avec caractères Unicode échappés
json1={"nom":"s\u00e9l\u00e9n\u00e9","pr\u00e9nom":"b\u00e9n\u00e9dicte","\u00e2ge":34}
encodage json du tableau array1 avec caractères Unicode non échappés
json2={"nom":"séléné","prénom":"bénédicte","âge":34}
décodage jSON de json2 dans tableau associatif
array(3) {
  ["nom"]=>
  string(9) "séléné"
  ["prénom"]=>
  string(11) "bénédicte"
  ["âge"]=>
  int(34)
}
nom:séléné
prénom:bénédicte
âge:34
décodage jSON de json2 dans objet stdClass
object(stdClass)#1 (3) {
  ["nom"]=>
  string(9) "séléné"
  ["prénom"]=>
  string(11) "bénédicte"
  ["âge"]=>
  int(34)
}
prénom=bénédicte
nom=séléné
âge=34

Yorumlar

• kodun 6. satırı: [json_encode] işlevi, parametresini jSON karakter dizisine dönüştürür;
• sonuçların 2. satırı: üretilen jSON karakter dizisi. éâ Unicode karakterleri, \u ile başlayan Unicode kodlarıyla değiştirilmiştir;
• kodun 10. satırı: aynı işlemi tekrarlıyoruz, ancak bu sefer Unicode karakterlerinin olduğu gibi korunmasını istiyoruz;
• sonuçların 4. satırı: ortaya çıkan jSON dizesi. Bu, çok daha okunaklıdır;
• kodun 14-18. satırları: ters işlemi gerçekleştiriyoruz. jSON dizesini bir ilişkisel diziye dönüştürüyoruz;
• sonuçların 6-13. satırları: bir ilişkisel dizinin elde edildiği görülüyor;
• kodun 19-25. satırları: jSON dizesini [stdClass] türünde bir nesneye dönüştürüyoruz;
• sonuçların 18-25. satırları: [stdClass] türünde bir nesne elde edildiği görülüyor;
• kodun 23-25. satırları: O nesnesinin A özniteliği, [O→A] olarak gösterilir;

Aşağıdaki [json-02.php] betiğinde gösterildiği gibi, çok düzeyli tabloları jSON formatında kodlayabiliriz:

<?php

$array = ["nom" => "séléné", "prénom" => "bénédicte", "âge" => 34,
  "mari" => ["nom" => "icariù", "prénom" => "ignacio", "âge" => 35],
  "enfants" => [
    ["prénom" => "angèle", "age" => 8],
    ["prénom" => "andré", "age" => 2],
  ]];
// çok düzeyli dizinin jSON kodlaması
print "encodage jSON d'un tableau à plusieurs niveaux\n";
$json = json_encode($array, JSON_UNESCAPED_UNICODE);
print "json=$json\n";

Sonuçlar

encodage jSON d'un tableau à plusieurs niveaux
json={"nom":"séléné","prénom":"bénédicte","âge":34,"mari":{"nom":"icariù","prénom":"ignacio","âge":35},"enfants":[{"prénom":"angèle","age":8},{"prénom":"andré","age":2}]}

Yorumlar

jSON dizesinde:

• ilişkisel olmayan diziler köşeli parantez [] ile çevrelenir;
• ilişkisel diziler ise küme parantezleri {} ile çevrelenmiştir;

[json-03.php] komut dosyası, aşağıdaki jSON ve [famille.json] dosyalarının nasıl kullanılacağını gösterir:

{
    "épouse": {
        "nom": "séléné",
        "prénom": "bénédicte",
        "âge": 34
    },
    "mari": {
        "nom": "icariù",
        "prénom": "ignacio",
        "âge": 35
    },
    "enfants": [
        {
            "prénom": "angèle",
            "age": 8
        },
        {
            "prénom": "andré",
            "age": 2
        }
    ]
}

[json-03.php] komut dosyası şöyledir:

<?php

// jSON dosyasının okunması
$json = file_get_contents("famille.json");
// json'un nesneye kod çözme
$famille1 = json_decode($json);
print "----famille1\n";
var_dump($famille1);
// JSON'u ilişkisel tabloya dönüştürme
print "----famille2\n";
$famille2 = json_decode($json, true);
var_dump($famille2);

Açıklamalar

• 4. satır: [file_get_contents] işlevi, [famille.json] adlı dosyanın içeriğini okur ve bunu [$json] değişkenine atar;
• değişken daha sonra nesneye (5-8. satırlar) ve ilişkisel diziye (9-12. satırlar) dönüştürülür;

Sonuçlar

----famille1
object(stdClass)#2 (3) {
  ["épouse"]=>
  object(stdClass)#1 (3) {
    ["nom"]=>
    string(9) "séléné"
    ["prénom"]=>
    string(11) "bénédicte"
    ["âge"]=>
    int(34)
  }
  ["mari"]=>
  object(stdClass)#3 (3) {
    ["nom"]=>
    string(7) "icariù"
    ["prénom"]=>
    string(7) "ignacio"
    ["âge"]=>
    int(35)
  }
  ["enfants"]=>
  array(2) {
    [0]=>
    object(stdClass)#4 (2) {
      ["prénom"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    object(stdClass)#5 (2) {
      ["prénom"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
----famille2
array(3) {
  ["épouse"]=>
  array(3) {
    ["nom"]=>
    string(9) "séléné"
    ["prénom"]=>
    string(11) "bénédicte"
    ["âge"]=>
    int(34)
  }
  ["mari"]=>
  array(3) {
    ["nom"]=>
    string(7) "icariù"
    ["prénom"]=>
    string(7) "ignacio"
    ["âge"]=>
    int(35)
  }
  ["enfants"]=>
  array(2) {
    [0]=>
    array(2) {
      ["prénom"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    array(2) {
      ["prénom"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}

Açıklamalar

• satır 1-38: jSON ve [famille.json] dosyalarının kodunun çözülmesiyle elde edilen nesne;
• satır 39-76: jSON ve [famille.json] dosyalarının kodunun çözülmesiyle elde edilen ilişkisel dizi;