<![CDATA[burhantanis.com Kod Dünyam RSS Feed]]> https://burhantanis.com/ Şehir Notları ve Kod Dünyam adında 2 farklı alanda bilgilerimi paylaşmakta, düşüncelerimi yazmaktayım. Fri, 04 Jan 2019 21:09:00 +0000 tr-TR burhanmt@outlook.com (Burhan T.) Copyright 2015-2020 3600 <![CDATA[Reference Operator ile PHP'de bir fonksiyondan birden fazla değer gönderebilme]]> https://burhantanis.com/blog_kod_dunyam/2020/04/26/reference-operator-ile-phpde-bir-fonksiyondan-birden-fazla-deger-goenderebilme https://burhantanis.com/blog_kod_dunyam/2020/04/26/reference-operator-ile-phpde-bir-fonksiyondan-birden-fazla-deger-goenderebilme post Sun, 26 Apr 2020 17:53:00 +0100 Normalde PHP dilinde bir fonksiyon, geriye tek bir değer gönderir; fakat farklı teknikler kullanarak birden fazla değer de göndertebiliriz. Bu tekniklere geçmeden önce PHP’de tek bir değer gönderiminin şu şekilde yapıldığını bilmemize rağmen tekrardan gösterelim:

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
]]>
<![CDATA[Adı Verilen Ülkelerdeki Covid-19 vakalarını güncel olarak Gün Gün Gösteren PHP Script Yazıyoruz]]> https://burhantanis.com/blog_kod_dunyam/2020/03/15/adi-verilen-uelkelerdeki-covid-19-vakalarini-guencel-olarak-guen-guen-goesteren-php-script-yaziyoruz https://burhantanis.com/blog_kod_dunyam/2020/03/15/adi-verilen-uelkelerdeki-covid-19-vakalarini-guencel-olarak-guen-guen-goesteren-php-script-yaziyoruz post Sun, 15 Mar 2020 18:34:00 +0000 Bir arkadaşımın isteği üzerine Pazar sabahı 1 saatlik bir çalışmadan sonra PHP ile güncel COVID-19 vakalarını alan bir script yazdım. İsteyen istediği gibi geliştirip herhangi bir amaç için kullanabilir. Güncel verileri almak için https://github.com/CSSEGISandData/COVID-19 kaynağını kullanıyorum. Veriler düzenli olarak 3 kategoride gün gün CVS dosyasında güncelleniyor. Bu kategoriler:

  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'];
]]>
<![CDATA[PHP'de "Generator function" kullanımı ve hafızayı verimli kullanmada oynadığı rol]]> https://burhantanis.com/blog_kod_dunyam/2019/09/13/phpde-generator-function-kullanimi-ve-hafizayi-verimli-kullanmada-oynadigi-rol https://burhantanis.com/blog_kod_dunyam/2019/09/13/phpde-generator-function-kullanimi-ve-hafizayi-verimli-kullanmada-oynadigi-rol post Fri, 13 Sep 2019 12:47:00 +0100 PHP’de GENERATOR FUNCTION diye adlandırlan bir fonksiyon türü. PHP 5.5 sürümü ile camiyaya katılıyor. Normal bir fonksiyona çok benziyor; ama bu fonksiyonda “return” yerine “yield” kullanıyoruz. Böylece yield kullandığımız fonksiyonlar otomatik olarak “Generator Function” diye adlandırılıyor.

“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 
]]>
<![CDATA[Builder Tasarım Kalıbı Nedir?]]> https://burhantanis.com/blog_kod_dunyam/2019/07/28/builder-tasarim-kalibi-nedir https://burhantanis.com/blog_kod_dunyam/2019/07/28/builder-tasarim-kalibi-nedir post Sun, 28 Jul 2019 03:14:00 +0100 Builder tasarım kalıbı da Tasarım kalıplarının “Creational” kategorisi içerisinde yer alır. Bu kategori önceden de bahsettiğim üzere nesnelerin oluşturulması ve yönetilmesi ile ilgili kalıpların bulunduğu kategoridir.

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 ?

]]>
<![CDATA[Strategy ve Factory Tasarım Kalıplarının Birlikte Kullanımı]]> https://burhantanis.com/blog_kod_dunyam/2019/07/27/strategy-ve-factory-tasarim-kaliplarinin-birlikte-kullanimi https://burhantanis.com/blog_kod_dunyam/2019/07/27/strategy-ve-factory-tasarim-kaliplarinin-birlikte-kullanimi post Sat, 27 Jul 2019 23:03:00 +0100 Factory Tasarım Kalıbında kullandığım örneği Strategy tasarım kalıbını da işin içine katarak genişletelim.

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.

]]>
<![CDATA[Strategy Tasarım Kalıbı Nedir?]]> https://burhantanis.com/blog_kod_dunyam/2019/07/23/strategy-tasarim-kalibi-nedir https://burhantanis.com/blog_kod_dunyam/2019/07/23/strategy-tasarim-kalibi-nedir post Tue, 23 Jul 2019 01:50:00 +0100 Bazen bazı durumlarda bir işlemi yapmak için birden fazla yöntem kullanmamız gerekebilir. Örneğin maaş hesaplama programımız olsun ve bu program yabancı çalışanlar için farklı bir yöntem izlerken, yerli çalışanlar için de ondan daha farklı bir hesaplama yöntemi yapmış olsun. Biz tüm bunları bir sınıfa dahil ederek

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);
]]>
<![CDATA[Factory Tasarım Kalıbı Nedir?]]> https://burhantanis.com/blog_kod_dunyam/2019/07/22/factory-tasarim-kalibi-nedir https://burhantanis.com/blog_kod_dunyam/2019/07/22/factory-tasarim-kalibi-nedir post Mon, 22 Jul 2019 15:39:00 +0100 Factory tasarım kalıbı kısaca istediğimiz özellikteki nesneyi oluşturup bize döndüren bir kalıptır. “Creational” tasarım kalıbı kategorisine girer. Bu kategori(Creational) bir yada daha fazla nesnenin oluşturulması ve yönetilmesi ile ilgilidir.

