Veri Tipleri ve Değişkenler

Değişkenler konusuna geldiğimizde değişkenlerin ne olduğunu anlatmadan önce veri tiplerinin ne olduğunu anlamak zorundayız. GoLang’de temel olarak 4 tane veri tipi bulunur. Bunlar;

• string
• int
• float
• bool

olarak sıralanabilir.

>>> string veri tipleri, sadece Metinsel ifadeleri tutmaya yarar. Örnek vermek gerekirse “Cyber Worm” ifadesi string bir ifadedir; çünkü metinseldir. Bu metinsel ifadeler kodlama yaparken tırnak içerisine alınmalıdır. Aksi hâlde hata yemek kaçınılmazdır.

>>> int veri tipleri, sadece sayısal değerleri ifade eder. Fakat sayısaldan kastımız tam sayılardır. Yani bir int veri tipi içerisinde tam sayıdan başka bir şey tutamazsınız. Örneğin 32, 90, 19832 gibi. Bu veri tipinde tırnak işaretine gerek yoktur, sadece sayıyı yazmanız yeterlidir. Eğer sayıyı tırnak içerisinde yazarsanız, yazmış olduğunuz şey sayı bile olsa string olarak algılanacaktır.

>>> float veri tipleri, int gibi sayısal verileri tutar ama tam sayı yerine virgüllü (kesirli) sayıları kabul eder. Örneğin 10.42, 100.01, 34122.235 gibi.

>>> bool veri tiplerinin ise alabileceği maksimum iki değer vardır. Bu değerler 'true' veya 'false' olarak geçer. Bool veri tipleri bize, bir şeyin doğruluğu veya yanlışlığı, varlığı veya yokluğu gibi mantıksal kararlarda çok yardımcı olur. Bir şey eğer varsa veya doğruysa 'true', yoksa veya yanlışsa 'false' değer döndürmemiz gerekir. Tam tersi de yapılabilir fakat ileriki zamanlarda kafa karışıklığına sebep olabileceği için önerilmeyen bir harekettir.

Değişkenler, bir değeri saklamak istediğimiz zaman bize yardımcı olan ve proje içerisinde her yerde kullanılabilen değerlerdir; adı üstünde değişkendir. İsimleri, aklınızı karıştırmasın. Matematikteki x = 5 gibi ifadeleri bilirsiniz. Burada ‘x’ değişkendir ve değeri ‘5’tir.

>>> İlk satırda

var name1 string = “Cyber”

şeklinde bir ifademiz mevcut. Bu satırın bize söylemek istediği şey tam olarak: ‘name1’ adında ve ‘string’ veri tipinde bir değişken tanımladın; bu değişkene verdiğin değer ise “Cyber”. Basitleştirecek olursak x = 5 yerine name1 = “Cyber” olmuş oldu.

>>> Eğer burada

var name1 string = 100

demiş olsaydık bir hata ile karşılaşırdık. Çünkü yukarıda da belirttiğimiz gibi ‘string’ tipindeki değişkenler sadece metinsel ifadeleri kabul eder.

>>> Fakat eğer

>>> İkinci satıra baktığımız zaman ‘int’ veri tipinde bir değişken atadığımızı görüyoruz. Bu satırın bize demek istediği şey: ‘age’ adında ve ‘int’ tipinde bir değişken tanımladın; bu değişkenin değeri de ‘29’dur.

>>> Eğer burada

var age int = “29”

şeklinde bir tanımlama yapmış olsaydık hata alırdık. Çünkü ‘int’ tipindeki değişkenler sadece tam sayıları kabul eder. Tırnak içerisine yazılan her değer, string veri tipinde algılanır.

>>> Dördüncü satır için de aynı şekilde düşünebiliriz. Burada da değişen tek şey değişken ve veri tipidir. Bool veri tipinin 'true' ve ‘false’ değer aldığını belirtmiştik. Biz oraya

var isGo bool = true

