Kotlin’de Konsol Girdisi ve Çıktısı: print(), println(), readLine(), Scanner ve REPL

Kotlin’de Konsol Girdisi ve Çıktısı: print(), println(), readLine(), Scanner ve REPL

Kotlin, modern ve pragmatik bir programlama dili olarak, geliştiricilere konsol üzerinden kullanıcıyla etkileşim kurmak için güçlü ve esnek araçlar sunar. Uygulamaların çoğu zaman bir grafik arayüze veya web tabanlı bir arayüze sahip olsa da, konsol etkileşimi özellikle betikler, komut satırı araçları, hata ayıklama süreçleri ve temel öğrenme aşamaları için vazgeçilmezdir. Bu makalede, Kotlin’in konsola çıktı verme (print(), println()) ve konsoldan girdi alma (readLine(), java.util.Scanner) mekanizmalarını derinlemesine inceleyecek, ayrıca etkileşimli bir geliştirme ortamı olan Kotlin REPL’i (Read-Eval-Print Loop) keşfedeceğiz. Bu araçların her biri, farklı senaryolarda geliştiricilere büyük kolaylıklar sağlar ve Kotlin uygulamalarının kullanıcılarla daha etkin bir şekilde iletişim kurmasını mümkün kılar.

print() ve println() Fonksiyonları

Kotlin’de konsola metin yazdırmak için kullanılan en temel fonksiyonlar print() ve println()‘dır. Her iki fonksiyon da kotlin.io paketinde yer alır ve standart çıktı akışına (genellikle konsol) veri gönderir.

Tanım ve Amaç

Bu fonksiyonlar, programın çalışma zamanında kullanıcıya bilgi vermek, işlem sonuçlarını göstermek veya hata mesajları iletmek gibi amaçlarla kullanılır. Geliştirme ve hata ayıklama süreçlerinde, değişken değerlerini veya program akışını izlemek için de sıkça başvurulan araçlardır.

Temel Kullanım

print() ve println() fonksiyonları, parametre olarak çeşitli veri tiplerini alabilir. En yaygın kullanımı, String literallerini veya değişkenlerini yazdırmaktır.

fun main() {
    // String literallerini yazdırma
    print("Merhaba, ")
    println("Kotlin!")

    // Değişkenleri yazdırma
    val isim = "Alice"
    val yas = 30
    print("İsim: $isim, ")
    println("Yaş: $yas")

    // İfade sonuçlarını yazdırma
    println(10 + 5)
    println(true && false)
}

Yukarıdaki örnekte görüldüğü gibi, doğrudan metinler, değişkenler veya ifadelerin sonuçları konsola yazdırılabilir. Kotlin, yazdırma fonksiyonlarına geçirilen herhangi bir nesneyi otomatik olarak toString() metodunu çağırarak metin formatına dönüştürür.

Farkları

print() ve println() arasındaki temel fark, println()‘ın çıktıdan sonra otomatik olarak yeni bir satıra geçmesidir. print() ise imleci mevcut satırda, yazdırdığı metnin hemen sonunda bırakır.

* print(): Metni yazar ve imleci aynı satırda bırakır. Sonraki çıktı aynı satırda devam eder.
* println(): Metni yazar ve ardından bir satır sonu karakteri (newline character) ekleyerek imleci bir sonraki satırın başına taşır. Sonraki çıktı yeni bir satırdan başlar.

fun main() {
    print("Bu ilk parça. ")
    print("Bu ikinci parça aynı satırda. ")
    println("Bu üçüncü parça, ve şimdi yeni bir satıra geçilecek.")
    println("Bu dördüncü parça, yeni satırdan başlıyor.")
}

Bu kodun çıktısı şu şekilde olacaktır:

Bu ilk parça. Bu ikinci parça aynı satırda. Bu üçüncü parça, ve şimdi yeni bir satıra geçilecek.
Bu dördüncü parça, yeni satırdan başlıyor.

println() fonksiyonu, parametre almadan da çağrılabilir. Bu durumda sadece bir satır sonu karakteri yazdırarak boş bir satır oluşturur.

println("Birinci satır.")
println() // Boş bir satır
println("İkinci satır.")

String Şablonları (String Templates)

