<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sercan Çakır on Medium]]></title>
        <description><![CDATA[Stories by Sercan Çakır on Medium]]></description>
        <link>https://medium.com/@sercancakir?source=rss-6a1776b2d759------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*p6Mtmd74PibkWy_l.jpg</url>
            <title>Stories by Sercan Çakır on Medium</title>
            <link>https://medium.com/@sercancakir?source=rss-6a1776b2d759------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 15:19:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sercancakir/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Understanding Enums]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/insiderengineering/understanding-enums-d75865f0f2a9?source=rss-6a1776b2d759------2"><img src="https://cdn-images-1.medium.com/max/2400/1*Ty0l9_VD5RcSuHuCXv4UyQ.png" width="2400"></a></p><p class="medium-feed-snippet">Constants are so yesterday&#x200A;&#x2014;&#x200A;meet Enums!</p><p class="medium-feed-link"><a href="https://medium.com/insiderengineering/understanding-enums-d75865f0f2a9?source=rss-6a1776b2d759------2">Continue reading on Insider One Engineering »</a></p></div>]]></description>
            <link>https://medium.com/insiderengineering/understanding-enums-d75865f0f2a9?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/d75865f0f2a9</guid>
            <category><![CDATA[enumeration]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[enum]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Mon, 24 Nov 2025 07:02:08 GMT</pubDate>
            <atom:updated>2025-11-24T07:02:08.514Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Understanding Laravel Pipelines]]></title>
            <link>https://medium.com/insiderengineering/understanding-laravel-pipelines-9717f5d58286?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/9717f5d58286</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[laravel]]></category>
            <category><![CDATA[pipeline]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Mon, 01 May 2023 07:01:53 GMT</pubDate>
            <atom:updated>2023-05-01T07:01:53.513Z</atom:updated>
            <content:encoded><![CDATA[<p>Today we will talk about the Laravel Pipeline class. Many developers not known this gem because this feature is not documented on the website. However, this is a very useful feature for organizing huge methods.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OEvNmRFo7n_9RqDq7Tqhog.png" /></figure><p>Let’s start to explore the API documentation:</p><p><a href="https://laravel.com/api/9.x/Illuminate/Pipeline/Pipeline.html">Illuminate\Pipeline\Pipeline | Laravel API</a></p><h4>What is Pipeline?</h4><p>In Laravel, the Pipeline class is implemented based on the Chain of Responsibility (aka CoR) design pattern.</p><p>In summary; the pipelines take a job, process it, and forward it to the next pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/0*FavcUWvQe8bIfoEp.jpg" /></figure><p>In Laravel, the pipe class has two parameters: one of the data and the other is the forwarder (aka: next closure) callback. Each pipe class handles the given data and then forwards it to the next pipe class.</p><h4>Chain of Responsibility Design Pattern</h4><p>CoR is a behavioral design pattern. This pattern is process the given data with many handlers. When the request arrived at to pipe class, it processes the data and forwards the next one. The rule is simple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cfGYgPGrElBQkYVd.png" /><figcaption><a href="https://miro.medium.com/max/1400/1*wqHGES91TwX_KazIOB8fAg.png">https://miro.medium.com/max/1400/1*wqHGES91TwX_KazIOB8fAg.png</a></figcaption></figure><p>Developers have used this pattern even if they don’t know its name. In the real world, the middleware layer is CoR.</p><h4>Laravel Abstraction</h4><p>The Pipeline is an abstracted CoR pattern. Laravel gives us some magic methods. Let’s meet them. The pipe class looks like that:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/32dceb72297d4ab8d191d5e431ead8a0/href">https://medium.com/media/32dceb72297d4ab8d191d5e431ead8a0/href</a></iframe><p>The $data can be any type. You can pass the Eloquent model or DTO etc...</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f3fbf3a136302b64c847ffd5639f22d0/href">https://medium.com/media/f3fbf3a136302b64c847ffd5639f22d0/href</a></iframe><p>In the above example, the $content will be passed to pipes in the defined order.</p><p>The default handler method is handle but you can change this with via the method. If you changed it, your pipe class must have the defined method.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/66d3ab8d9fd1687b1853fd8c83713936/href">https://medium.com/media/66d3ab8d9fd1687b1853fd8c83713936/href</a></iframe><p>And finally, Laravel gives us two options to us. If we use thenReturn it will return the data $contentwhen the pipeline is complete. You can also use the thenmethod instead. Here is an example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f06762ae6097ac49768c4c600cbadf4e/href">https://medium.com/media/f06762ae6097ac49768c4c600cbadf4e/href</a></iframe><h4>Example Usecase</h4><p>In this section, we’ll make a real-world example. Before saving the data, we will pass some business rules.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5005027384ebee068df63d9e91b2d0e8/href">https://medium.com/media/5005027384ebee068df63d9e91b2d0e8/href</a></iframe><p>The pipeline classes will process the data. After processing the Pipeline returns the data and it will be saved with the Repository layer.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/239e415aaa8dda420709241752cc9a64/href">https://medium.com/media/239e415aaa8dda420709241752cc9a64/href</a></iframe><p>That’s it. As you can see, you can decide something in your pipe class. If passed your rules, the handler will work. Otherwise, you can pass the data to the next pipeline without manipulation.</p><p>In the pipeline, you can store data in your storage, you can send requests to API, or can change the original data.</p><h4>Conclusion</h4><p>This is not the only/correct way to solve problems. This is an idea for you. You can feel free to choose the correct way.</p><p>You can create small parts of business logic with Laravel’s pipeline instead of one big class or method. Easily maintained extendable and small test cases. It sounds pretty good.</p><p>If you liked this article, you can also check <a href="https://medium.com/insiderengineering/how-to-build-a-flexible-role-based-access-control-system-in-10-minutes-8834d01281b1"><strong>this</strong></a><strong> </strong>one or our <a href="https://medium.com/insiderengineering"><strong>Insider Engineering</strong></a> blog.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9717f5d58286" width="1" height="1" alt=""><hr><p><a href="https://medium.com/insiderengineering/understanding-laravel-pipelines-9717f5d58286">Understanding Laravel Pipelines</a> was originally published in <a href="https://medium.com/insiderengineering">Insider One Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Circuit Breaker Pattern]]></title>
            <link>https://medium.com/insiderengineering/circuit-breaker-pattern-67d1ac6750ef?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/67d1ac6750ef</guid>
            <category><![CDATA[prevention]]></category>
            <category><![CDATA[circuit-breaker]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Mon, 10 Jan 2022 07:02:47 GMT</pubDate>
            <atom:updated>2022-01-10T07:02:47.203Z</atom:updated>
            <content:encoded><![CDATA[<p>In the real world, circuit breakers are used to prevent electrical faults. To prevent bigger problems, the circuit breaker is automatically activated in case of a problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qX1VzOMlpGLWPN_g.jpg" /><figcaption>The circuit breaker systemlifecycle</figcaption></figure><p>Developers like to adapt real world solutions to software. In this article, we will talk about circuit breakers for software.</p><h3>The Theory</h3><p>Many applications need to communicate with different sources. Sometimes we may need to connect the DB or cache driver, sometimes we use synchronous remote calls. Each factor affects the app’s health. Because, sometimes we may not be able to communicate with them for any reason.</p><p>It will be a waste of both resources and time to perform a transaction knowing that we will get a failure. Also, the rollback scenario may be hard on large systems. Instead of this if we know the transaction may be a failure, we can prevent it instead of execute.</p><p>That’s exactly the mission of the circuit breaker.</p><h3>Important Variables</h3><p>To implement a circuit breaker, it is useful to know some keywords for your workflow. We need to keep some data to determine state.</p><h4><strong>Threshold</strong></h4><p>It keeps the maximum number of failures allowed. If the number of failures exceeds this value, the circuit breaker will be open.</p><h4><strong>Timeout</strong></h4><p>When the Circuit Breaker is in the open state, it must allow limited transactions after waiting for a while. Because we need to repair the state. Here it is defined how long to wait after the last failed transaction.</p><h4>Failure Transactions</h4><p>We need to keep count of failure and last failure timestamp. This data may be kept in Redis, DB or etc for not losing these values. However, these values may be array. Sometimes, you need to separate failures status.</p><p>For example, the exchange service requests should be executed even if the weather service is blocked.</p><h3>States</h3><p>Generally, the Circuit Breaker pattern has 3 states. We don’t have best practices for changing the state. Depending on the application needs the state changer strategies may be different.</p><h4>Closed</h4><p>The <strong>default</strong> state is closed. This means the count of failures did not exceed the threshold and the system is working as expected. In this state all transactions will be processed without preventing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aXyNvBUKedPazIq-Iu1pmA.png" /><figcaption>All transactions will be processing in closed state</figcaption></figure><h4>Open</h4><p>When the number of failures exceeds the threshold, the circuit breaker will change state to open. The transactions are <strong>blocked immediately</strong> without being attempted.</p><p>In this state your application can have a different strategy. For example, you can return cached data when the API requests are blocked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Da9bevp8hKkq2jk8ro_eww.png" /><figcaption>All transactions will be prevented in open state</figcaption></figure><h4>Half-Open</h4><p>In this state, the circuit breaker allows some transactions. The state may be <strong>closed</strong> when the transactions are successful. But, if the transactions continue to fail the state will be <strong>open</strong>.</p><p>Your application may follow different strategies when returning <strong>open</strong> or <strong>closed</strong> state.</p><p>For example, sometimes you can reset the previous failures when a transaction executed successfully or you can stay half-open state for some failures. In this case no best practices. Because each application’s requirements are different.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lJ2ZOARaRg8PQNgr6KgTKg.png" /><figcaption>Limited transactions will be allowed in half-open state</figcaption></figure><blockquote>TL;DR</blockquote><blockquote>The Circuit Breaker pattern prevents the execution of a potentially failing operation.</blockquote><h4>Example</h4><p>Now we will prepare a very simple class of circuit breaker. Normally circuit breaker states need to be kept as permanently. We keep it in the Redis.</p><p>For simplicity in this example, we will keep it simple with class property.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/07d313d19708a953fe4652b3fe5059f5/href">https://medium.com/media/07d313d19708a953fe4652b3fe5059f5/href</a></iframe><p>This is a very simple class. The circuit breaker will be open when 20 transactions have failed. Operations are inhibited when the circuit breaker is in open mode. However, some transactions are retried 30 seconds after the last failure. And the new status is determined according to the transaction’s status.</p><p>Example usage:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e44bf0a8bbb665b0feb527a879fecee/href">https://medium.com/media/1e44bf0a8bbb665b0feb527a879fecee/href</a></iframe><p>Output:</p><pre>string(25) &quot;the default state: closed&quot;<br>string(23) &quot;after 20 failures: open&quot;<br>string(24) &quot;after wait 10 secs: open&quot;<br>string(29) &quot;after wait 30 secs: half-open&quot;<br>string(26) &quot;after successfully: closed&quot;<br>string(25) &quot;after again failure: open&quot;</pre><h3>References</h3><p>For more about this pattern:</p><ul><li><a href="https://martinfowler.com/bliki/CircuitBreaker.html">Circuit Breaker</a> by Martin Fowlers</li><li><a href="https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern">Circuit Breaker design pattern</a> on Wikipedia</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67d1ac6750ef" width="1" height="1" alt=""><hr><p><a href="https://medium.com/insiderengineering/circuit-breaker-pattern-67d1ac6750ef">Circuit Breaker Pattern</a> was originally published in <a href="https://medium.com/insiderengineering">Insider One Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redis ile Leaderboard Oluşturma]]></title>
            <link>https://medium.com/i%CC%87yi-programlama/redis-ile-leaderboard-olu%C5%9Fturma-cd4f6414003?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd4f6414003</guid>
            <category><![CDATA[gamification]]></category>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[leaderboard]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Wed, 07 Oct 2020 09:30:09 GMT</pubDate>
            <atom:updated>2020-10-07T13:24:51.212Z</atom:updated>
            <content:encoded><![CDATA[<p>Neredeyse her uygulamada karşımıza çıkan oyunlaştırma, aslında ziyaretçileri (oyuncuları) hırsa teşvik etmek ve uygulama içinde daha fazla zaman geçirmesini sağlamak için geliştirilmiş bir iş kuralıdır.</p><p>Uygulama türünün ne olduğu önemli değildir. Oyunlaştırma her alanda uygulanabilir. Farklı oyunlaştırma yöntemleri olsa da lider tablosu (leaderboard) en kolay uygulanabilir çeşididir. Oyuncuların o listeye girme arzusu uygulamanın daha fazla kullanılmasını sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/0*SsfU9JwZYvIgo0fA" /><figcaption><a href="https://techcrunch.com/2015/08/20/swarm-gets-back-into-the-game-with-leaderboards/">https://techcrunch.com/2015/08/20/swarm-gets-back-into-the-game-with-leaderboards/</a></figcaption></figure><p>Kullanıcıların hareketlerini veritabanında saklarız. Kim ne kadar başarılı olmuş, nerelerde hatalar yapmış gibi istatistiksel verilere sahip olduğumuzu göz önüne aldığımızda basit bir SQL sorgusu ise lider tablosunu elde edebileceğimizi düşünebilirsiniz.</p><p>Kesinlikle haklısınız, yük altında olmayan uygulamalarda SQL sorgusu ile bu işlemi hızlıca karşılayabilirsiniz. Ancak reklam çalışmaları başladığında, artık uygulamanıza eskisinden çok daha fazla sayıda kullanıcı gelmeye başlarsa ne olacak? Belirli bir süre sonra veritabanına giden çok sayıda sorgu canınızı yakacak. Belki veritabanına giden sorguları önbelleğe almayı bir çözüm olarak görebilirsiniz. Ancak bu seferde veriler güncelliğini kaybedecek. Oyuncu yeni puan kazandı ve bu puanı veritabanına yazmanıza rağmen lider tablosu güncellenmedi! Sürekli önbelleği temizle, yeniden oluştur gibi çözümlerde sizi istediğiniz hedefe götürmeyecek.</p><p>Bu problemi teknik açıdan ele aldığımızda, üretilecek çözüm için aşağıdaki beklentilerin karşılanması gereklidir:</p><ul><li>Performans sorunlarına yol açmamalı.</li><li>Elde edilen son veriler güncel olmalı.</li><li>Kolay uygulanabilir olmalı.</li></ul><p>Tüm bu beklentileri karşılamak zor gibi görünüyor. Ancak endişelenmeyin çözümü var.</p><h3>Redis</h3><p><a href="https://redis.io/">Redis</a>, diğer önbellek sürücülerinin aksine veriyi sadece hash tablosu olarak tutmak yerine, farklı veri yapıları desteği ile önbellekteki veri üzerinde işlem yapma ve karar verme yeteneğine sahiptir.</p><p>Lider tablolarını saklamak ve sonuç elde edebilmek için sıralı kümeler (sorted sets) veri yapısını kullanacağız.</p><p>Hızlıca bazı komutları tanıyalım:</p><ul><li><a href="https://redis.io/commands/zincrby">ZINCRBY</a>: Tabloya yeni kayıt ekler. Lider tablosunda sadece skor ve oyuncu kimliği (tercihe göre username veya ID değeri) çifti tutulur. ZINCRBY yerine INCR seçeneği ile <a href="https://redis.io/commands/zadd">ZADD</a> komutu da kullanılabilir. Eklemek istediğiniz kayıt lider tablosunda yoksa başlangıç değeri 0 kabul edilerek eklediğiniz skora eşitler.</li><li><a href="https://redis.io/commands/zrevrange">ZREVRANGE</a>: Tabloda kayıtlı verileri skor değerine göre azalan modda (en yüksek skordan en düşüğe doğru) sıralar. Oyuncunun lider tablosundaki sıralamasıyla birlikte mevcut skor değerini de almak için WITHSCORES seçeneği ile kullanılabilir. Puanı eşit olan oyuncular, oyuncu adına göre alfabetik önceliğe göre sıralanır.</li><li><a href="https://redis.io/commands/zrevrank">ZREVRANK</a>: Belirli bir oyuncunun lider tablosundaki sıralamasını (konumunu) döndürür.</li><li><a href="https://redis.io/commands/zscore">ZSCORE</a>: Belirli bir oyuncunun lider tablosundaki o anki puanını döndürür.</li><li><a href="https://redis.io/commands/zcard">ZCARD</a>: Lider tablosundaki toplam oyuncu sayısını döndürür.</li></ul><p>Redis, bir lider tablosuna veri eklendiğinde tablodaki oyuncuların sıralamasını hızlıca hesaplar. Herhangi bir gecikme yaşamadan güncel sonuçlara hızlıca erişebilirsiniz.</p><h3>Uygulama</h3><p>Bu bölümde şimdiye kadar ifade ettiğimiz senaryolardan yola çıkarak basit bir örnek yapacağız. Uygulamayı deneyeceğiniz bilgisayarda Redis kurulu olduğunu kabul ediyorum.</p><p>Adı “scores” olan lider tablosuna bazı verileri ekleyelim:</p><pre>ZINCRBY scores 10 &quot;PL_1&quot;<br>ZINCRBY scores 20 &quot;PL_2&quot;<br>ZINCRBY scores 20 &quot;PL_3&quot;<br>ZINCRBY scores 25 &quot;PL_4&quot;<br>ZINCRBY scores 15 &quot;PL_5&quot;<br>ZINCRBY scores 20 &quot;PL_1&quot;<br>ZINCRBY scores 50 &quot;PL_2&quot;</pre><p>ZINCRBY komutu 3 parametre alıyor. Birinci parametre lider tablonun adı veya anahtarıdır, bu örnekte “scores” isimli lider tablosu oluşturmak istiyoruz. Daha sonra sırasıyla puan ve oyuncu adı. Tabloya eklemek istediğiniz puan oyuncunun o an hak ettiği puan değeridir.</p><p>ZINCRBY komutunu kullandığımız için hak edilen skorlar mevcut skor değerinin üzerine eklenerek depolanacağı için genel sonuç aşağıdaki gibi görünecektir:</p><pre>PL_1 -&gt; 30<br>PL_2 -&gt; 70<br>PL_3 -&gt; 20<br>PL_4 -&gt; 25<br>PL_5 -&gt; 15</pre><p>Bu liste Redis tarafından oluşturulmadı. Biz hangi kullanıcının hangi skora sahip olduğunu belirtmek için oluşturduk. Şimdi bu listeyi puana göre sıralayalım:</p><pre>ZREVRANGE scores 0 10</pre><p>Yukarıdaki komutu çalıştırdığımızda, Redis hafızasında tuttuğu verileri skor değerine göre azalan modda sıralayarak sonuç döndürür. ZREVRANGE komutu 3 parametre kabul eder. Birinci parametre olarak lider tablosunun adı, ikinci parametre sıralamanın başlayacağı konum ve son parametre olarak başlangıçtan itibaren kaç adet kayıt döndürüleceğidir. Biz burada “scores” tablosundaki en iyi 10 oyuncuyu talep ediyoruz. Eğer talep ettiğiniz sayı kadar sonuç yoksa Redis sahip olduğu kadar veriyi döndürür.</p><p>Redis tarafından çıktılanan sonuç:</p><pre>1) &quot;PL_2&quot;<br>2) &quot;PL_1&quot;<br>3) &quot;PL_4&quot;<br>4) &quot;PL_3&quot;<br>5) &quot;PL_5&quot;</pre><p>Eğer bu listede oyuncuların puanlarını da göstermek istersek WITHSCORES seçeneğini kullanmalıyız:</p><pre>ZREVRANGE scores 0 10 WITHSCORES</pre><p>Böylece Redis, çıktılanan sonuca oyuncuların o anki toplam puanlarını da ekleyecektir. Çıktı şöyle görünecektir:</p><pre> 1) &quot;PL_2&quot;<br> 2) &quot;70&quot;<br> 3) &quot;PL_1&quot;<br> 4) &quot;30&quot;<br> 5) &quot;PL_4&quot;<br> 6) &quot;25&quot;<br> 7) &quot;PL_3&quot;<br> 8) &quot;20&quot;<br> 9) &quot;PL_5&quot;<br>10) &quot;15&quot;</pre><p>Komut işlendikten sonra ikili değer çifti döndürülür. Elde edilen veri çiftinde ilk değer oyuncunun adı, ikinci değer ise oyuncunun skorudur. Bu değer çiftini ihtiyacınıza göre işleyebilirsiniz.</p><p>Belirli bir oyuncunun lider tablosundaki o anki sıralamasını öğrenmek için:</p><pre>ZREVRANK scores PL_1</pre><p>komutunu kullanabiliriz. Komut azalan modda sıralanmış lider tablosundaki oyuncu sıralamasını döndürür. En iyi skora sahip kullanıcı için geriye 0 (sıfır) değeri döndürüleceği için, elde edilen yanıt +1 değeri ile toplanması gerekebilir.</p><p>Oyuncunun lider tablosundaki toplam puanını öğrenmek için:</p><pre>ZSCORE scores PL_1</pre><p>komutunu kullanabiliriz.</p><p>Son olarak lider tablosundaki toplam oyuncu sayısını elde etmek istediğimizde ise:</p><pre>ZCARD scores</pre><p>komutunu kullanabilirsiniz. Bu komut henüz listede yer almamış oyuncu pozisyonunu belirlemek için kullanılabilir. Mesela oyuna yeni giriş yapmış ve hiç puan kazanmamış bir kullanıcıyı sorguladığınızda Redis geriye (nil) değeri (sonuç yok) döndürür:</p><pre>ZREVRANK scores PL_6</pre><p>Elde edilecek (nil) değeri oyuncu için anlamsızdır. Henüz listede yer almayan oyuncuları sanki listede varmış gibi göstermek için basit bir çözüm bulabiliriz:</p><pre>oyuncunun puanı  = 0<br>oyuncunun konumu = listedeki toplam oyuncu sayısı + 1</pre><p>Hepsi bu kadar.</p><h3>Öneriler</h3><p>Artık basit lider tabloları oluşturabilir durumdayız. Yukarıda uygulanan model tüm zamanların en iyiler listesini elde etmenizi sağlar.</p><p>Günlük lider tablosu oluşturmanız gerektiğinde, gün sonunda sürekli Redis içindeki veriyi temizlemekle uğraşmak yerine lider tablosunun ismini tarihli olarak oluşturabilirsiniz. Örneğin; 7 Ekim 2020 tarihli lider tablosu için “scores-20201007” ismini tercih edebilirsiniz.</p><p>Lider tablosunu isimlendirirken tarih verilerini kullanarak istediğiniz tarihli veriye ulaşabilirsiniz. Bazen sadece günün en iyileri yerine, oyuncunun bir önceki güne göre konumunun değişimini veya farklı periyotlardaki liderlik tablolarını servis etmek isteyebilirsiniz. Örneğin, haftanın en iyilerini bulmak isterseniz <a href="https://redis.io/commands/zunionstore">ZUNIONSTORE</a> ile birden fazla lider tablosunu birleştirip yeni bir lider tablosu elde edilebilir.</p><p>Redis sunucusunu konfigüre edecek yeterli bilgiye sahip değilseniz belirli periyotlarla (cron ile) Redis tablolarını temizleyip, veritabanındaki verilerle toplu olarak (bulk) yeniden oluşturabilirsiniz.</p><h3>Sonuç</h3><p>Redis, lider tablolarının oluşturulması ve sorgulanması için tatmin edici performansa ve basitliğe sahip. Ayrıca Redis üzerindeki veriyi kalıcı olarak koruyabilme özelliği de göz önüne alındığında gerçekten bu iş için en pratik çözüm olarak karşımıza çıkıyor.</p><p>Bu yazıda yer alan komutlar Redis dünyasının çok küçük kısmı. Yaptığımız örnek ise oldukça basitti. Daha karmaşık iş kuralına sahip örnekler için farklı komutlara da yönelebilirsiniz.</p><p>Sevgiler.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd4f6414003" width="1" height="1" alt=""><hr><p><a href="https://medium.com/i%CC%87yi-programlama/redis-ile-leaderboard-olu%C5%9Fturma-cd4f6414003">Redis ile Leaderboard Oluşturma</a> was originally published in <a href="https://medium.com/i%CC%87yi-programlama">İyi Programlama</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PHPUnit ve Mock]]></title>
            <link>https://medium.com/i%CC%87yi-programlama/phpunit-ve-mock-19281466fdf1?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/19281466fdf1</guid>
            <category><![CDATA[phpunit]]></category>
            <category><![CDATA[php]]></category>
            <category><![CDATA[mock]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Mon, 05 Oct 2020 07:56:01 GMT</pubDate>
            <atom:updated>2020-10-07T13:25:29.508Z</atom:updated>
            <content:encoded><![CDATA[<p>Test yazma kültürü olmayan geliştiriciler için test yazmak oldukça zorludur. Daha önce yazılmış testleri inceleyerek olayı anlamaya çalışsalarda genellikle en zorlandıkları kısım ise Mock olmuştur.</p><p>Kültüre aşina olmayan meslektaşlarımdan sıkça “sahte sınıflar oluşturuyorsak, test yazmanın ne anlamı var” veya “sahte sınıfları test etmenin amacı ne” isyanını duyuyorum. Bu yazıda en azından bu düşünceyi yok etmeyi hedefliyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YyZ8SLi9p87sDtgp.png" /></figure><h3>Ön Hazırlık</h3><p>Bu yazıda yer alan örnekleri kendi bilgisayarınızda çalıştırabilmek için aşağıdaki adımları hızlıca uygulayın.</p><blockquote>PHPUnit kurulumuyla ilgili daha fazla ayrıntılı bilgiye, PHPUnit belgelerindeki <a href="https://phpunit.readthedocs.io/en/9.3/installation.html">Installation</a> sayfasından erişebilirsiniz.</blockquote><p>Kendinize bir çalışma dizini seçin ve aşağıdaki komutları çalıştırın.</p><pre>mkdir src tests<br>touch composer.json phpunit.xml</pre><p>Yukarıdaki komutlar çalışma dizininize 2 adet klasör ve 2 adet dosya oluşturacak.</p><p>PHPUnit ayarlarını tanımlamak için phpunit.xml dosyasını açın ve aşağıdaki ayarları kopyalayarak kaydedin:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;phpunit xmlns:xsi=&quot;<a href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>&quot;<br>         xsi:noNamespaceSchemaLocation=&quot;./vendor/phpunit/phpunit/phpunit.xsd&quot;<br>         bootstrap=&quot;vendor/autoload.php&quot;<br>         colors=&quot;true&quot;<br>&gt;<br>    &lt;testsuites&gt;<br>        &lt;testsuite name=&quot;Unit&quot;&gt;<br>            &lt;directory suffix=&quot;Test.php&quot;&gt;./tests&lt;/directory&gt;<br>        &lt;/testsuite&gt;<br>    &lt;/testsuites&gt;<br>    &lt;filter&gt;<br>        &lt;whitelist processUncoveredFilesFromWhitelist=&quot;true&quot;&gt;<br>            &lt;directory suffix=&quot;.php&quot;&gt;./src&lt;/directory&gt;<br>        &lt;/whitelist&gt;<br>    &lt;/filter&gt;<br>&lt;/phpunit&gt;</pre><blockquote>PHPUnit senaryolarını konfigüre etmek için çok sayıda parametre mevcuttur. Yukarıdaki dosya en temel haliyle yeterlidir. Ancak yine de daha fazla bilgi almak isterseniz PHPUnit belgelerindeki <a href="https://phpunit.readthedocs.io/en/9.3/configuration.html">The XML Configuration File</a> sayfasını ziyaret edebilirsiniz.</blockquote><p>PHP bağımlılıklarını çekmek için composer.json dosyasını açın ve aşağıdaki tanımları kopyalayarak kaydedin:</p><pre>{<br>    &quot;require&quot;: {<br>        &quot;php&quot;: &quot;^7.2.5&quot;<br>    },<br>    &quot;autoload&quot;: {<br>        &quot;psr-4&quot;: {<br>            &quot;App\\&quot;: &quot;app/&quot;<br>        }<br>    },<br>    &quot;require-dev&quot;: {<br>        &quot;phpunit/phpunit&quot;: &quot;^9.4&quot;<br>    }<br>}</pre><blockquote>Eğer bilgisayarınızda daha düşük PHP versiyonu mevcutsa yukarıdaki ifadeleri kendinize göre değiştirmeniz gerekiyor. Ancak artık daha düşük versiyonların sağlıklı olmadığını göz önünde bulundurursak, kendi PHP versiyonunu yükseltmeniz daha doğru olabilir.</blockquote><p>Terminali açın ve çalışma dizininize kadar gidip aşağıdaki komutu çalıştırın. Bu komutla PHP bestecisi bağımlılıkları çözüp vendor klasörüne yükleyecektir.</p><pre>composer install</pre><p>Bu aşamadan itibaren oluşturulan somut sınıf dosyalarını app, test sınıf dosyalarını ise tests klasörüne yazmanız gerekiyor.</p><h3>Unit Test</h3><p>Farklı test yöntemleri vardır, burada unit test (birim test) konusunu ele alacağız. Adından da anlaşılacağı üzere, test edilecek bir birimi ele alır ve sadece onu test eder.</p><p>Nesne yönelimli programlamada birim olarak kast ettiğimiz şey bir sınıfın bir metodu olarak düşünebilirsiniz. Yani her metodu ayrı ayrı test edeceğiz.</p><p>Normalde Test Driven Development (TDD) odaklı yazılım geliştirme sürecine göre önce test yazılır, sonra geliştirme yapılır. Ancak şu an karmaşıklığı gidermek için önce sınıfımızı yazıp sonra bu sınıfın testini yazmaya çalışacağız.</p><pre>&lt;?php<br> <br>namespace App;<br> <br>class GoogleWeather<br>{<br>    public function fetch(int $timestamp): int<br>    {<br>        return 18;<br>    }<br>}</pre><p>GoogleWeather sınıfımızı tanımladık. Kabaca int tipinde $timestamp değerini parametre olarak kabul edip, geriye int tipinde o güne ait hava durumu verisini derece cinsinden döndürmektedir.</p><p>Test kültüründe sadece başarılı denemeler yapılmaz. Bazen başarısız olacak durumlarda test edilmesi gerekir. Ancak bu sınıfın sadece bir durumda test etmemiz konumuz gereği yeterlidir.</p><pre>&lt;?php<br> <br>use App\GoogleWeather;<br>use PHPUnit\Framework\TestCase;<br> <br>class GoogleWeatherTest extends TestCase<br>{<br>    /**<br>     * <a href="http://twitter.com/test">@test</a><br>     */<br>    public function it_should_fetch_value_as_degree()<br>    {<br>        $instance = new GoogleWeather;<br>        $actual = $instance-&gt;fetch(time());<br>        $expected = 18;<br> <br>        $this-&gt;assertSame($expected, $actual);<br>    }<br>}</pre><p>Test kültüründe beklenen çıktı <strong>expected</strong>; elde edilen, test edilecek gerçek çıktıya ise <strong>actual</strong> adı verilir. Testin başarılı olması için actual değeri expected değeri ile örtüşmesi gerekiyor.</p><blockquote>PHPUnit paketinde çok sayıda sınama metodu vardır. Bu örneğimizde assertSame yöntemini kullandık. Diğer yöntemleri öğrenmek için PHPUnit belgelerindeki <a href="https://phpunit.readthedocs.io/en/9.3/assertions.html">Assertions</a> sayfasına göz atabilirsiniz.</blockquote><h3>Mock</h3><p>Şimdi yeni bir sınıf oluşturalım ve GoogleWeather sınıfı ile bağımlı hale getirelim.</p><pre>&lt;?php<br> <br>namespace App;<br> <br>class Weather<br>{<br>    protected $driver;<br> <br>    public function __construct(GoogleWeather $driver)<br>    {<br>        $this-&gt;driver = $driver;<br>    }<br> <br>    public function forDate(int $timestamp): array<br>    {<br>        return [<br>            &#39;value&#39; =&gt; $this-&gt;driver-&gt;fetch($timestamp),<br>            &#39;unit&#39; =&gt; &#39;degree&#39;,<br>        ];<br>    }<br>}</pre><p>Evet, GoogleWeather sınıfına bağımlı Weather sınıfına sahibiz. Bu aşamada birim testi anlamak için lütfen odaklanın.</p><p>Birim testinde Weather sınıfı ayrı, GoogleWeather sınıfı ayrı ayrı test edilmeli. Her iki sınıf birbirinden ayrı olarak test edildiği için bağımlılık oluşması halinde somut sınıf yerine sahte sınıf (mock) kullanabiliriz. Yani, GoogleWeather sınıfı zaten test edildiğini kabul edip, bu sınıfı gerçekte çağırmak yerine sahte sınıf kullanacağız.</p><blockquote>Sahte sınıfları test etmiyoruz. Sahte sınıfları, test çalışma zamanını hızlandırmak ve test süreçlerini kolaylaştırmak için kullanıyoruz.</blockquote><pre>&lt;?php<br> <br>use App\Weather;<br>use App\GoogleWeather;<br>use PHPUnit\Framework\TestCase;<br> <br>class WeatherTest extends TestCase<br>{<br>    /**<br>     * <a href="http://twitter.com/test">@test</a><br>     */<br>    public function it_should_get_weather_data()<br>    {<br>        $timestamp = time();<br>        $value = rand();<br> <br>        $mockDependency = $this-&gt;createMock(GoogleWeather::class);<br>        $mockDependency-&gt;expects($this-&gt;once())<br>                       -&gt;method(&#39;fetch&#39;)<br>                       -&gt;with($timestamp)<br>                       -&gt;willReturn($value);<br> <br>        $instance = new Weather($mockDependency);<br>        $actual = $instance-&gt;forDate($timestamp);<br>        $expected = [&#39;value&#39; =&gt; $value, &#39;unit&#39; =&gt; &#39;degree&#39;];<br> <br>        $this-&gt;assertSame($expected, $actual);<br>    }<br>}</pre><p>Daha önce GoogleWeather sınıfını birim olarak ele alıp test etmiştik. Dolayısıyla o sınıfın doğru çalıştığına eminiz. Bu yüzden Weather sınıfını test ederken bağımlılığa gerçek sınıf yerine sahte sınıf verebiliriz. Böylece test çalışma süresini hızlandırabiliriz.</p><p>Yukarıdaki örnekte, Weather sınıfının kurucu parametresine gerçek bağımlılık yerine sahte bağımlılık verdik. Sahte sınıfı ise bir expects, method, with ve willReturn metodları ile beklenen gibi çalışması için ayarladık.</p><ul><li><strong>method</strong>: çalıştırılacak metodun adı.</li><li><strong>expects</strong>: metodun kaç defa çalışması gerektiği, once bir defa çalışması gerektiğini belirtir.</li><li><strong>with</strong>: metod hangi parametreleri almalı</li><li><strong>willReturn</strong>: metod hangi değeri döndürmeli.</li></ul><p>Her ne kadar mock sınıf kullansak dahi, metodun çalışma sayısı, aldığı parametreler ve döndürdüğü değerler gerçek haliyle uyuşmalıdır. Yani beklenenden farklı bir şekilde çalışırsa (mesela metod beklenen parametreleri alamazsa ya da metod beklenenden daha fazla veya eksik sayıda çağırılırsa) test başarısız olur.</p><p>Yukarıda oluşturduğumuz mock nesnesine şu görevi yüklemiş oluyoruz; fetch metodu sadece 1 defa çalışmalı ve Weather sınıfına verilen timestamp değeri bu metoda da parametre olarak geçmeli. Geriye de bir int değer döndürmeli. Sahte metodun çalışması için tüm senaryolar kusursuz olarak yerine getirilmeli. Zaten bu şartlar yerine getirildiğinde GoogleWeather sınıfı, GoogleWeatherTest sınıfında test edildiği haliyle çalışacağını biliyoruz.</p><blockquote>PHPUnit paketinde farklı tiplerde mock örnekleri mevcuttur. Bu örneğimizde createMock yöntemini kullandık. Diğer yöntemleri öğrenmek için PHPUnit belgelerindeki <a href="https://phpunit.readthedocs.io/en/9.3/test-doubles.html">Test Doubles</a> sayfasına göz atabilirsiniz.</blockquote><p>GoogleWeather sınıfı $timestamp değerini aldığında geriye $value değerini döndüreceğinden emin olduğumuz için bu yöntemi mocklamak doğru bir hamle oluyor. Dolayısıyla Weather sınıfı bu çağrıyı yerine getirdiğinde elde ettiği sonucu işleyip geriye value ve unit değerini içeren bir bir array döndürmesi gerektiğini test etmiş oluyor.</p><p>Her iki sınıf unit test kurallarına uygun olarak test edilmiş oluyor.</p><h3>Sonuç</h3><p>Nesne yönelimli programlamada sınıf içindeki metodlar birim olarak ele alınarak ayrı ayrı test edilir. Her bir birim ayrı ayrı test edildiğinde, bağımlılıklar arasındaki testler süreci hızlandırmak için mock olarak kullanılır.</p><p>Böylece birim gelecekte bir değişime uğrasa dahi, girdi ve çıktı korunacağı için bağımlı oldukları sınıfları ve bu sınıfların testlerini etkilemeyecektir. Katmanlı mimaride bağımlılık sayısının ve derinliğinin artma ihtimali olduğu için, her sınıfın çalışma mantığı kendi test sınıfı içinde kapsüllenir.</p><p>Özetle birim testi yazarken;</p><ul><li>Başka sınıflara olan bağımlılıklarda,</li><li>Aynı sınıfın farklı metodlarının zincirleme olarak çağırılması durumunda,</li><li>HTTP istekleri gibi zaman alan bağımlılıklarda,</li><li>Socket, veritabanı gibi bağlantıların açılması gerektiği durumlarda,</li></ul><p>mock kullanılması önerilmektedir.</p><p>Bol bol test yazın. TDD kurallarını uygulayamasanız bile en azından yazdığınız sınıfların testlerini yazmaya çalışın. Bir süre sonra yazdığınız sınıflardaki hataları farkedecek ve daha iyi sınıflar yazmanıza yardımcı olacaktır.</p><p>Hep okunabilir kod yazmaktan söz ediyoruz. Okunabilir kod yazmak kadar anlaşılabilir test yazmakta önemlidir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19281466fdf1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/i%CC%87yi-programlama/phpunit-ve-mock-19281466fdf1">PHPUnit ve Mock</a> was originally published in <a href="https://medium.com/i%CC%87yi-programlama">İyi Programlama</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Strategy Pattern]]></title>
            <link>https://medium.com/@sercancakir/strategy-pattern-21c0f03fadf3?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/21c0f03fadf3</guid>
            <category><![CDATA[php]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[strategy-pattern]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Sun, 04 Oct 2020 22:12:21 GMT</pubDate>
            <atom:updated>2020-10-04T22:53:10.567Z</atom:updated>
            <content:encoded><![CDATA[<p>Üzerinde çalıştığım eski projelerde gördüğüm en büyük sorun, davranışların if koşulları ile yönlendirilmesi. Gelişime açık olmayan projeler, ürün sahibi (product owner) tarafından gelen her yeni özellik (feature) ile yeni bir if ifadesine mahkum olur.</p><p>Başlangıçta zararsız gibi görünen bu durum; bir süre sonra ciddi baş ağrılarına neden olur. En büyük sorun ise, kodu yazan geliştirici veya geliştiriciler bu projenin okunabilir olduğunu iddia edip, projeye yeni katılan geliştiricileri büyük bir stres altında bırakırlar.</p><p>Laravel framework ile kodlanmış bir projede karşılaştığım kodu biraz değiştirerek problemlerin neler olduğunu anlamaya çalışalım.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fce4c5c5eec626a25c963e29d7e5bd63/href">https://medium.com/media/fce4c5c5eec626a25c963e29d7e5bd63/href</a></iframe><p>Notification servisinde, istekte bulunan type değerine göre farklı obje oluşturuluyor. Tahmin edeceğiniz gibi Email, Sms ve WebPush sınıflarının ortak bir arayüzü olmadığı için geriye mixed değerini dönen getDriver metodunda tüm olay çözülmek istenmiş.</p><p>Ürün sahibi, veritabanı destekli yeni bildirim bildirim kanalı oluşturmak istediğinde getDriver metoduna database kontrolü eklemek ve daha önce yazılmış herhangi bir sürücüyü kopyalayıp Database sınıfını oluşturmak kimi zaman kötü geliştiriciler için hızlı çözüm kabul ediliyor. Çözüm hızlı ama ölümcül!</p><p>Tasarım desenlerini kullanma alışkanlığı olmayan takım arkadaşlarıma, doğru çözümü anlatmak oldukça zorlu oluyor. Basit bir iş için çok sayıda sınıf oluşturmayı gereksiz görende var, aciliyeti olduğu için kaybedilen zamana üzülende. Günü kurtaran geliştiriciler, sadece görev (task) kapatma uğruna savaşır ve geleceği hiç düşünmez. Bir görev üzerinde çalışırken hem anı hem de gelecekteki bakım maliyetini düşünmemiz gerekiyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/0*_Kc7I4IpLLnQamet.jpg" /></figure><p>Özetle; çabucak iş çıkarmak uğruna ölümcül teknik borçlar oluşturuyoruz. Kötü yazılmış bir kodun testlerini yazmak çok zordur, bazen imkansızdır. İnat edilip test yazılsa dahi, bu test caseleri değişimi asla kolaylaştırmaz.</p><blockquote>Zaman sıkıntısının olmadığı durumlarda her geliştiricisi iyi kod yazabilir, önemli olan kısıtlı zamanda iyi kod yazabilmek!</blockquote><h3>Düşünceni Değiştir</h3><p>Gerçek dünyadan beklentimiz, çözümlerin sade, okunabilir ve genişlemeye açık olmasıdır. Tasarım desenlerinden faydalanarak herkes tarafından anlaşılabilir çözümler üretebiliriz.</p><p>Şimdi yukarıdaki kodu adım adım Strategy Pattern ile yeniden inşaa edelim. Öncelikle somut bildirim sınıflarının uygulayacağı arayüzü oluşturalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb5eb799ca70456d092cea05ba067266/href">https://medium.com/media/eb5eb799ca70456d092cea05ba067266/href</a></iframe><p>Harika. Artık mixed yerine herkes tarafınan anlaşılabilir Notifiable arayüzü ile konuşacağız.</p><p>Oluşturacağımız her somut sınıf yukarıdaki arayüzü uygulamalıdır. Bu <strong>Strategy Pattern</strong> için bir kuraldır. Her strateji sınıfı aynı ortak arayüzü uygulamalıdır.</p><p>Arayüzde bulunan Input ve Output sınıflarını istediğiniz gibi oluşturabilirsiniz. İlerleyen örneklerde gereksiz karmaşa yaratmamak için Input sınıfında type isimli özellik olması yeterli görüldü.</p><p>Hızlıca somut sınıflarımızı oluşturalım. Unutmayın, somut sınıflar Notifiable arayüzünü uygulamalıdır:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e96d9ed11714392077164d5104cba1a4/href">https://medium.com/media/e96d9ed11714392077164d5104cba1a4/href</a></iframe><p>Temel olarak somut sınıflardan 2 beklentinin yerine getirilmesi isteniyor:</p><ul><li>support metodu: isteğin işlenebilir olup olmadığına karar verir.</li><li>send metodu: isteği yerine getirir ve Output çıktısı üretir.</li></ul><p>Ürün sahibi artık yeni bir kanal eklemek isterse yapmanız gereken tek şey Notifiable arayüzünü uygulayan yeni bir somut sınıf oluşturmak ve yukarıdaki beklentileri karşılamak. Oldukça kolay değil mi?</p><p>Son olarak tüm senaryoyu yönetecek bir yöneticiye (orkestra) ihtiyacımız var. Karar işlemini yürüten ve uygulayan yönetici sınıfı:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2043a262128266de67fcd44dbdbd1403/href">https://medium.com/media/2043a262128266de67fcd44dbdbd1403/href</a></iframe><p>Oluşturduğumuz NotificationManager sınıfının kurucu metodu, destek verilen kanalların listesini talep etmektedir. Bu talebi yerine getirdiğimizde artık send metodu kullanıma hazır hale gelmektedir.</p><p>Yönetici sınıfındaki send metodu, gelen talebi daha önce tanımladığımız tüm kanallarda tek tek denetmektedir. Eğer support metodu bu isteğin işlenebilir olduğuna kanaat getirirse, istek desteklenen somut sınıf tarafından işlenecektir. İstek, hiç bir strateji tarafından desteklenmiyorsa RuntimeException istisnası fırlatılır. Böylece, ihtiyaç halinde hatayı yakalayıp kullanıcıyı bilgilendirebiliriz.</p><p>Laravel framework, ServiceProvider ile bu tür kararların verildiği sınıfları yönetmemize olanak tanır. Şimdi aşağıdaki kodu AppServiceProvider sınıfının register metoduna ekleyerek strateji yöneticisini framework tarafından tanınabilir hale getirebiliriz:</p><pre>$this-&gt;app-&gt;singleton(NotificationManager::class, function () {<br>    $notifiables = [<br>        $this-&gt;app-&gt;make(Email::class),<br>        $this-&gt;app-&gt;make(Sms::class),<br>        $this-&gt;app-&gt;make(WebPush::class),<br>    ];</pre><pre>    return new NotificationManager($notifiables);<br>});</pre><p>Yeni bir kanal eklemeniz gerektiğinde, yukarıdaki $notifiable değişkenine ilave yaparak NotificationManager tarafından kullanılabilir hale getirebilirsiniz.</p><p>Son olarak, daha önce hatalı kullanılan NotificationController sınıfını düzeltelim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/99f6a73c52c8e4fdcc791d8393a301b9/href">https://medium.com/media/99f6a73c52c8e4fdcc791d8393a301b9/href</a></iframe><p>Harika. Dependency Injection uyumlu NotificationManager sınıfımız kullanıma hazır. Artık ürün sahibi tarafından gelecek her yeni kanalı kolayca ekleyebilir durumdayız.</p><h3>Sonuç</h3><p>Tasarım desenlerinden <strong>Strategy Pattern</strong>, bir veya birden fazla koşula göre hangi davranışın tetiklenmesi gerektiğine karar veren tasarım örüntüsüdür. Projeyi gereksiz if koşullarından arındırır ve yeni davranışlar eklemenize veya var olan davranışı değiştirmeye/silmeye yardımcı olur.</p><p><em>Bu yazıda yer alan örnek kodları çalışan bir Laravel projesinde denemedim. Tekrardan gözden geçirmeme rağmen syntax hatası farkederseniz lütfen yorum olarak bildirin.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21c0f03fadf3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sıfırdan “Go”!]]></title>
            <link>https://medium.com/i%CC%87yi-programlama/golang-c31ab87eb67c?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/c31ab87eb67c</guid>
            <category><![CDATA[gopher]]></category>
            <category><![CDATA[türkçe-yayın]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Sun, 05 Apr 2020 11:27:51 GMT</pubDate>
            <atom:updated>2020-10-07T13:25:10.211Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://golang.org/">Go programlama dili</a>, Google mühendisleri <a href="https://twitter.com/robertgriesemer">Robert Griesemer</a>, <a href="https://en.wikipedia.org/wiki/Rob_Pike">Rob Pike</a> ve <a href="https://en.wikipedia.org/wiki/Ken_Thompson">Ken Thompson</a> tarafından 2007 yılında geliştirilmeye başlandı. İlk kararlı sürüm <a href="https://golang.org/doc/devel/release.html#go1">Mart 2012</a>&#39;de açık kaynak olarak yayınlandı.</p><p>Tüm kaynak kodlarına <a href="https://github.com/golang">Github</a> üzerinden erişebilir hatta gelişim için katkıda bulunabilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dj2yTdzSGvmFtiPzLMlsjw.png" /><figcaption>Go’nun yeni markası: <a href="https://blog.golang.org/go-brand">https://blog.golang.org/go-brand</a></figcaption></figure><p>Go’nun öne çıkan başlıca özellikleri:</p><ul><li>Açık kaynaklı</li><li><a href="https://stackoverflow.com/a/1517670">Statik olarak</a> yazılmıştır</li><li>Yüksek performans</li><li>Hızlı derlenme (milyarlarca satırlık proje saniyeler içinde derlenebilir)</li><li><a href="https://blog.golang.org/ismmkeynote">Garbage collector</a> (çöp toplayıcı) desteği</li><li>Dahili paket yöneticisi</li><li><a href="https://github.com/golang/go/wiki/LearnConcurrency">Eşzamanlılık</a> (dil seviyesinde)</li><li>Her şeyin belgelendiği ayrıntılı dokümantasyonlar</li><li>ve <a href="https://github.com/golang/go/wiki/whygo">dahası</a>…</li></ul><p>Bir Go dosyası temel olarak;</p><ul><li>fonksiyonlar (methodlar)</li><li>değişkenler</li><li>türler</li><li>yorumlar</li><li>sabit değişkenlerden oluşur.</li></ul><h3>Önsöz</h3><p>Bu yazı, sizleri Go’ya ısındırmak ve hızlı başlangıç yapmanıza yardımcı olmak için oluşturuldu. Isınma turundan sonra Go’yu anlamak için <a href="https://golang.org/doc/">golang.org</a>‘daki dokümanları mutlaka okuyun.</p><p>Öğrenmeyi etkili hale getirmek için örnekleri kopyalamak yerine el alışkanlığı kazanmak için yazmaya çalışın. Kodları değiştirin, çıktıları gözlemleyin ve değişimi anlamaya çalışın.</p><p>Bölüm içinde (veya sonunda) referans olarak verilen bağlantıları mutlaka inceleyin. Bu kaynaklar, konuyla alakalı daha fazla bilgi ve örneğe ulaşmanız için size yardımcı olacaktır.</p><p>Örnek kodları <a href="https://play.golang.org/">Playground</a>‘da çalıştırabilirsiniz.</p><blockquote>Önce alışkanlıklarından vazgeç!</blockquote><blockquote>Ezberlemek yerine, bir işin Go’da nasıl yapıldığını öğren, dilin felsefesini anla.</blockquote><h3>Kurulum</h3><p>Çalışacağınız ortamda kodları derlemek için öncelikle Go derleyicisini yüklemeniz gerekiyor. <a href="https://golang.org/dl/">Downloads</a> sayfasından işletim sisteminize uygun derleyiciyi indirin ve yükleyin.</p><p>Dilerseniz <a href="https://golang.org/doc/install#install">kurulum</a> sayfasındaki yönergeleri takip edebilirsiniz.</p><p>Kurulum tamamladıktan sonra test etmek için terminale (CL: komut satırı) aşağıdaki komutu yazın:</p><pre>go version</pre><p>Bu komut yüklü olan Go versiyonunu ekrana yazdıracak.</p><p>Go aracı tarafından desteklenen tüm komutları görüntülemek için go help komutunu kullanabilirsiniz.</p><h4>IDE</h4><p>Go kodlarını herhangi bir IDE (tümleşik geliştirme ortamı) üzerinde yazabilirsiniz. Aşağıdaki önerilerden herhangi birini seçebilirsiniz.</p><ul><li><a href="https://www.jetbrains.com/go/download/">JetBrains GoLand</a></li><li><a href="https://code.visualstudio.com/Download">Visual Studio Code</a></li><li><a href="https://atom.io/">Atom</a></li><li><a href="https://www.sublimetext.com/">Sublime Text</a></li></ul><p>Tercihinize göre IDE için bazı eklentileri kurmakta özgürsünüz.</p><h4>Çalışma Dizini</h4><p>Derleyici kurulumundan sonra, Go yükleyicisi ihtiyacına uygun bir kaç dizin oluşturur. Programların geliştirilmesi, derlenmesi ve yürütülmesi için bu dizinler önemlidir. Başlangıçta bilmemiz gereken 2 önemli dizini tanıyalım:</p><p>$GOROOT : Go’nun kurulduğu dizin</p><p>$GOPATH : geliştirilen projelerin yer aldığı dizin</p><p>Kurulum esnasında otomatik tanımlandığı için $GOROOT üzerinde değişiklik yapmaya gerek yoktur.</p><p>$GOPATH dizinini tanımlamak/değiştirmek için <a href="https://github.com/golang/go/wiki">wiki sayfası</a> veya <a href="https://golang.org/doc/install/source#gopath">kurulum belgesi</a> sayfasındaki talimatları (işletim sistemine uygun) takip edebilirsiniz. Başlangıçta değişiklik yapmadan varsayılan $GOPATH dizinini kullanabilirsiniz. Birden fazla $GOPPATH değişkeni tanımlanabilir. Geliştirilecek uygulamaya ait her şey $GOPATH dizininin (çalışma dizini) altında olması gerektiğini unutmayın.</p><blockquote><em>$GOPATH</em> varsayılan olarak MAC sistemler için <em>~/go</em> olarak tanımlıdır.</blockquote><p>Terminal üzerinde go env komutunu yazarak tüm ortam değişkenlerini listeleyebilirsiniz.</p><h3>İlk Go Programı</h3><p>Bir programlama dili öğrenirken, gelenek haline gelen “merhaba dünya” örneği ile başlamaya ne dersiniz?</p><p>Çalışma dizininde yeni bir Go projesi oluşturun. Proje dizinin içine main.go dosyası oluşturun. Bu dosyanın içine aşağıdaki kodları yazın ve kaydedin:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    fmt.Println(&quot;merhaba dünya&quot;)<br>}</pre><p>Go programları paketlerden oluşur. Bu nedenle her Go dosyası mutlaka bir paket adına sahip olmalıdır. Dosyanın en üstüne package sözcüğünden sonra paket adı yazılır. Yürütülebilir (library olmayan) programlar için main paketi başlangıç noktasıdır.</p><blockquote>Ortak bir amaca yönelik oluşturulan yeniden kullanılabilir paketlere library (kütüphane) diyebiliriz. Örneğin; kendisine verilen sayıların ortalamasını hesaplayan bir paket oluşturup Github ya da benzeri kaynaklara bu paketi yükleyebilirsiniz. İhtiyaç duyduğunuz her projede bu paketi kullanarak aynı kodları tekrar tekrar yazmaktan kurtulursunuz.</blockquote><blockquote>İş kuralı (business rule) içermediği sürece paketlerinizi açık kaynak olarak yayınlayarak, herkesin kullanımına da açabilirsiniz.</blockquote><p>Sonraki satırda import sözcüğü ile fmt paketi içe aktarıldı. İçe aktarılan fmt paketinin dışarıdan erişilebilir (exported) tüm değişkenler, fonksiyonlar ve metodlar artık bu program içinde kullanılabilir.</p><blockquote>Değişken, fonksiyon ya da method isimlendirmeleri büyük harf ile başlıyorsa bu ifadeler diğer paketler tarafından erişilebilir (public) olur. Örneğin; Ortalama, OrtalamaHesapla, …</blockquote><blockquote>Ancak ifade isimleri küçük harf ile başlıyorsa diğer paketler tarafından erişlemez (protected) olur. Sadece aynı paket içindeki diğer dosyalar tarafından erişilebilir. Örneğin; ortalama, ortalamaHesapla , …</blockquote><p>Go’da ana giriş noktası main fonksiyonudur. Bu fonksiyon parametre almaz ve geriye herhangi bir değer döndürmez. Son olarak, fonksiyon gövdesinde fmt paketinden Println işlevi (method) ile ekrana istediğimiz mesajı yazdırıyoruz.</p><blockquote>Fonksiyonlar ve işlevler (methods) birbirlerine benzerler ancak ifade biçimleri ve kullanım amaçları bakımından birbirlerinden farklıdır. İlerleyen bölümlerde her ikisini de ayrı ayrı inceleyeceğiz.</blockquote><p>Bu programı çalıştırarak sonucu görelim. Go programlarını çalıştırmak için farklı yollar mevcuttur. İlk olarak; yazdığımız kodu derleyip, derlenmiş programı yürütmek için 2 farklı komut kullanacağız. Programı derlemek için terminal’i açın ve projenin olduğu dizine gidin. Çalışma dizini üzerindeyken aşağıdaki komutu yazın:</p><pre>go build ./main.go</pre><p>Bu komut, yürütülebilir bir ikili (binary) dosya oluşturur. Programı yürütmek için derlenmiş binary dosyayı çalıştırın:</p><pre>./main</pre><p>Geliştirme ortamında (local) her seferinde programı derlemek ve derlenmiş dosyayı çalıştırmak yerine daha basit bir yolu tercih edebilirsiniz. Yukarıdaki işlemlerin yerine, derleme adımını soyutlayan run komutunu kullanabiliriz. Aşağıdaki komut; soyut olarak programı derleyip, derlenmiş programı çalıştıracaktır:</p><pre>go run ./main.go</pre><p>Go derlenebilir bir dil olduğu için; Go kodlarında herhangi bir değişiklik yapıldığında, değişikliğin yürütülen (çalışan) programa yansıması için programın durdurulup yeniden (derlenerek) çalıştırılması gerekmektedir. Bu Go’ya özel bir durum değil, derlenebilir tüm diller için gerekliliktir.</p><blockquote>I/O ve formatlama işlemlerinin gerçekleştirildiği fmt paketi hakkında daha fazla bilgi için <a href="https://golang.org/pkg/fmt/">paket belgelerine</a> mutlaka göz atın.</blockquote><h3>Yorumlar</h3><p>Bazen, programın herhangi bir yerine daha sonra hatırlamak için yorum veya açıklama eklemek ya da fonksiyon/method kullanımını göstermek için basit örnekler yazmak isteyebilirsiniz.</p><p>Yorumlar (comments), diğer dillerde de olduğu gibi Go tarafından da desteklenir. Tüm yorum satırları derlenme sırasında göz ardı edilir. Yorum satırları arasına ne isterseniz yazabilirsiniz.</p><p>// karakterleri ile başlayan satır, yorum satırı olarak kabul edilir:</p><pre>// buraya istediğiniz açıklamayı yazabilirsiniz</pre><p>/* ve */ karakterleri arasındaki her şey blok (çok satırlı) yorum olarak kabul edilir:</p><pre>/*<br>buraya<br>istediğiniz<br>açıklamayı yazabilirsiniz<br>*/</pre><p>Genellikle blok yorumlar bir şeyi uzun uzun ifade etmek için tercih edilir. Bir kaç satırlık açıklama için blok yorum yerine, satır yorumları tekrarlayarak ifade edebilirsiniz:</p><pre>// buraya<br>// istediğiniz<br>// açıklamayı yazabilirsiniz</pre><p>Yorumları kullanarak kodlarınız için kullanım klavuzu (dokümantasyon) hazırlayabilirsiniz. Mesela, geliştirdiğiniz bir paketi belgeleyerek diğer geliştiriciler için kullanım kolaylığı sağlayabilirsiniz.</p><p>Dokümantasyon oluşturmak için bir kaç kurala sadık kalmak gerekiyor:</p><ul><li>Usule uygun kullanım için <a href="https://golang.org/doc/effective_go.html#commentary">Effective Go</a> açıklamalarını mutlaka okuyun.</li><li>Dokümantasyon oluşturmak için bilinmesi gerekenler <a href="https://blog.golang.org/godoc-documenting-go-code">Documenting Go Code</a> blog yazısında anlatılmış, incelemenizi öneririm.</li><li>Yorumları, dokümantasyon belgelerine dönüştüren komut aracını tanımak için <a href="https://golang.org/cmd/godoc/">godoc</a> paketi için hazırlanan belgeleri inceleyebilirsiniz.</li></ul><blockquote>Go’da paket dokümantasyonları, kodların hemen üzerindeki yorumlar ile oluşturulur. Bu özellik, kodlarına doküman yazmak (belgelemek) isteyen bir kişi için inanılmaz kolaylık sağlar.</blockquote><blockquote>Yazılım dünyasında dokümantasyonlar çok önemlidir. Daha iyi ifadeler için <a href="http://github.com/golang/">Github</a> üzerindeki Go paketlerine ait kod yorumlarını mutlaka inceleyin.</blockquote><h3>Değişkenler</h3><p>Go statik olarak yazıldığı için, derlenme sırasında değişkenlerin türlerini bilmek veya tahmin etmek ister. Bu nedenle, bir değişken tanımlanırken türü belirtilmeli veya Go’nun tahmin etmesi için açık bir değerle başlatılmalıdır.</p><p>Değişkenler, adından da anlaşılabileceği gibi istenildiği zaman değeri değiştirilebilir. Tek kural, yeni değer değişkenin kabul ettiği türde olmalıdır.</p><p>Go’da değişken tanımlamak için var deyimi kullanılır. Hemen sonrasında değişkenin adı ve türü belirtilir.</p><pre>var name  string<br>var email string<br>var age   int</pre><p>Değişkenleri tek tek tanımlamak yerine gruplayarak da tanımlayabilirsiniz. Go tercihi size bırakıyor, özgürsünüz.</p><pre>var (<br>    name  string<br>    email string<br>    age   int<br>)</pre><p>Türü aynı olan değişkenleri tek seferde bildirebilirsiniz. Derlenme sırasında Go kendi anlayacağı formata dönüştürür.</p><pre>var name, email string<br>var age int</pre><p>veya;</p><pre>var (<br>    name, email string<br>    age         int<br>)</pre><p>Bir değişken tanımlanırken ilk değerle başlatılabilir. Sabit bir değer olmadığı için başlatılan değer daha sonra aynı türde farklı değerle değiştirilebilir.</p><pre>var (<br>    name  string = &quot;John Doe&quot;<br>    email string = &quot;john@doe.com&quot;<br>    age   int    = 34<br>)</pre><pre>// değişkenler, türü aynı olan herhangi bir veri ile<br>// istenildiği zaman güncellenebilir<br>age = 27</pre><pre>// her ne olursa olsun, bir değişken farklı türde<br>// veriyi asla kabul etmez<br>// age = &quot;on iki&quot;</pre><p>Değişken eğer başlatıcı değere sahipse, değişken tanımlanırken tür bildirimi atlanabilir. Go, derlenme zamanında başlatıcı değerden tür çıkarımı yaparak (inferred typing) değişkene tür bildirimini yapabilir.</p><pre>var (<br>    name  = &quot;John Doe&quot;<br>    email = &quot;john@doe.com&quot;<br>    age   = 34<br>)</pre><p>veya;</p><pre>var name, email, age = &quot;John Doe&quot;, &quot;john@doe.com&quot;, 34</pre><p>Değişken başlatıcı değere sahipse := atama operatörü ile var anahtar sözcüğü atılabilir. Bu bildirim şekli sadece fonksiyonların gövdelerinde kullanılabilir, global kapsamda := operatörüne izin verilmez.</p><pre>import &quot;main&quot;</pre><pre>// bu alanda kısa/hızlı değişken bildirimi kullanılamaz,<br>// sadece &quot;var&quot; deyimi ile değişken bildirilebilir.</pre><pre>int main() {<br>    // fonksiyon gövdelerinde hem &quot;var&quot; deyimi hem de<br>    // kısa bildirim kullanılabilir.<br>    name, email, age := &quot;John Doe&quot;, &quot;john@doe.com&quot;, 34</pre><pre>    // ...<br>}</pre><p>Go, derlenme zamanında kısa bildirimi çözümler ve kendi anlayacağı formata dönüştürür.</p><p>Go’da bir değişken daha önce tanımlandıysa, aynı kapsam içinde var deyimi ile ikinci kez bildirime (aynı türde olsa dahi) izin verilmez. Ancak kısayol bildirim operatörü ile çoklu değişken bildirimi yaparken, eğer yeni değişken bildirimi yapılıyorsa Go daha önceden tanımlanmış bir değişkeni tolere edebilir. Sıradaki örnekleri inceleyelim.</p><p>Aşağıdaki örnek hatalıdır. Her iki değişkende yeniden tanımlandığı için derleyici bu satırın düzeltilmesini ister:</p><pre>name, age := &quot;John Doe&quot;, 34<br>name, age := &quot;Jane Doe&quot;, 30</pre><p>Aşağıdaki örnekte ise tanımlı değişken, daha sonra bir başka yeni değişken bildirimi ile kullanıldığı için derleyici buna müsade eder. Go, tanımlı bir değişkenin ikinci bildirimini değişken tanımlama yerine değer güncelleme olarak kabul eder.</p><pre>name, email := &quot;John Doe&quot;, &quot;john@doe.com&quot;<br>name, age := &quot;Jane Doe&quot;, 30</pre><p>Go yukarıdaki kod bloğunu derlenme zamanında çözümleyerek kendi anlayacağı formata dönüştürür. Dönüştürülmüş hali şöyle olacaktır:</p><pre>var name string = &quot;John Doe&quot;<br>var email string = &quot;john@doe.com&quot;<br>name = &quot;Jane Doe&quot;<br>var age int = 30</pre><p>Bu bildirim biçiminin sağladığı avantajı ilerleyen bölümlerde “hata yönetimi” konusunu incelerken anlayacaksınız.</p><h3>Scope</h3><p>Go dilinde, değişkenler bulundukları scope (kapsam) içinde oluşturulur ve kapsam sonunda öldürülür.</p><p>Kısaca, süslü parantezler içinde kalan gövde olarak tanımlayabiliriz kapsamı. Her yeni süslü parantez yeni bir kapsam doğurur.</p><ul><li>Farklı kapsamlarda, aynı isimde yeni bir değişken oluşturulabilir, hatta aynı isimde fakat türü farklı olabilir.</li><li>Bir değişken, kapsam dışında kaldığında tanımsızdır.</li><li>Alt kapsamlar, kendisinden daha üst kapsamda yer alan değişkenlere erişebilir. Ancak tersi mümkün değildir.</li></ul><p>Anlamak için devam edelim.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    msg := &quot;x&quot;<br> <br>    {<br>        fmt.Println(&quot;1:&quot;, msg)<br> <br>        msg := &quot;y&quot;<br> <br>        fmt.Println(&quot;2:&quot;, msg)<br>    }<br> <br>    fmt.Println(&quot;3:&quot;, msg)<br>}</pre><p>Sizce bu program ne yapar? Program çalıştırıldığında aşağıdaki çıktı ekrana yazdırılacaktır:</p><pre>1: x<br>2: y<br>3: x</pre><p>Yukarıda aslında birbirinden bağımsız 2 farklı değişken tanımladık. Bellekteki yerleri, değerleri birbirinden farklıdır. Sonuçların neden böyle oluştuğunu yorumlayalım:</p><p>1: x alt kapsamlar, kendisinden daha üst kapsamdaki değişkenlere erişebilir. Dolayısıyla alt kapsam oluşturulan bu değer kendisinden daha üst katmandaki değişkenin değerini kullandı.</p><p>2: yalt kapsamlar, kendisinden daha üst kapsamdaki değişkenleri yeniden oluşturabilir veya güncelleyebilir. Go, kapsam değiştiğinde aynı isimde yeni bir değişken tanımlanmaya izin verdi. Hatta değişkenin türünü dahi değiştirebilirdik. Dilerseniz msg := “y&quot; yerine msg := 5 deneyin.</p><p>3: x : üst kapsamlar, alt kapsamda oluşturulmuş olan değişkenlere erişemez. Halen kendi kapsamındaki değere sahip.</p><p>Kodları biraz değiştirirsek, alt kapsamların kendisinden daha üst katmandaki değerleri nasıl etkilediğini inceleyebilme fırsatına sahip olabiliriz:</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func main() {<br>    msg:= &quot;x&quot;<br> <br>    {<br>        fmt.Println(&quot;1:&quot;, msg)</pre><pre>        msg = &quot;y&quot;<br><br>        fmt.Println(&quot;2:&quot;, msg)<br>    }<br> <br>    fmt.Println(&quot;3:&quot;, msg)<br>}</pre><p>Örnekte tek yaptığımız değişiklik, alt kapsamdaki msg := &quot;y&quot; değerini değişken oluşturma yerine msg = &quot;y&quot; değer güncelleme olarak değiştirdik. Peki sizce sonuç ne olacak?</p><pre>1: x<br>2: y<br>3: y</pre><p>Sonuçlardan da anlayacağınız üzere, üst kapsamdaki değişkene alt kapsamda eriştiğimiz için güncelleme yetkisine de sahip olduk. Yeni bir değişken tanımlamadığımız için, mevcut değişkeni güncelleyebildik.</p><blockquote>Kuralı unutmayın! Değişkenler sadece aynı türde değer ile güncellenebilir. Bu örnekte msg = &quot;y&quot; yerine msg = 5 değişimine izin verilmez. Aynı türde değer atamadığımız için bu hatalı olur.</blockquote><p>Kapsam; global, fonksiyon, işlev, if-else ve döngü gövdelerinde de geçerlidir.</p><pre>for i := 1; i &lt; 5; i++ {<br>    fmt.Println(i)<br>}<br> <br>// &quot;i&quot; değişkeni &quot;for&quot; kapsamında tanımlı olduğu için<br>// bu alanda &quot;i&quot; değişkenine erişilemez</pre><p>Değişkeni döngü kapsamı yerine daha üst kapsama çıkarmak için:</p><pre>// &quot;i&quot; değişkenini &quot;for&quot; kapsamından daha üst<br>// kapsamda tanımlıyoruz<br>var i int<br> <br>for i = 1; i &lt; 5; i++ {<br>    fmt.Println(i)<br>}<br> <br>// &quot;i&quot; değişkeni artık burada erişilebilir<br>// hatta değeri &quot;for&quot; kapsamında değişti<br>fmt.Println(&quot;son değer: &quot;, i)</pre><p>Bu örneği mutlaka deneyin.</p><h3>Veri Türleri</h3><p>Go, her şeyin türünü ve değerini bilmek ister. Go, değişkene atanan değeri inceleyerek türünü çıkarım yoluyla keşfedebilir. Ya da türü belirtilmiş ancak değeri atanmamış değişkene varsayılan değeri (varsayılan değer değişken türüne göre farklılık gösterir) atayabilir.</p><blockquote>Veri türleri hakkında daha fazlası için <a href="https://golang.org/ref/spec#Types">Types Specification</a> belgelerini mutlaka inceleyin. Her şey en ince ayrıntısına kadar anlatılmaktadır.</blockquote><p>Çok sayıda değişken türü Go tarafından desteklenir. Hatta bazı veri türlerinin farklı kapasiteli halleri mevcuttur. Hızlıca veri türlerine göz atalım:</p><h4>Numbers</h4><p>Go’nun sayıları temsil eden birkaç farklı türü vardır. Genellikle sayıları iki farklı türde kabul ederiz: tamsayılar ve kayan nokta sayıları.</p><h4>Integers<strong> (</strong>Tamsayılar<strong>)</strong></h4><p>Tamsayı veri tipinin bit sayısına göre değişkenin bellekte kapladığı alan ve kapasitesi farklı olabilir. İşte Go tarafından desteklenen tamsayı veri tipleri:</p><p>int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr</p><pre>var i uint8<br>fmt.Printf(&quot;%d\n&quot;, i)<br> <br>i = 34<br>fmt.Printf(&quot;%d\n&quot;, i)</pre><p>Bu örneğimizde 8 bitlik unsigned sayısal bir değişken tanımı yapıldı, . Bilgisayar biliminde sayısal bir ifade signed ve unsigned olabilir. Eğer değişken unsigned tipinde ise sadece pozitif (sıfır dahil) sayılardan oluşabilir.</p><p>Tamsayı tipli değişkene, herhangi bir değer atanmamışsa derleme sırasında varsayılan 0 (sıfır) değeri atanır.</p><p>Sayısal veri tipi için iki takma ad türü vardır; uint8 ile byte ,int32 ile rune aynıdır.</p><p>Go geliştiricileri, bellek kullanımını ve performansı çok fazla önemser. Bu nedenle ihtiyaca uygun veri türü kullanılır. Değer int8 veri tipi ihtiyacınızı görüyorsa int64 tanımlamanız önerilmez.</p><p>Genellikle Go programlarında int veri türü kullanılır.</p><h4>Kayan Nokta Sayılar (Float Numbers)</h4><p>Ondalıklı sayıları tutan değişken tipidir. Sayının hassalığına göre float32 veya float64 türünden birine sahip olabilir. Her iki tür için varsayılan olarak 0 (sıfır) değeri atanır.</p><pre>var f float32<br>fmt.Printf(&quot;%f\n&quot;, f)<br> <br>f = 3.12<br>fmt.Printf(&quot;%f\n&quot;, f)</pre><h4>String</h4><p>Dize değerlerini tutabileceğiniz değişken tipidir. Değer atanmadığı durumda &quot;&quot; (boş dize) değerine sahiptir.</p><pre>var s string<br>fmt.Printf(&quot;%#v\n&quot;, s)<br> <br>s = &quot;go&quot;<br>fmt.Printf(&quot;%#v\n&quot;, s)</pre><h4>Boolean</h4><p>Yalnızca true veya false değerini tutar. Değeri atanmamış bir değişken varsayılan false değerine sahiptir.</p><pre>var b bool<br>fmt.Printf(&quot;%t\n&quot;, b)<br> <br>b = true<br>fmt.Printf(&quot;%t\n&quot;, b)</pre><h3>Tür Dönüşümü</h3><p>Go, değişkenlerin türü konusunda fazlaca hassastır. Örneğin; 2 sayısal ifade üzerinde matematiksel işlem yapılacaksa, değişken türlerinin aynı olması beklenir.</p><p>Tür dönüşümü T(v) formülü ile özetlenebilir. Yani; v değerini T türüne dönüştürür.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    var i int = 42<br>    var f float64 = float64(i)<br><br>    fmt.Printf(&quot;%T(%v)\n&quot;, i, i)<br>    fmt.Printf(&quot;%T(%v)\n&quot;, f, f)<br>}</pre><p>Bu örnekte; türü int olan i değişkeni, türü float64 olan f değişkenine kopyalanmadan önce verinin tür dönüşümüne uğradığını söyleyebiliriz.</p><p>Tür dönüşümü hakkında daha fazla bilgi ve diğer tür dönüşüm fonksiyonlar için <a href="https://yourbasic.org/golang/conversions/">convensions</a> yazısını mutlaka inceleyin.</p><h3>Sabit Değişkenler</h3><p>Bazen programda bir defa tanımlanan ve değeri daha sonra değişmemesini istediğimiz ifadelere ihtiyaç duyarız.</p><p>Mesela programı versiyonlamak istediğinizde, güncel versiyon numarası bir sabittir. Programa yeni bir özellik eklediğimizde bu değeri bir artırarak sabit tutarız. Neden uygulamanın herhangi bir yerinde değişsin ki?</p><p>Sabitler, değişkenlere benzer ancak bazı farklılıklar vardır. Sabitler hakkında bilmeniz gerekenler:</p><ul><li>var yerine const kullanılır.</li><li>string, boolean veya numeric türde değer atanabilir.</li><li>kısayol := operatörü desteklenmez.</li><li>kesinliği olmayan veriler değer olarak atanamaz.</li><li>tür bildirilmemişse bağlamın türünü alır.</li><li>değeri asla değiştirilemez.</li><li>tanımlanmış ancak kullanılmamış sabitler için derleyici hata vermez.</li></ul><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>const (<br>    Locale string = &quot;tr_TR&quot;<br>    PI            = 3.14<br>    PILong        = float64(22) / float64(7)<br>    // aşağıdaki ifade sürekli değişen değer ürettiği için<br>    // için sabit bir değişkene atanamaz<br>    // Now        = time.Now()<br>)<br> <br>func main() {<br>    fmt.Printf(&quot;%T(%v)\n&quot;, Locale, Locale)<br>    fmt.Printf(&quot;%T(%v)\n&quot;, PI, PI)<br>    fmt.Printf(&quot;%T(%v)\n&quot;, PILong, PILong)<br>}</pre><h3>Operatörler</h3><p>Go programlama dilinde farklı amaçlarla kullanılan bir takım operatörler bulunur. En çok ihtiyaç duyulan operatörleri hızlıca inceleyelim:</p><h4>Aritmetik Operatörler</h4><p>Bu operatörler, sayısal veriler üzerinde matematiksel işlem yapmamıza olanak tanır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4c7bd7989917da873cccfa9c24c8449c/href">https://medium.com/media/4c7bd7989917da873cccfa9c24c8449c/href</a></iframe><h4>Atama Operatörleri</h4><p>Bir değişkene değer atamak için kullanılan operatörlerdir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/908d76f617f9bdf7a104534136358c55/href">https://medium.com/media/908d76f617f9bdf7a104534136358c55/href</a></iframe><h4>Karşılaştırma Operatörleri</h4><p>İki veriyi birbiriyle kıyaslayarak bool (mantıksal) bir sonuç döndürür. Eğer karşılaştırma doğru ise true , yanlış ise false değerini döndürür.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d3e8e9b510d2da61a424d17153543dac/href">https://medium.com/media/d3e8e9b510d2da61a424d17153543dac/href</a></iframe><h4>Mantıksal Operatörler</h4><p>Birden fazla mantıksal veriyi zincirleyerek kontrol eder. Kullanılan operatöre göre çıktılanan sonuç farklılık gösterebilir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7641446bbe530add8f22df73bca89714/href">https://medium.com/media/7641446bbe530add8f22df73bca89714/href</a></iframe><h4>Adres/İşaretçi Operatörleri</h4><p>Bir değişkenin bellekteki adresini almak ya da bellek adresinde bulunan değeri öğrenmek için kullanılan operatörlerdir. Yazının devamında işaretçiler (pointers) bölümünde ayrıntılı ele alınacaktır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f2a7a1648bcf87103f65d5973a5f6a5/href">https://medium.com/media/0f2a7a1648bcf87103f65d5973a5f6a5/href</a></iframe><p>Go, çok daha fazla operatör içerir. Başlangıç için bu listede yer alan operatörleri bilmek yeterlidir. Yine de daha fazlası için <a href="https://golang.org/ref/spec#Operators">operatörler sayfasını</a> inceleyebilirsiniz.</p><h3>Arrays</h3><p>Belirli bir uzunlukta (kapasitede) verinin tutulduğu birleşik veri türüdür. Bir array (dizi) oluşturulurken, dizinin kapasitesi önceden belirtilir.</p><p>[n]T, T türünde n adet değeri tutan bir dizidir.</p><pre>var a [5]int</pre><p>Yukarıdaki ifade 5 adet int türünde veri tutan bir dizi tanımlar. Dizilerin başlangıç indisleri sıfırdır. 2 elemanlı bir dizi 0 ve 1 nolu indislere sahip olur. Kapasiteleri dahilinde, bir dizinin sahip olduğu herhangi bir indisine değer atanabilir veya sahip olduğu indisin değeri güncellenebilir.</p><p>Örneğin;</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    var m [2]int<br> <br>    m[0] = 25<br> <br>    // dizi kapasitesinin yeterli olmadığı indislere<br>    // veri ataması yapılamaz<br>    // m[2] = 5<br> <br>    fmt.Printf(&quot;%#v&quot;, m)<br>}</pre><p>Yukarıdaki örnekte 2 elemanlı bir dizi tanımladık. Dizinin birinci elemanına (0 nolu indis) değer atadık. Ancak ikinci elemanına (1 nolu indis) değer atamadık. Değer ataması yapılmamış dizi elemanları, veri türüne uygun olan varsayılan değer ile doldurulur.</p><p>Dilerseniz, dizi tanımlarken dizi elemanlarının sahip olacağı değerleri önceden verebilirsiniz. Dizinin ilk değerlerini tanımlamak için, dizi ifadesinden hemen sonra süslü parantezler içinde ilklendirme değerlerini belirtebilirsiniz.</p><p>Aşağıdaki örnekte, dizinin bir kısım elemanları ilklendirilmiştir. İlklendirilmeyen değerlerin, varsayılan değerler ile doldurulduğunu sakın unutmayın.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    m := [3]int{25, 5}<br>   <br>    fmt.Printf(&quot;%#v&quot;, m)<br>}</pre><p>Dizi elemanlarına erişmek için, erişilmek istenen elemanın indisi köşeli parantezler içinde bildirilmesi yeterlidir:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    m := [2]string{&quot;foo&quot;, &quot;bar&quot;}<br> <br>    fmt.Println(m[0])<br> <br>    // dizi 2 nolu indise sahip olmadığı için<br>    // aşağıdaki ifade hata fırlatır<br>    // fmt.Println(m[2])<br>}</pre><p>Bir dizi veriye sahip olduğunuzu ve kapasite belirtmeden bunu yeni bir diziye atamak istediğinizi varsayalım. Go, bu durumda sizin yerinize kapasite tahmini yapabilir. Bu durumda uzunluğu yazmak yerine ... (üç nokta) operatörünü kullanabilirsiniz.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    m := [...]string{&quot;foo&quot;, &quot;bar&quot;}<br> <br>    fmt.Printf(&quot;%#v&quot;, m)<br>}</pre><p>Hep tek boyutlu diziler ile çalıştık ama zaman zaman çok boyutlu matrislere de ihtiyaç duyarız. Go, çok boyutlu dizileri destekler. Aşağıdaki örneği inceleyelim:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    var a [2][3]string<br> <br>    for i := 0; i &lt; 2; i++ {<br>        for j := 0; j &lt; 3; j++ {<br>            a[i][j] = fmt.Sprintf(&quot;%d-%d&quot;, i+1, j+1)<br>        }<br>    }<br> <br>    fmt.Println(a)<br>}</pre><p>Yukarıdaki örneği tek boyutlu dizilerde olduğu gibi, daha önceden sahip olduğunuz bir çok boyutlu dizi ile ilklendirebilirsiniz:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    a := [3][2]int{<br>        {0, 1},<br>        {2, 3},<br>        {4, 5},<br>    }</pre><pre>    fmt.Printf(&quot;%#v&quot;, a)<br>}</pre><p>Çok boyutlu dizilerde bir elemana ulaşmak için tek boyutlu dizilerde olduğu gibi köşeli parantezleri kullanırız. Örneğin; 2 nolu satırın ilk elemanına ulaşmak için:</p><pre>a[2][0]</pre><p>ifadesini kullanmamız yeterlidir.</p><blockquote>Dizilerle ilgili daha fazla bilgi için <a href="https://gobyexample.com/arrays">örnek uygulamalara</a> ya da <a href="https://golang.org/ref/spec#Array_types">Go belgelerine</a> göz atabailirsiniz.</blockquote><h3>Slices</h3><p>Dilimler (slices), dizilere daha kullanışlı hale getirmek için dizileri sarar. Dizilere benzer ancak dilimlerin kapasitesi belirsiz olabilir.</p><p>[]T, T türünde bir dilimdir.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    n := []int{1, 2, 3, 4}<br> <br>    fmt.Printf(&quot;%#v&quot;, n)<br>}</pre><p>Go’da diziler dilimlenerek, yeni bir dilim değişkeni oluşturulabilir. Bir dizinin sınırları belirlenerek yeni bir dilim oluşturmak için:</p><pre>msg[low:high]</pre><p>ifadesi kullanılır. Bu ifade ilk elemanı (low) içeren ancak sonuncusu (high) hariç tutan yarı açık bir dilim seçer. İfade biraz karışık, anlaşılmak için örnek üzerinden ilerleyelim.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    chars := [6]string{&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;, &quot;f&quot;} <br> <br>    var slice []string = chars[1:4]<br> <br>    fmt.Printf(&quot;%#v&quot;, slice)<br>}</pre><p>Bu örnek, dizinin 1–4 numaralı indisleri arasında kalan (1 nolu indeks dahil, 4 nolu indeks dahil değil) değerleri seçecektir. Dizilerin başlangıç indeksinin 0 (sıfır) olduğunu unutmayın.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*BicpjtM9ES9AwxSB0zlRLg.png" /><figcaption>Dizilerden referans yoluyla dilim oluşturma</figcaption></figure><p>Bu görsel, bir önceki yaptığımız işlemin görselleştirilmiş halidir. Diziler, dilimlere ayrılırken referans yoluyla kopyalanır. Yani, dizinin değeri değil, aslında referansı değer olarak aktarılır.</p><p>Devam etmek için aşağıdaki kodu çalıştırıp, çıktıyı gözlemleyin.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    chars := [6]string{&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;, &quot;f&quot;} <br> <br>    var slice []string = chars[1:4]<br> <br>    chars[2] = &quot;x&quot;<br> <br>    fmt.Printf(&quot;%#v&quot;, slice)<br>}</pre><p>Yeni boş bir dilim oluşturmak için make sözcüğünü kullanırız. Go, make sözcüğü için bir uzunluk belirtilmesini bekler.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    s := make([]int, 2)<br> <br>    fmt.Printf(&quot;%#v:&quot;, s)<br>}</pre><p>Bu örnekte uzunluğu (len) 2 olan yeni bir dilim oluşturduk. Dilime henüz bir değer atamadığımız için Go başlangıç değeriyle doldurdu.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    s := make([]int, 2)<br> <br>    s[0] = 10<br>    s[1] = 20<br> <br>    fmt.Printf(&quot;%#v:&quot;, s)<br>}</pre><p>Dizilerde olduğu gibi, dilimlere de indisleri üzerinden erişebilir veya değer atayabilirsiniz.</p><p>Dilimler, uzunluk limiti bakımından kolaylık sağladığından bahsetmiştik. O halde başlangıçta belirlenen uzunluk miktarı yeterli olmadığı durumlarda ne yapacağız?</p><pre>s[2] = 30</pre><p>Yukarıdaki ifadeyi örneğimize eklediğimizde, Go dilim uzunluğunu aştığımız için bize kızacak. Peki ne yapabiliriz?</p><pre>s = append(s, 30)</pre><p>Dilim uzunluğu genişletmek, dilimin sonuna yeni elemanlar eklemek için append sözcüğünü kullanabiliriz. Go, bizim yerimize dilimi genişletecek ve yeni elemanı dilimin sonuna ekleyecektir.</p><pre>s = append(s, 30, 40, 50)</pre><p>Dilerseniz tek bir satırda çok sayıda veriyi dilime ekleyebilirsiniz.</p><p>Boş bir dilim oluşturulduğunda ilk değerlerin doldurulduğunu unutmayın. Ayrıca, append sadece yeni değerleri dilimin sonuna ekler. Yani herhangi bir indisteki değeri güncellemez.</p><p>İşte bir örnek:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    s := make([]int, 2)<br> <br>    s = append(s, 10)<br> <br>    fmt.Printf(&quot;%#v:&quot;, s)<br>}</pre><p>Bir dilimin uzunluğunu öğrenmek için len sözcüğünü kullanabilirsiniz.</p><pre>l := len(s)</pre><blockquote>Daha fazlası için <a href="https://tour.golang.org/moretypes/7">Go turuna</a> katılabilir ya da bu konuyu harika özetleyen “<a href="https://yourbasic.org/golang/slices-explained/">slices explained</a>” makalesini okuyabilirsiniz.</blockquote><h3>Maps</h3><p><em>yakında güncellenecek.</em></p><h3>Koşullu İfadeler</h3><p>Programlar, bir durumun doğru veya yanlış olma ihtimaline göre farklı davranışlar sergiler. Mevcut şartları sorgulamak ve programın akışını yönlendirmek için koşullu ifadelerden (kontrol yapılarından) faydalanırız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S_CDzowQ7HrafR2ueRTWHA.png" /><figcaption>“a&quot; değişken değerinin 5&#39;e eşit olup olmadığını kontrol eden basit bir kontrol yapısı</figcaption></figure><h4>If/Else</h4><p>Bir durumu “eğer” şartı/şartları ile kontrol etmemizi sağlar.</p><p>Örneğin, sayısal tipli bir değişkenin sahip olduğu değeri tek ya da çift olma durumuna göre kontrol etmek istiyoruz. Sayı eğer çift ise ekrana mesaj yazdıracağız.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    i := 4<br> <br>    if i%2 == 0 {<br>        fmt.Println(&quot;çift&quot;)<br>    }<br>}<br> <br>// output: çift</pre><p>Örnekte mod operatörü ile i değişkeni kontrol ediliyor. Eğer bölümden kalan sonuç sıfır (0) ise true değeri oluşturulacak ve if bloğu içindeki şart karşılanacaktır. Koşula uyduğu için if bloğu gövdesindeki kod parçası çalıştırılacak. Eğer sayı tek olsaydı koşul sağlanmadığı için ekrana hiçbir şey yazdırılmayacaktı. Değeri değiştirerek deneyin.</p><blockquote>İster sevin, ister sevmeyin ama Go dilinde if sonrasında koşul gövdesi için süslü parantezler kullanılmalı.</blockquote><p>Ya her iki durumda da ekrana bir şey yazdırmamız gerekseydi?</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    i := 3<br> <br>    if i%2 == 0 {<br>        fmt.Println(&quot;çift&quot;)<br>    } else {<br>        fmt.Println(&quot;tek&quot;)<br>    }<br>}<br> <br>// output: tek</pre><p>Örnekte, koşul false sonucu üreteceği için if koşulu sağlanmayacak. Program if koşulunu sağlamadığı için else gövdesini çalıştırır. Eğer if koşulu sağlansaydı bu seferde else gövdesi çalışmayacaktı.</p><p>Bazen programı çok sayıda koşulla sınamak isteyebiliriz. Yani if ve else haricinde farklı kontrollere de ihtiyacımız olabilir. O halde else if tanışalım.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    i := 7<br> <br>    if i &lt; 5 {<br>        fmt.Println(&quot;sayı beşten küçük&quot;)<br>    } else if i == 6 {<br>        fmt.Println(&quot;sayı altıya eşit&quot;)<br>    } else if i == 7 {<br>        fmt.Println(&quot;sayı yediye eşit&quot;)<br>    } else {<br>        fmt.Println(&quot;sayı hiçbir şartı karşılamıyor&quot;)<br>    }<br>}<br> <br>// output: sayı yediye eşit</pre><p>Örnekte if koşulu sağlanmadığı için bir sonraki sırada yer alan koşul ile sınanır. Bu koşul da doğru değilse, bir sonraki, bir sonraki... Eğer herhangi bir koşula uymazsa else gövdesi tetiklenir. Her şey sıralı yürütülür. Ancak örneğimizde koşulun sağlandığı bir blok var: i==7 durumu.</p><p>Koşullu ifadeler bir tane if ve else bloğu içerebilirken, çok sayıda else if bloğuna sahip olabilir. Dürüst olmak gerekirse her şey if ve else bloklarından oluşur. Aslında else if sadece bizlere görsel kolaylık sağlamak için vardır.</p><pre>if i == 5 {<br>    ...<br>} else if i == 7 {<br>    ...<br>} else {<br>    ...<br>}</pre><p>eşittir:</p><pre>if i == 5 {<br>    ...<br>} else {<br>    if i == 7 {<br>        ...<br>    } else {<br>        ...<br>    }<br>}</pre><p>Okunabilirliği azalttığı için, iç içe (nested) kod blokları yazmamaya gayret edin. Sadece böyle çalıştığını bilin, gönül rahatlığıyla else if kontrol bloğunu kullanabilirsiniz.</p><blockquote>Daha fazlası için <a href="https://golang.org/doc/effective_go.html#control-structures">kontrol yapıları</a> belgelerine göz atabilirsiniz.</blockquote><h4>Switch</h4><p>if/else kontrol bloğuna güçlü bir alternatif olan switch bloğu, benzer kontrollerin yanında daha güçlü bir arayüz sunar. Yine koşullar yukarıdan aşağı doğru sıralı olarak sınanır. Bir durum (sav, şart) başarılı olduğunda koşul gövdesi yürütülür.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    num := 2<br> <br>    switch num {<br>    case 1:<br>        fmt.Println(&quot;num: 1&quot;)<br>    case 2:<br>        fmt.Println(&quot;num: 2&quot;)<br>    }<br>}</pre><p>Yukarıdaki örnekte, switch deyimi şarta uygulanacak değeri tutar. Daha sonra case deyimleri ile sırayla koşullar sınanır. Kazanan durum gövdesi çalıştırılır.</p><p>Aklınıza else geliyor değil mi? Merak etmeyin, hiç bir şart karşılanmadığı durumda çalıştırabileceğiniz default bloğu mevcut. Aynı else gibi çalışır.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    num := 200<br> <br>    switch num {<br>    case 1:<br>        fmt.Println(&quot;num: 1&quot;)<br>    case 2:<br>        fmt.Println(&quot;num: 2&quot;)<br>    default:<br>        fmt.Println(&quot;num: diğer&quot;)<br>    }<br>}</pre><p>Eğer switch ifadelerinde, default durumu varsa ve tüm şartlar sorgulanmasına rağmen hiç bir şart sağlanmamışsa default gövdesi çalıştırılarak kontrol sonlandırılır. Eğer en az bir tane şart sağlanmışsa default gövdesi çalıştırılmaz.</p><pre>package main<br> <br>import (<br>    &quot;fmt&quot;<br>    &quot;time&quot;<br>)<br> <br>func main() {<br>    switch hour := time.Now().Hour(); {<br>    case hour &lt; 12:<br>        fmt.Println(&quot;günaydın&quot;)<br>    case hour &lt; 17:<br>        fmt.Println(&quot;tünaydın&quot;)<br>    default:<br>        fmt.Println(&quot;iyi akşamlar&quot;)<br>    }<br>}</pre><p>Bu örnekte ise switch kapsamına özel bir değişken tanımlandı. Tanımlı değişkene kapsam içinde erişebilir, gelişmiş kontroller oluşturabilirsiniz.</p><pre>package main<br> <br>import (<br>    &quot;fmt&quot;<br>    &quot;time&quot;<br>)<br> <br>func main() {<br>    switch time.Now().Hour() {<br>    case 6, 7, 8, 9, 10, 11:<br>        fmt.Println(&quot;günaydın&quot;)<br>    case 12, 13, 14, 15, 16:<br>        fmt.Println(&quot;tünaydın&quot;)<br>    default:<br>        fmt.Println(&quot;iyi akşamlar&quot;)<br>    }<br>}</pre><p>Bir başka kullanım örneği ile devam edelim. Kontrol durumlarında bir liste halinde şart belirtebilirsiniz. Eğer şart listesi içindeki herhangi bir değere eşitlik koşulu sağlanırsa, koşul gövdesi çalıştırılır.</p><blockquote>Daha fazlası için <a href="https://golang.org/doc/effective_go.html#switch">switch</a> belgelerine veya <a href="https://gobyexample.com/switch">örneklere</a> göz atabilirsiniz.</blockquote><h3>Döngüler</h3><p>Döngü (loop), bir kod bloğunu tekrar tekrar yürütmek için kullanılır. Go, tüm döngü türlerini tek bir for anahtar sözcüğü ile yapabilir.</p><h4>For Döngüsü</h4><p>Başlangıcı, bitişi ve artırım/azalım miktarı belli olan döngü türüdür. Döngü, çalışacağı şartları öncesinden bilir.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    sum := 0</pre><pre>    for i := 1; i &lt; 10; i++ {<br>        sum += i<br>    }</pre><pre>    fmt.Println(sum)</pre><pre>    // döngü kapsamında olmadığı için &quot;i&quot; değişkeni<br>    // bu alan için tanımlı değildir<br>}</pre><p>Yukarıdaki program belirli aralıktaki sayıların toplamını ekrana yazdırır. Döngü aşağıdaki durumlarda çalışır:</p><ol><li>i := 1 durumu ile başlatılır (init)</li><li>i &lt; 10 koşulu (condition) hesaplanır. Koşul sağlanıyorsa döngü gövdesi çalıştırılır, aksi halde döngü tamamlanır.</li><li>i++ durumu çalıştırılır (post)</li><li>2. adıma geri dön</li></ol><h4>While Döngüsü</h4><p>Önceki bölümde ifade edilen for döngüsü biraz değiştirilerek while döngüsü elde edilebilir.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    sum, i := 0, 1</pre><pre>    for i &lt; 10 {<br>        sum += i<br>        i++<br>    }</pre><pre>    fmt.Println(sum)<br>}</pre><p>Aslında while döngüsü sadece şarttan oluşur. Şart sağlandığı sürece tekrar tekrar çalışır. Döngü aşağıdaki durumlarda çalışır:</p><ol><li>i &lt; 10 koşulu (condition) hesaplanır. Koşul sağlanıyorsa döngü gövdesi çalıştırılır, aksi halde döngü tamamlanır.</li><li>1. adıma geri dön</li></ol><h4>For-each Döngüsü</h4><p>Yinelenilir (tekrarlı) string, array, slice, map veya channel veri türünde değişkenlerin sahip olduğu verileri sırayla işlemek için ideal döngüdür. Mesela;</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main () {<br>    list := []string{&quot;cat&quot;, &quot;dog&quot;, &quot;rabbit&quot;}</pre><pre>    for key, value := range list {<br>        fmt.Println(key, value)<br>    }<br>}</pre><p>Döngü, liste içindeki her elemanı baştan sona doğru sırayla gezer. Son eleman işlendikten sonra imha olur. Liste, range anahtarı ile döngüye tanıtılır. Döngü her elemanı key ve value haritasıyla işler.</p><p>Eğer key değerine ihtiyacınız yoksa null identifier (boş tanımlayıcı) ile yok sayabilirsiniz. Boş tanımlayıcı için _ (alt çizgi) karakteri kullanılır.</p><pre>for _, value := range list {<br>    fmt.Println(value)<br>}</pre><p>Sadece key değerine ihtiyacınız varsa, value değeri atmanız yeterli.</p><pre>for key := range list {<br>    fmt.Println(key)<br>}</pre><h4>Sonsuz Döngü</h4><p>Bazen bir döngünün programın çalıştığı süre boyunca çalışması istenebilir. Hiç bir şart altında çalışmayan döngüdür.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    for {<br>        fmt.Println(&quot;.&quot;)<br>    }<br>}</pre><p>Bu program çalıştığı süre boyunca ekrana nokta yazacak.</p><h4>Break/Continue</h4><p>Neredeyse tüm programlama dillerinde olan break ve continue anahtar sözcükleri, Go tarafından desteklenir.</p><p>break: döngüyü kırıp çıkar</p><p>continue : mevcut çevrimi atlar ve döngüye devam eder.</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    sum := 0</pre><pre>    for i := 1; ; i++ {<br>        // i değeri 2 ve 3&#39;e tam bölünüyorsa atla<br>        if i%2 == 0 &amp;&amp; i%3 == 0 {<br>            continue<br>        }<br>    <br>        // sum değeri 15&#39;ten büyükse döngüyü kır<br>        if sum &gt; 15 {<br>            break<br>        }</pre><pre>        sum += i<br>    }</pre><pre>    fmt.Println(sum)<br>}</pre><h3>Fonksiyonlar</h3><p>Bilgisayar biliminde fonksiyon (işlev), matematik bilimindeki fonksiyonlara benzer. Tanımlanan f(x) fonksiyonu, ihtiyaç duyulduğunda tekrar tekrar kullanılabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*JKzLfz6a8088SHTu.png" /><figcaption>Fonksiyon prototipi</figcaption></figure><p>Yukarıdaki görselde bulunan siyah kutuyu fonksiyon olarak hayal edin. Fonksiyonlar; sıfır veya daha fazla girdi parametresi (inputs) alır ve sıfır veya daha fazla sayıda çıktı (outputs) oluşturur.</p><p>Go dilinde fonksiyonlar func anahtar sözcüğü ile tanımlanır. Her fonksiyon, benzersiz bir isime sahiptir. Daha önce, parametresiz ve sonuç döndürmeyen main isimli fonksiyon ile sıkça karşılaşmıştık.</p><pre>func main() {<br>  // ...<br>}</pre><p>Fonksiyonları anlamak için minik bir program yazalım:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    n := []int{5,10,15,20}<br>    t := 0<br> <br>    for _, v := range n {<br>        t += v<br>    }<br> <br>    fmt.Println(t)<br>}</pre><p>Örnekte n değişkenine atanmış bir dizi sayısal veriyi toplayıp ekrana yazdıran kod bloğu yazdık. Toplama işlemini gerçekleştiren kod bloğunu, ana bloktan kopararak yeni bir fonksiyona dönüştürelim.</p><pre>func toplam(n []int]) {<br>    t := 0<br> <br>    for _, v := range n {<br>        t += v<br>    }<br> <br>    fmt.Println(t)<br>}</pre><p>Yukarıdaki örnekte toplam isimli fonksiyon bir adet girdi istiyor (parametre) ve geriye herhangi bir sonuç döndürmüyor. Bu çıkarımı, fonksiyonun prototip sözleşmesinden anlayabiliriz. Hadi devam edelim.</p><pre>func name(inputs) outputs {<br>    // body<br>}</pre><p>Yukarıdaki ifade, fonksiyonların en basit formülüdür, bir başka deyişle prototip. Oluşturduğumuz toplam fonksiyonunu bu formüle göre açıklamamız istenirse, fonksiyon isminden hemen sonra n []int tipinde bir adet parametre aldığını söyleyebilirsiniz. Yine formüle göre, çıktı hanesinde herhangi bir şey tanımlı olmadığı için geriye değer döndürmediğini söylemek isabetli çıkarım olur.</p><p>Fonksiyonu çağırmak için main fonksiyona geri dönerek, fonksiyon gövdesini güncelleyelim:</p><pre>func main() {<br>    toplam([]int{5,10,15,20})<br>}</pre><p>Program temiz görünüyor ancak yeniden kullanılabilir (reusable) değil. Hesaplanan toplam değeri fonksiyon içinde ekrana yazdırmak yerine, geriye çıktı olarak döndürürsek daha iyi olmaz mı? Böylece çıktılanan değer farklı amaçlarda kullanılabilir. Biraz değişiklik yaparak sonuç döndüren fonksiyonları tanıyalım:</p><pre>func toplam(n []int]) int {<br>    t := 0<br> <br>    for _, v := range n {<br>        t += v<br>    }<br> <br>    return t<br>}</pre><p>Değişikliği fark ettiniz mi? Go, fonksiyonlardan geriye sonuç döndürülecekse döndürülecek değerin tipini önceden bilmek ister. Fonksiyondan geriye int tipinde bir adet sonuç döndürüleceği garanti edildi. Gövdenin son satırında ise sonucu ekrana yazdırmak yerine return anahtar sözcüğü ile değer geri döndürüldü.</p><p>Şimdi main fonksiyonuna geri dönelim ve değişikliği uygulayalım:</p><pre>func main() {<br>    sonuc := toplam([]int{5,10,15,20})<br> <br>    fmt.Println(sonuc)<br>}</pre><p>Artık toplam fonksiyonundan elde edilen yeni değer farklı amaçlarla kullanılabilir. Sonuç değerini ister ekrana yazdırın, isterseniz bir dosyaya kaydedin.</p><p>İşleri biraz daha karmaşıklaştıralım. Çok sayıda parametre alan ve çok sayıda sonuç döndüren program yazmaya ne dersiniz?</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    o1, o2:= islem(5, 6)<br> <br>    fmt.Printf(&quot;o1: %v, o2: %v&quot;, o1, o2)<br>}</pre><pre>func islem(a int, b int) (int, float64) {<br>    x := a * b<br>    y := float64(a) * 0.25<br> <br>    return x, y<br>}</pre><p>Daha önce tanımladığımız parametreli fonksiyonlara benzer olarak, kabul edilecek her parametrenin adı ve tipi fonksiyon başlığında bildiriliyor. Birden fazla sonuç döndürüleceği zaman, çıktılanacak verilerin tipleri parantez içinde tanımlanıyor.</p><p>Fonksiyondan geriye döndürülecek veri birden fazla ise, döndürülecek veri tipleri fonksiyon başlığında parantez içinde belirtilmesi zorunluluktur. Tek bir adet sonuç döndürüleceği zaman parantezlere gerek yoktur.</p><pre>func islem (a, b int) (int, float64) {<br>    // ...<br>}</pre><p>Go’da, tipleri aynı olan ardışık parametreleri yukarıdaki örnekte olduğu gibi gruplayabilirsiniz.</p><p>Şu durumu hayal edin: geriye çok sayıda sonuç döndüren bir fonksiyonumuz var ancak uygulama içinde hepsini kullanmamıza gerek yok. Yani bazı sonuçlar bizim için gereksiz. Bu durumda kullanılmayacak fonksiyon çıktılarını boş tanımlayıcı ile yok saymamız gerekiyor:</p><pre>package main<br> <br>import &quot;fmt&quot;<br> <br>func main() {<br>    _, iki, _ := fn()<br> <br>    fmt.Println(iki)<br>}<br> <br>func fn() (int, int, int) {<br>    return 1, 2, 3<br>}</pre><p>Unutmayın, Go’da bir değişken tanımlanmışsa mutlaka kullanılması gerekiyor. Bu nedenle fonksiyonlardan elde ettiğimiz ihtiyaç fazlası değerleri boş tanımlayıcı ile yok saymalıyız.</p><p>Son olarak, belirsiz (sıfır, bir ya da çok) sayıda parametre kabul eden <strong>variadic functions</strong> olarak bilinen fonksiyonları hızlıca inceleyelim. Çok sık kullandığımız fmt.Println fonksiyonu aslında variadic fonksiyondur. Go kaynak kodlarında fonksiyon <a href="https://golang.org/src/fmt/print.go?s=7925:7974#L273">şöyle</a> tanımlanmış:</p><pre>func Println(a ...interface{}) (n int, err error)</pre><p>Bu fonksiyonda a isimli parametre,, interface{} türünde (herhangi bir türde) ve belirsiz sayıda girdiyi kabul ediyor. Parametre sayısındaki belirsizlik … (3 nokta) ifadesi ile bildiriliyor.</p><p>Örnekte kullandığımız toplam fonksiyonunu değiştirerek belirsiz sayıda parametre almasını sağlayalım:</p><pre>func toplam(n ...int) int {<br>    t := 0<br> <br>    for _, v := range n {<br>      t += v<br>    }<br> <br>    return t<br>}</pre><p>Daha önce oluşturduğumuz fonksiyona bağlı kalarak n []int olan parametre bildirimini a ...int olarak güncelledik. Hepsi bu kadar. Bu fonksiyonu çağırmak için:</p><pre>func main() {<br>    sonuc := toplam(1, 2, 10, 15)<br> <br>    fmt.Println(sonuc)<br>}</pre><h3>Hata Yönetimi</h3><p>Go, hataların işlenmesini geliştiriciye bırakıyor. Diğer dillerin aksine, Go her hatanın tek tek ele alınmasını ister. Go’nun iki farklı hata işleme mekanizması vardır:</p><ul><li>fonksiyonlar geriye türü error olan bir sonuç döndürür</li><li>panic deyimi ile çalışma zamanı (run-time) istisnası fırlatılır (önerilmez)</li></ul><p>Go, geriye çok sayıda sonuç döndürme yeteneğine sahip olduğu için, programlarda oluşan hatalar error arayüzünden türetilmiş bir sonuçla bildirilir.</p><pre>type error interface {<br>    Error() string<br>}</pre><p>Go hata işleme için try/catch mekanizmasına sahip değildir. Bunun yerine fonksiyonlardan döndürülen error sonucu kontrol edilir. Aslında bu özellik diğer dillerdeki çözümlere göre hem daha pratik hem de daha temizdir.</p><p>Örneğin; dosya sistemleri ile çalışırken os.Open işlevi bir dosyayı açamadığı durumlarda geriye türü error olan sonuç döndürür. Aşağıda bu işlevin prototipi yer almaktadır:</p><pre>func Open(name string) (file *File, err error)</pre><p>Bu işlevi kullandığımızda, işlem hata üretip üretmediğini kontrol etmemiz gerekir. Aşağıdaki örnekte bir hatayı nasıl kontrol edeceğiniz yer almaktadır.</p><pre>f, err := os.Open(&quot;file.txt&quot;)</pre><pre>if err != nil {<br>    log.Fatal(err)<br>}</pre><pre>// &quot;f&quot; değişkeni ile bir şeyler yapın</pre><p>Kendi örneğimizi yazarak konuyu anlamaya çalışalım. Bölme işlemi gerçekleştiren basit bir fonksiyon yazacağız. Eğer bölüm değeri sıfır ise hata oluşturacağız ve programda bu hatayı yakalayacağız.</p><pre>package main</pre><pre>import (<br>   &quot;errors&quot;<br>   &quot;fmt&quot;<br>   &quot;log&quot;<br>)</pre><pre>func bol(sayi, bolen float64) (float64, error) {<br>    if bolen == 0 {<br>        return 0, errors.New(&quot;bölen değeri sıfır olamaz&quot;)<br>    }</pre><pre>    sonuc := sayi / bolen</pre><pre>    return sonuc, nil<br>}</pre><pre>func main() {<br>    sonuc, err := bol(5, 0)</pre><pre>    if err != nil {<br>        log.Fatal(err)<br>    }</pre><pre>    fmt.Printf(&quot;sonuc: %v&quot;, sonuc)<br>}</pre><p>Örnekte, fonksiyonlardan hata döndürme ve hata işleme ile ilgili önerilen kullanım biçimi yer almaktadır. Özel hata oluşturmak için <a href="https://golang.org/pkg/errors/"><strong>errors paketi</strong></a> içinde yer alan işlevlerden birini kullanmak yeterli.</p><pre>err := errors.New(&quot;hata mesajı&quot;)</pre><p>Fonksiyonlarda hataları sonuç olarak döndürme sırasında dikkat edeceğimiz noktalar:</p><ul><li>hata durumunda error haricindeki diğer değer parametreleri, türe ait varsayılan değerlerle doldurulabilir</li><li>hata olmadığı durumlarda ise error dönüş değeri nil değerinde olmalı</li><li>çoklu sonuç dönen fonksiyonlarda genellikle error türündeki parametre en son sırada olur (best practice)</li></ul><p>Daha fazlası için <a href="https://golang.org/pkg/errors/">paket belgelerine</a>, <a href="https://blog.golang.org/error-handling-and-go">blog yazısına</a> ve <a href="https://golang.org/doc/effective_go.html#errors">Effective Go</a> açılamalarına göz atabilirsiniz.</p><h3>Structs</h3><p>Go dilinde sınıflar yoktur, zaten nesne yönelimli programlama (object-oriented programming) dili değildir. Sadece OOP yaklaşımının avantajlarını barındırır.</p><p>Sınıflar, structs (yapılar) ile taklit edilebilir. Yapı elemanları, property (özellik) olarak kabul edilebilir.</p><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><p>Yukarıdaki örnekte width ve height değişkenlerini barındıran Rect isimli bir yapı oluşturduk. Yapı elemanları şu ana kadar öğrendiğimiz tüm veri tiplerine sahip olabilir. Hatta bir başka yapıyı dahi tip olarak kabul edebilir.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>func main() {<br>    r := Rect{}</pre><pre>    fmt.Printf(&quot;%+v\n&quot;, r)<br>}</pre><p>Tanımladığımız Rect yapısından örnek (instance) aldık. Henüz yapı elemanlarına herhangi bir değer yüklemediğimiz için, değişkenler bölümünden de hatırlayacağınız üzere varsayılan değerler otomatik olarak atanır.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>func main() {<br>    r := Rect{}<br>    r.width = 5.0<br>    r.height = 4.0</pre><pre>    fmt.Printf(&quot;%+v\n&quot;, r)<br>    fmt.Printf(&quot;width: %.2f, height: %.2f&quot;, r.width, r.height)<br>}</pre><p>Yapı elamanlarına erişmek için . (nokta) operatörü kullanılır. Bir elemana değer atamak ya da değerini almak için instance alınan değişken üzerinden nokta operatörü yardımıyla elemanlara erişebiliriz.</p><pre>r := Rect{5.0, 4.0}</pre><p>Yapı oluştururken, başlangıç değerlerini de tanımlayabiliriz. Yukarıdaki örnekte, yapı tanımındaki sıraya göre değişkenlere değer atanacaktır. Bu durumda width değeri 5.0 ve height değeri 4.0 olacaktır.</p><pre>r := Rect{<br>    width:  5.0,<br>    height: 4.0,<br>}</pre><p>Yapı ilklendirme için en çok tercih edilen yazım şeklidir. Genellikle bir yapıdan örnek alınırken, değişkenlerin değeri açıkça belirtilir.</p><h3>Methods</h3><p>Go’da yapılar için tanımlanan özel fonksiyonlardır. Bu fonksiyonlar, yapılara aittir ve sadece yapı örnekleri ile kullanılabilir.</p><p>Bir önceki bölümde oluşturduğumuz Rect yapısı için alan (area) değerini hesaplayıp geri döndüren method (işlev) yazalım.</p><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>func (r Rect) Area() float64 {<br>    return r.width * r.height<br>}</pre><p>Fonksiyonlar için geçerli olan tüm kurallar method tanımı içinde geçerlidir. Fonksiyonların aksine, fonksiyon adının hemen başına hangi yapı için kullanılacağı belirtilir. Bu durumda, Area fonksiyonunun Rect yapısına ait olduğu anlamına gelir.</p><pre>r := Rect{<br>    width:  5.0,<br>    height: 4.0,<br>}</pre><pre>fmt.Println(&quot;area:&quot;, r.Area())</pre><p>Bir işlevi çağırmak için nokta operatörünü kullanırız. Instance değişken üzerinden işlev çağrımı yapılır.</p><p>Örneğimizde, parametre almayan bir işlev tanımladık. Go’da, parametreli ve geriye çoklu değer dönen işlevler de tanımlanabilir.</p><h3>Pointers</h3><p>Pointers (işaretçiler), bir değerin bellekteki adresini tutar.</p><p>Bir değişkenin bellekteki adresi &amp; (and) operatörü ile alınır. Bellek adresindeki değer ise * (yıldız) operatörü ile görüntülenir.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func main() {<br>    a := 5<br>    c := &amp;a</pre><pre>    fmt.Println(c)<br>}</pre><p>Yukarıdaki örnekte c değişkenine a değişkeninin referansı atandı. Programı çalıştırdığınızda ekrana 0x40e020 değerine benzer bir çıktı basılır. Bu aslında a değişkeninin bellekteki adres değeridir.</p><p>Referans tutan değişken değerini ekrana yazdırmak için * operatörünü kullanalım:</p><pre>fmt.Println(*c)</pre><p>Pointer kullanırken dikkatli olmak gerekir. Normalde bir değişkenin değerini başka bir değişkene atadığınızda değer kopyalaması yapılır. Ancak referans yoluyla atama yapıldığında, değer yerine referans kopyalama yapılır. Böylece orijinal ya da referans değişkeni bir değişme uğrarsa her iki değişken değeride değişmiş olur.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func main() {<br>    a := 5<br>    b := a<br>    c := &amp;a</pre><pre>    // a = 3<br>    *c = 3</pre><pre>    fmt.Println(a, b, *c)<br>}</pre><p>Yukarıdaki programı çalıştırdığınızda a ve c değişkenlerinin değerinin değiştiğini, ancak b değişkeninin değerinin etkilenmediğini göreceksiniz.</p><p>Fonksiyon ve methodlar parametre olarak referans kabul edebilir. Fonksiyonlara bir parametre gönderildiğinde değişkenin bir kopyası oluşturulur. Ancak parametre referans ise yeni bir kopya oluşturmak yerine değişkenin bellekteki adresi gönderilir. Eğer fonksiyon içinde değişken herhangi bir değişime uğrarsa, fonksiyona aktarılan değişken ya da işlevin çağırıldığı yapı (değişken) da değişime uğrar.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>func (r Rect) setWidth(w float64) {<br>    r.width = w<br>}</pre><pre>func (r *Rect) setHeight(h float64) {<br>    r.height = h<br>}</pre><pre>func main() {<br>    r := Rect{<br>        width:  5.0,<br>        height: 4.0,<br>    }</pre><pre>    r.setWidth(2.0)<br>    r.setHeight(3.0)</pre><pre>    fmt.Printf(&quot;%+v&quot;, r)<br>}</pre><p>Yukarıdaki örnekte setWidth değer olarak uyguladığı için, işleve uygulanan yapının bir kopyası oluşturulur. İşlev içinde width değeri değiştirilse de bu çağrıyı gerçekleştiren yapıda bir değişime neden olmaz.</p><p>Ancak setHeight referans olarak uygulandığı için, yapının yeni bir kopyası yerine refeansı aktarılır. İşlev gövdesinde height değeri değiştiğinde çağrıyı gerçekleştiren yapıda etkilenir.</p><p>Programı çalıştırıp sonucu gözlemleyebilirsiniz.</p><h3>Interfaces</h3><p>Interfaces yani arayüzler, OOP dünyasında çok yaygın kullanılır. Go, yapı ve işlevlerle birlikte arayüzleri uygular ve sahte bir OOP desteği sunar.</p><p>Nesne yönelimli programlama dillerin aksine, Go’da interface açıkça uygulanmaz. Arayüzün uygulanması için, arayüz içindeki tüm işlevlerin bir yapı üzerinde tanımlanmış olması gerekir. Tüm işlevler oluşturulduğunda, Go arayüz implementasyonunu kabul eder.</p><p>Konuyu anlamak için bir örnek yapalım. Şekiller için alan hesabı yapan bir programa ihtiyacınız olduğunu düşünün. Her şekil için alan hesabı formülü farklıdır. Daha önce diktörtgen için alan hesabı yapmıştık ancak bu daire için uyumlu değil. Arayüz uygulayarak hem dikdörtgen, hem daire hem de gelecekteki diğer şekiller için destek veren bir program gerçekleştirelim.</p><pre>type Shaper interface {<br>    Area() float64<br>}</pre><p>Yukarıdaki Shaper arayüzümüz bir adet işlev içermektedir. Go dilinde anlamlı olsun ya da olmasın arayüz isimlerinin er ile bitmesi önerilmektedir. Arayüzler, sıfır, bir ya da çok sayıda işlev içerebilir.</p><p>Daha önce oluşturduğumuz Rect yapısı için bu arayüzü uygulayalım.</p><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>func (r Rect) Area() float64 {<br>    return r.width * r.height<br>}</pre><p>Oluşturduğumuz Rect yapısı artık Shaper arayüzünün koşullarını yerine getirdiği için arayüz başarıyla uygulanmıştır. Dilerseniz test edelim:</p><pre>func main () {<br>    var r Shaper = Rect{<br>        width:  5.0,<br>        height: 4.0,<br>    }<br> <br>    fmt.Printf(&quot;type of r is %T\n&quot;, r)<br>    fmt.Printf(&quot;value of r is %v\n&quot;, r)<br>    fmt.Printf(&quot;value of r area is %.2f\n\n&quot;, r.Area())<br>}</pre><p>Örnekte Shaper tipli yeni bir değişken oluşturmak istediğimizde derleyici bu isteğimize izin verdi. Eğer Rect yapısı, arayüz kurallarını yerine getirmemiş olsaydı derleyici isteğimizi reddecek ve hata fırlatacaktı.</p><p>Fonksiyonlar, arayüz tipini parametre tipi olarak kabul edebilir. Bu özellik sayesinde daha esnek (genişlemeye müsait) programlar yazabiliriz.</p><p>Yeni bir tane daire yapısı oluşturup arayüzü uygulayalım:</p><pre>type Circle struct {<br>     radius float64<br>}</pre><pre>func (c Circle) Area() float64 {<br>    return 3.14 * c.radius * c.radius<br>}</pre><p>Ve son olarak hesaplamayı gerçekleştiren Calculator fonksiyonumuzu yazalım. Eğer arayüzler olmasaydı farklı iki türdeki (rect ve circle) şekil yapısını aynı fonksiyonda işlemek mümkün olmazdı.</p><pre>func Calculator(s Shaper) float64 {<br>    return s.Area()<br>}</pre><p>Sizinde farkettiğiniz gibi, fonksiyon parametre olarak Shaper tipinde bir değişken kabul ediyor. Böylece Shaper arayüzünü uygulayan her değişken Calculator fonksiyonuna parametre olarak gönderilebilir.</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>type Shaper interface {<br>    Area() float64<br>}</pre><pre>func Calculator(s Shaper) float64 {<br>    return s.Area()<br>}</pre><pre>type Rect struct {<br>    width  float64<br>    height float64<br>}</pre><pre>type Circle struct {<br>    radius float64<br>}</pre><pre>func (r Rect) Area() float64 {<br>    return r.width * r.height<br>}</pre><pre>func (c Circle) Area() float64 {<br>    return 3.14 * c.radius * c.radius<br>}</pre><pre>func main() {<br>    r := Rect{width: 5.0, height: 4.0}<br>    c := Circle{radius: 3.0}</pre><pre>    fmt.Printf(&quot;rect area is %.2f\n\n&quot;, Calculator(r))<br>    fmt.Printf(&quot;circle area is %.2f\n\n&quot;, Calculator(c))<br>}</pre><p><a href="https://play.golang.org/p/aKb6nmePiL_L">The Go Playground</a></p><p>Go çekirdeğinde, çok sayıda ön tanımlı arayüz vardır, hatta arayüzler çok sık kullanılır. Zaman zaman geliştirdiğimiz programlarda çekirdek arayüzleri uygularız.</p><p>Daha fazla esneklik kazandırmak için fonksiyonlara ya da işlevlere parametre olarak yapı türü tanımlamak yerine, arayüz türü tanımlarız. Böylece yapı her ne olursa olsun, fonksiyon tanıdığı türde bir arayüz kabul eder.</p><p>Özetle:</p><ul><li>Arayüz isimlendirirken er son ekiyle bitmesi önerilir.</li><li>Arayüzler sıfır, bir ya da çok sayıda işlev içerebilir. İşlevler, yapılar için tanımlanan fonksiyonlardır.</li><li>Arayüz işlevleri parametreli ya da parametresiz olabilir.</li><li>Arayüz işlevleri geriye sıfır, bir ya da çok sayıda değer döndürebilir.</li><li>Yapılar bir ya da çok sayıda arayüzü uygulayabilir. Büyük bir arayüz tanımlamak yerine, arayüzleri ortak amaca uygun olacak şekilde parçalamak daha doğrudur. (ReadWriter yerine iki ayrı Reader ve Writer arayüzleri)</li></ul><blockquote>Büyük uygulamalar sürekli gelişir ve değişime uğrar. Arayüzler doğru kullanıldığında, gelecekteki ihtiyaçlar daha az eforla kolayca karşılanabilir. Her zaman esnekliğe özen gösterin.</blockquote><p><a href="https://en.wikipedia.org/wiki/Dependency_injection">Dependency Injection</a> konusunu araştırmanızı öneririm.</p><h3>Packages</h3><p>Yazının henüz başında, Go uygulamaları paketler aracılığıyla modüler olarak geliştirildiğinden bahsetmiştik.</p><p>Lego’yu hatırlayın. Paketler Lego’nun farklı birer parçasıdır. Parçaları bir araya getirerek hayalinizdeki harika evi hatta çok büyük kasabayı kolayca inşa edebilirsiniz. Parçalar birbirinden bağımsızdır ve yeniden kullanılabilirdir.</p><p>Go’da paketlerde öyle. Her bir birinden bağımsız yetenekler içerir ve bir kere yazdığınızda tekrar tekrar kullanabilirsiniz. Hatta açık kaynak olarak servis edebilirsiniz. Paketler farklı kaynaklardan (yerel veya uzak sunucudan) içe aktarılabilir:</p><ul><li>“fmt”</li><li>“math/rand”</li><li>“github.com/guptarohit/asciigraph”</li></ul><p>Kural olarak, paket adı içe aktarma yolunun son öğesiyle aynıdır. Ancak bu bazen farklılık gösterebilir. Özel durumlar paket kullanım kılavuzunda belirtilir. Yukarıdaki paketlerin içe aktarıldığında isim uzayları:</p><ul><li>fmt</li><li>rand</li><li>asciigraph</li></ul><p>olacaktır.</p><p>İhtiyacınız olan paketleri Github, Gitlab, Bitbucket gibi kod servis sitelerinden araştırabilirsiniz.</p><h4>Paket İndirme</h4><p>Go, paket yöneticisiyle birlikte gelir. İhtiyaç duyduğunuz paketleri go get komutu ile kolayca indirebilirsiniz. İndirdiğiniz paketi import deyimi ile programınızda içe aktarıp kullanabilirsiniz.</p><p>Terminali açın, çalışma dizinine girdikten sonra ve aşağıdaki komutu yazın:</p><pre>go get github.com/guptarohit/asciigraph</pre><p>İndirme işlemi tamamlandıktan sonra paket kullanıma hazır hale gelecektir. Paket açıklamalarında bulunan bir örneği kullarak paket kullanımını görelim:</p><pre>package main</pre><pre>import (<br>    &quot;fmt&quot;<br>    &quot;github.com/guptarohit/asciigraph&quot;<br>)</pre><pre>func main() {<br>    data := []float64{3, 4, 9, 6, 2, 4, 5, 8, 5, 10, 2, 7, 2, 5, 6}<br>    graph := asciigraph.Plot(data)</pre><pre>    fmt.Println(graph)<br>}</pre><p>Gayet basit. İhtiyaca uygun paketi go get ile geliştirme ortamına indir ve import ile projeye dahil ederek kullanmaya başla.</p><p>Bazen paket isimleri birbiriyle çakışabilir veya paket ismini takma bir ad ile kullanmak isteyebilirsiniz. Bu durumda paketi import ederken isminin başına takma ad eklemek yeterli olacaktır. Aşağıdaki örneği inceleyelim:</p><pre>package main</pre><pre>import (<br>    &quot;fmt&quot;<br>    rnd &quot;math/rand&quot;<br>)</pre><pre>func main() {<br>    n := rnd.Int()</pre><pre>    fmt.Println(n)<br>}</pre><p>Paket adı rand olmasına rağmen rnd olarak kullanacağımızı bildirdik. Artık paket içindeki işlevleri çağırırken rand.Int() yerine rnd.Int() kullanmamız gerekiyor.</p><p>Son olarak paketleri içe aktarırken . (nokta) operatörünü kullanalım. Paket adının hemen önüne nokta operatörü eklendiğinde, paketin dışa açık olan tanımlayıcıları sanki geçerli pakete aitmiş gibi kullanılabilir.</p><pre>package main</pre><pre>import (<br>    &quot;fmt&quot;<br>    . &quot;math/rand&quot;<br>)</pre><pre>func main() {<br>    n := Int()</pre><pre>    fmt.Println(n)<br>}</pre><p>Artık rand paketi içindeki tanımlayıcılar herhangi bir paket adı olmadan çağırılabilir. Sadece Int() olarak kullanılabilir.</p><p>Nokta operatörü, tanımlayıcının hangi pakette olduğunu gizlediği için çok tercih edilmez.</p><h4>Paket Oluşturma</h4><p>Go’da paket oluşturmak çok kolay. Hemen basit bir örnek yapalım. Çalışma alanında funding isminde bir klasör oluşturun ve içine fund.go dosyası oluşturun. Aşağıdaki örnek kodları yazarak kaydedin.</p><pre>package funding</pre><pre>type Fund struct {<br>    balance int<br>}</pre><pre>func NewFund(initial int) *Fund {<br>    return &amp;Fund{<br>        balance: initial,<br>    }<br>}</pre><pre>func (f *Fund) Balance() int {<br>    return f.balance<br>}</pre><pre>func (f *Fund) Withdraw(amount int) {<br>    f.balance -= amount<br>}</pre><p>Hepsi bu kadar. Go, main paketinin dışında olduğu için derlenme zamanında bu kodları yerel paket olarak anlayacak. Kullanmak istediğiniz yerde içe aktarıp, dışa aktarılan tüm tanımlayıcılara erişebilirsiniz. İçe aktarmak için:</p><pre>import &quot;PROJE-ADI/funding&quot;</pre><p>Yukarıdaki örnekte PROJE-ADI yazan yere, proje oluştururken isimlendirdiğiniz kendi projenizin adını yazmalısınız.</p><p>Dilerseniz bu basit paketi kod servislerine (Github) yükleyerek sürümleyebilir (git, svn) ve ihtiyacınız olduğunda go get ile indirebilirsiniz.</p><blockquote>Daha fazlası için <a href="https://blog.golang.org/using-go-modules">Go Modules</a> ve <a href="https://golang.org/doc/gopath_code.html">How to Write Go Code</a> dokümanlarını mutlaka inceleyin.</blockquote><h3>Testing</h3><p>Geliştirmesi tamamlanan uygulama sıkı testlerden geçti ve her şey yolunda olduğu için dağıtıma hazır hale geldi. Dağıtımdan sonra yeni bir özellik eklemek istedik. Geliştirmeyi tamamladık ve yeniden test ettik. Bu döngü her geliştirme sonrasında tekrarlanmalı.</p><p>Sürekli her şeyi insan gücüyle kontrol etmek çok zor olmaz mı? Her geliştirme sonrasında geliştirmenin bir yeri etkileyip etkilemediğini kontrol etmek için uygulama en baştan (bütünüyle) test edilmeli. Gelişen uygulamada test edilecek özelliklerin sayısı sürekli artacak.</p><p>Yazılım madem sorun çözmek için var, neden bunu otomatik hale getirmiyoruz? Go zaten gömülü bir test paketi sunuyor.</p><p>Bir önceki bölümde oluşturduğumuz paket için test senaryolarını yazarak hızlıca test paketine göz atalım.</p><p>Go’da test edilecek dosya funding.go ise test dosyasının funding_test.go olarak isimlendirilmesi önerilir. Test işlemlerini yürüten araç *_test.go dosyalarını keşfeder ve bu dosya içindeki test metodlarını çalıştırır.</p><pre>package funding</pre><pre>import &quot;testing&quot;</pre><pre>func TestNewFund(t *testing.T) {<br>    f := NewFund(5)</pre><pre>    if f.Balance() != 5 {<br>        t.Error(&quot;Balance değeri hatalı&quot;)<br>    }<br>}</pre><p>Yukarıdaki örnekte NewFund fonksiyonu test edildi. Test edilecek öğenin isminin başına Test öneki eklemek yeterli. Bu yüzden, NewFund fonksiyonu için TestNewFund isminde yeni bir test fonksiyonu tanımladık. Başlangıçta yapıya atanan değerin doğruluğu test ediyor.</p><p>Testi çalıştırmak için go test aracı kullanılır. Bir dosyayı ya da uygulama/paket içindeki tüm testleri çalıştırabilirsiniz. Çalışma dizininde aşağıdaki komutu çalıştırdığınızda tüm testler çalıştırılır.</p><pre>go test ./...</pre><p>Eğer bir tek dosya için testi çalıştırmak isterseniz ./... yerine çalıştırmak istediğiniz Go doyasını yazmanız yeterli.</p><pre>go test ./funding</pre><p>Testleri bir kaç senaryoda test etmek isteyebilirsiniz:</p><pre>package funding</pre><pre>import &quot;testing&quot;</pre><pre>func TestNewFund(t *testing.T) {<br>    testPairs := []struct {<br>        set int<br>        get int<br>    }{<br>        {0, 0},<br>        {5, 5},<br>    }</pre><pre>    for _, p := range testPairs {<br>        f := NewFund(p.set)</pre><pre>        if f.Balance() != p.get {<br>            t.Errorf(&quot;Sonuç: %d, Beklenen: %d&quot;, f.Balance(), p.get)<br>        }<br>    }<br>}</pre><p>Yukarıdaki örnekte testPairs adında test senaryolarını tutan yeni bir yapı oluşturduk. Başlangıçta yüklediğimiz değeri set ve geri almak istediğimiz değeri get adıyla sakladık. Döngü ile tümünü uygulayıp sonucun aynı olup olmadığını test ettik.</p><p>Paket içindeki tüm fonksiyonlar için test senaryoları hazırlayarak her birimi test edebiliriz.</p><pre>package funding</pre><pre>import &quot;testing&quot;</pre><pre>testPairs := []struct {<br>    i int // ilk değeri<br>    w int // çekim miktarı<br>    b int // kalan<br>}{<br>    {0, 0, 0},<br>    {0, 5, -5},<br>    {10, 10, 0},<br>    {10, 0, 10},<br>    {10, 5, 5},<br>}</pre><pre>func TestFund(b *testing.B) {<br>    for _, p := range testPairs {<br>        f := NewFund(p.i)</pre><pre>        f.Withdraw(p.w)</pre><pre>        if fund.Balance() != 0 {<br>            t.Errorf(&quot;Sonuç: %d, Beklenen: %d&quot;, f.Balance(), p.b)<br>        }<br>    }<br>}</pre><p>Yukarıda senaryoyu tek seferde test eden genel bir test yazdık. Böylece tüm akışı tek bir test fonksiyonunda test etmiş olduk. Genelde testler birime özel yazılsa da bazen senaryo bütünüyle test edilebilir.</p><p>Daha fazlası için <a href="https://golang.org/pkg/testing/">paket paketi</a> belgelerini ziyaret edebilirsiniz.</p><h3>Kapanış</h3><p>Gelişmeleri yakından takip etmek ve Go hakkında daha fazlasını öğrenmek için aşağıdaki bağlantıları takip edebilirsiniz:</p><ul><li><a href="http://tour.golang.org/">The Go Tour</a> en iyi başlangıç noktasıdır.</li><li>Etkili kodlama için <a href="https://golang.org/doc/effective_go.html">Effective Go</a> harika ipuçlar içerir.</li><li>Sık kullanılan dahili paketler <a href="https://golang.org/pkg/">standard library</a> üzerinde belgelenmiştir.</li><li>Basit örnek programlar <a href="http://play.golang.org/">Go Playground</a> üzerinden çalıştırılabilir.</li><li>Twitter’da <a href="https://twitter.com/hashtag/golang">#golang</a> etiketini takip edin.</li><li>Duyurulardan haberdar olmak için <a href="https://groups.google.com/group/golang-announce">golang-announce</a> grubuna abone olun.</li></ul><p>Sevgiyle kalın.</p><p>Yorum bölümünden yazıyla ilgili eleştirilerinizi paylaşabilirsiniz. Eksik veya hatalı olduğunu düşündüğünüz yerleri belirtmekten çekinmeyin.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c31ab87eb67c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/i%CC%87yi-programlama/golang-c31ab87eb67c">Sıfırdan “Go”!</a> was originally published in <a href="https://medium.com/i%CC%87yi-programlama">İyi Programlama</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go: Sort (Sıralama)]]></title>
            <link>https://medium.com/@sercancakir/go-s%C4%B1ralama-92df90734928?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/92df90734928</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[türkçe-yayın]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[sorting]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Thu, 27 Feb 2020 20:35:23 GMT</pubDate>
            <atom:updated>2020-02-29T19:30:17.141Z</atom:updated>
            <content:encoded><![CDATA[<p>Bilgisayar biliminde farklı sıralama algoritmaları vardır. Bazen yeni bir sıralama fonksiyonu yazmak yerine, hali hazırda uygulanmış çözümlere güvenmek daha iyidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1GDpx9kAnD9tIaXHv2dYFQ.png" /></figure><p>Bu yazı sonunda, Go’da bulunan dahili sort paketinin nasıl kullanılacağını öğreneceğiz.</p><h3>Dizilerin Sıralanması</h3><p>Go, basit verilerden oluşan dizileri sıralamanıza olanak tanıyan bazı sıralama fonksiyonları ile gelir. Bu fonksiyonları kullanarak int, string ve float64 türündeki dizileri <strong>artan mod</strong> (A’dan Z’ye, 0&#39;dan 9&#39;a) sıralayabilirsiniz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8ae8f9e5ee887b06325f727208e1511d/href">https://medium.com/media/8ae8f9e5ee887b06325f727208e1511d/href</a></iframe><p>Tanımladığımız sayı dizisine herhangi bir işlem uygulamadan ekrana yazdırdığımız için, dizi elemanları olduğu gibi çıktılanacaktır:</p><pre>[4, 3, 1, 2, 5]</pre><p>Diziyi sıralamak için <a href="https://golang.org/pkg/sort">sort</a> paketini kullanalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/560d93d0ebaf1534bdb369abe1aea9bd/href">https://medium.com/media/560d93d0ebaf1534bdb369abe1aea9bd/href</a></iframe><p>Dizi elemanlarını sıralamak için sort.Ints fonksiyonuna []int tipindeki bir parametre uyguladık.</p><pre>[1, 2, 3, 4, 5]</pre><p>Ön tanımlı dizi sıralama fonksiyonları ve kabul ettikleri veri tipleri için aşağıdaki tabloyu inceleyelim. Tablo altındaki linkte, tüm fonksiyonlar için örnek program yer almaktadır.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/da74d94e473d0085d761e6e921e629df/href">https://medium.com/media/da74d94e473d0085d761e6e921e629df/href</a></iframe><h3>Özel Karşılaştırıcı ile Sıralama</h3><p>Bu bölümde, özel karşılaştırıcı fonksiyonları kullanacağız. Dahili fonksiyonlar ile dizi elemanlarını sadece <strong>artan mod</strong> sıralayabiliyoruz. Ancak ya azalan mod (Z’den A’ya, 9&#39;dan 0&#39;a) sıralamaya ihtiyacımız varsa ne yapacağız?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d9ac047034dc9f8ed0b48bd4b642aad/href">https://medium.com/media/1d9ac047034dc9f8ed0b48bd4b642aad/href</a></iframe><p>Yukarıdaki programda, <a href="https://golang.org/pkg/sort/#Slice">sort.Slice</a> fonksiyonuna basit bir closure fonksiyon uyguladık. Go, bu fonksiyonu kullanarak sıralama işlemini gerçekleştirecek. Programın çıktısı:</p><pre>[5 4 3 2 1]</pre><p>İfade içinde &gt; operatörü ile sıralama modu azalan olarak belirledik. Modu artan olarak belirlemek için &lt; operatörünü kullanabiliriz. Bir diğer yöntem, karşılaştırılacak değişkenlerin yerleri de değiştirebilir. Bu konu hakkında daha fazla bilgi için <a href="https://en.wikipedia.org/wiki/Comparison_sort">Comparison Sort</a> sayfasına göz atabilirsiniz.</p><p>Biraz daha karmaşık veri türü olan struct tipi sort.Slice fonksiyonu ile sıralanabilir. Yapı içinde yer alan herhangi bir anahtarı kullanarak sıralama işlemi yapabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/daf158d86f8d07bbb21986fd4011bf40/href">https://medium.com/media/daf158d86f8d07bbb21986fd4011bf40/href</a></iframe><p>Programı çalıştırdığımızda, dizi Name ve Age değerlerine göre ayrı ayrı sıralanmış halleri ekrana yazdırılacak:</p><pre>By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]<br>By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]</pre><p>Go, sort.Slice fonksiyonu her uygulandığında, değişkenin ilk haline göre yeniden sıralama algoritmasını çalıştırır. Mevcut sıralanmış durumu korumak istersek sort.SliceStable fonksiyonunu kullanabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4b143122a60bafe75642019a2cee9040/href">https://medium.com/media/4b143122a60bafe75642019a2cee9040/href</a></iframe><p>Dizi önce Name değerine göre sıralanır, daha önce bir sıralama yapılmadığı için korunacak bir durum yok. Bir sonraki sıralama işleminde ise Age değerine göre sıralama yapılırken, bir önceki sıralanmış durum korunur. Programın çıktısı şöyle olacaktır:</p><pre>By name: [{Alice 25} {Alice 75} {Alice 75} {Bob 75} {Bob 25} {Colin 25} {Elizabeth 75} {Elizabeth 25}]<br>By age, name: [{Alice 25} {Bob 25} {Colin 25} {Elizabeth 25} {Alice 75} {Alice 75} {Bob 75} {Elizabeth 75}]</pre><p>Bu programı sort.Slice fonksiyonu ile deneyerek farklı durumlarda nasıl sonuçlar üretildiğini gözlemleyin.</p><h3>Özel Veri Yapılarını Sıralama</h3><p>Go, sort.Sort ve sort.Stable fonksiyonları ile özel veri yapılarını sıralamayı mümkün kılar. Bu fonksiyonlar, <a href="https://golang.org/pkg/sort/#Interface"><strong>Sort.Interface</strong></a> arabirimini uygulayan herhangi bir koleksiyonu parametre olarak kabul eder.</p><p>Bu bölümde, özel veri yapılarını nasıl sıralayacağımızı öğreneceğiz. Öncelikle Person yapımızı oluşturalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fb2b6a3021a0d494506ce32b96a4180e/href">https://medium.com/media/fb2b6a3021a0d494506ce32b96a4180e/href</a></iframe><p>Sıralanacak veri bir koleksiyon (dizi) olmalı. O halde People isimli Person dizisi oluşturalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d50e641a6d5b33ec7d118081e6c213e3/href">https://medium.com/media/d50e641a6d5b33ec7d118081e6c213e3/href</a></iframe><p>People tipine <a href="https://golang.org/pkg/sort/#Interface">Sort.Interface</a> arabirimini uygulayalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb5605767f125b53d59abf7977f16b5d/href">https://medium.com/media/eb5605767f125b53d59abf7977f16b5d/href</a></iframe><p>İşte bu kadar. Artık People tipindeki herhangi bir koleksiyon Age değerine göre artan mod sıralama yeteneğine sahip.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/01a6aab17e73e9fa1c995d16b53bc2a4/href">https://medium.com/media/01a6aab17e73e9fa1c995d16b53bc2a4/href</a></iframe><p>Programın çıktısı:</p><pre>unsorted: [{Gopher 7} {Alice 55} {Vera 24} {Bob 75}]<br>sorted: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]</pre><p>Eşit öğelerin orijinal sırasını korumak için sort.Sort yerine sort.Stable fonksiyonunu kullanabiliriz.</p><h3>Sıralama Kontrol</h3><p>Programda bir dizinin sıralı olup olmadığını tespit etmek istediğimizde, paket içindeki hali hazırda sıralama kontrol fonksiyonlarını kullanabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9c9f15a348f4e3b72832bdbaeb185db0/href">https://medium.com/media/9c9f15a348f4e3b72832bdbaeb185db0/href</a></iframe><p>Kontroller sadece artan modda sıralanmış diziler üzerinde gerçekleştirir. Bir dizi azalan modda sıralı olsa dahi, Go bunu sıralı kabul etmez.</p><p>Yukarıdaki programı çalıştırdığımızda, sadece artan modda sıralı olan dizinin sıralanmış kabul edildiğini göreceğiz:</p><pre>true<br>false<br>false</pre><p>Ön tanımlı sıralama kontrol fonksiyonları ve kabul ettikleri veri tipleri için aşağıdaki tabloyu inceleyelim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/043271016dc585cb9ef32ae2f595677b/href">https://medium.com/media/043271016dc585cb9ef32ae2f595677b/href</a></iframe><h3>Sonuç</h3><p>Bu yazıda, Go uygulamalarında sort paketini nasıl uygulayacağımızı öğrendik. Sıralama fonksiyonları ile basit verileri ve özel sıralama işlevleri ile karmaşık veri yapılarını sıraladık.</p><h3>Kaynaklar</h3><ul><li><a href="https://golang.org/pkg/sort/">https://golang.org/pkg/sort/</a></li><li><a href="https://gobyexample.com/sorting">https://gobyexample.com/sorting</a></li><li><a href="https://gobyexample.com/sorting-by-functions">https://gobyexample.com/sorting-by-functions</a></li><li><a href="https://en.wikipedia.org/wiki/Comparison_sort">https://en.wikipedia.org/wiki/Comparison_sort</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92df90734928" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simple Factory Pattern]]></title>
            <link>https://medium.com/@sercancakir/design-patterns-simple-factory-669087049cc?source=rss-6a1776b2d759------2</link>
            <guid isPermaLink="false">https://medium.com/p/669087049cc</guid>
            <category><![CDATA[factory-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[php]]></category>
            <dc:creator><![CDATA[Sercan Çakır]]></dc:creator>
            <pubDate>Sat, 17 Nov 2018 14:46:53 GMT</pubDate>
            <atom:updated>2020-10-04T22:25:18.481Z</atom:updated>
            <content:encoded><![CDATA[<p>Simple Factory, basit fabrika tasarım (kalıbı) desenidir ve tasarım desenleri ailesinin yaratışsal (creational) kategorisinde yer alır. Fabrika tasarım deseni, bir kaç farklı kullanıma sahiptir ve basit fabrika bunlardan biridir.</p><p>Bir nesne yaratımındaki gerçek mantığı gizlemek için kullanılan soyutlama (abstraction) biçimidir. Bu fabrika tasarım deseninin genel amacıdır.</p><p>Basit fabrikalar, talep edilen nesneyi oluşturmak ve iade etmekle sorumludur. İstemci (client) oluşturulacak nesnenin yaratışsal (örnekleme) karmaşıklığı ile ilgilenmez ve bunu hiç umursamaz. İstemci, fabrikadan çıkacak ortak arayüze (interface) sahip nesneyi tüketmeye (kullanmaya) odaklanır.</p><p>Hadi başlayalım.</p><p>Öncelikle somut sınıfların uygulayacağı ortak arayüz oluşturalım. Daha sonra fabrikaya sadece bu türde bir nesne oluşturmasını söyleyeceğiz.</p><pre>namespace DesignPatterns\Creational\SimpleFactory;</pre><pre>interface SocialMediaInterface<br>{<br>    <em>/**<br>     * Get the latest feed messages.<br>     *<br>     * @param  int  $count<br>     * @return array<br>     */</em><br>    public function feed(int $count): array;<br>}</pre><p>Bu arayüzü uygulayan somut sınıflarımızı oluşturalım.</p><pre>namespace DesignPatterns\Creational\SimpleFactory;</pre><pre>class Facebook implements SocialMediaInterface<br>{<br>    <em>/**<br>     * {@inheritdoc}<br>     */</em><br>    public function feed(int $count): array<br>    {<br>        $messages = [&#39;foo&#39;, &#39;bar&#39;, &#39;baz&#39;, &#39;qux&#39;, &#39;quux&#39;];<br>        <br>        return array_slice($messages, 0, $count);<br>    }<br>}</pre><p>Yeni bir tane daha somut sınıf oluşturalım.</p><pre>namespace DesignPatterns\Creational\SimpleFactory;</pre><pre>class Twitter implements SocialMediaInterface<br>{<br>    <em>/**<br>     * {@inheritdoc}<br>     */</em><br>    public function feed(int $count): array<br>    {<br>        $messages = [&#39;lorem&#39;, &#39;ipsum&#39;, &#39;dolor&#39;, &#39;sit&#39;, &#39;amet&#39;];<br>        <br>        return array_slice($messages, 0, $count);<br>    }<br>}</pre><p>Sıra geldi fabrikayı oluşturmaya. Daha önceden de söylediğimiz gibi, fabrikalar istemciye yaratışsal sorunları ve karmaşıklığı göstermez. O halde, bir parametre kabul edelim ve bu parametreye uygun ortak arayüzlü bir nesne dönelim. Eğer fabrikanın desteklemediği bir şey talep edilirse Exception fırlatarak istemciyi uyaralım.</p><pre>namespace DesignPatterns\Creational\SimpleFactory;</pre><pre>class SocialMediaFactory<br>{<br>    <em>/**<br>     * The list of products supported by the factory.<br>     * <br>     * @var array <br>     */</em><br>    protected $networks = [<br>        &#39;twitter&#39; =&gt; Twitter::class,<br>        &#39;facebook&#39; =&gt; Facebook::class,<br>    ];<br>    <br>    <em>/**<br>     * Make a new concrete class for the given type.<br>     *<br>     * @param  string  $type<br>     * @return SocialMediaInterface<br>     * <br>     * @throws \InvalidArgumentException <br>     */</em><br>    public function make(string $type): SocialMediaInterface<br>    {<br>        if (array_key_exists($type, $this-&gt;networks)) {<br>            $class = $this-&gt;networks[$type];<br>            <br>            return new $class();<br>        }<br>        <br>        throw new \InvalidArgumentException(&quot;The [{$type}] type is not supported!&quot;);<br>    }<br>}</pre><p>Harika, iki adet somut sınıfımızı fabrikaya tanıttık. Eğer tanımsız bir tip gönderirsek hata oluşacağını da biliyoruz.</p><pre>use DesignPatterns\Creational\SimpleFactory\SocialMediaFactory;</pre><pre>$factory = new SocialMediaFactory();</pre><pre>$network = $factory-&gt;make(&#39;twitter&#39;);</pre><pre>$messages = $network-&gt;feed(3);</pre><pre>var_dump($messages);</pre><pre><em># Çıktı: lorem, ipsum, dolor</em></pre><p>Bir nesne talebine fabrika başarılı yanıt verdiğinde nesneyi oluşturup iade eder. İstemci, kendisinin kullanımına izin verilen metodları (örneğimize göre feed) kullanabilir durumdadır.</p><p>Fabrikamızın testini yazmamız gerekirse;</p><pre>namespace DesignPatterns\Creational\SimpleFactory;</pre><pre>use PHPUnit\Framework\TestCase;</pre><pre>class SocialMediaFactoryTest extends TestCase<br>{<br>    protected $factory;</pre><pre>    protected function setUp()<br>    {<br>        $this-&gt;factory = new SocialMediaFactory();<br>    }<br>    <br>    public function getNetworkTypes(){<br>        return [<br>            [&#39;facebook&#39;],<br>            [&#39;twitter&#39;],<br>        ];<br>    }<br>    <br>    <em>/**<br>     * @dataProvider getNetworkTypes<br>     */</em><br>    public function testCanCreateConcreteClass($type)<br>    {<br>        $network = $this-&gt;factory-&gt;make($type);</pre><pre>        $this-&gt;assertInstanceOf(SocialMediaInterface::class, $network);<br>    }</pre><pre>    <em>/**<br>     * @expectedException InvalidArgumentException<br>     */</em><br>    public function testCanThrowException()<br>    {<br>        $this-&gt;factory-&gt;make(&#39;undefined&#39;);<br>    }<br>}</pre><p>Sevgiyle kalın.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=669087049cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>