Şimdi örnekle daha iyi açıklamaya çalışacağım.

Bir Interface oluşturalım:

 <?php

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

Şimdi arabaları oluşturalım:

 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";
     }
 }

Şimdi Factory tasarım kalıbı ile istediğimiz özellikteki nesneyi bize sağlattıralım. Şöyle:

 Class CarFactory {

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

         if ($luks === true) {

             return new Mercedes();
         }

         return new Tofas();

     }

 }

Kullanımı:

 $car = CarFactory::getCar(true);
 echo $car->drive();

Hepsi bu kadar! İstediğimiz özellikteki nesneyi oluşturup $car değişkenine atıyoruz ve o nesneyi artık kullanıyoruz. Burada dikkatinizi çekmiştir ki nesne oluşturma işi Factory içerisinde yapılıyor.

Factory tasarım kalıbı, Strategy tasarım kalıbına çok benziyor; ama aradaki fark biri diğer sınıflara ait nesneleri factory içerisinde oluşturup kullanıma hazır hale getirirken, Strategy kalıbında buna ihtiyaç duyulmuyor.

“CarFactory” sınıfına tekrar dikkatle bakın. Şarta göre “Mercedes” ya da “Tofas” CarFactory içinde oluşturulup hazır hale getiriliyor ve ben kullanırken $car = CarFactory::getCar(true); tarzında istenen şart sağlandığında nesneler zaten factory içerisinde oluşturulup kullanıma hazır hale getirileceğinden bana echo $car->drive(); şeklinde oluşturulmuş nesneyi kullanmak düşüyor.

Bu yüzden Factory tasarım kalıbı “Creational” kategorisinde yer alırken, “Strategy” tasarım kalıbı da “Behavioral” tasarım kalıpları kategorisinde zikredilir.

]]>