değerini verdik. Fakat istersek ‘false’ değerini de verebilirdik. Özellikle bool veri tipi için ‘ne işime yarayacak ki’ diye düşünebilirsiniz fakat eğitimin ilerleyen bölümlerinde ne kadar işlevsel bir veri tipi olduğunu çok net bir şekilde kavrayacaksınız.

Detay: bool veri tiplerine true veya false değer atarken tırnak içerisinde yazılmamalıdır. Eğer tırnak içerisinde true veya false yazarsanız artık bu bir bool değil bir string olarak algılanacaktır.

Yeşil kutu içerisindeki kullanım doğru, kırmızı kutu içerisindeki kullanım ise yanlış. Zaten gördüğünüz üzere kırmızı kutudaki “false” değerinin altı çizildi. Yani VS Code bize, burada bir sıkıntı olduğunu söylemek istiyor.

Değişken tanımlarken kesinlikle dikkat etmemiz gereken bazı noktalar var; bunları aşağıda görebilirsiniz.

1. Bir değişken büyük harfle ve sayı ile başlayamaz. Değişkenler ya küçük harfle başlamak zorundadır ya da '_' (alt tire) ile başlamak zorunadır. Bununla birlikte bir değişken hiçbir noktalama işareti veya özel karakter içeremez; sadece alt tire kullanılabilir. Yanlış tanımlanan bazı değişkenler:
   • 1.sayi         >>> hem sayı ile başlamış hem de noktalam işareti mevcut.
   • 5numara    >>> sayı ile başlamış.
   • Numara1   >>> Büyük harf ile başlamış.
2. Bir değişken içerisinde Türkçe karakter kullanmamalıyız. İşin aslı, GoLang UTF-8 ile çalışır yani birçok alfabeyi destekler. Dolayısıyla Türkçe karakter içeren bir değişken atamanız diğer birçok programlama diline karşın mümkündür. Fakat ben bunu önermiyorum. Elbette öğrenme seviyesindeyken yapabilirsiniz ama geliştikçe İngilizce değişkenler atamanızı öneririm. İleride, iş hayatında bir takımınız olduğu zaman ve takım üyeleri farklı ülkelerden olduğu zaman bu sizi dara sokacaktır; kodunuz anlaşılmayacaktır. Bunun yanında İngilizce global bir dil olduğu için tanımlamalarınızı İngilizce olarak yapmanızı önerebilirim.
   • öğrenci1    >>> Türkçe'de bulunan 'ö' ve 'ğ' harfleri mevcut.
   • sayı            >>> Türkçe'de bulunan 'ı' harfi mevcut.
   • değişken    >>> Türkçede bulunan 'ğ' ve 'ş' harfleri mevcut.
3. Değişkenlere mantıklı isimler vermeliyiz. Bunu yapmazsak proje büyüdükçe 'bu neyi ifade ediyor?' tarzında anlaşılmayan kodlara sebep olarak büyük sorunlarla karşılaşılabilir. Bunun yanında bir yazılım şirketine mülakata gittiğiniz zaman sizden belli bir konuyu koda dökmeniz istenebilir. Siz eğer o konuya ait terimleri değişken olarak tanımlamak yerine sayi1, sayi2 gibi değişkenler tanımlarsanız yüksek olasılıkla işe alınmayacaksınız.
   • Üniversiteli öğrenci ders ortalaması hesabı yapan bir program yazdığımızı düşünelim. Bu projede öğrencinin girdiği genelde 1 vize, 1 final ve eğer kalırsa da 1 bütünleme sınavı olur. Buradaki değişkenleri örneğin 'sayi1, sayi2, sayi3' şeklinde tanımlamak çok yanlış olacaktır. Bunun yerine 'vize, final, butunleme' tarzında tanımlamalar yapmak yani gerçekten tanımlayıcı değişkenler yaratmak gerekir.