Kotlin’in güçlü özelliklerinden biri olan String Şablonları, print() ve println() fonksiyonlarıyla birlikte kullanıldığında çıktıları çok daha okunabilir ve dinamik hale getirir. String şablonları, bir string literalinin içine değişkenleri veya ifadeleri doğrudan $ sembolüyle gömmeyi sağlar.

* $değişken: Bir değişkenin değerini doğrudan string içine ekler.

val ad = "Mehmet"
    val yas = 25
    println("Merhaba, ben $ad ve $yas yaşındayım.")

* ${if (koşul) "evet" else "hayır"} gibi karmaşık ifadeler: Süslü parantezler ({}) içinde herhangi bir Kotlin ifadesi yazılabilir. Bu ifade değerlendirilir ve sonucu string’e dahil edilir.

val fiyat = 15.50
    val kdvOrani = 0.18
    println("Ürünün fiyatı: $fiyat TL. KDV dahil fiyatı: ${fiyat * (1 + kdvOrani)} TL.")

    val isOnline = true
    println("Kullanıcı durumu: ${if (isOnline) "Çevrimiçi" else "Çevrimdışı"}")

String şablonları, özellikle birden fazla değişkenin veya ifadenin birleştirilmesi gereken durumlarda string birleştirme operatöründen (+) çok daha temiz ve hataya açık olmayan bir yöntem sunar.

Formatlı Çıktı

Bazen çıktıların belirli bir formatta (örneğin, ondalık basamak sayısı, hizalama) gösterilmesi gerekebilir. Kotlin’de doğrudan printf gibi bir fonksiyon bulunmasa da, Java’nın String.format() metodu veya Kotlin’in format() uzantı fonksiyonu bu ihtiyacı karşılar.

fun main() {
    val pi = 3.14159265
    val sayi = 123.4567

    // İki ondalık basamak ile formatlama
    println("Pi sayısı: %.2f".format(pi))
    println("Sayı: %.1f".format(sayi))

    // Genişlik ve hizalama
    val urun = "Klavye"
    val stok = 150
    println("%-10s %5d".format(urun, stok)) // Sol hizalı 10 karakter, sağ hizalı 5 karakter
}

Bu örnekte, String.format() (Kotlin’de format() uzantı fonksiyonu olarak erişilebilir) C dilindeki printf benzeri format belirteçleri (%f ondalık sayılar için, %s stringler için, %d tam sayılar için) kullanarak çıktının hassasiyetini ve hizalamasını kontrol etmemizi sağlar.

Örnekler

fun main() {
    // Basit mesaj
    println("Program başladı.")

    // Kullanıcı bilgisi
    val kullaniciAdi = "Ayşe"
    val puan = 1250
    println("Hoş geldin, $kullaniciAdi! Puanın: $puan")

    // Hesaplama sonucu
    val a = 10
    val b = 7
    println("Toplama: ${a + b}")
    println("Çıkarma: ${a - b}")
    println("Çarpma: ${a * b}")
    println("Bölme: ${"%.2f".format(a.toDouble() / b)}") // Ondalık bölme ve formatlama

    // Durum kontrolü
    val sicaklik = 22
    if (sicaklik > 25) {
        println("Hava sıcak.")
    } else {
        println("Hava ılıman.")
    }

    // Döngü içinde çıktı
    for (i in 1..3) {
        print("$i ")
    }
    println("\nDöngü tamamlandı.") // Yeni satıra geçmek için \n kullanıldı
}

readLine() Fonksiyonu

Kullanıcıdan konsol aracılığıyla girdi almak, interaktif programların temel bir parçasıdır. Kotlin, bu amaç için readLine() adlı basit ve etkili bir fonksiyon sunar.

Tanım ve Amaç

readLine() fonksiyonu, standart girdi akışından (genellikle klavye) bir satır metin okur ve bu metni bir String olarak döndürür. Kullanıcı Enter tuşuna basana kadar girilen tüm karakterleri yakalar.

Temel Kullanım

readLine() fonksiyonu, kullanıcıdan tek bir metin satırı almak için idealdir. Ancak, önemli bir detayı vardır: döndürdüğü değer String? (nullable String) tipindedir. Bunun nedeni, girdi akışının sonuna ulaşılması (EOF – End Of File) durumunda null dönebilmesidir.

