koddla

Yazılımcıları bilgi ile güçlendirir.

PHP’de Değişkenler

$ PHP’de değişkenlere atama yapmanın yoludur. PHP’deki değişkenler dinamik olarak yazılır, yani türleri kendilerine atanan şey tarafından belirlenir.

$a = “Bu bir string”;

$b = 1; // Bu bir int

$bldgA = new Building(‘red’); // bldgA bir değişkendir ve Building sınıfının bir nesnesidir (diğer adıyla bir nesne).

$bldgA->describe(); // Bu, Building sınıfının bir üye işlevi olan describe() işlevini çağırır ($bldgA’nın Building sınıfının bir nesnesi olarak bildirildiğini hatırlayın)

$bldgA->number_of_floors; // number_of_floors, Building sınıfının bir veri üyesidir. Bunu bir sınıfın içindeki bir değişken olarak düşünebilirsiniz, ancak sınıfın sabit bir adı olan bir parçası olduğu için $ ile atıfta bulunmazsınız.

Söz dizimi

  • $variable = ‘value’; // Genel değişken atama
  • $object->property = ‘value’; // Bir nesne özelliği atayın
  • ClassName::$property = ‘value’; // Statik bir sınıf özelliği atayın
  • $array[0] = ‘value’; // Dizinin bir indeksine değer atayın
  • $array[] = ‘value’; // Dizinin sonuna bir öğe ekleyin
  • $array[‘key’] = ‘value’; // Bir dizi değeri atayın
  • echo $değişken; // Bir değişken değerini yazdırın
  • some_function($variable); // Değişkeni fonksiyon parametresi olarak kullan
  • unset($variable); // Bir değişkenin kaydını sil
  • $$variable = ‘value’; // Bir değişkene değişken atayın
  • isset($variable); // Bir değişkenin atanmış olup olmadığını kontrol edin
  • empty($variable); // Bir değişkenin boş olup olmadığını kontrol edin

Tür kontrolü

Değişkenler ve türlerle ilgili bazı belgelerde PHP’nin statik tipleme kullanmadığından bahsedilmektedir. Bu doğrudur, ancak PHP, işlev/yöntem parametreleri ve dönüş değerleri söz konusu olduğunda bazı tür denetimleri yapar (özellikle PHP 7 ile).

PHP 7’de tür imi kullanarak parametre ve dönüş değeri tür denetimini aşağıdaki gibi uygulayabilirsiniz:

<?php

/**
 * Sayılarla hokkabazlık yapın ve hokkabazlık başarılıysa true döndürün.
 */
function numberJuggling(int $a, int $b) : bool
{
    $sum = $a + $b;

    return $sum % 2 === 0;
}

Not: PHP’nin tamsayılar ve booleanlar için gettype() işlevi sırasıyla integer ve boolean’dır. Ancak bu tür değişkenler için tür bilgisi için int ve bool kullanmanız gerekir. Aksi takdirde PHP size bir sözdizimi hatası vermez, ancak integer ve boolean sınıflarının geçilmesini bekler.

Yukarıdaki örnek, $a veya $b parametresi olarak sayısal olmayan bir değer verilmesi ve fonksiyonun true veya false dışında bir değer döndürmesi durumunda hata verir. Yukarıdaki örnek “gevşektir”, yani $a veya $b’ye float değeri verebilirsiniz. Eğer katı tipleri uygulamak istiyorsanız, yani sadece tamsayı girebilir ve float giremezseniz, PHP dosyanızın en başına aşağıdakileri ekleyin:

<?php
declare('strict_types=1');

PHP 7’den önce işlevler ve yöntemler aşağıdaki türler için tür ipucuna izin veriyordu:

  • callable (çağrılabilir bir işlev veya yöntem)
  • dizi (başka dizileri de içerebilen herhangi bir dizi türü)
  • Arayüzler (Fully-Qualified-Class-Name veya FQDN)
  • Sınıflar (FQDN)

Değişkenleri bastırma: echo ve print