4. Değişken birden fazla kelime içeriyor olabilir. Böyle durumlarda kelimeler arasında alt tire koymak elzemdir. Alt tire yerine ilk kelimenin ilk harfi haricinde diğer kelimelerin ilk harfi büyük yazılmalıdır.
   • toplamaislemi >>> yanlış değil fakat tercih edilmeyen bir kullanım olacaktır. Bunun yerine aşağıdaki kullanımları deneyebilirsiniz.
     • toplamaİslemi
     • toplama_islemi
5. İngilizce tanımlamalar yapmak daha uygun olabilir.
   • Türkçe karakter kullanmamak koşuluyla Türkçe tanımlamalar yapabiliriz, evet (örneğin 'sayi' veya 'degisken' şeklinde). Fakat bunları ingilizce hâli ile yazmak daha okunabilir bir kod olmasını sağlar. İngilizce, global bir dil olduğu için ve yazılımda halihazırda Türkçe karakter kullanımı yasak olduğu için bu tarz tanımlamalar yapmak daha hoş olacaktır. Böylece hem daha okunabilir bir kod yazmış olacaksınız hem de daha rahat değişken tanımlamaları yapacaksınız.
     • sayi yerine number
     • degisken yerine variable
     • sinav yerine exam şeklinde.

Şimdi, aslında size söylemediğim farklı bir değişken tanımlama şekli de mevcut. Az önce anlattıklarım, mantığı kavramanız ve neyin ne olduğunu iyice öğrenmeniz içindi. Şimdi sıra değişken tanımlamanın ikinci ve kolay yolunu öğrenmeye geldi.

NOT: // işareti tek bir satırı yorum satırına dönüştürür. Yorum satırları derleyici tarafından okunmaz; yani çalıştırılmaz. Bunu yapmamızın sebebi, kodun açıklayıcı olmasını sağlamak ve uzun bir süre sonra ‘Bu kod ne işe yarıyordu ya?’ dememektir. Aynı şekilde /* */ şeklindeki bu ifadede ise yıldızların arasına yazdıklarınız okunmaz. Uzun bir not alacaksanız tavsiye edebilirim. Kısaca, yeşil satırlar okunmayacaktır.

Şimdi, yukarıdaki koda bir göz atalım. Değişken tanımlamanın kısa yolu tam olarak:

>>> <degiskenismi> := <degiskendegeri> şeklindedir. Yani;

>>> age := 29 şeklindedir.

 Peki, biz bu yöntemde hiçbir veri tipi belirtmedik; Go bunu nasıl anlayacak? Çok basit; size söylediğim "string'ler tırnak içerisinde, sayılar normal bir şekilde, float'lar virgüllü şekilde ve bool'lar true-false şeklinde değerler alır." cümlesini aklınıza getirin. Biz zaten veri tipi belirtmeden değişkenin değerini belli bir formatta yazdığımız için Go bunu belli bir formatta algılayacaktır. Çıktıya baktığımızda çıktının değişmediğini, aynı sonucu ürettiğini görebiliriz. Dilerseniz Go'ya hemen çok basit bir toplama işlemi yaptıralım ve gerçekten çalışıp çalışmadığını görelim.

Dikkat ederseniz değişkenlerimizi, ikinci ve basit olan yöntem ile tanımladık. Daha sonra fmt fonksiyonunu kullandık. Burada dikkat etmemiz gereken nokta ‘number1 + number2’ kodudur.

Değişkenleri bir kez tanımladıktan sonra onları birden fazla yerde birden fazla çeşitte kullanabileceğimizi söylemiştik. Lütfen yukarıdaki kodu diğer temel matematik işlemlerini uygulayarak deneyin:

Çarpma: *

Bölme: /

Çıkarma: -

Değişken tanımlamanın iki farklı yolunu öğrendik.

Birincisi: ‘var <degisken> <veri tipi> = <deger>’

İkincisi: ‘<degisken> := <deger>’

Daha farklı değişken tanımlama yolları da mevcut, dilerseniz onlara da bir göz atalım. 

