Bu seriye 3. bir yazıyı daha ekleyerek devam etmek istiyorum. Çünkü yeni hedeflerim var.

Son 3 yıldır İngiltere’de hem startup şirketlerde hem de orta büyüklükteki şirketlerde çalışarak çok ciddi deneyimler elde ettim. Son zamanlarda 8 aylık bir bootcamp programını bitirerek DevOps alanına da girdim. Böylece IT’deki ufkumu çok daha geniş açılara çektiğimi söyleyebilirim.

Hani Matrix filmindeki Neo karakteri, filmin sonunda Matrix’i bulduğunda ekranda, yukarıdan aşağı belirsiz bir şekilde akan karakterlerin artık anlamlı hale gelmesindeki ve Matrix dünyasını görmeye başlamasındaki gibi bende de DevOps’u öğrendikten sonra öyle bir etki yapmaya başladı. Çükü önemli olan bir web uygulaması geliştirmek değil, geliştirilen uygulamanın belli bir andan sonra ölçeklenebilme kabiliyetinin olmasıdır. İşte bunu anlayabilmek için DevOps’dan bir parça bilmek gerekir.

Benim gelecek yıllar içinki motivasyon ve hedeflerim öğrendiğim bilgilerde derinleşme devam edecektir. Bu derinleşme Bloom Taxonomy (öğrenme modelinde) bulunan 6 basamaklı pramidin en az 5. basamağı olan “Değerlendirme(evaluate)” düzeyi ve üstü olmalıdır. Bu da şu demektir; Öğrendiğin konuya artık katkıda bulunacak düzeydesin.

Bu düzlemde hedefim PHP, Laravel cemiyetleri içinde açık kaynaklı projelere katkıda bulunmak ya da kendim açık kaynaklı projeler başlatarak cemiyete bilfil katkıda bulunmaktır.

Bu durum JavaScript içerisinde de VueJS ekosisteminde olacaktır.

Bunlar haricinde bu yılın en büyük motivasyonu NodeJS‘i öğrenmek ve TypeScript ile JavaScript projeleri geliştirmek ön hedefimdir.

Sunucu kısmında da başta AWS servislerini çok iyi öğrenerek, AWS Cloud Practitioner ve Solution Architect sertifikalarını almak ve o alanlarda da kendimi ispatlamam olacaktır. Takiben Kubernetes ile nasıl bir uygulamanın ölçeklenebilir yapıldığıyla alakalı derinleşmek olacaktır.

Bun haricinde yakın zamanda İngilizce blog sitemi aktif hale geçirerek artık 2 dilde de bilgilerimi paylaşmaya çalışacağım.

Bitmedi! Tüm bunlarla uğraşırken hali hazırda sessizce ve çok emek vererek geliştirdiğim bir yan projemi görücüye çıkartmaya hazırlanacağım. Bu projeyle bir startup şirketinin kuruluşu başlamış olacak ve artık bambaşka bir alana ve ilmi yolculuğa yelkenleri açmış olacağım.

function hesapla($x, $y) 
{
    $result = $x + $y;

    return $result;
}

Şimdi bir diğer teknik olan dizileri kullanarak da birden fazla değeri de tek bir değişken içinde yollattırabiliriz; ama yazımın konusunda vurguladığım yöntem bu değil tabi ki :-). Şu şekilde:

function hesapla($x,$y)
{
    $result  = [];
    $toplama = $x + $y;
    $cikarma = $x - $y;
    $carpma  = $x * $y;
    $bolme   = $x / $y;

     $result = [
     'toplama' => $toplama,
    'cikarma' => $cikarma,
    'carpma'  => $carpma,
    'bolme'   => $bolme,
    ];

     return $result;
}

$sonuc = hesapla(3, 2);

echo $sonuc['toplama'];
echo $sonuc['cikarma'];

Peki yazı başlığımda vurguladığım yönteme geçecek olursak, PHP’de bulunan reference operator “&” ler ile fonksiyon parametresi olarak da yollatırabileceğimizi göstermek istiyorum.