fun main() {
    print("Adınızı girin: ")
    val ad = readLine() // ad değişkeni String? tipindedir

    // Null kontrolü yapmak önemlidir
    if (ad != null) {
        println("Merhaba, $ad!")
    } else {
        println("Geçerli bir ad girmediniz.")
    }
}

Genellikle kullanıcıdan girdi beklendiğinde null dönme ihtimali düşüktür (kullanıcı Ctrl+D veya Ctrl+Z gibi bir kombinasyonla EOF sinyali göndermedikçe). Bu nedenle, çoğu zaman güvenli çağrı operatörü (?.) veya null olmayan kesinlik operatörü (!!) ile kullanılır. Ancak !! operatörünün dikkatli kullanılması gerekir, çünkü null olması durumunda NullPointerException fırlatır.

fun main() {
    print("Favori renginizi girin: ")
    val renk = readLine() ?: "Bilinmiyor" // Elvis operatörü ile null durumunu ele alma
    println("Favori renginiz: $renk")

    print("En sevdiğiniz meyve: ")
    val meyve = readLine()!! // Null olmayacağından eminseniz kullanın
    println("En sevdiğiniz meyve: $meyve")
}

Veri Tipi Dönüşümü

readLine() her zaman bir String döndürdüğü için, sayısal veya boolean gibi farklı veri tiplerine ihtiyaç duyulduğunda bu string’in dönüştürülmesi gerekir. Kotlin, bunun için çeşitli uzantı fonksiyonları sunar: toInt(), toDouble(), toBoolean(), toLong(), vb.

fun main() {
    print("Yaşınızı girin: ")
    val yasStr = readLine()
    val yas = yasStr?.toIntOrNull() // Null güvenli dönüşüm ve hata yönetimi

    if (yas != null) {
        println("Yaşınız: $yas")
        if (yas >= 18) {
            println("Reşitsiniz.")
        } else {
            println("Reşit değilsiniz.")
        }
    } else {
        println("Geçersiz yaş girişi.")
    }

    print("Bir ondalık sayı girin: ")
    val ondalikStr = readLine()
    val ondalikSayi = ondalikStr?.toDoubleOrNull()

    if (ondalikSayi != null) {
        println("Girdiğiniz sayı: $ondalikSayi")
    } else {
        println("Geçersiz ondalık sayı girişi.")
    }
}

toIntOrNull(), toDoubleOrNull() gibi fonksiyonlar, dönüşüm başarısız olduğunda null döner. Bu, try-catch bloklarına gerek kalmadan daha temiz bir hata yönetimi sağlar. Eğer dönüşümün kesinlikle başarılı olacağını düşünüyorsanız (veya başarısız olursa programın çökmesini kabul ediyorsanız), toInt(), toDouble() gibi doğrudan dönüşüm fonksiyonlarını kullanabilirsiniz. Ancak bu fonksiyonlar, geçersiz bir string ile çağrıldığında NumberFormatException fırlatır.

fun main() {
    print("Lütfen bir sayı girin: ")
    val sayiStr = readLine()

    try {
        val sayi = sayiStr!!.toInt() // !! ile String? -> String
        println("Girdiğiniz sayı: $sayi")
    } catch (e: NumberFormatException) {
        println("Hata: Geçersiz sayı formatı. Lütfen sadece rakam girin.")
    } catch (e: NullPointerException) {
        println("Hata: Girdi boş olamaz.")
    }
}

Bu yaklaşım, özellikle kullanıcıdan beklenen formatın dışına çıkabilecek girdilerde daha sağlam programlar yazmak için önemlidir.

Örnekler

fun main() {
    // İki sayıyı toplayan basit bir program
    print("Birinci sayıyı girin: ")
    val sayi1Str = readLine()
    print("İkinci sayıyı girin: ")
    val sayi2Str = readLine()

    val sayi1 = sayi1Str?.toIntOrNull()
    val sayi2 = sayi2Str?.toIntOrNull()

    if (sayi1 != null && sayi2 != null) {
        val toplam = sayi1 + sayi2
        println("Sayıların toplamı: $toplam")
    } else {
        println("Geçersiz sayı girdisi. Lütfen sadece tam sayı girin.")
    }

    // Kullanıcıdan evet/hayır yanıtı alma
    print("Devam etmek ister misiniz? (evet/hayır): ")
    val yanit = readLine()?.toLowerCase() // Küçük harfe çevirerek karşılaştırma

    if (yanit == "evet") {
        println("İşleme devam ediliyor...")
    } else if (yanit == "hayır") {
        println("İşlem iptal edildi.")
    } else {
        println("Anlaşılmayan yanıt. Lütfen 'evet' veya 'hayır' girin.")
    }
}