Yalnız, kırmızı kutular ile işaretlediğim kısımlara dikkat ederek kendi tarzınıza uygun tanımlamayı seçebilir ve kullanabilirsiniz. Lütfen hepsini, bir defalığına da olsa deneyin.

Şimdi de, ekrana yazdırma işlemlerimizi inceleyelim. fmt.Println() komutunun ne olduğundan yukarıda bahsetmiştik, eğer unuttuysanız dönüp bakabilirsiniz. Yukarıdaki ekrana yazdırma işlemimiz basit bir şekilde modülün fonksiyonunu çağırıp içine dilediğimizi yazmaktı. Şu an Println() fonksiyonunun aldığı değer, yukarıda tanımladığımız değişken isminin kendisi oldu. Değişkenler sayesinde her seferinde değişkenin değerini yasmak yerine bin satır sonra bile sadece değişkenin ismini yazarak değişkenin değerine ulaşabiliriz.

Ayrıca bin satırlık bir projeniz olduğunu düşünün ve bir değişkeni onlarca yerde kullandığınızı hayal edin. Daha sonra o değişkenin değerini değiştirmeniz gerektiğini düşünün. O değişkeni nerede kullandıysanız tek tek bulup tek tek değiştirmek yerine, değişkeni tanımladığınız satıra gidip sadece oradaki değeri değiştirmeniz, tüm değerleri değiştirmeniz anlamına gelecektir. Örneğin

var name1 string = “Cyber”                 iken

var name1 string = “Cyber Worm”         yazarsanız name1 değişkeninin değeri tüm projede “Cyber Worm” olarak değişecektir.

Yukarıda gördüğünüz gibi sırasıyla 'name1', 'age', 'rank' ve 'isGo' değişkenlerini yazdırabildik. İsterseniz bu çıktıyı daha da güzelleştirebilirsiniz:

Yukarıda görüğünüz, Println() fonksiyonunun daha efektif bir kullanımıdır. Bu şekilde, bir kullanım yaparak daha anlaşılır kodlar yazabilirsiniz Bunu yaparken 'virgül' koymayı lütfen unutmayın. Herhangi bir sorunla karşılaşırsanız Telegram kanalımıza veya Instagram hesabımıza gelip soru sormaktan çekinmeyin.

Güncelleme

Tip Dönüştürme (Type Conversion)

Değişkenlerde veri dönüştürme hakkında konuşmamız gerekiyor. İlk ‘fmt’ fonksiyonumuza yani ‘Int ile int toplamı:’ kısmındaki işleme bakın; bunu zaten açıkladık.

İkinci ‘fmt’ fonksiyonuna bakalım. Burada bir int tipi değişkeni, bir de float tipi değişkeni toplamaya çalıştık fakat küçük mavi kutucuk ile işaretlediğim yere dikkatli bakarsanız ‘f_number’ değişkenimiz, ‘int’ çerçevesine alınmış. Yani ‘int(f_number)’ şeklinde bir kullanım oluşmuş ve ‘number’ ile ‘f_number’ değişkenlerinin toplam değeri ’42.45’ çıkması gerekirken ‘42’ olarak çıkmış. Buradan da anlayabileceğimiz gibi, eğer bir işlemin sonucunun tam sayı çıkmasını istiyorsak float tipindeki değeri int tipine dönüştürmemiz gerekir. Bu dönüşüm, float tipindeki değişken değerinin virgüllü kısmının atılacağı anlamına gelir. Bunun yanında int veri tipini float veri tipine de dönüştürebiliriz. Kafanıza, ‘Ne zaman hangisini dönüştürmem gerekiyor ki?’ şeklinde bir soru takılabilir. Bu sorunun cevabı ‘yerine göre değişir.’ Olacaktır. Örneğin bir banka işlemi yapıyorsunuz. Normalde bakiye değeri virgüllü yani float tipinde olur (1232.25 gibi) ama yatırılan para miktarının tamsayı yani int olduğunu düşünün; bunları nasıl toplayacaksınız?