Bilindiği gibi PHP dilinde equals “=” operatör kullandığımızda, operatörün solunda bulunan değişkene sağındaki kopyalanıyordu. Şöyle:

$b = 2;

$a = $b;

Yukarıda $a’ya $b değeri eşit dediğimiz anda kopyalanıyor.

Şimdi bu durumda ben “reference operand (&)” kullanırsam kopyalama değil, o değişkenin hafızadaki referans değerini kopyalarım. Pointer gibi düşünebilirsiniz.

Bu durumda

$b = 2;

$a =& $b;

dersem $b değişkeni kod içinde herhangi bir yerde değiştiğinde $a’da değişmiş olacak. Çünkü $a değişkeni $b‘nin hafızadaki referans değerini tutuyor. Aynı object oriented programlamada nesnelerin davranışı gibi.

Örnek yapalım:

$b = 2;

$a =& $b;

echo $a; // ekrana 2 yazar

$b = 3;

echo $a; // ekrana 3 yazar

Bu mantıkla bir fonksiyona birden fazla değer şöyle yollattırabiliriz:

function hesapla($x, $y, &$toplama, &$cikarma, &$carpma) 
{
    $toplama = $x + $y;
    $cikarma = $x - $y;
    $carpma  = $x * $y;
}

Kullanımı:

hesapla(3, 2, $toplama_degeri, $cikarma_degeri, $carpma_degeri);

echo $toplama_degeri; // cikti 5

echo $cikarma_degeri; // cikti 1

echo $carpma_degeri; // cikti 6

1. Onaylanmis Covid-19 vakaları
2. Covid-19 vakasından ölenlerin sayısı
3. Covid-19 hastalığından kurtulan hasta sayısı

Bu bilgileri elde etmek için PHP’de şöyle bir sınıf yazdım:

<?php
/*
 *
 * Copyright Burhan Tanis
 * W: burhantanis.com
 */

class CovidDataProvider
{
   public function readCSVGenerator($file)
    {
        //readonly modunda dosyayi ac.
        $handle = fopen($file, "r");
        while (!feof($handle)) {
            //iterator ile hafizayi fazla yormuyorum. Cursor teknigiyle datalar arasi dolasiyorum.
            yield fgetcsv($handle);
        }
        fclose($handle);
    }

    /**
     *
     * Bu metod bilgileri array icinde belli bir duzene sokuyor ki ileride ulkeye gore data cekeyim.
     *
     * @param $raw_url
     * @param $country
     * @return array|mixed
     */
    public function getCountryData($raw_url, $country)
    {
        $result = [];
        $i      = 0;
        $cols   = [];
        foreach ($this->readCSVGenerator($raw_url) as $line) {
            if ($i == 0) {
                $c = 0;
                foreach ($line as $col) {
                    $cols[$c] = $col;
                    $c++;
                }
            } else if ($i > 0) {
                $c = 0;
                foreach ($line as $col) {
                    $data[$i][$cols[$c]] = $col;
                    $c++;
                }
            }
            $i++;
        }
        foreach ($data as $line) {
            if ($line['Country/Region'] === $country) {
                $result = $line;
                break;
            }
        }
        return $result;
    }
}

Kullanımı şu şekilde:

$covid = new CovidDataProvider();

//URL BILGILERI:

// Confirmed : https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_19-covid-Confirmed.csv

// Death: https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_19-covid-Deaths.csv

// Recovered: https://github.com/CSSEGISandData/COVID-19/blob/master/csse_covid_19_data/csse_covid_19_time_series/time_series_19-covid-Recovered.csv

//Asagida confirmed covid virus vakalarini cekiyorum.
$raw_url = 'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_19-covid-Confirmed.csv';

$data    = $covid->getCountryData($raw_url, 'Turkey');

//Hangi tarihi cekeceksen asagidaki formatta yaziyorsun.
//Dongu icinde tarihleri gostereceksen $data arrayini kullanarak dongude belirledigin tarihler arasindaki datayi aldirtabilirsin.
echo $data['3/14/20'];