Scanner Sınıfı (java.util.Scanner)

Kotlin, readLine() gibi basit ve doğrudan bir fonksiyona sahip olsa da, daha karmaşık girdi senaryoları için Java’nın zengin java.util.Scanner sınıfını kullanabilir. Scanner, özellikle farklı veri tiplerini okuma, belirteçlere (delimiters) göre ayrıştırma ve daha esnek girdi işleme yetenekleri sunar.

Neden Scanner?

readLine() tek bir satırı String olarak okurken, Scanner daha granüler kontrol sağlar.

* Çeşitli Veri Tipleri: nextInt(), nextDouble(), nextBoolean() gibi metodlarla doğrudan farklı veri tiplerini okuyabilir.
* Belirteçlere Göre Ayrıştırma: Varsayılan olarak boşluk karakterlerini belirteç olarak kullanarak girdiyi parçalara ayırabilir. Özel belirteçler de tanımlanabilir.
* Akıştan Okuma: Sadece konsoldan değil, dosyalardan veya diğer girdi akışlarından da okuma yapabilir.

Temel Kullanım

Scanner sınıfını kullanmak için öncelikle java.util.Scanner‘ı import etmeli ve System.in (standart girdi akışı) ile bir Scanner nesnesi oluşturmalıyız.

import java.util.Scanner

fun main() {
    val scanner = Scanner(System.in) // System.in, Java'nın standart girdi akışıdır

    print("Adınızı ve yaşınızı girin (örnek: Ali 30): ")
    val ad = scanner.next() // Bir sonraki belirteçle ayrılmış token'ı String olarak okur
    val yas = scanner.nextInt() // Bir sonraki token'ı Int olarak okur

    println("Merhaba, $ad! $yas yaşındasın.")

    scanner.close() // Kaynakları serbest bırakmak önemlidir
}

Farklı Veri Tiplerini Okuma

Scanner‘ın en büyük avantajlarından biri, farklı veri tiplerini doğrudan okuyabilmesidir:

* next(): Bir sonraki token’ı (boşlukla ayrılmış kelime) String olarak okur.
* nextLine(): Bir sonraki satırın tamamını String olarak okur.
* nextInt(): Bir sonraki token’ı Int olarak okur.
* nextLong(): Bir sonraki token’ı Long olarak okur.
* nextDouble(): Bir sonraki token’ı Double olarak okur.
* nextBoolean(): Bir sonraki token’ı Boolean olarak okur.

Ayrıca, hasNext(), hasNextInt(), hasNextLine() gibi metodlar, girdi akışında belirli bir tipte bir sonraki token’ın olup olmadığını kontrol etmek için kullanılır. Bu, girdi doğrulaması ve hata yönetimi için faydalıdır.

import java.util.Scanner

fun main() {
    val scanner = Scanner(System.in)

    print("Bir tam sayı girin: ")
    if (scanner.hasNextInt()) { // Girdinin tam sayı olup olmadığını kontrol et
        val sayi = scanner.nextInt()
        println("Girdiğiniz tam sayı: $sayi")
    } else {
        println("Geçersiz tam sayı girdisi.")
        scanner.next() // Geçersiz token'ı tüket, aksi halde sonsuz döngüye girer
    }

    // next() vs nextLine() farkı
    // nextInt() gibi metodlar sadece sayıyı okur, satır sonu karakterini akışta bırakır.
    // nextLine() çağrılmadan önce bu satır sonu karakteri tüketilmelidir.
    scanner.nextLine() // Önceki nextInt() tarafından bırakılan satır sonunu tüket

    print("Şehrinizi girin: ")
    val sehir = scanner.nextLine() // Tüm satırı okur
    println("Yaşadığınız şehir: $sehir")

    scanner.close()
}