echo ve print işlev değil, dil yapılarıdır. Bu, bir işlevin yaptığı gibi argümanın etrafında parantez gerektirmedikleri anlamına gelir (hemen hemen her PHP ifadesinin etrafına her zaman parantez eklenebilir ve bu nedenle echo(“test”) de herhangi bir zarar vermez). Bir değişkenin, sabitin veya ifadenin dize gösterimini çıktılarlar. Dizileri veya nesneleri yazdırmak için kullanılamazlar.

  • Joel dizesini $name değişkenine atayın
$name = "Joel";
  • echo & print kullanarak $name değerinin çıktısını alın
echo $name;   #> Joel
print $name;  #> Joel
  • Parantezler gerekli değildir, ancak kullanılabilir
echo($name);  #> Joel
print($name); #> Joel
  • Birden fazla parametre kullanma (sadece echo)
echo $name, "Smith";       #> JoelSmith
echo($name, " ", "Smith"); #> Joel Smith
  • print, echo’dan farklı olarak bir ifadedir (1 döndürür) ve bu nedenle daha fazla yerde kullanılabilir:
print("hey") && print(" ") && print("you"); #> you11
  • Yukarıdakiler şuna eşdeğerdir:
print ("hey" && (print (" " && print "you"))); #> you11

Echo için kısa gösterim

PHP etiketlerinin dışındayken, echo için öntanımlı olarak, çıktıyı başlatmak için kullanan bir kısaltma gösterimi mevcuttur. Örneğin:

<p><?=$variable?></p>    
<p><?= "This is also PHP" ?></p>

Sonlandırıcı ; olmadığına dikkat edin. Bunun nedeni, kapanış PHP etiketinin tek bir deyim için sonlandırıcı görevi görmesidir. Dolayısıyla, bu kısaltılmış gösterimde noktalı virgülün atlanması gelenekseldir.

print önceliği 

print dil yapısı olmasına rağmen operatör gibi önceliğe sahiptir. .= += -= *= **= /= .= %= &= ve and operatörleri arasında yer alır ve sol ilişkilendirmeye sahiptir. Örnek:

echo '1' . print '2' + 3; //çıktı 511

Parantezlerle aynı örnek:

echo '1' . print ('2' + 3); //çıktı 511

echo ve print arasındaki farklar 

Kısacası, iki temel farklılık vardır:

  • print yalnızca bir parametre alırken, echo birden fazla parametre alabilir.
  • print bir değer döndürür, bu nedenle bir ifade olarak kullanılabilir.

Dizileri ve nesneleri ekrana bastırma

print_r() – Hata ayıklama için Dizilerin ve Nesnelerin Çıktısını Alma 

print_r bir dizinin veya nesnenin insan tarafından okunabilir bir biçiminin çıktısını verir.

Bir dizi veya nesne olan bir değişkeniniz olabilir. Bir echo ile çıktı almaya çalışmak hata verecektir:

Uyarı: Diziden dizeye dönüştürme. Bunun yerine, bu değişkenin insan tarafından okunabilir bir biçimini dökmek için print_r işlevini kullanabilirsiniz.

İçeriği bir dize olarak döndürmek için ikinci parametre olarak true değerini geçebilirsiniz.

$myobject = new stdClass();
$myobject->myvalue = 'Hello World';
$myarray = [ "Hello", "World" ];
$mystring = "Hello World";
$myint = 42;

// print_r kullanarak dizinin tuttuğu verileri görüntüleyebiliriz.
print_r($myobject);
print_r($myarray);
print_r($mystring);
print_r($myint);

Bu, aşağıdaki çıktıları verir:

stdClass Object
(
    [myvalue] => Hello World
)
Array
(
    [0] => Hello
    [1] => World
)
Hello World
42

Ayrıca, print_r çıktısı basitçe echo edilmek yerine bir string olarak yakalanabilir. Örneğin, aşağıdaki kod $myarray’in biçimlendirilmiş halini yeni bir değişkene dökecektir:

$formatted_array = print_r($myarray, true);

PHP’nin çıktısını bir tarayıcıda görüntülüyorsanız ve HTML olarak yorumlanıyorsa, satır sonlarının gösterilmeyeceğini ve aşağıdaki gibi bir şey yapmadığınız sürece çıktının çok daha az okunaklı olacağını unutmayın