“Return” den farklı olarak, yield işlemi gerçekleştirdikten sonra yordamı sonlandırıp fonksiyondan çıkartmıyor bizi; tam tersi işlemi devam ettiriyor. Bu yüzden döngü içerisinde kullanımı aslında işlevini en iyi gerçekleştirdiği yer. Çünkü döngü içinde biz “return” kullanmış olsak ilk işlemden sonra yordamı sonlandırır ve değer döndürür. İşte burada “yield” kullandığımız takdirde işlem sonlanmıyor ve döngü bitene kadar işlem devam ediyor. Her bir döngü içerisindeki sonucu yield içerisine “array” tipindeymiş gibi koyuyor; ama “yield” bir array de değil. Tam manada “Allocated memory” kullanmıyor. Her bir işlemden sonra oluşturduğu iterator nesnesinin son pozisyonundan işleme devam ediyor. Daha da somutlaştırırsak örneğimizi, hani veritabanlarinda bulunan “Cursor” mantığı ile aynı şekilde çalışıyor. Hafızaya almaktansa cursor pozisyonunu next() şeklinde ilerletiyor. Bu yüzden bir hafıza limiti ile de karşılaşmayacağız.

Eğer büyük datasetler ile calışacaksanız “yield” kullanmalısınız. Mesela bir text dosyasını okuduğunuzu düşünelim. Bu iş için yield kullanılabilir.

Ayrıca tekrar belirtmeliyim ki “yield” bir fonksiyon içerisinde kullanılmak zorundadır. Bu yüzden yazının başında da dediğim gibi “yield” in kullanıldığı fonksiyonun adına da “Generator Function” diyoruz.

Örneklerle açıklamaya devam edelim:

function numbers() {
     for($i=0; $i<=10; $i++) {
        yield $i; 
    } 
}

Yukarıdaki örnekte görülmek üzere “yield” kısmında “$i” değişkeni iterator nesnesi şeklinde yield içerisinde oluyor ve işlem devam ediyor. En son işlemden sonra yordam sonlanıyor. Buradan şu sonucu da çıkartabiliriz: “yield” tek başına return den farklı olarak hiç bir değişken ya da dizi kullanmadan birden fazla değer tutabiliyor içinde.

“yield” içerisindeki veriyi okuyabilmek için dizilerde yaptığımız gibi şöyle yapmalıyız:

$numbers =  numbers();

foreach($numbers as $number) {
echo "$number \n";
}

Yield’in faydaları neler?

1. Hafızadan belirli bir yer ayırma ihtiyacı duymadığı için hafıza limiti problemi yok. Çok geniş verilerle çalışabiliriz.

2. Generator functionlar normal functionlardan daha hızlı çalışır.

3. Kod karmaşıklığını daha da azaltıyor. Kodun okunabilirliğini artırıyor.

4. Bu özellik PHP 5.5 sürümünde ekleniyor; Generator fonksyionlar normalde return değeri göndermezler; ama 7.0 ile gönderebilmeleri sağlanıyor ve “getReturn()” ile bu değeri alabiliyoruz. Şöyle:

    <?php

    $gen = (function() {
        yield 1;
        yield 2;

        return 3; // bu özellik 7.0 ile geldi
    })();

    foreach ($gen as $val) {
        echo $val, PHP_EOL;
    }

    echo $gen->getReturn(), PHP_EOL;

Çıktı:
    1
    2
    3

Şimdi hafıza kullanımı ile ilgili bir örnek yazalım. Böylece array ile arasında nasıl bir fark olduğunu görün:

<?php


function sample_array($value)
{
    $i = 0;
    $data = [];


    while ($i < $value) {
        $i++;
        $data[] = round(memory_get_usage(true) / 1024 / 1024, 2);
    }

    return $data;

}


function sample_generator($value)
{
    $i = 0;

    while ($i < $value) {
        $i++;
        yield round(memory_get_usage(true) / 1024 / 1024, 2);

    }


}


foreach (sample_array(150000) as $value) {
    $result = $value;
}
echo "Memory Consumption (function with array): $result MB \n";

echo "-----------------\n";

foreach (sample_generator(150000) as $value) {
    $result = $value;
}
echo "Memory Consumption (generator function with yield):  $result MB \n";