nextInt(), nextDouble() gibi metodlar, sayısal değeri okuduktan sonra Enter tuşuyla girilen satır sonu karakterini girdi akışında bırakır. Eğer hemen ardından nextLine() çağrılırsa, bu kalan satır sonu karakteri nextLine() tarafından okunur ve boş bir string döndürülür. Bu yaygın bir hatadır ve nextLine() çağrılmadan önce scanner.nextLine() çağrılarak bu artık satır sonu karakterinin tüketilmesi gerekir.

Belirteçlere Göre Ayrıştırma (Delimiters)

Scanner, varsayılan olarak boşluk karakterlerini (boşluk, tab, yeni satır) belirteç olarak kullanır. Ancak, useDelimiter() metodu ile özel belirteçler tanımlanabilir. Bu, virgülle ayrılmış değerler (CSV) veya diğer özel formatlardaki girdileri ayrıştırmak için çok kullanışlıdır.

import java.util.Scanner

fun main() {
    val scanner = Scanner(System.in)

    print("Üç sayıyı virgülle ayırarak girin (örnek: 10,20,30): ")
    val girdi = scanner.nextLine() // Tüm satırı string olarak al

    val customScanner = Scanner(girdi) // Girdiyi yeni bir Scanner nesnesine ver
    customScanner.useDelimiter(",") // Virgülü belirteç olarak ayarla

    val s1 = customScanner.nextInt()
    val s2 = customScanner.nextInt()
    val s3 = customScanner.nextInt()

    println("Sayılar: $s1, $s2, $s3")

    customScanner.close()
    scanner.close()
}

Kaynak Yönetimi

Scanner bir girdi akışı üzerinde çalıştığı için, işi bittiğinde close() metodunu çağırarak kaynakları serbest bırakmak önemlidir. Aksi takdirde, kaynak sızıntılarına yol açabilir. Kotlin’in use fonksiyonu, Closeable arayüzünü uygulayan nesnelerle çalışırken kaynakların otomatik olarak kapatılmasını sağlar.

import java.util.Scanner

fun main() {
    Scanner(System.in).use { scanner ->
        print("Adınız: ")
        val ad = scanner.nextLine()
        println("Merhaba, $ad!")
    } // 'use' bloğu bittiğinde scanner otomatik olarak kapanır
}

readLine() vs Scanner

Hangi yöntemin kullanılacağı, ihtiyaca ve karmaşıklığa bağlıdır:

* readLine():
* Avantajları: Basit, Kotlin’e özgü, tek bir satır metin okumak için ideal.
* Dezavantajları: Her zaman String? döndürür, farklı veri tiplerine dönüştürmek için manuel olarak toIntOrNull() gibi fonksiyonlar kullanılmalıdır. Belirteçlere göre ayrıştırma için ek kod yazmak gerekir.
* Ne Zaman Kullanılır: Kullanıcıdan tek bir metin satırı, bir sayı veya basit bir boolean değeri beklediğinizde.

* Scanner:
* Avantajları: Farklı veri tiplerini doğrudan okuma, belirteçlere göre ayrıştırma, girdi akışını daha esnek yönetme yeteneği. hasNextX() metodları ile girdi doğrulaması daha kolaydır.
* Dezavantajları: java.util.Scanner sınıfını import etmeyi gerektirir, nextLine() sorunları gibi küçük tuzakları vardır, readLine()‘a göre biraz daha fazla kurulum gerektirir.
* Ne Zaman Kullanılır: Kullanıcıdan farklı tiplerde birden fazla girdi beklediğinizde, girdiyi belirli belirteçlere göre ayrıştırmanız gerektiğinde veya dosya gibi diğer girdi akışlarından okuma yaparken.

Genel olarak, basit tek satır girdiler için readLine() tercih edilirken, daha karmaşık ve çoklu girdi senaryolarında Scanner daha güçlü ve esnek bir çözüm sunar.

Örnekler

import java.util.Scanner