echo '<pre>' . print_r($myarray, true) . '</pre>';

Bir sayfanın kaynak kodunu açmak da değişkeninizi <pre> etiketi kullanmadan aynı şekilde biçimlendirecektir.

Alternatif olarak tarayıcıya çıktısını aldığınız şeyin HTML değil düz metin olduğunu söyleyebilirsiniz:

header('Content-Type: text/plain; charset=utf-8');
print_r($myarray);

var_dump() – Türü ve değeri de dahil olmak üzere değişken(ler)in çıktısı 

Çıktı, print_r ile karşılaştırıldığında daha ayrıntılıdır çünkü değeriyle birlikte değişkenin türünü ve nesne kimlikleri, dizi boyutları, dize uzunlukları, referans işaretleyicileri vb. gibi diğer bilgileri de çıktı olarak verir.

Hata ayıklama amacıyla daha ayrıntılı bir sürüm çıktısı almak için var_dump kullanabilirsiniz.

var_dump($myobject, $myarray, $mystring, $myint);

Çıktı daha ayrıntılıdır:

object(stdClass)#12 (1) {
  ["myvalue"]=>
  string(11) "Hello World"
}
array(2) {
  [0]=>
  string(5) "Hello"
  [1]=>
  string(5) "World"
}
string(11) "Hello World"
int(42)

var_export() – Geçerli PHP Kodu Çıktısı 

var_export() öğenin PHP ile çözümlenebilir bir gösterimini döker.

İçeriği bir değişkene döndürmek için ikinci parametre olarak true değerini geçebilirsiniz.

var_export($myarray);
var_export($mystring);
var_export($myint);

Çıktı geçerli PHP kodudur:

array (
  0 => 'Hello',
  1 => 'World',
)
'Hello World'
42

İçeriği bir değişkene koymak için şunu yapabilirsiniz:

$array_export = var_export($myarray, true);
$string_export = var_export($mystring, true);
$int_export = var_export($myint, 1); // herhangi bir `Doğru` değeri

Bundan sonra, bu şekilde çıktı alabilirsiniz:

printf('$myarray = %s; %s', $array_export, PHP_EOL);
printf('$mystring = %s; %s', $string_export, PHP_EOL);
printf('$myint = %s; %s', $int_export, PHP_EOL);

Bu, aşağıdaki çıktıyı üretecektir:

$myarray = array (
  0 => 'Hello',
  1 => 'World',
);
$mystring = 'Hello World';
$myint = 42;

Bir Değişkene Dinamik Olarak Erişme – İsim Değişken Değişkenleri

Değişkenlere dinamik değişken adları aracılığıyla erişilebilir. Bir değişkenin adı başka bir değişkende saklanabilir ve böylece değişkene dinamik olarak erişilebilir. Bu tür değişkenler, değişken değişkenleri olarak bilinir.

Bir değişkeni değişken değişkene dönüştürmek için, değişkeninizin önüne fazladan bir $ işareti koyarsınız.

$variableName = 'foo';
$foo = 'bar';

// Aşağıdakilerin hepsi eşdeğerdir ve hepsi "bar" çıktısı verir:
echo $foo;
echo ${$variableName};
echo $$variableName;

//aynı şekilde,
$variableName  = 'foo';
$$variableName = 'bar';

// Aşağıdaki ifadeler de 'bar' çıktısı verecektir
echo $foo; 
echo $$variableName; 
echo ${$variableName};

Değişken değişkenler, fonksiyon/metot çağrılarını eşlemek için kullanışlıdır:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

Bu özellikle PHP sınıflarında çok daha yardımcı olur:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Çıktı "Hello World"
    }
}

{} arasına $variableName koymak mümkündür, ancak gerekli değildir:

${$variableName} = $value;

Aşağıdaki örneklerin her ikisi de eşdeğerdir ve “baz” çıktısı verir:

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Çıktı "baz"
echo ${$varPrefix . 'Bar'}; // Çıktı "baz"

{} kullanılması yalnızca değişkenin adı aşağıdaki gibi bir ifade olduğunda zorunludur:

${$variableNamePart1 . $variableNamePart2} = $value;

Bununla birlikte, daha okunabilir olduğu için her zaman {} kullanılması önerilir.

Yapılması tavsiye edilmese de, bu davranışı zincirlemek de mümkündür:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

Değişken değişkenlerin aşırı kullanımının birçok geliştirici tarafından kötü bir uygulama olarak görüldüğünü belirtmek önemlidir. Modern IDE’ler tarafından statik analiz için uygun olmadıklarından, çok sayıda değişken değişkene (veya dinamik yöntem çağrılarına) sahip büyük kod tabanlarının bakımı hızla zorlaşabilir.

PHP5 ve PHP7 arasındaki farklar 

Her zaman {} veya () kullanmanın bir başka nedeni de, PHP5 ve PHP7’nin dinamik değişkenleri ele alma yöntemlerinin biraz farklı olması ve bazı durumlarda farklı sonuçlara yol açmasıdır.

PHP7’de, dinamik değişkenler, özellikler ve yöntemler PHP5’teki özel durumların karışımının aksine artık soldan sağa sırayla değerlendirilecektir. Aşağıdaki örnekler değerlendirme sırasının nasıl değiştiğini göstermektedir.

Durum 1 : $$foo['bar']['baz'] 

  • PHP5 yorumlaması : ${$foo['bar']['baz']}
  • PHP7 yorumlaması : ($$foo)['bar']['baz']

Durum 2 : $foo->$bar['baz'] 

  • PHP5 yorumlaması : $foo->{$bar['baz']}
  • PHP7 yorumlaması : ($foo->$bar)['baz']

Durum 3 : $foo->$bar['baz']() 

  • PHP5 yorumlaması : $foo->{$bar['baz']}()
  • PHP7 yorumlaması : ($foo->$bar)['baz']()

Durum 4 : Foo::$bar['baz']() 

  • PHP5 yorumlaması : Foo::{$bar['baz']}()
  • PHP7 yorumlaması : (Foo::$bar)['baz']()

Veri Türleri

Farklı amaçlar için farklı veri türleri vardır. PHP’de açık tür tanımları yoktur, ancak bir değişkenin türü atanan değerin türüne veya atandığı türe göre belirlenir.

PHP’de şu veri türleri vardır: null, boolean, integer, float, string, object, resource ve array.

Null 

Null herhangi bir değişkene atanabilir. Değeri olmayan bir değişkeni temsil eder.

$foo = null;

Bu, değişkeni geçersiz kılar ve çağrıldığında değeri tanımsız veya geçersiz olur. Değişken bellekten temizlenir ve çöp toplayıcı tarafından silinir.

Boolean 

Bu, yalnızca iki olası değeri olan en basit türdür.

$foo = true;
$bar = false;

Boolean’lar kod akışını kontrol etmek için kullanılabilir.

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

Integer 

Tamsayı, pozitif veya negatif bir tam sayıdır. Herhangi bir sayı tabanı ile kullanılabilir. Bir tamsayının boyutu platforma bağlıdır. PHP işaretsiz tamsayıları desteklemez.

$foo = -3;  // negatif
$foo = 0;   // sıfır (null veya false (boolean olarak) da olabilir)
$foo = 123; // pozitif ondalık
$bar = 0123; // octal = 83 ondalık
$bar = 0xAB; // hexadecimal = 171 ondalık
$bar = 0b1010; // binary = 10 ondalık
var_dump(0123, 0xAB, 0b1010); // çıktı: int(83) int(171) int(10)

Float 

Kayan noktalı sayılar, “çiftler” veya kısaca “float” olarak adlandırılan sayılar ondalık sayılardır.

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

Array 

Dizi, bir değerler listesi gibidir. Bir dizinin en basit biçimi tamsayı ile indekslenir ve ilk eleman 0 indisinde olacak şekilde indekse göre sıralanır.

$foo = array(1, 2, 3); // Bir tamsayı dizisi
$bar = ["A", true, 123 => 5]; // Kısa dizi sözdizimi, PHP 5.4+

echo $bar[0];    //  "A"
echo $bar[1];    // true
echo $bar[123];  // 5
echo $bar[1234]; // null