Örneğin, bakiyemiz 100,25 lira olsun ve bize yatırılacak tutar 200 lira olsun; biri float iken diğeri int veri tipidir. Banka hesabımızda toplam 300,25 lira olmasını bekleriz fakat biri float, diğeri de int iken; nasıl olacak? Float ve int değerlerini toplarsak hata almaz mıyız?

Elbette yukarıdaki gibi sonucun float olması gerekiyorsa int veri tipini float veri tipine dönüştürerek işlem yapmamız lazım. Lütfen yukarıdaki ve bir önceki kodu güzelce inceleyin. Hemen bir özet geçelim: "Eğer sonucun int yani tam sayı olarak gözükmesini istiyorsanız int dışındaki tüm float yapıları int'e dönüştürmelisiniz. Bunu da şöyle yapabilirsiniz: 'int(<degisken>)'. Eğer sonucun virgüllü yani float olarak gözükmesini istiyorsanız float dışındaki tüm int yapılarını float'a dönüştürmelisiniz. Bunu da şöyle yapabilirsiniz: 'float(<degisken>)'"

Bu işlemi kısaca; veritipi(degisken) şeklinde yapmamız gerekir.

En sondaki ‘fmt’ fonksiyonuna baktığımızda ise Go, iki float değerinin toplanmasında herhangi bir mahsur görmedi ve sonuçları yazdırdı.

Şimdi, Stringler bu konuda bize (haklı olarak) biraz sorun yaratıyorlar. Mantıksal açıdan düşündüğümüz zaman iki string değerini yani iki metni toplayabiliriz. Örneğin;

“Cyber Worm” + “Cyber Worm” = Cyber WormCyber Worm şeklinde.

Hatta bu toplama işlemini daha da güzel bir hale getirebiliriz. Bunu, iki string değerinin arasında tırnak işareti içerisinde yazacağımız şeyler ile yapabiliriz; önüne, arkasına da koyabiliriz. Lütfen inceleyin ve uygulayın.

Sorunumuza geldiğimizde ise "normal şartlarda";

• iki string değer için toplama işlemi dışında 4 işlem yapılamaz.
• String ile int için 4 işlem yapılamaz.
• String ile float için 4 işlem yapılamaz.

Bakın, çalıştırdığım zaman aşağıda kırmızı ile işaretlediğim yerde bize söylenen şeyler:

• ‘Geçersiz operasyon: number + text (eşleşmeyen türler; int ve string)’

• ‘Geçersiz operasyon: f_number + text (eşleşmeyen türler; float ve string)’

Hatta hatanın bulunduğu kısma fare imlecimizi götürdüğümde bize, yukarıda söylediğim gibi hatanın sebebini söylüyor. Bu da demek oluyor ki biz "normal şartlarda", string dışındaki bir veri tipi ile bir işlem yapamıyoruz. Aynı zamanda bir string ile bir başka string'i birbiriyle matematiksel açıdan çarpamıyor, bölemiyor ve onları birbirinden çıkaramıyoruz.

'strconv'

Şimdi, neden deminden beri 'normal şartlarda' dediğimi açıklayayım. Biraz daha ileri seviye için uygundur ama string için de 'type conversion' yapılabilir. Yani daha doğrusu diğer veri tiplerini string tipine dönüştürüp bunları toplamak mümkün. Hemen göstereyim:

Yukarıdaki görselde dikkat etmenizi istediğim ilk şey, 'import' kısmıdır. Oraya, 'fmt' için yaptığımız gibi, 'strconv' adında bir kütüphane daha eklemişiz. Bu kütüphane, sayıları string olarak dönüştürmemize olanak sağlar ama biraz karışık gelebilir. Hemen inceleyelim.

Az önce değişkenimizi tanımlama şeklimiz şöyle idi: 'number := 12' 

