Submit a Pull Request Report a Bug

    string

    Bir dize string türünde bir sayıl değer olup bir dizi tek baytlık karakterden oluşur. Yani, olası karakter sayısı 256'dan ibarettir. Bu yüzden PHP Unicode için yerleşik desteğe sahip olamıyor. Dize türünün ayrıntıları belgesine bakınız.

    Bilginize: 32 bitlik derlemelerde, dize uzunluğu en fazla 2GB (2147483647 bayt) olabilir.

    Sözdizimi

    string türünde bir sayıl dört şekilde belirtilebilir:

    Tek tırnaklı dizeler

    Bir dizeyi belirtmenin en basit yolu dizeyi tek tırnak (') imlerinin arasına almaktır.

    Tek tırnaklı bir dize içinde tek tırnağı sayıl değeriyle kullanmak isterseniz önüne bir tersbölü imi getirmelisiniz (\). Bir tersbölü imini sayıl değeriyle kullanmak isterseniz onun da önüne bir tersbölü imi getirmelisiniz (\\). Tersbölü imini bunlardan başka bir karakterin önünde kullanırsanız, tersbölü imi karakterle birlikte basılır. \r veya \n gibi özel anlamı olan öncelemeler özel anlamı yoksayılarak olduğu gibi basılır.

    Bilginize: çift tırnak ve yorumlu metin sözdizimlerinin aksine, değişkenler ve özel karakterlerin öncelemleri tek tırnaklı dizelerin içinde kullanıldıklarında yorumlanmazlar.

    <?php
    echo 'Bu basit bir dizedir';

    echo     'Dizgelerin içinde satırsonu karakterlerini
    tıpkı buradaki gibi
    kullanabilirsiniz'    ;

    // Çıktısı: Arnold dedi ki: "I'll be back"
    echo 'Arnold dedi ki: "I\'ll be back"';

    // Çıktısı: You deleted C:\*.*?
    echo 'You deleted C:\\*.*?';

    // Çıktısı: You deleted C:\*.*?
    echo 'You deleted C:\*.*?';

    // Çıktısı: This will not expand: \n a newline
    echo 'This will not expand: \n a newline';

    // Çıktısı: Variables do not $expand $either
    echo 'Variables do not $expand $either';
    ?>

    Çift tırnaklı dizeler

    Eğer bir dize çift tırnak (") içine alınmışsa PHP, aşağıdaki özel karakter öncelemlerini yorumlayacaktır:

    Tersbölü ile öncelenmiş karakterler
    Öncelem Anlamı
    \n satırsonu (LF veya ASCII 10 (0x0A))
    \r satırbaşı (CR veya ASCII 13 (0x0D))
    \t yatay sekme (HT veya ASCII 9 (0x09))
    \v düşey sekme (VT veya ASCII 11 (0x0B))
    \e escape (ESC veya ASCII 27 (0x1B)
    \f sayfa ileri (FF veya ASCII 12 (0x0C))
    \\ tersbölü
    \$ dolar imi
    \" çift tırnak
    \[0-7]{1,3} Sekizlik: Bu düzenli ifade ile eşleşen dizilim, karakterin sekizlik gösterimi (örn, "\101" === "A") olup bir bayta sığmak için sessizce taşar (örn, "\400" === "\000").
    \x[0-9A-Fa-f]{1,2} Onaltılık: Bu düzenli ifade ile eşleşen dizilim, karakterin onaltılık gösterimidir (örn, "\x41" === "A").
    \u{[0-9A-Fa-f]+} Unicode: Bu düzenli ifade ile eşleşen dizilim bir Unicode karakter kodu olup, dizeye karakter kodunun UTF-8 gösterimini çıktılar. Kod kaşlı ayraçlarla sarmalanmalıdır (örn, "\u{41}" === "A").

    Tersbölü imini bunlardan başka bir karakterin önünde kullanırsanız, tersbölü imi karakterle birlikte basılır.

    Çift tırnaklı dizelerin en önemli özelliği içerdiği değişkenlerin yorumlanmasıdır. Bu konuda daha ayrıntılı bilgi edinmek için Değişken çözümleme bölümüne bakınız.

    Yorumlu metinler

    Bir dizenin sınırlarını belirlemenin üçüncü yolu, yorumlu metin sözdizimidir. Bir yorumlu metin daima <<< karakterleri ile başlar ve hemen ardından bir betimleyici ve bir satırsonu karakteri gelir. Asıl dize satırsonu karakterinden sonra yer alır. Dizgenin sonunu belirtmek üzere dizenin sonuna, baştaki betimleyici konur.

    Kapanış betimleyicisinin dizeden sonraki satırın başında olması gerekmez. Boşluk veya sekme karakterleriyle girintilenebilir. Bu durumda girinti miktarı dizedeki tüm satırlardan ayıklanır. PHP 7.3.0 öncesinde kapanış betimleyicisinin satırın başında olması gerekirdi.

    Ayrıca, betimleyici PHP'deki diğer isimlere uygulanan kurallara uygun olmalıdır: Sadece bir harfle veya alt çizgi imi ile başlayabilir; sadece harfler, rakamlar veya alt çizgi imleri içerebilir.

    Örnek 1 - PHP 7.3.0 ve sonrası için Yorumlu Metin örneği

    <?php
    // girintisiz
    echo <<<END
     a
    b
    c
    \n
    END;

    // 4 boşluk girintili
    echo <<<END
     a
    b
    c
     END;

    Yukarıdaki örneğin PHP 7.3 çıktısı:

          a
     b
    c

  a
 b
c

    Kapanış betimleyicisi, dizedeki tüm satırlardan daha uzun girintilenmişse ParseError istisnası yavrulanır:

    Örnek 2 - Kapanış betimleyicisi, dizedeki tüm satırlardan daha uzun girintilenmemeli

    <?php
    echo <<<END
     a
    b
    c
     END;

    Yukarıdaki örneğin PHP 7.3 çıktısı:

    PHP Parse error:  Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4

    Kapanış betimleyicisi ve metin girintilenirken sekmeler kullanılabilir, ancak sekmeler ve boşluklar birlikte kullanılmamalıdır. Böyle bir durumda ParseError istisnası yavrulanır. Girinti için sekmeleri ve boşlukları karıştırmak okunabilirliğe zararlı olduğundan bu kısıtlamaya gidilmiştir.

    Örnek 3 - Kapanış betimleyicisin girintilenirken sekmeler ve boşluklar birlikte kullanılmamalı

    <?php
    // Aşağıdaki kod çalışmaz.

    // Metin boşluklarla kapanış betimleyici sekmelerle girintilenmiş
    {
    echo <<<END
     a
     END;
    }

    // Metinde boşluk ve sekmelerin karışık kullanımı
    {
    echo <<<END
     a
     END;
    }

    // Kapanış betimleyicide boşluk ve sekmelerin karışık kullanımı
    {
    echo <<<END
     a
     END;
    }

    Yukarıdaki örneğin PHP 7.3 çıktısı:

    PHP Parse error:  Invalid indentation - tabs and spaces cannot be mixed in example.php line 8

    Kapanış betimleyicisinin noktalı virgül ve satırsonu ile sonlandırılması gerekmez. Örneğin PHP 7.3.0 ve sonrasında aşağıdaki gibi bir kod çalışır:

    Örnek 4 - Kapanış betimleyicisinden sonra devam eden ifade

    <?php
    $values     = [<<<END
    a
    b
    c
    END, 'd e f'];
    var_dump($values);

    Yukarıdaki örneğin PHP 7.3 çıktısı:

    array(2) {
  [0] =>
  string(11) "a
  b
    c"
  [1] =>
  string(5) "d e f"
}
    Uyarı

    Kapanış betimleyicisi satırın hemen başındaysa başka bir sözcüğün parçası olup olmadığında bakılmaksızın kapanış betimleyici olarak ele alınır ve ParseError istisnasına sebep olur.

    Örnek 5 - Metin içindeki kapanış betimleyici dizesi ParseError yavrulatır

    <?php
    $values     = [<<<END
    a
    b
    END ING
    END    , 'd e f'];

    Yukarıdaki örneğin PHP 7.3 çıktısı:

    PHP Parse error:  syntax error, unexpected identifier "ING", expecting "]" in example.php on line 6

    Bu sorundan kaçınmak için basit bir kurala uymak yeterlidir: betimleyiciyi metin gövdesi içinde görünenlerden seçme..

    Uyarı

    PHP 7.3.0 öncesinde, kapanış betimleyicisinin bulunduğu satırda betimleyicinin hemen ardına konan muhtemel bir noktalı virgül (;) dışında hiçbir karakter bulunmaması çok önemli olup buna özellikle dikkat etmelisiniz. Yani, betimleyici özellikle girintilenmemeli; noktalı virgülden önce ve sonra herhangi bir boşluk karakteri bulunmamalıdır. Ayrıca, kapanış betimleyicisinden hemen önce gelen karakterin yerel işletim sistemine özgü satırsonu karakteri olması çok önemlidir. Bu karakter Unix ve macOS için \n'dir. Kapanış betimleyicisinden (ve olası noktalı virgül karakterinden) sonraki karakter de böyle bir satırsonu karakteri olmalıdır.

    Eğer bu kurallara uyulmaz ve kapanış betimleyicisinin etrafı temiz tutulmazsa kapanış betimleyicisi algılanamayacağından PHP kapanış betimleyicisini aramaya devam edecektir. Eğer dosyanın sonuna kadar uygun bir kapanış betimleyicisi bulunamazsa son satırda bir çözümleme hatası oluşacaktır.

    Yorumlu metinler sınıf özelliklerini ilklendirmek için kullanılamazlar. PHP 5.3'ten beri bu sınırlama sadece değişken içeren yorumlu metinler için geçerlidir. Bunun yerine yorumsuz metinler kullanılabilir.

    Örnek 6 - PHP 7.3.0 öncesi için geçersiz örnek

    <?php
    class foo {
    public     $bar = <<<EOT
    bar
     EOT;
    }
    // Betimleyici girintilenmez
    ?>

    Örnek 7 - PHP 7.3.0 öncesi için bile geçerli örnek

    <?php
    class foo {
    public     $bar = <<<EOT
    bar
    EOT;
    }
    ?>

    Değişken içeren yorumlu metinler sınıf özelliklerini ilklendirmek için kullanılamaz.

    Yorumlu metinler tıpkı çift tırnaklı dizeler gibi davranırlar. Yorumlu metin çift tırnaklar arasına alınmaz ve metin içindeki çift tırnak imlerinin tersbölü ile öncelenmesi gerekmez, ancak yukarıda çift tırnaklı dizeler için belirtilen öncelem kodları kullanılabilir. Değişkenler yorumlanır, fakat yorumlanan metin içinde yer alan karmaşık değişkenler ifade edilirken dizelerde dikkate alınması gerekenler yorumlu metinlerde de dikkate alınmalıdır.

    Örnek 8 - Yorumlu metin örneği

    <?php
    $str     = <<<EOD
    Yorumlu metin sözdizimi
    kullanılarak çok sayıda
    satıra bölünmüş dize örneği.
    EOD;

    /* Değişkenlerin de kullanıldığı daha karmaşık bir örnek */
    class foo
    {
    var     $foo;
    var     $bar;

    function     __construct()
    {
    $this->foo = 'Foo';
    $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
    }

    $foo = new foo();
    $name = 'Kimimben';

    echo <<<EOT
    Adım "$name" ve işim $foo->foo basmak.
    Şimdi     {$foo->bar[1]} basıyorum.
    Bu büyük 'A' basmalı: \x41\n
    EOT;
    ?>

    Yukarıdaki örneğin çıktısı:

    Adım "Kimimben" ve işim Foo basmak.
Şimdi Bar2 basıyorum.
Bu büyük 'A' basmalı: A

    Ayrıca işlev bağımsız değişkeninde veri aktarırken de yorumlu metin kullanılabilir:

    Örnek 9 - Bağımsız değişkenlerde yorumlu metin kullanımı

    <?php
    var_dump    (array(<<<EOD
    foobar!
    EOD
    ));
    ?>

    Statik değişkenleri ve sınıf özelliklerini veya sabitlerini yorumlu metin sözdizimini kullanarak ilklendirmek mümkündür:

    Örnek 10 - Statik değer olarak yorumlu metin kullanımı

    <?php
    // Statik değişkenler
    function foo()
    {
    static     $bar = <<<LABEL
    Burada hiçbir şey yok...
    LABEL;
    }

    // Sınıf özellikleri ve sabitleri
    class foo
    {
    const     BAR = <<<FOOBAR
    Sınıf sabiti örneği
    FOOBAR;

    public     $baz = <<<FOOBAR
    Özellik örneği
    FOOBAR;
    }
    ?>

    Yorumlu metinlerin açılış betimleyicisi seçimlik olarak çift tırnaklarla kapatılabilir:

    Örnek 11 - Yorumlu metin bildiriminde çift tırnak kullanımı

    <?php
    echo <<<"TIRNAKLI"
    Merhaba Dünya!
    TIRNAKLI;
    ?>

    Yorumsuz metinler

    Yorumlu metinlerin çift tırnaklı dizelere karşılık gelmesi gibi yorumsuz metinler de tek tırnaklı dizelere karşılık gelir. Yorumsuz metinler de yorumlular gibi belirtilir ama, yorumsuz metin içinde çözümleme yapılmaz. Yorumsuz metinler, PHP kodlarını veya büyük metin bloklarını herhangi bir önlem almaksızın içine yerleştirmek için elverişlidirler. Belirtilen metin bloğunun çözümlenmemesinden dolayı SGML'nin <![CDATA[ ]]> oluşumu ile benzer özelliklere sahiptir.

    Yorumsuz metin de yorumlu metindeki <<< dizesini kullanır fakat betimleyicisi tek tırnak içine alınır; yani, şuna benzer: <<<'EOT'. Yorumlu metin için geçerli tüm diğer kurallar yorumsuz metin için de geçerlidir; özellikle de kapanış betimleyici ile ilgili olanlar.

    Örnek 12 - Yorumsuz metin örneği

    <?php
    $str     = <<<'EOD'
    Yorumlu metin sözdizimi kullanılarak çok sayıda satıra bölünmüş
    dize örneği. Tersbölüler daima birebir ele alınır,
    örn, \\ and \'
    EOD;

    Yukarıdaki örneğin çıktısı:

    Yorumlu metin sözdizimi kullanılarak çok sayıda satıra bölünmüş
dize örneği. Tersbölüler daima birebir ele alınır,
örn, \\ and \'

    Örnek 13 - Değişkenli yorumsuz metin örneği

    <?php
    class foo
    {
    public     $foo;
    public     $bar;

    function     __construct()
    {
    $this->foo = 'Foo';
    $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
    }

    $foo = new foo();
    $name = 'Kimimben';

    echo <<<'EOT'
    İsmim "$name" ve işim $foo->foo basmak.
    Artık {$foo->bar[1]} basıyorum.
    Bu büyük 'A' basmalı: \x41
    EOT;
    ?>

    Yukarıdaki örneğin çıktısı:

    İsmim "$name" ve işim $foo->foo basmak.
Artık {$foo->bar[1]} basıyorum.
Bu büyük 'A' basmalı: \x41

    Örnek 14 - Statik veri örneği

    <?php
    class foo {
    public     $bar = <<<'EOT'
    bar
    EOT;
    }
    ?>

    Değişken çözümleme

    Bir dize çift tırnaklar arasında veya bir yorumlu metin olarak belirtilmişse içindeki değişkenler çözümlenir.

    İki sözdizimi türü vardır: Biri basit, diğeri karmaşık. Basit sözdizimi en çok kullanılanı ve elverişli olanıdır; bir değişken, bir dizi değeri veya bir nesne özelliğini bir dize içinde en az çabayla kullanmayı sağlar.

    Karmaşık sözdizimi ifadeyi sarmalayan kaşlı ayraçlar biçiminde kendini gösterir.

    Basit Sözdizimi

    Çözümleyici, bir dolar imine ($) rastlandığında, geçerli bir değişken ismi oluşturmak için alabildiği bütün dizecikleri açgözlülükle toplar. Değişken isminin kaşlı ayraçlar arasına alınması ismin sonunun açıkça belirtilmesini sağlar.

    <?php
    $juice     = "apple";

    echo     "He drank some $juice juice.".PHP_EOL;

    // "s" değişken ismi olarak geçerli karakterdir fakat, $juice değişkendir.
    echo "He drank some juice made of $juices.";

    // Kaşlı ayraçların içine alınarak değişken isminin bitimi açıkça belirtilmiş
    echo "He drank some juice made of ${juice}s.";
    ?>

    Yukarıdaki örneğin çıktısı:

    He drank some apple juice.
He drank some juice made of .
He drank some juice made of apples.

    Bir dizi indisi veya bir nesne özelliği de benzer şekilde çözümlenebilir. Dizi indislerinde indis sonunu, kapayan köşeli ayraç (]) belirler. Aynı kural, basit değişkenler olarak nesne özelliklerine de uygulanır.

    Örnek 15 - Basit sözdizimi örneği

    <?php
    $juices     = array("apple", "orange", "koolaid1" => "purple");

    echo     "He drank some $juices[0] juice.".PHP_EOL;
    echo     "He drank some $juices[1] juice.".PHP_EOL;
    echo     "He drank some $juices[koolaid1] juice.".PHP_EOL;

    class     people {
    public     $john = "John Smith";
    public     $jane = "Jane Smith";
    public     $robert = "Robert Paulsen";

    public     $smith = "Smith";
    }
    $people = new people();

    echo     "$people->john drank some $juices[0] juice.".PHP_EOL;
    echo     "$people->john then said hello to $people->jane.".PHP_EOL;
    echo     "$people->john's wife greeted $people->robert.".PHP_EOL;
    echo     "$people->robert greeted the two $people->smiths."; // Won't work
    ?>

    Yukarıdaki örneğin çıktısı:

    He drank some apple juice.
He drank some orange juice.
He drank some purple juice.
John Smith drank some apple juice.
John Smith then said hello to Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen greeted the two .

    PHP 7.1.0 ve sonrasında negatif sayısal indisler desteklenir.

    Örnek 16 - Negatif sayısal indisler

    <?php
    $string     = 'string';
    echo     "The character at index -2 is $string[-2].", PHP_EOL;
    $string[-3] = 'o';
    echo     "Changing the character at index -3 to o gives $string.", PHP_EOL;
    ?>

    Yukarıdaki örneğin çıktısı:

    The character at index -2 is n.
Changing the character at index -3 to o gives strong.

    Bunlardan daha karmaşık herşey için karmaşık sözdizimini kullanmalısınız.

    Karmaşık (kaşlı ayraçlı) sözdizimi

    Buna karmaşık denmesinin sebebi sözdiziminin karmaşıklığı değil, karmaşık ifadelerin kullanımını mümkün kılmasıdır.

    Herhangi bir sayıl değer, dizi elemanı veya nesne özelliği bir dize içinde bu sözdizimi ile yer alabilir. İfade dize dışındaki gösterimiyle yazılıp { ve } arasına alınır. { öncelenemeyeceğinden bu sözdizimi sadece $ iminin { iminin hemen ardında yer aldığı durumlarda tanınır. {\$ kullanımı {$ imlerinin kendilerinin alınmasıyla sonuçlanır. Bazı örnekler:

    <?php
    // Tüm hataları görelim
    error_reporting(E_ALL);

    $şahane = 'harika';

    // Çalışmaz, çıktısı: Bu çok { harika}
    echo "Bu çok { $şahane}";

    // Çalışır, çıktısı: Bu çok harika
    echo "Bu çok {$şahane}";

    // Çalışır
    echo "Bu karenin bir kenarı {$square->width}00 santimetre uzunluktadır.";

    // Çalışır, tırnaklı anahtarlar sadece kaşlı ayraç sözdizimi kullanılarak çalışır
    echo "Bu çalışır: {$arr['key']}";


    // Çalışır
    echo "Bu çalışır: {$arr[4][3]}";

    // $foo[bar] bir dize dışında neden yanlışsa bu da o yüzden yanlıştır.
    // Yani, bu yine de çalışır fakat PHP önce foo adında bir sabit
    // arayacağından çalışır; bununla birlikte E_NOTICE seviyesinde
    // bir hata oluşacaktır (tanımsız sabit).
    echo "Bu yanlış: {$arr[foo][3]}";

    // Çalışır. Çok boyutlu dizileri dizelerin içinde kullanılırken,
    // dizileri daima kaşlı ayraçlar arasına alın.
    echo "Bu çalışır: {$arr['foo'][3]}";

    // Çalışır.
    echo "Bu çalışır: " . $arr['foo'][3];

    echo     "Bu da çalışır: {$obj->values[3]->name}";

    echo     "$name adlı değişkenin değeri: {${$name}}";

    echo     "Adı getName() işlevinin dönüş değeri olan değişkenin değeri: {${getName()}}";

    echo     "Adı \$object->getName() yönteminin dönüş değeri olan değişkenin değeri: {${$object->getName()}}";

    // Çalışmaz, çıktısı: This is the return value of getName(): {getName()}
    echo "This is the return value of getName(): {getName()}";

    // Çalışmaz, çıktısı: C:\folder\{harika}.txt
    echo "C:\folder\{$şahane}.txt"
    // Çalışır, çıktısı: C:\folder\harika.txt
    echo "C:\\folder\\{$şahane}.txt"
    ?>

    Bu sözdizimini kullanan dizeler içindeki değişkenler üzerinden de sınıf özelliklerine erişmek mümkündür.

    <?php
    class foo {
    var     $bar = 'I am bar.';
    }

    $foo = new foo();
    $bar = 'bar';
    $baz = array('foo', 'bar', 'baz', 'quux');
    echo     "{$foo->$bar}\n";
    echo     "{$foo->{$baz[1]}}\n";
    ?>

    Yukarıdaki örneğin çıktısı:

     I am bar.
 I am bar.

    Bilginize:

    {$} içindeki işlev ve yöntem çağrılarından, statik sınıf değişkenlerinden ve sınıf sabitlerinden erişilen değer, dizenin tanımlandığı etki alanındaki bir değişkenin ismi olarak yorumlanır. Kaşlı ayraçların tek başına kullanımı ({}), statik sınıf değişkenlerinin veya sınıf sabitlerinin değerlerine veya işlev ve yöntemlerin dönüş değerlerine erişim için kullanılmaz.

    <?php
    // Tüm hatalar gösterilsin.
    error_reporting(E_ALL);

    class     beers {
    const     softdrink = 'rootbeer';
    public static     $ale = 'ipa';
    }

    $rootbeer = 'A & W';
    $ipa = 'Alexander Keith\'s';

    // Bu çalışır; çıktısı: I'd like an A & W
    echo "I'd like an {${beers::softdrink}}\n";

    // Bu da çalışır; çıktısı: I'd like an Alexander Keith's
    echo "I'd like an {${beers::$ale}}\n";
    ?>

    Dizge erişimi ve karaktere göre değişiklik

    Dizgelerin içindeki karakterlere, dizilerin köşeli ayraçları arasında karakterin dizinin başlangıcından itibaren (ilk karakterin indisi sıfır olmak üzere) kaçıncı karakter olduğu belirtilerek ($dize[42] gibi) erişilebilir veya o karakterde değişiklik yapılabilir. Dizgeler bu nedenle bir karakter dizisi olarak düşünülür. 1 karakterden fazlasını elde etmek veya yer değiştirmek isterseniz substr() ve substr_replace() işlevlerini kullanabilirsiniz.

    Bilginize: PHP 7.1.0 ve sonrasında, negatif dize başlangıçları da desteklenmektedir. Öncesinde, bunların okunması boş bir dizeyle ve E_NOTICE çıktılanmasıyla, yazılması ise dizenin olduğu gibi bırakılması ve E_WARNING çıktılanması ile sonuçlanırdı.

    Bilginize: PHP 8.0.0 öncesinde, dizge karakterlerine ayrıca $str{42} biçeminde kaşlı ayraçlar kullanılarak da erişilebiliyordu. Bu tür kaşlı ayraç kullanımı PHP 7.4.0 itibariyle önerilmemekte olup PHP 8.0.0 ve sonrasında desteklenmemektedir.

    Uyarı

    Karakter indisi olarak dizenin uzunluğundan büyük bir değer belirtmek, dizenin sonuna boşlukların eklenmesine sebep olur. Tamsayı olmayan indis değerleri tamsayıya dönüştürülür. Kuraldışı indis belirtimi E_WARNING'e sebep olur. Atanmış bir dizenin sadece ilk karakteri kullanılır. PHP 7.1.0 ve sonrasında, boş dize ataması ölümcül hata ile sonuçlanır. Evvelce, bir NULL bayt atanırdı.

    Uyarı

    Dahili olarak, PHP dizeleri bayt dizileridir. Sonuç olarak, dizi ayraçları kullanarak bir dizeye erişmek ve değişklik yapmak, çok baytlı gösterimde güvenli değildir. Bu işlem dizelere sadece ASCII gibi tek baytlık kodlamalarda yapılmalıdır.

    Bilginize: PHP 7.1.0 ve sonrasında, boş dize üzerinde boş indis işleci kullanımı ölümcül hataya yol açar. Evvelce, boş dize sessizce bir diziye dönüştürülürdü.

    Örnek 17 - Bazı dize örnekleri

    <?php
    // Dizgenin ilk karakterini alalım
    $str = 'This is a test.';
    $first = $str[0];

    // Dizgenin üçüncü karakterini alalım
    $third = $str[2];

    // Dizgenin son karakterini alalım
    $str = 'This is still a test.';
    $last = $str[strlen($str)-1];

    // Dizgenin son karakterini değiştirelim
    $str = 'Look at the sea';
    $str[strlen($str)-1] = 'e';

    ?>

    Dizi başlangıçları ya tamsayı ya da tamsayı benzeri dize olmalıdır, aksi takdirde bir uyarı yavrulanır.

    Örnek 18 - Geçersiz dize başlangıçları örneği

    <?php
    $str     = 'abc';

    var_dump($str['1']);
    var_dump(isset($str['1']));

    var_dump($str['1.0']);
    var_dump(isset($str['1.0']));

    var_dump($str['x']);
    var_dump(isset($str['x']));

    var_dump($str['1x']);
    var_dump(isset($str['1x']));
    ?>

    Yukarıdaki örneğin çıktısı:

    string(1) "b"
bool(true)

Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)

Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)

    Bilginize:

    Dize değişmezleri içindeki karakterlere [] veya {} kullanılarak erişilebilir.

    Bilginize:

    {} sözdizimini kullanarak dize değişmezleri içindeki karakterlere erişim PHP 7.4'te kullanımdan kaldırılmıştır. PHP 8.0'da ise tamemen kaldırılmıştır.

    Kullanışlı işlevler ve işleçler

    Dizgeler '.' (nokta) işleci kullanılarak ardarda eklenebilir. '+' (toplama) işlecinin bu amaçla kullanımının yararsız oluşuna dikkat ediniz. Daha ayrıntılı bilgi edinmek için Dizge İşleçleri belgesine bakınız.

    Dizgelerde değişiklik yapmak için çok sayıda yararlı işlev mevcuttur.

    Genel işlevler için Dize İşlevlerine, ileri düzey bul ve değiştir işlevselliği için Perl uyumlu düzenli ifade işlevlerine bakınız.

    Ayrıca, URL dizeleri için işlevler ve dizeleri şifrelemek veya şifrelerini çözmek için Sodium ve Hash işlevleri vardır.

    Son olarak, karakter türü işlevlerine de bakabilirsiniz.

    Dizgeye dönüşüm

    Bir değer bir dizeye (string) tür çarpıtması veya strval() işleviyle dönüştürülür. Bir dizenin gerekli olduğu ifade bağlamlarında dizeye dönüşüm otomatik olarak gerçekleşir. Bu genellikle, echo veya print işlevleri kullanılırken veya bir değişken bir dize ile karşılaştırılırken gerçekleşir. Aşağıdakilere, Türler ve Tür Dönüşümü bölümlerinde daha ayrıntılı değinilmiştir. Ayrıca, settype() işlevine de bakabilirsiniz.

    bool türündeki true değeri string türündeki "1" değerine dönüştürülür. bool türündeki false değeri string türündeki "" değerine (boş dizeye) dönüştürülür. Bu şekilde, bool ve string değerler arasında her iki yönde de dönüşüm yapılabilmektedir.

    integer veya float türünde bir değerin string türüne dönüşümü sayının dizesel gösterimiyle (üstel gösterim dahil) sonuçlanır. Kayan noktalı sayılar üstel gösterim kullanılarak dönüştürülebilir (4.1E+6 gibi).

    Bilginize:

    PHP 8.0.0 itibariyle, ondalık nokta karakteri daima noktadır ("."). PHP 8.0.0 öncesinde betiğin çalıştığı yerele (LC_NUMERIC) özgüdür. Bakınız: setlocale() işlevi.

    Diziler daima "Array" dizesine dönüştürülür; bundan dolayı echo ve print bir dizinin içeriğini kendiliklerinden gösteremezler. Tek bir dizi elemanını görüntüleyebilmek için echo $arr['foo'] gibi bir oluşum kullanınız. İçeriğin tamamının görüntülenebilmesiyle ilgili ipuçları için aşağıya bakınız.

    object türleri string türüne dönüştürmek için __toString sihirli yöntemi kullanılmalıdır.

    resource türler daima "Resource id #1" benzeri bir dizeye dönüştürülürler; buradaki 1, özkaynağa PHP tarafından çalışma anında atanan eşsiz bir sayıdır. Bu dizenin tam yapısı değişikliğe konu olduğundan güvenilmemelidir ve değişime tabi tutulmalıdır. Çalıştırılan bir betiğin (bir sayfa isteği veya CLI işlemi) ömrü boyunca, belirli bir özkaynak için daima benzersiz olacak ve yeniden kullanılabilir olmayacaktır. Özkaynağın türünü öğrenmek için get_resource_type() işlevini kullanınız.

    null daima boş bir dizeye dönüştürülür.

    Yukarıda bahsedildiği gibi, bir diziyi, nesneyi veya özkaynağı doğrudan dönüştürmek, bunların değerleri hakkında işe yarar hiçbir bilgi sağlamaz. Bu tür içerikleri daha verimli şekilde incelemek isterseniz print_r() ve var_dump() işlevlerine bakınız.

    Çoğu PHP değeri kalıcı olarak saklamak amacıyla dizelere dönüştürülebilir. Bu yönteme dizeleştirme adı verilir ve serialize() işlevi tarafından gerçekleştirilir.

    String Türü ve Ayrıntılar

    PHP'de string türü bir bayt dizisi ve tampon uzumlığunu belirten bir tamsayı olarak gerçeklenmiştir. Bu baytların nasıl karakterlere dönüştüğü hakkında bir bilgiye sahip değildir, bu görev yazılımcıya bırakılmıştır. Bir dizeyi oluşturan değerlerle ilgili bir sınırlama yoktur. Özellikle 0 değerli baytlara (NUL baytlar) dizenin her yerinde izin verilir. (Bununla birlikte, bu kılavuzda "ikil olarak güvenli" olmadığı belirtilen bir kaç işlev, dizeleri, NULL baytından sonra verileri yok sayan kitaplıklara dağıtabilir.)

    string türünün bu doğası, PHP'de neden ayrı bir bayt türünün olmadığını açıklar; bu rolü dizeler üstlenir. Örneğin metin veri döndürmeyen işlevler, ham veriyi bir ağ soketinden okuyup yine de dize döndürecektir.

    PHP dizelere belli bir karakter kodlaması dayatmaz, dizelerin nasıl baytlara dönüştüğü merak edilebilir. Örneğin, "á" dizesi "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C form), "\x61\xCC\x81" (UTF-8, D form) olarak mı yoksa olası başka bir gösterime göre mi kodlanacak? Bunun yanıtı, betiğin karakter kodlaması neyse ona göre karakterler kodlanır, olacaktır. Bu bakımdan, betik örneğin ISO-8859-1'de yazılmışsa dize de ISO-8859-1'de kodlanacaktır. Ancak, Zend Çokbaytlılık etkinse bu uygulanmaz; bu durumda betik keyfi bir kodlamada (açıkça belirtilmiş veya algılanmış olabilir) yazılabilir ve ardından belli bir dahili kodlamaya (dizeler için kullanılacak kodlama) dönüştürülebilir. Betiğin kodlanmasında (veya dahili kodlamada, Zend Çokbaytlılık etkin olmalıdır) bazı kısıtlamalar olduğunu unutmayın. Bu hemen hemen her zaman, bu kodlamanın UTF-8 veya ISO-8859-1 gibi ASCII'nin uyumlu bir üst kümesi olması gerektiği anlamına gelir. Bununla birlikte, büyük/küçük harf durumlarında aynı bayt değerlerinin kullanılabildiği durum bağımlı kodlamaların sorunlu olabileceğini unutmayın.

    Şüphesiz, kullanışlı olmak noktasında, metinler üzerinde çalışan işlevler dizenin nasıl kodlanacağına ilşkin bazı varsayımlarda bulunabilir. Ne yazık ki, işlevler arasında bu konuda çok farklı varsayımlar mevcuttur:

    • Bazı işlevler dizenin tek baytlı bir kodlamayla kodlanacağını varsayar, fakat bu baytları belli karakterlere yorumlama gereği duymazlar. substr(), strpos(), strlen() ve strcmp() işlevleri bu durumdadır. Bu işlevlerin bellek tamponlarında, yani baytlar ve bayt adresleriyle çalıştıkları için böyle oldukları düşünülebilir.
    • Diğer bir işlev grubu, dizgenin kodlamasının aktarıldığını ya da bir öntanımlı kodlamanın olduğunu varsayar. mbstring eklentisindeki işlevler ve htmlentities() böyledir.
    • Bir başka işlev grubu geçerli yereli kullanır (bak setlocale()), fakat bayt bayt çalışır.
    • Son grup, dizenin belli bir kodlamayı, normal olarak UTF-8 kullandığını varsayar. intl ve PCRE eklentilerindeki işlevlerin çoğu böyledir (PCRE eklentilerindeki işlevlerde sadece u değiştircisi kullanıldığında).

    Sonuç olarak, Unicode kullanarak doğru programların yazılması, çalışmayan ve büyük olasılıkla verileri bozacak işlevlerden itinayla kaçınmaya ve bunun yerine doğru davranan, genellikle intl ve mbstring eklentilerindeki işlevleri kullanmaya bağlıdır. Bununla birlikte, Unicode kodlamaları işleyebilen işlevleri kullanmak sadece başlangıçtır. Dilin sağladığı işlevler ne olursa olsun, asıl olan Unicode belirtimini bilmektir. Örneğin, sadece büyük ve küçük harfler olduğunu varsayan bir yazılım yanlış kabul yapıyor demektir.

    add a note add a note

    User Contributed Notes 26 notes

    up
    370
    John
    7 years ago
    I've been a PHP programmer for a decade, and I've always been using the "single-quoted literal" and "period-concatenation" method of string creation. But I wanted to answer the performance question once and for all, using sufficient numbers of iterations and a modern PHP version. For my test, I used:

    php -v
    PHP 7.0.12 (cli) (built: Oct 14 2016 09:56:59) ( NTS )
    Copyright (c) 1997-2016 The PHP Group
    Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies

    ------ Results: -------

    * 100 million iterations:

    $outstr = 'literal' . $n . $data . $int . $data . $float . $n;
    63608ms (34.7% slower)

    $outstr = "literal$n$data$int$data$float$n";
    47218ms (fastest)

    $outstr =<<<EOS
    literal$n$data$int$data$float$n
    EOS;
    47992ms (1.64% slower)

    $outstr = sprintf('literal%s%s%d%s%f%s', $n, $data, $int, $data, $float, $n);
    76629ms (62.3% slower)

    $outstr = sprintf('literal%s%5$s%2$d%3$s%4$f%s', $n, $int, $data, $float, $data, $n);
    96260ms (103.9% slower)

    * 10 million iterations (test adapted to see which of the two fastest methods were faster at adding a newline; either the PHP_EOL literal, or the \n string expansion):

    $outstr = 'literal' . $n . $data . $int . $data . $float . $n;
    6228ms (reference for single-quoted without newline)

    $outstr = "literal$n$data$int$data$float$n";
    4653ms (reference for double-quoted without newline)

    $outstr = 'literal' . $n . $data . $int . $data . $float . $n . PHP_EOL;
    6630ms (35.3% slower than double-quoted with \n newline)

    $outstr = "literal$n$data$int$data$float$n\n";
    4899ms (fastest at newlines)

    * 100 million iterations (a test intended to see which one of the two ${var} and {$var} double-quote styles is faster):

    $outstr = 'literal' . $n . $data . $int . $data . $float . $n;
    67048ms (38.2% slower)

    $outstr = "literal$n$data$int$data$float$n";
    49058ms (1.15% slower)

    $outstr = "literal{$n}{$data}{$int}{$data}{$float}{$n}"
    49221ms (1.49% slower)

    $outstr = "literal${n}${data}${int}${data}${float}${n}"
    48500ms (fastest; the differences are small but this held true across multiple runs of the test, and this was always the fastest variable encapsulation style)

    * 1 BILLION iterations (testing a completely literal string with nothing to parse in it):

    $outstr = 'literal string testing';
    23852ms (fastest)

    $outstr = "literal string testing";
    24222ms (1.55% slower)

    It blows my mind. The double-quoted strings "which look so $slow since they have to parse everything for \n backslashes and $dollar signs to do variable expansion", turned out to be the FASTEST string concatenation method in PHP - PERIOD!

    Single-quotes are only faster if your string is completely literal (with nothing to parse in it and nothing to concatenate), but the margin is very tiny and doesn't matter.

    So the "highest code performance" style rules are:

    1. Always use double-quoted strings for concatenation.

    2. Put your variables in "This is a {$variable} notation", because it's the fastest method which still allows complex expansions like "This {$var['foo']} is {$obj->awesome()}!". You cannot do that with the "${var}" style.

    3. Feel free to use single-quoted strings for TOTALLY literal strings such as array keys/values, variable values, etc, since they are a TINY bit faster when you want literal non-parsed strings. But I had to do 1 billion iterations to find a 1.55% measurable difference. So the only real reason I'd consider using single-quoted strings for my literals is for code cleanliness, to make it super clear that the string is literal.

    4. If you think another method such as sprintf() or 'this'.$var.'style' is more readable, and you don't care about maximizing performance, then feel free to use whatever concatenation method you prefer!
    up
    96
    gtisza at gmail dot com
    12 years ago
    The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.

    This works:

    <?php
    $foo     = <<<END
    abcd
    END;
    ?>

    This does not:

    <?php
    foo    (<<<END
    abcd
    END;
    );
    // syntax error, unexpected ';'
    ?>

    Without semicolon, it works fine:

    <?php
    foo    (<<<END
    abcd
    END
    );
    ?>
    up
    22
    garbage at iglou dot eu
    7 years ago
    You can use string like array of char (like C)

    $a = "String array test";

    var_dump($a);
    // Return string(17) "String array test"

    var_dump($a[0]);
    // Return string(1) "S"

    // -- With array cast --
    var_dump((array) $a);
    // Return array(1) { [0]=> string(17) "String array test"}

    var_dump((array) $a[0]);
    // Return string(17) "S"

    - Norihiori
    up
    9
    Ray.Paseur sometimes uses Gmail
    5 years ago
    md5('240610708') == md5('QNKCDZO')

    This comparison is true because both md5() hashes start '0e' so PHP type juggling understands these strings to be scientific notation.  By definition, zero raised to any power is zero.
    up
    19
    og at gams dot at
    16 years ago
    easy transparent solution for using constants in the heredoc format:
    DEFINE('TEST','TEST STRING');

    $const = get_defined_constants();

    echo <<<END
    {$const['TEST']}
    END;

    Result:
    TEST STRING
    up
    3
    vseokdog at gmail dot com
    4 years ago
    Don't forget about new E_WARNING and E_NOTICE errors from PHP 7.1.x: they have been introduced when invalid strings are coerced using operators expecting numbers (+ - * / ** % << >> | & ^) or their assignment equivalents. An E_NOTICE is emitted when the string begins with a numeric value but contains trailing non-numeric characters, and an E_WARNING is emitted when the string does not contain a numeric value.

    Example:
    $foo = 1 + "bob-1.3e3"; 
    $foo = "10.2 pigs " + 1.0;
    Will produce: Warning: A non-numeric value encountered

    Read more: https://www.php.net/manual/en/migration71.other-changes.php
    up
    17
    lelon at lelon dot net
    19 years ago
    You can use the complex syntax to put the value of both object properties AND object methods inside a string.  For example...
    <?php
    class Test {
        public     $one = 1;
        public function     two() {
            return     2;
        }
    }
    $test = new Test();
    echo     "foo {$test->one} bar {$test->two()}";
    ?>
    Will output "foo 1 bar 2".

    However, you cannot do this for all values in your namespace.  Class constants and static properties/methods will not work because the complex syntax looks for the '$'.
    <?php
    class Test {
        const     ONE = 1;
    }
    echo     "foo {Test::ONE} bar";
    ?>
    This will output "foo {Test::one} bar".  Constants and static properties require you to break up the string.
    up
    4
    sideshowAnthony at googlemail dot com
    8 years ago
    Something I experienced which no doubt will help someone . . .
    In my editor, this will syntax highlight HTML and the $comment:

    $html = <<<"EOD"
    <b>$comment</b>
    EOD;

    Using this shows all the same colour:

    $html = <<<EOD
    <b>$comment</b>
    EOD;

    making it a lot easier to work with
    up
    10
    chAlx at findme dot if dot u dot need
    15 years ago
    To save Your mind don't read previous comments about dates  ;)

    When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:

    <?php
    var_dump    ('1.22' > '01.23'); // bool(false)
    var_dump('1.22.00' > '01.23.00'); // bool(true)
    var_dump('1-22-00' > '01-23-00'); // bool(true)
    var_dump((float)'1.22.00' > (float)'01.23.00'); // bool(false)
    ?>
    up
    8
    headden at karelia dot ru
    14 years ago
    Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:

    <?php

    // Hack declaration
    function _expr($v) { return $v; }
    $_expr = '_expr';

    // Our playground
    define('qwe', 'asd');
    define('zxc', 5);

    $a=3;
    $b=4;

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

    // Usage
    echo "pre {$_expr(1+2)} post\n"; // outputs 'pre 3 post'
    echo "pre {$_expr(qwe)} post\n"; // outputs 'pre asd post'
    echo "pre {$_expr(c($a, $b)+zxc*2)} post\n"; // outputs 'pre 17 post'

    // General syntax is {$_expr(...)}
    ?>
    up
    6
    steve at mrclay dot org
    15 years ago
    Simple function to create human-readably escaped double-quoted strings for use in source code or when debugging strings with newlines/tabs/etc.

    <?php
    function doubleQuote($str) {
            $ret = '"';
        for (    $i = 0, $l = strlen($str); $i < $l; ++$i) {
                $o = ord($str[$i]);
            if (    $o < 31 || $o > 126) {
                switch (    $o) {
                    case     9: $ret .= '\t'; break;
                    case     10: $ret .= '\n'; break;
                    case     11: $ret .= '\v'; break;
                    case     12: $ret .= '\f'; break;
                    case     13: $ret .= '\r'; break;
                    default:     $ret .= '\x' . str_pad(dechex($o), 2, '0', STR_PAD_LEFT);
                }
            } else {
                switch (    $o) {
                    case     36: $ret .= '\$'; break;
                    case     34: $ret .= '\"'; break;
                    case     92: $ret .= '\\\\'; break;
                    default:     $ret .= $str[$i];
                }
            }
        }
        return     $ret . '"';
    }
    ?>
    up
    1
    nospam at nospam dot com
    7 years ago
    Beware that consistent with "String conversion to numbers":

    <?php

    if ('123abc' == 123) echo '(intstr == int) incorrectly tests as true.';

    // Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.

    // True for all conditionals such as if and switch statements (probably also while loops)!

    // This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.

    // It seems the only fix is for 123 to be a string as '123' so no conversion happens.

    ?>
    up
    1
    mark at manngo dot net
    7 years ago
    I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.

    Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.

    An expression such as:

    <?php
        $fruit    =array(
                'a'=>'apple',
                'b'=>'banana',
                //    etc
            );

        print     "This is a $fruit['a']";    //    T_ENCAPSED_AND_WHITESPACE
    ?>

    will definitely fall to pieces.

    You can resolve it as follows:

    <?php
            print "This is a $fruit[a]";    //    unquote the key
            print "This is a ${fruit['a']}";    //    Complex Syntax
            print "This is a {$fruit['a']}";    //    Complex Syntax variation
    ?>

    I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.

    It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string — once the string is already being parsed the quotes just get in the way … ?
    up
    3
    php at richardneill dot org
    11 years ago
    Leading zeroes in strings are (least-surprise) not treated as octal.
    Consider:
      $x = "0123"  + 0;  
      $y = 0123 + 0;
      echo "x is $x, y is $y";    //prints  "x is 123, y is 83"
    in other words:
    * leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
    * leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().
    up
    4
    Richard Neill
    16 years ago
    Unlike bash, we can't do
      echo "\a"       #beep!

    Of course, that would be rather meaningless for PHP/web, but it's useful for PHP-CLI. The solution is simple:  echo "\x07"
    up
    0
    necrodust44 at gmail dot com
    10 years ago
    String conversion to numbers.

    Unfortunately, the documentation is not correct.

    «The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero).»

    It is not said and is not shown in examples throughout the documentation that, while converting strings to numbers, leading space characters are ignored, like with the strtod function.

    <?php
            echo "     \v\f    \r   1234" + 1;    // 1235
            var_export ("\v\f    \r   1234" == "1234");    // true
    ?>

    However, PHP's behaviour differs even from the strtod's. The documentation says that if the string contains a "e" or "E" character, it will be parsed as a float, and suggests to see the manual for strtod for more information. The manual says

    «A hexadecimal number consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent.  A binary exponent consists of a 'P' or 'p', followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.»

    But it seems that PHP does not recognise the exponent or the radix character.

    <?php
            echo "0xEp4" + 1;     // 15
    ?>

    strtod also uses the current locale to choose the radix character, but PHP ignores the locale, and the radix character is always 2E. However, PHP uses the locale while converting numbers to strings.

    With strtod, the current locale is also used to choose the space characters, I don't know about PHP.
    up
    3
    atnak at chejz dot com
    20 years ago
    Here is a possible gotcha related to oddness involved with accessing strings by character past the end of the string:

    $string = 'a';

    var_dump($string[2]);  // string(0) ""
    var_dump($string[7]);  // string(0) ""
    $string[7] === '';  // TRUE

    It appears that anything past the end of the string gives an empty string..  However, when E_NOTICE is on, the above examples will throw the message:

    Notice:  Uninitialized string offset:  N in FILE on line LINE

    This message cannot be specifically masked with @$string[7], as is possible when $string itself is unset.

    isset($string[7]);  // FALSE
    $string[7] === NULL;  // FALSE

    Even though it seems like a not-NULL value of type string, it is still considered unset.
    up
    -3
    jonijnm at example dot com
    6 years ago
    Both should work :(

    <?php

    class Testing {
        public static     $VAR = 'static';
        public const VAR =     'const';
       
        public function     sayHelloStatic() {
            echo     "hello: {$this::$VAR}";
        }
       
        public function     sayHelloConst() {
            echo     "hello: {$this::VAR}"; //Parse error:  syntax error, unexpected '}', expecting '['
            }
    }

    $obj = new Testing();
    $obj->sayHelloStatic();
    $obj->sayHelloConst();
    up
    -3
    shd at earthling dot net
    14 years ago
    If you want a parsed variable surrounded by curly braces, just double the curly braces:

    <?php
      $foo     = "bar";
      echo     "{{$foo}}";
    ?>

    will just show {bar}. The { is special only if followed by the $ sign and matches one }. In this case, that applies only to the inner braces. The outer ones are not escaped and pass through directly.
    up
    -3
    rkfranklin+php at gmail dot com
    16 years ago
    If you want to use a variable in an array index within a double quoted string you have to realize that when you put the curly braces around the array, everything inside the curly braces gets evaluated as if it were outside a string.  Here are some examples:

    <?php
    $i     = 0;
    $myArray[Person0] = Bob;
    $myArray[Person1] = George;

    // prints Bob (the ++ is used to emphasize that the expression inside the {} is really being evaluated.)
    echo "{$myArray['Person'.$i++]}<br>";

    // these print George
    echo "{$myArray['Person'.$i]}<br>";
    echo     "{$myArray["Person{$i}"]}<br>";

    // These don't work
    echo "{$myArray['Person$i']}<br>";
    echo     "{$myArray['Person'$i]}<br>";

    // These both throw fatal errors
    // echo "$myArray[Person$i]<br>";
    //echo "$myArray[Person{$i}]<br>";
    ?>
    up
    -2
    webmaster at rephunter dot net
    18 years ago
    Use caution when you need white space at the end of a heredoc. Not only is the mandatory final newline before the terminating symbol stripped, but an immediately preceding newline or space character is also stripped.

    For example, in the following, the final space character (indicated by \s -- that is, the "\s" is not literally in the text, but is only used to indicate the space character) is stripped:

    $string = <<<EOT
    this is a string with a terminating space\s
    EOT;

    In the following, there will only be a single newline at the end of the string, even though two are shown in the text:

    $string = <<<EOT
    this is a string that must be
    followed by a single newline

    EOT;
    up
    -4
    bishop
    18 years ago
    You may use heredoc syntax to comment out large blocks of code, as follows:
    <?php
    <<<_EOC
        // end-of-line comment will be masked... so will regular PHP:
        echo (    $test == 'foo' ? 'bar' : 'baz');
        /* c-style comment will be masked, as will other heredocs (not using the same marker) */
        echo <<<EOHTML
    This is text you'll never see!       
    EOHTML;
        function defintion(    $params) {
            echo 'foo';
        }
        class definition extends nothing     {
           function definition(    $param) {
              echo 'do nothing';
           }      
        }

        how about syntax errors?; = gone, I bet.
    _EOC;
    ?>

    Useful for debugging when C-style just won't do.  Also useful if you wish to embed Perl-like Plain Old Documentation; extraction between POD markers is left as an exercise for the reader.

    Note there is a performance penalty for this method, as PHP must still parse and variable substitute the string.
    up
    -5
    cvolny at gmail dot com
    15 years ago
    I commented on a php bug feature request for a string expansion function and figured I should post somewhere it might be useful:

    using regex, pretty straightforward:
    <?php
    function stringExpand($subject, array $vars) {
            // loop over $vars map
            foreach ($vars as $name => $value) {
                // use preg_replace to match ${`$name`} or $`$name`
                $subject = preg_replace(sprintf('/\$\{?%s\}?/', $name), $value,
    $subject);
        }
            // return variable expanded string
            return $subject;
    }
    ?>

    using eval() and not limiting access to only certain variables (entire current symbol table including [super]globals):

    <?php
    function stringExpandDangerous($subject, array $vars = array(), $random = true) {
       
                // extract $vars into current symbol table
                extract($vars);
           
                $delim;
                // if requested to be random (default), generate delim, otherwise use predefined (trivially faster)
                if ($random)
                    $delim = '___' . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . '___';
            else
                    $delim = '__ASDFZXCV1324ZXCV__';  // button mashing...
           
            // built the eval code
                $statement = "return <<<$delim\n\n" . $subject . "\n$delim;\n";
           
                // execute statement, saving output to $result variable
                $result = eval($statement);
           
                // if eval() returned FALSE, throw a custom exception
                if ($result === false)
                throw new     EvalException($statement);
           
                // return variable expanded string
                return $result;
        }
    ?>

    I hope that helps someone, but I do caution against using the eval() route even if it is tempting.  I don't know if there's ever a truely safe way to use eval() on the web, I'd rather not use it.
    up
    -7
    Hayley Watson
    6 years ago
    Any single expression, however complex, that starts with $ (i.e., a variable) can be {}-embedded in a double-quoted string:

    <?php

    echo "The expression {$h->q()["x}"]->p(9 == 0 ? 17 : 42)} gets parsed just as well as " . $h->q()["x}"]->p(9 == 0 ? 17 : 42) . " does.";

    ?>
    up
    -20
    M. H. S.
    4 years ago
    <?php

    // Its A Example for "Heredoc":

    $n = 10;

    $var_heredoc = <<<HEREDOC

    Its A String For "    $var_heredoc" variable.

    heredoc can expanding variables.
    (example:     $n)

    if you want not expanding, you need print " \ " befor variable.
    (example: /    $n)

    heredoc can use " /n, /t, /r, ... ".

    heredoc = the string of double-qoutation;

            HEREDOC; -> its bad closing of heredoc!

    HEREDOC;
    // its a good closing of heredoc!

    ?>
    up
    -3
    greenbluemoonlight at gmail dot com
    3 years ago
    <?php
    \\Example # 10 Simple Syntax - Solution for the last "echo" line.

    class people {
        public     $john = "John Smith";
        public     $jane = "Jane Smith";
        public     $robert = "Robert Paulsen";

        public     $smith = "Smith";
    }

    $people = new people();

    echo     "$people->john then said hello to $people->jane.".PHP_EOL;
    echo     "$people->john's wife greeted $people->robert.".PHP_EOL;
    echo     "$people->robert greeted the two $people->smiths";
    \\    Won't work
    \\Outputs: Robert Paulsen greeted the two

    /**Solution:**\

    echo "$people->robert greeted the two $people->smith\x08s";

    \\Will work
    \\Outputs: Robert Paulsen greeted the two Smiths

    ?>
    add a note add a note
    To Top