Diziler, bir değere tamsayı indeksinden başka bir anahtar da ilişkilendirebilir. PHP’de, tüm diziler perde arkasında ilişkisel dizilerdir, ancak bir ‘ilişkisel dizi’den farklı olarak bahsettiğimizde, genellikle tamsayı olmayan bir veya daha fazla anahtar içeren bir diziyi kastederiz.

$array = array();
$array["foo"] = "bar";
$array["baz"] = "quux";
$array[42] = "hello";
echo $array["foo"]; // Çıktı "bar"
echo $array["bar"]; // Çıktı "quux"
echo $array[42]; // Çıktı "hello"

String 

Bir dize, karakterlerden oluşan bir dizi gibidir.

$foo = "bar";

Bir dizi gibi, bir dize de tek tek karakterlerini döndürmek için indekslenebilir:

$foo = "bar";
echo $foo[0]; // b', $foo içindeki dizenin ilk karakterini yazdırır.

Object 

Nesne, bir sınıfın örneğidir. Değişkenlerine ve yöntemlerine -> operatörü ile erişilebilir.

$foo = new stdClass(); // önceden tanımlanmış olan stdClass sınıfından yeni bir nesne oluşturur, 
$foo->bar = "baz";
echo $foo->bar; // çıktı "baz"
// Ya da bir diziyi bir nesneye dönüştürebiliriz:
$quux = (object) ["foo" => "bar"];
echo $quux->foo; // Bu, "bar" çıktısını verir.

Resource 

Kaynak değişkenleri, açılan dosyalara, veritabanı bağlantılarına, akışlara, görüntü tuval alanlarına ve benzerlerine (kılavuzda belirtildiği gibi) özel tutamaçlar tutar.

$fp = fopen('file.ext', 'r'); // fopen(), disk üzerindeki bir dosyayı kaynak olarak açma işlevidir.
var_dump($fp); // çıktı: (stream) türünde kaynak(2)

—

Bir değişkenin türünü dize olarak almak için gettype() fonksiyonunu kullanın:

echo gettype(1); // çıktı "integer"
echo gettype(true); // "boolean"

Global değişkenler

Aşağıdaki koda bakalım:

function foo() {
    global $bob;
    $bob->doSomething();
}

Buradaki ilk sorunuz çok açık

$bob nereden geldi?

Kafanız mı karıştı? Güzel. Globallerin neden kafa karıştırıcı olduğunu ve kötü bir uygulama olarak kabul edildiğini öğrendiniz.

Bu gerçek bir program olsaydı, bir sonraki eğlenceniz $bob’un tüm örneklerini takip etmek ve doğru olanı bulmayı ummak olurdu ($bob her yerde kullanılıyorsa bu daha da kötüleşir). Daha da kötüsü, eğer başka biri $bob’u tanımlarsa (ya da siz bu değişkeni unutup tekrar kullanırsanız) kodunuz bozulabilir (yukarıdaki kod örneğinde, yanlış nesneye sahip olmak ya da hiç nesneye sahip olmamak ölümcül bir hataya neden olur).

Neredeyse tüm PHP programları include(‘file.php’) gibi kodlar kullandığından, ne kadar çok dosya eklerseniz bu gibi kodları korumak işiniz o kadar zorlaşır.

Ayrıca bu, uygulamalarınızı test etme görevini çok zorlaştırır. Veritabanı bağlantınızı tutmak için global bir değişken kullandığınızı varsayalım:

$dbConnector = new DBConnector(...);function doSomething() {global $dbConnector;$dbConnector->execute("...");}

Bu işlevi birim testine tabi tutmak için global $dbConnector değişkenini geçersiz kılmanız, testleri çalıştırmanız ve ardından orijinal değerine sıfırlamanız gerekir ki bu da hataya çok meyillidir:

/*** @test*/function testSomething() {global $dbConnector;$bkp = $dbConnector; // Make backup$dbConnector = Mock::create('DBConnector'); // OverrideassertTrue(foo());$dbConnector = $bkp; // Restore}

Globallerden nasıl kaçınırız?

Globallerden kaçınmanın en iyi yolu Dependency Injection adı verilen bir felsefedir. Bu, ihtiyaç duyduğumuz araçları fonksiyona veya sınıfa aktardığımız yerdir.

function foo(\Bar $bob) {
    $bob->doSomething();
}

Bunu anlamak ve sürdürmek çok daha kolaydır. Bob’un nerede kurulduğunu tahmin etmek gerekmez çünkü bunu bilmek çağıranın sorumluluğundadır (bilmemiz gerekenleri bize aktarır). Daha da iyisi, aktarılanları kısıtlamak için tip bildirimlerini kullanabiliriz.

Böylece $bob’un Bar sınıfının bir örneği ya da Bar’ın bir çocuğunun örneği olduğunu biliyoruz, yani bu sınıfın yöntemlerini kullanabileceğimizi biliyoruz. Standart bir autoloader (PHP 5.3’ten beri mevcut) ile birlikte, artık Bar’ın nerede tanımlandığını bulabiliriz. PHP 7.0 veya sonrası, skaler türleri (int veya string gibi) de kullanabileceğiniz genişletilmiş tür bildirimlerini içerir.

Süper global değişkenler

PHP’deki süper globaller, her zaman kullanılabilir olan ve betik boyunca herhangi bir kapsamdan erişilebilen önceden tanımlanmış değişkenlerdir.

Fonksiyonlar/yöntemler, sınıflar veya dosyalar içinde bunlara erişmek için global $variable yapmaya gerek yoktur.

Bu PHP superglobal değişkenleri aşağıda listelenmiştir:

Tanımlanmamış değişkenlerin varsayılan değerleri

PHP’de gerekli olmamakla birlikte, değişkenleri önce tanımlamak çok iyi bir uygulamadır. Tanımlanmamış değişkenler, kullanıldıkları bağlama bağlı olarak türlerinin varsayılan bir değerine sahiptir:

Unset ve unreferenced

var_dump($unset_var); // çıktı NULL

Boolean

echo($unset_bool ? "true\n" : "false\n"); // çıktı 'false'

String

$unset_str .= 'abc';
var_dump($unset_str); // çıktı 'string(3) "abc"'

Integer

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // çıktı 'int(25)'

Float/double

$unset_float += 1.25;
var_dump($unset_float); // çıktı 'float(1.25)'

Array

$unset_arr[3] = "def";
var_dump($unset_arr); //  çıktı array(1) {  [3]=>  string(3) "def" }

Object

$unset_obj->foo = 'bar';
var_dump($unset_obj); // çıktı: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

Tanımlanmamış bir değişkenin varsayılan değerine güvenmek, bir dosyanın aynı değişken adını kullanan başka bir dosyaya dahil edilmesi durumunda sorunludur.

Değişkenin “Değer Doğruluğu” ve Özdeşlik Operatörü

PHP’de, değişken değerlerinin ilişkili bir “doğruluğu” vardır, bu nedenle boolean olmayan değerler bile doğru veya yanlışa eşit olacaktır. Bu, herhangi bir değişkenin koşullu bir blokta kullanılmasına izin verir, örn.

if ($var == true) { /* açık versiyon */ }
if ($var) { /* $var == true'nun kapalı hali */ }

Farklı değişken değer türleri için bazı temel kurallara bakalım:

  • Sıfır olmayan uzunluğa sahip dizeler, ‘ ‘ gibi yalnızca beyaz boşluk içeren dizeler de dahil olmak üzere true değerine eşittir.
  • Boş ” dizeleri false değerine eşittir.
$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '   ';
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false
  • Tamsayılar sıfırdan farklıysa true değerine eşitken, sıfır false değerine eşittir.
$var = -1;
$var_is_true = ($var == true); // true
$var = 99;
$var_is_true = ($var == true); // true
$var = 0;
$var_is_true = ($var == true); // false
  • null yanlışa eşittir
$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
  • Boş dizeler ” ve sıfır dizesi ‘0’ yanlışa eşittir.
$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '0';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true
  • Floating point değerleri sıfırdan farklıysa true değerine eşitken, sıfır değerleri false değerine eşittir.
    • NAN: (PHP’nin Not-a-Number) değeri true değerine eşittir, yani NAN == true değeri true değeridir. Bunun nedeni NAN değerinin sıfır olmayan bir floating-point değeri olmasıdır.
    • Sıfır değerleri IEEE 754 tarafından tanımlandığı gibi hem +0 hem de -0 değerlerini içerir. PHP, çift hassasiyetli floating-point için +0 ve -0 arasında ayrım yapmaz, yani floatval('0') == floatval('-0') truedur. Aslında, floatval('0') === floatval('-0').
    • Ayrıca, hem floatval('0') == false hem de floatval('-0') == false.
$var = NAN;
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

$var = floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = floatval('0') == floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

Özdeşlik Operatörü

PHP Belgelerinde Karşılaştırma İşleçleri için bir Özdeşlik İşleci vardır ===. Bu işleç bir değişkenin bir başvuru değeriyle aynı olup olmadığını denetlemek için kullanılabilir:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

Buna karşılık gelen bir “özdeş olmayan” !== işleci vardır:

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

Özdeşlik operatör, is_null() gibi dil fonksiyonlarına alternatif olarak kullanılabilir.

strpos()

strpos($haystack, $needle) dil fonksiyonu, $needle’ın $haystack içinde hangi indekste yer aldığını veya hiç yer alıp almadığını bulmak için kullanılır. strpos() fonksiyonu büyük/küçük harfe duyarlıdır; eğer ihtiyacınız olan büyük/küçük harfe duyarsız bulma ise stripos($haystack, $needle) ile devam edebilirsiniz

strpos & stripos fonksiyonu ayrıca üçüncü parametre offset (int) içerir; bu parametre belirtilirse, arama dizenin başından itibaren sayılan bu karakter sayısı kadar başlar. Strrpos ve strripos’tan farklı olarak, ofset negatif olamaz.

İşlev aşağıdakileri geri döndürebilir:

  • 0 eğer $needle $haystack’in başında bulunursa;
  • eğer $needle $haystack içinde başlangıçtan başka bir yerde bulunuyorsa indeksi belirten sıfırdan farklı bir tamsayı;
  • ve $needle $haystack içinde hiçbir yerde bulunmazsa false değerini alır.

Hem 0 hem de false PHP’de false doğruluğuna sahip olduğundan, ancak strpos() için farklı durumları temsil ettiğinden, bunları birbirinden ayırmak ve sadece false’a eşit olan bir değeri değil, tam olarak false’u aramak için === özdeş işlecini kullanmak önemlidir.

$idx = substr($haystack, $needle);
if ($idx === false) 
{
    // $needle $haystack içinde bulunamadığında kullanılacak mantık
} 
else
{
    // $haystack içinde $needle bulunduğunda uygulanacak mantık
}

Alternatif olarak, aynı değil operatörünü kullanın:

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // $haystack içinde $needle bulunduğunda uygulanacak mantık
} 
else
{
    // $needle $haystack içinde bulunamadığında kullanılacak mantık
}

Tanımlanmış tüm değişkenleri görme

get_defined_vars() işlevi, işlevin çağrıldığı kapsamda tanımlanan değişkenlerin tüm adlarını ve değerlerini içeren bir dizi döndürür. Veriyi yazdırmak istiyorsanız, print_r veya var_dump gibi verilerin çıktısını almak için standart fonksiyonları kullanabilirsiniz.

var_dump(get_defined_vars());

Not: Bu fonksiyon genellikle sadece 4 süper global döndürür: $_GET,$_POST,$_COOKIE,$_FILES. Diğer süper globaller yalnızca kodda bir yerde kullanılmışlarsa döndürülürler. Bunun nedeni öntanımlı olarak etkin olan auto_globals_jit yönergesidir. Etkinleştirildiğinde, $_SERVER ve $_ENV değişkenleri kod başladığında değil, ilk kullanıldıklarında (Just In Time) oluşturulur. Bu değişkenler bir betik içinde kullanılmıyorsa, bu yönergenin açık olması bir performans kazancı sağlayacaktır.

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Back to top