Fakat biz bu sayıyı string olarak da kullanabilmek, onunla string'i toplamak istiyoruz. Bunun için bu tanımlama işini biraz değiştirerek 'strconv' kütüphanesini kullanıyoruz. Şu anki değişken tanımlama şeklimiz böyle: 'number := strconv.Itoa(12)'. 12 yerine dilediğiniz değeri verebilirsiniz, aklınız karışmasın; basit bir değişken değeri.

Bu tarz bir tanımlama yaptığımız zaman artık 'fmt.Println(number + text)' işlemini yapabilir hâle geliyoruz. Çıktımızı kontrol ettiğimizde de '12Cyber Worm' şeklinde bir çıktımız olduğunu görüyoruz. Yani işlemimiz gerçekten başarılı; bir sayı ile bir string'i toplayabildik. Burada, aslında yerine göre büyük sıkıntı yaratabilecek bir durum var. O da, bir sayıyı bu şekilde tanımladığınız zaman o sayıyı artık başka bir sayı ile toplayamıyorsunuz. Şöyle göstereyim:

Yukarıda iki farklı tanımlama yaptığımızı görüyorsunuz. Üstteki 'number' tanımlamasını 'strconv' ile yaptık, bir altındaki 'number2' tanımlamasını da normal bir şekilde yaptık. fmt.Println(number + number2) diye bir kod yazdığımız zaman normalde bu ikisinin toplanması ve 32 sonucunu vermesi gerekiyordu ama hata aldık. Çıktımıza baktığımız zaman bir açıklama görüyoruz; Türkçesi: "Geçersiz operasyon: number + number2 (uyuşmayan veri tipleri, string ve int)"

Buradan ne anlamamız gerekiyor? 'strconv' ile tanımladığımız bir değişken sayı bile olsa gerçekten de string oluyor. Bu yüzden kodun ilerleyen bölümlerinde bu değişkeni başka bir sayı ile toplayamıyoruz; işte sıkıntı burada başlıyor. Bunu daha esnek bir şekilde kullanmak istersek ne yapmalıyız? Yani tanımladığımız sayıyı hem string hem de normal int olarak kullanabilmek için ne yapmalıyız? Hemen gösterelim:

Dikkat edin, değişkenlerimizi her zaman nasıl tanımlıyorsak o şekilde tanımladım. Daha sonra 'fmt' kısmında geldiğimde 'sadece o anki işleme göre' string olarak algılanmasını istediğim değişkeni 'strconv.Itoa' içerisine yazdım. Yani; 'strconv.Itoa(number)'.

Burada dikkat etmeniz gereken en önemli şey syntax yapısıdır. Parantezler aklınızı kurcalayabilir. fmt.Println() dedikten sonra parantez içerisine, ihtiyacımız olan her şeyi giriyoruz. Fakat strconv kısmına geldiğimizde onun kendi parantezi olduğunu unutmamamız lazım. Zaten parantezler renkli bir şekilde gösterilmiş; aynı renkli parantezler, kapsama alanını belirtir. Yani mor parantezler bütün fmt.Println() kısmını kapsarken mavi parantezler sadece 'number' değişkenini tutuyor.

Bu şekilde tanımlama yaptıktan sonra değişkenimiz string olarak değişmeyecektir; int olarak kalacaktır. Sadece, istediğimiz yerde o int tipindeki değişkeni string olarak kullanabilir duruma geleceğiz. Int tipi olduğunu kanıtlamak açısından 'number2' diye bir değişken daha tanımlayalım ve bu ikisini toplamaya çalışalım.

Çıktıya baktığınız zaman iki çeşit işlemi de yaptığını görüyorsunuz. Yani hem string ile hem de int ile işlem yapabildik.

Şimdi, bu tarz bir dönüşüm işlemi float veri tipleri için de geçerlidir. Hemen bunu da gösterelim:

Burada, yine ilk olarak dikkat etmeniz gereken yer 'import' kısmıdır. Dikkat ederseniz float ile bu tarz bir işlem yaparken 'strconv' kütüphanesi kaldırılıyor. Bunun yerine bu işlemi fmt modülü içerisinde bulunan (Println gibi) Sprint()  fonksiyonu ile yapıyoruz. Yukarıdaki tanımlamaya dikkat edin; az önceki gibi, direkt olarak tek satırda f_number := fmt.Sprint(30.45) olarak tanımladık. Mantık aynı; bu değişkeni bu şekilde tanımlarsanız bu float ile bir başka float'u toplayamazsınız. Çıktıya baktığımızda doğru sonuç verdiğini yani bir float tipi değişken ile string tipi değişkeni toplayabildiğini görüyoruz. Bunu bu şekilde tanımlarsanız dilediğiniz string ile toplayabilirsiniz ama bir başka float ile toplayamazsınız. Hemen görelim:

Bunu test etmek adına 'f_number2' adında bir değişken daha tanımladım ama bu, normal; bizim bildiğimiz şekilde oldu. Aşağıda da 'fmt.Println(f_number + f_number2)' kodunu gerçekleştirmeye çalıştık ama az önceki gibi bir hata ile karşılaştık: "Geçersiz operasyon: f_number + f_number2 (uyuşmayan tipler string ve float64)". Burada da anlamamız gereken şey, direkt olarak Sprint ile tanımlama yaparsak değer normal bir float değeri gibi gözükse de bu her zaman string olarak algılanacaktır. Bunun da esnek hâli vardır:

Veri Tipleri Detaylar (Data Types Details)

Bir yazılım geliştirirken bu yazılımın işlevi kadar verimliliği ve kapladığı yer de bizim için çok önemlidir. Bir yazılımın çok iyi bir işlevi olabilir ama kapladığı yer çoksa ve buna bağlı olarak verimliliği düşükse işte o zaman bir problem vardır. Bunun önüne geçebilmeniz için birçok programlama dilinde var olan veri tipi ayırımları mevcuttur. GoLang için bu ayırımların tamamına https://go.dev/ref/spec#Types adresinden ulaşabilirsiniz. Ben de şimdi birkaç tanesini açıklayacağım.

Yukarıdaki yorum satırlarını, az önce size verdiğim siteden aldım. O siteden daha kapsamlısını bulabilirsiniz. Şimdi, bizim 4 adet; string, int, float ve bool olmak üzere veri tipimiz vardı fakat bunlar bazı işlemler için hafızada boş yer kaplayan veri tipleridir. Bu yüzden örneğin ‘int’ veri tipi için genel olarak 2 ayırım ve o 2 ayırım için de 4’er ayırım gerçekleştirilmiş.

uint > unsigned integer > sadece pozitif tam sayıları kapsar.

int > integer > hem pozitif hem de negatif tam sayıları kapsar.

Tanımladığımız ilk değişken satırına bakmanızı istiyorum. ‘number1’, ‘number2’ ve ‘number3’ adında üç değişken tanımlamışız ve bunların değerlerini sırasıyla 25, 255 ve 256 olarak tanımlamışız. Daha sonra tanımadığımız veri tipine bakın; ‘uint8’. Beyaz kutu ile işaretlediğim değerler, hatalı verilerdir. GoLang bizi bu konuda uyarıyor. GoLang’in bize söylemeye çalıştığı şey tam olarak şudur:

“uint8 veri tipi yalnızca 0 ile 255 arasında değer alabilir ama sen bu aralığın dışına çıkan bir tanımlama yapmışsın (256 değeri).”

Aynı şekilde negatif değerler de vermiş olsaydık yine hata alacaktık çünkü uint8 veri tipinin kapsama alanı dışına çıkacaktık.