Çıktı:

Memory Consumption (function with array): 10 MB 
-----------------
Memory Consumption (generator function with yield):  2 MB 

Bu tasarım kalıbı, bazı nesnelerin “constructor” kısmında karmaşık değişkenler girmek zorunda olduğumuz zaman bu durumu basitleştirerek daha okunaklı, tekrar kullanılabilir ve bakımı kolay yapılabilir hale getirir.

Örnekle anlatmaya devam edelim.

Mesela bir “Pizza” sınıfımız olsun. Bu tasarım kalıbını kullanmadan önce şöyle bir tasarım yaptığımızı farz edin:

<?php

class Pizza
{
    private $tarif;
    private $ekPeynir;
    private $boyut;
    private $sos

    public function __construct(string $tarif, bool $ekPeynir, int $boyut, string $sos) 
    {
        $this->tarif    = $tarif;
        $this->ekPeynir = $ekPeynir;
        $this->boyut    = $boyut;
        $this->sos      = $sos;
    } 

    public function olusturulanPizza():string
    {
        $peynir = $this->ekPeynir ? " (ek peynir)" : "";

        return $this->tarif.$peynir. " pizza ile ". $this->sos.
        " sos ve boyutu ".$this->size;

    }

}

Kullanımı:

$pizzam = new Pizza('Margarita',true,10,'ketçap');
echo $pizzam->olusturulanPizza();

Yukarıdaki koda şöyle bir göz attığımızda idare ettiğini görüyoruz ama nesne oluştururken girilen parametre değişkenleri gerçekten biraz karışık gibi duruyor. Bu parametre sayısının çok daha fazla olduğunu düşünürseniz ne kadar çirkin duracağını siz düşünün.

İşte bu durumlarda “Builder” tasarım kalıbını kullanarak constructor’da kullanacağımız değişkenlerin sayısını azaltarak kodumuzu daha okunaklı, tekrar kullanılabilen ve bakımı kolay yapabiliriz.

Evvela bir PizzaBuilder adında sınıf oluşturalım:

class PizzaBuilder
{
    private $tarif;
    private $ekPeynir;
    private $boyut;
    private $sos

    public function __construct(string $tarif)
    {
        $this->tarif    = $tarif;

        //ön değerler giriyorum. Kullanılmadığında
        // otomatik bunları atayacak.
        $this->ekPeynir = false
        $this->boyut    = 10;
        $this->sos      = 'ketçap';     
    }

    public function peynirEkle()
    {
        $this->ekPeynir = true;
        return $this;
    }

    public function boyutBelirle(int $boyut)
    {
        $this->boyut = $boyut;

        return $this;
    }  

    public function sosEkle(string $sos)
    {
        $this->sos = $sos;

        return $this;

    }

    //magic metod kullandım. Private değişkenler($tarif,$ekPeynir,$boyut,$sos) sınıf dışı kullanıldığında küçük bir hile ile  bunları bu magic metod ile dışarıda kullanıma sunuyorum. Aşağıdaki Pizza sınıfında göreceksiniz bunu.
    public function __get($propertyName)
    {
        return $this->$propertyName;
    }
}

Şimdi “Pizza” sınıfımıza özelleştirilmiş pizza menümüzü dışarıdan enjekte edebiliriz. Şöyle:

class Pizza
{
    private $tarif;
    private $ekPeynir;
    private $boyut;
    private $sos

    public __construct(PizzaBuilder $builder)
    {
        $this->tarif    = $builder->tarif;
        $this->ekPeynir = $builder->ekPeynir;
        $this->boyut    = $builder->boyut;
        $this->sos      = $builder->sos;            
    }   

    public function olusturulanPizza():string
    {
        $peynir = $this->ekPeynir ? " (ek peynir)" : "";

        return $this->tarif.$peynir. " pizza ile ". $this->sos.
        " sos ve boyutu ".$this->size;

    }
}

Kullanımı:

$pizzam = (new PizzaBuilder('FourCheese'))
                     ->peynirEkle()
                     ->sosEkle('Acılı Domates Sosu');