fun main() {
    Scanner(System.in).use { scanner ->
        println("Hesap Makinesi")
        print("İlk sayıyı girin: ")
        val num1 = if (scanner.hasNextDouble()) scanner.nextDouble() else {
            println("Geçersiz sayı girdisi. Çıkılıyor.")
            return
        }
        scanner.nextLine() // Satır sonunu tüket

        print("İkinci sayıyı girin: ")
        val num2 = if (scanner.hasNextDouble()) scanner.nextDouble() else {
            println("Geçersiz sayı girdisi. Çıkılıyor.")
            return
        }
        scanner.nextLine() // Satır sonunu tüket

        print("Operatörü girin (+, -, *, /): ")
        val operator = scanner.nextLine()

        val result = when (operator) {
            "+" -> num1 + num2
            "-" -> num1 - num2
            "" -> num1  num2
            "/" -> {
                if (num2 != 0.0) num1 / num2 else {
                    println("Sıfıra bölme hatası!")
                    return
                }
            }
            else -> {
                println("Geçersiz operatör.")
                return
            }
        }
        println("Sonuç: $result")
    }
}

Kotlin REPL (Read-Eval-Print Loop)

REPL (Read-Eval-Print Loop), etkileşimli bir programlama ortamıdır. Geliştiricilerin kod parçacıklarını anında çalıştırmasına, sonuçlarını görmesine ve programın durumunu interaktif olarak incelemesine olanak tanır. Kotlin REPL, özellikle dilin özelliklerini denemek, küçük kod parçacıklarını test etmek veya bir kütüphanenin nasıl çalıştığını anlamak için paha biçilmez bir araçtır.

REPL Nedir?

REPL, adından da anlaşılacağı gibi dört ana adımı tekrarlayan bir döngüdür:

1. Read (Oku): Kullanıcının girdiği kodu okur.
2. Eval (Değerlendir): Okunan kodu değerlendirir/çalıştırır.
3. Print (Yazdır): Çalıştırmanın sonucunu kullanıcıya yazdırır.
4. Loop (Döngü): Tekrar ilk adıma döner ve yeni bir girdi bekler.

Bu döngü, anında geri bildirim sağlayarak hızlı deneme ve yanılma süreçlerini destekler.

REPL’i Başlatma

Kotlin REPL’i başlatmak için, Kotlin derleyicisinin (genellikle kotlinc) veya Kotlin çalışma zamanının (kotlin) kurulu olması gerekir. Komut satırından kotlin yazıp Enter’a basmak yeterlidir:

$ kotlin
Welcome to Kotlin version 1.9.22 (JRE 17.0.9+8-LTS)
Type :help for help, :quit to exit
>>>

>>> işareti, REPL’in girdi beklediğini gösterir.

Temel Kullanım

REPL’de doğrudan Kotlin kodunu yazabilir ve Enter tuşuna basarak anında çalıştırabilirsiniz.

>>> println("Merhaba REPL!")
Merhaba REPL!
>>> val x = 10
>>> val y = 20
>>> x + y
30
>>> fun topla(a: Int, b: Int) = a + b
>>> topla(x, y)
30
>>> val isim = readLine()
John Doe
>>> println("Hoş geldin, $isim")
Hoş geldin, John Doe

Görüldüğü gibi, değişkenler tanımlanabilir, fonksiyonlar oluşturulabilir ve çağrılabilir, hatta readLine() gibi etkileşimli fonksiyonlar bile kullanılabilir. Her ifadenin sonucu anında ekrana yazdırılır.

REPL Komutları

REPL, özel komutlarla yönetilebilir. Bu komutlar : ile başlar:

* :help: Mevcut komutların listesini ve açıklamalarını gösterir.
* :quit veya :q: REPL oturumundan çıkar.
* :vars: Geçerli oturumda tanımlanmış tüm değişkenleri ve tiplerini listeler.
* :fun: Geçerli oturumda tanımlanmış tüm fonksiyonları listeler.
* :reset: REPL ortamını sıfırlar, tanımlanmış tüm değişkenleri ve fonksiyonları siler.
* :load : Belirtilen Kotlin dosyasındaki kodu REPL oturumuna yükler ve çalıştırır.
* :paste: Çok satırlı kod bloklarını yapıştırmak için kullanılır. Yapıştırma moduna girer, Ctrl+D (Unix/Linux/macOS) veya Ctrl+Z (Windows) ile çıkılır.

>>> :vars
val x: kotlin.Int = 10
val y: kotlin.Int = 20
val isim: kotlin.String = "John Doe"

>>> :fun
fun topla(a: kotlin.Int, b: kotlin.Int): kotlin.Int

>>> :reset
All local changes in the REPL have been reset.
>>> x
error: unresolved reference: x

Avantajları ve Kullanım Senaryoları