Şimdi, ikinci satırda tanımladığımız değişken satırına bakalım. İkinci satırdaki veri tipimiz ‘uint16’dır ve açıklama kısmında gördüğünüz üzere ‘unit16’nın değer aralığı ‘uint8’e göre daha geniş. Yine beyaz kutu ile işaretlediğimiz değere baktığımızda bir hata aldığımızı görürüz. Bunun sebebini biliyorsunuz; ‘uint16’nın kapsama alanı dışına çıktık. Mantık, ‘uint32’ ve ‘uint64’ için de geçerlidir. Deneyerek kendiniz gözlemleyebilirsiniz.

Aynı şeyleri bir de ‘int8’ ve ‘int16’ ile deneyelim. Dediğimiz gibi ‘int’ değişkenleri hem negatif hem de pozitif değerler alabilir. Üçüncü değişken tanımlama satırına bakalım; tanımladığımız veri tipi ‘int8’. Bu yüzden ‘int8’in kapsama alanı dışında olan ‘-129’ ve ‘128’ sayıları bize hata verecektir. Yine ‘int16’, kapsama alanı daha geniş bir veri tipi olduğundan “kapsama alanı dahilinde” daha büyük değerler girebiliriz.

Peki bu ayırım neden var, neden sadece ‘int’ kullanmıyoruz?

Buradaki her veri tipinin hafızada kapladığı belli bir yer vardır. Örneğin int8 hafızada 1 byte’lık bir yer kaplarken int16, hafızada 16 byte’lık yer kaplar. Bu çok küçük bir alan fakat bunu çok büyük projelerde kullanırken buna dikkat etmeliyiz.

Veri Tipi	Boyut
int8 – uint8	1 byte
int16 – uint16	2 bytes
int32 – uint32	4 bytes
int64 – uint64	8 bytes
float32	4 bytes
float64	8 bytes

Düşünelim: 18 yaş altındaki insanların ehliyet sınavına katılamayacağını, 18 yaşından büyüklerin ise bu sınava katılabileceğini, başvuru yapanların arasında otomatik olarak belirleyen bir yazılım hazırlıyorsunuz. Bunun için bir değişkene ihtiyacınız vardır ve bu değişkeni şu şekilde tanımlarsınız.

>>> var age int = 18

Daha sonra bu değişken için kullanıcıdan girdi (kimlik okutmak gibi) alırsınız ve bunun sonucunda 18 yaşından küçükler sınava giremez. Fakat oturup bir düşünelim: Genel olarak bir insan maksimum 100 yaşına kadar yaşayabilir ve yaşı negatif bir değer olamaz. Int veri tipini tanımladığımız için bu değişkenin alabileceği değerler hem negatif hem de pozitif olarak çok geniş aralıkta olur. Dolayısıyla bu bir depolama sorununa işaret eder. Bunun yerine direkt olarak şu tanımlamayı yapmanız gerekir:

>>> var age uint8 = 18

Bu sayede hem daha küçük bir değer aralığı ile işi çözmüş olursunuz hem de depolama açısından ‘int8’ daha az yer kaplamış olur.

'Depolama' kavramına değinmişken bir şeyden daha bahsetmek istiyorum. GoLang'de bir değişken atadığınız zaman bu değişkeni bir yerde kesinlikle kullanmanız gerekir; yoksa Go sizi durdurur. Hemen görelim:

Yukarıda gördüğünüz gibi ‘name’ ve ‘surname’ olarak iki değişken atadım. Aşağıda ‘fmt’ ile birlikte ‘name’ değişkenimi kullandım fakat ‘surname’ değişkenimi sadece atadım; herhangi bir yerde kullanmadım. Çıktımıza baktığımızda bize ‘surname declared but not used’ dediğini ve programı çalıştırmadığını görüyoruz. Bize demek istediği şey şu: “’surname’ diye bir değişken atadın ama bunu kullanmadın.” Bu özelliği ile GoLang’in, gereksiz kodların bulunmasını engelleyerek depolama dostu olduğunu görüyoruz.

---

Yayınlanma Tarihi: 2022-07-12 23:07:30

Son Düzenleme Tarihi: 2022-08-17 16:21:51