//ya da

$pizzam = (new PizzaBuilder('Margarita'))
                     ->peynirEkle()
                     ->boyutBelirle(8)
                     ->sosEkle('Tatlı Domates Sosu');


$pizzaHazirla = new Pizza($pizzam);
echo $pizza->olusturulanPizza();                 

Nasıl ama ?

Evvela tekrardan bir “Car” interface’i oluşturulalım. Sonra bu interface’den diğer arabalarımızı implement edeceğiz.

 <?php

 interface Car
 {
     public function arabayiSur(): string;
 }

Daha sonra Tofas ve Mercedes arabalarımızı implement edelim aşağıdaki gibi:

 class Tofas implements Car
  {
     public function arabayiSur(): string
     {
         return "Tofaş arabayı sürüyorum";
     }
 }


 class Mercedes implements Car
  {
     public function arabayiSur(): string
     {
         return "Mercedes arabayı sürüyorum";
     }
 }

Buraya kadar tamam. Bu adımdan sonra Strategy tasarım kalıbını kullanarak bu nesneleri çalışma esnasında enjekte edecek şekilde ana kodumuzu aşağıdaki gibi yazalım:

 Class CarStrategy {

  private $strategy;

     Public __construct(Car $strategy) {

         $this->strategy = $strategy
     }

     Public function arabayiSur() {

            return $this->strategy->arabayiSur();

     }

 }

Şimdi Yukarıda Stategy tasarım kalıbını kullanarak kodladığımız sınıfı, CarFactory sınıfının içerisinde Factory Tasarım kalıbını kullanarak yazalım:

 Class CarFactory {

     Public static function arabaAl(bool $luks):Car {

          $car = new CarStrategy();


         if ($luks === true) {

             return $car->set_new_strategy(new Mercedes());
         }

         return $car->set_new_strategy(new Tofas());

     }

 }

Kullanımı:

 $car = CarFactory::arabaAl(true);
 echo $car->arabayiSur();

Bu kadar! Bu örnekle hem Strategy hem de Factory kalıbını bir arada kullanmış oldum.

function yabancıMaasHesapla($maas)
function yerliMaasHesapla($maas)

tarzında metodlar yazarsak bir çok yazılım prensibi kuralını ihlal etmiş oluruz. İşte bu durumlar için Strategy tasarım kalıbını kullanarak yazılım prensiplerini ihlal etmeden genişletilebilir, tekrar kullanılabilir, test edilebilir ve daha okunaklı bir kod yapısı orta çıkartmış oluruz.

Strategy tasarım kalıbı Behavioral dediğimiz birlikte belirli bir işi yerine getirmek için çeşitli sınıfların nasıl birlikte davranabileceğinin belirlenmesi kategori grubundadır.

Yukarıdaki senaryomuzu örneğe dökerek açıklamaya devam edelim:

İlk başta bir interface oluşturalım:

Interface Maas
{

    public function maasHesapla(int $maas): int;
}

Sonra bu interface’den YabanciMaas ve YerliMaas sınıflarımızı implement edelim. Sonrada hesaplama yöntem, katsayı vs. kodlayalım sınıf içinde aşağıdaki gibi:

Class YabanciMaas implements Maas
{

    public function maasHesapla(int $maas): int
    {

        return ($maas * 3);

    }
}

Class YerliMaas implements Maas
{

    public function maasHesapla(int $maas): int
    {
        return ($maas * 4);
    }
}

Şimdi de ana sınıfımızı yazalım:

Class MaasHesaplama
{

    private $maas;

    public function maasHesaplamaYontemi(Maas $maas)
    {
        $this->maas = $maas;

        return $this;
    }

    public function maasHesapla($maas)
    {
        return $this->maas->maasHesapla($maas);

    }
}

Kullanımı şu şekilde:

$maas = new MaasHesaplama();

echo $maas->maasHesaplamaYontemi(new YabanciMaas())
            ->maasHesapla(200);

echo $maas->maasHesaplamaYontemi(new YerliMaas())
            ->maasHesapla(200);