Kotlin REPL’in sunduğu avantajlar ve yaygın kullanım senaryoları şunlardır:

* Hızlı Öğrenme ve Deneme: Yeni başlayanlar için Kotlin sözdizimini ve temel özelliklerini anında test etmek için mükemmeldir.
* Kütüphane Fonksiyonlarını Keşfetme: Bilinmeyen bir kütüphanenin veya API’nin belirli bir fonksiyonunun nasıl çalıştığını hızlıca denemek için idealdir.
* Hata Ayıklama ve Küçük Testler: Bir programın belirli bir bölümündeki mantığı veya bir ifadenin sonucunu hızlıca kontrol etmek için kullanılabilir.
* Prototipleme: Tam bir proje oluşturmadan önce küçük fikirleri veya algoritmaları hızlıca prototiplemek için uygundur.
* Komut Satırı Betikleri: Basit, tek seferlik görevler için komut satırından hızlıca kod çalıştırmak.

Örnekler

>>> // Basit bir hesaplama
>>> val radius = 5.0
>>> val pi = 3.14159
>>> val area = pi  radius  radius
>>> println("Dairenin alanı: $area")
Dairenin alanı: 78.53975

>>> // Bir liste üzerinde işlem
>>> val numbers = listOf(1, 2, 3, 4, 5)
>>> val squaredNumbers = numbers.map { it * it }
>>> println(squaredNumbers)
[1, 4, 9, 16, 25]

>>> // Koşullu ifade
>>> val temperature = 28
>>> val message = if (temperature > 25) "Çok sıcak!" else "Hava güzel."
>>> println(message)
Çok sıcak!

>>> // Fonksiyon tanımlama ve çağırma
>>> fun greet(name: String) = "Merhaba, $name!"
>>> greet("Kotlin")
Merhaba, Kotlin!

>>> // Sınıf tanımlama ve nesne oluşturma
>>> class Person(val name: String, val age: Int) {
...     fun introduce() = "Benim adım $name ve $age yaşındayım."
... }
>>> val person1 = Person("Elif", 28)
>>> person1.introduce()
Benim adım Elif ve 28 yaşındayım.

REPL, Kotlin geliştirme deneyiminin önemli bir parçasıdır ve hızlı iterasyonlar için vazgeçilmez bir araçtır.

En İyi Uygulamalar ve İpuçları

Konsol girdisi ve çıktısı ile çalışırken, uygulamalarınızın daha sağlam, kullanıcı dostu ve sürdürülebilir olması için bazı en iyi uygulamaları takip etmek önemlidir.

Kullanıcı Girişini Doğrulama

Kullanıcıdan alınan her türlü girdi, potansiyel olarak geçersiz veya beklenmedik olabilir. Her zaman girdiyi beklenen formata uygun olup olmadığını kontrol edin.

* Null Kontrolü: readLine()‘ın String? döndürdüğünü unutmayın. ?. güvenli çağrı operatörünü, Elvis operatörünü (?:) veya açık null kontrolünü (if (input != null)) kullanın.
* Veri Tipi Dönüşümü Hataları: toIntOrNull(), toDoubleOrNull() gibi güvenli dönüşüm fonksiyonlarını tercih edin. Eğer toInt() gibi doğrudan dönüşüm fonksiyonları kullanıyorsanız, NumberFormatException gibi hataları yakalamak için try-catch bloklarını kullanın.
* Mantıksal Doğrulama: Sayıların belirli bir aralıkta olup olmadığını, string’lerin belirli bir desene uyup uymadığını (regex kullanarak) veya boolean değerlerin doğru formatta olup olmadığını kontrol edin.

print("Lütfen 1 ile 10 arasında bir sayı girin: ")
val input = readLine()
val number = input?.toIntOrNull()

if (number == null || number < 1 || number > 10) {
    println("Geçersiz girdi. Lütfen belirtilen aralıkta bir sayı girin.")
} else {
    println("Girdiğiniz sayı: $number")
}

Hata Yönetimi

Girdi okuma veya dönüştürme sırasında oluşabilecek hataları öngörün ve kullanıcıya anlamlı geri bildirim sağlayın. Programın aniden çökmesi yerine, hatayı açıklayın ve kullanıcıdan tekrar denemesini isteyin.

* try-catch bloklarını, özellikle Scanner kullanırken veya toInt() gibi hata fırlatan fonksiyonlarla çalışırken kullanın.
* toIntOrNull() gibi fonksiyonların döndürdüğü null değerlerini doğru şekilde işleyin.

Kaynakları Kapatma

java.util.Scanner gibi girdi/çıktı akışlarıyla çalışan nesneler, işleri bittiğinde kapatılmalıdır. Bu, kaynak sızıntılarını önler. Kotlin’in use fonksiyonu, Closeable arayüzünü uygulayan nesneler için otomatik kaynak yönetimini sağlar ve bu konuda en iyi yaklaşımdır.

import java.util.Scanner

Scanner(System.in).use { scanner ->
    // Scanner ile işlemler
} // scanner otomatik olarak kapatılır

Anlaşılır Çıktı Sağlama

Kullanıcıya verilen çıktıların açık, özlü ve anlaşılır olduğundan emin olun.

* Kullanıcıya Yönlendirme: Kullanıcıdan ne beklediğinizi açıkça belirtin (örneğin, “Adınızı girin:”, “Evet veya Hayır (E/H) girin:”).
* Dinamik Mesajlar: String şablonlarını kullanarak çıktıları daha kişisel ve bilgilendirici hale getirin.
* Formatlama: Sayısal değerleri (özellikle para birimi veya ondalık sayılar) okunaklı bir şekilde biçimlendirin. String.format() veya Kotlin’in format() uzantı fonksiyonunu kullanın.
* Boş Satırlar: Okunabilirliği artırmak için println() ile boş satırlar ekleyerek çıktıları gruplandırın.

println("--- Kullanıcı Bilgi Sistemi ---")
print("Adınız: ")
val ad = readLine() ?: "Misafir"
print("Yaşınız: ")
val yasStr = readLine()
val yas = yasStr?.toIntOrNull()

println("\n--- Girilen Bilgiler ---")
println("Ad: $ad")
println("Yaş: ${yas ?: "Bilinmiyor"}")
if (yas != null && yas >= 18) {
    println("Durum: Reşit")
} else if (yas != null) {
    println("Durum: Reşit Değil")
}
println("--------------------------")

Bu uygulamalar, konsol tabanlı Kotlin uygulamalarınızın daha profesyonel ve kullanıcı dostu olmasını sağlayacaktır.

Sonuç

Bu makalede, Kotlin’in konsol ile etkileşim kurma mekanizmalarını derinlemesine inceledik. print() ve println() fonksiyonları ile çıktı vermenin temellerini, String şablonlarının gücünü ve formatlı çıktı seçeneklerini öğrendik. Kullanıcıdan girdi almak için readLine() fonksiyonunun basitliğini ve String? dönüş tipinin önemini vurguladık. Daha karmaşık girdi senaryoları için Java’dan miras alınan java.util.Scanner sınıfının esnekliğini, farklı veri tiplerini okuma yeteneğini ve belirteçlere göre ayrıştırma özelliklerini keşfettik. Son olarak, Kotlin REPL’in (Read-Eval-Print Loop) etkileşimli yapısını, nasıl başlatılacağını, temel kullanımını ve öğrenme, deneme ve prototipleme süreçlerindeki paha biçilmez rolünü ele aldık.

Her aracın kendine özgü avantajları ve kullanım senaryoları vardır. Basit çıktılar ve tek satırlık girdiler için print()/println() ve readLine() yeterli olurken, farklı veri tiplerini ayrıştırma ve daha sağlam girdi işleme gerektiren durumlarda Scanner daha uygun bir seçimdir. REPL ise, Kotlin dilini keşfetmek, küçük kod parçacıklarını test etmek ve anında geri bildirim almak için ideal bir ortam sunar.

Bu araçları etkin bir şekilde kullanarak, Kotlin geliştiricileri kullanıcılarla daha güçlü ve etkili konsol tabanlı etkileşimler kurabilir, hata ayıklama süreçlerini hızlandırabilir ve genel olarak daha verimli bir geliştirme deneyimi yaşayabilirler. Konsol etkileşimi, her ne kadar modern uygulamalarda arka planda kalsa da, programlamanın temelini oluşturmaya devam etmektedir ve Kotlin bu alanda geliştiricilere zengin bir araç seti sunmaktadır.