summaryrefslogtreecommitdiffhomepage
path: root/tr-tr
diff options
context:
space:
mode:
Diffstat (limited to 'tr-tr')
-rw-r--r--tr-tr/kotlin-tr.html.markdown472
1 files changed, 472 insertions, 0 deletions
diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
new file mode 100644
index 00000000..043cf31f
--- /dev/null
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -0,0 +1,472 @@
+---
+language: kotlin
+contributors:
+ - ["Baha Can Aydın", "https://github.com/bahacan19"]
+---
+Kotlin, JVM, Android ve tarayıcı için statik olarak yazılmış bir programlama dilidir.
+Java %100 birlikte çalışabilir.
+[Daha:](https://kotlinlang.org/)
+
+```kotlin
+
+// Tek satır yoruma almak için : //
+/*
+ Birkaç satırı yoruma almak için
+*/
+
+// "package" anahtar kelimesi tıpkı Java'da olduğu gibidir.
+package com.learnxinyminutes.kotlin
+
+/*
+Bir Kotlin programının başlama noktası (Java'da olduğu gibi) "com.learnxinyminutes.kotlin.main" metodudur.
+Bu metoda komut satırından bir 'Array' gönderilebilir.
+*/
+fun main(args: Array<String>) {
+ /*
+ Bir değer tanımlamak için "var" ya da "val" anahtar kelimeleri kullanılıyor.
+ "val" tanımlananlar tekrar atanamazken "var" tanımlananlar atanabilir.
+ */
+ val fooVal = 10 // fooVal değerini daha sonra tekrar atayamıyoruz
+ var fooVar = 10
+ fooVar = 20 // fooVar tekrar atanabilir.
+
+ /*
+ Çoğu zaman, Kotlin bir değişkenin tipini anlayabilir,
+ bu yüzden her zaman belirtmeye gerek yoktur.
+ Bir değişkenin tipini şöyle belirtebiliriz:
+ */
+ val foo: Int = 7
+
+ /*
+ String değerler Java'da olduğu gibi tanımlanır.
+ */
+ val fooString = "İşte String bu!"
+ val barString = "Yeni satıra geçiyorum...?\nGeçtim!"
+ val bazString = "Tab mı istedin?\tAl bakalım!"
+ println(fooString)
+ println(barString)
+ println(bazString)
+
+ /*
+ Raw string, üçlü çift-tırnak sınırlandırılan String bloklarıdır.
+ Tıpkı bir text editör gibi String tanımlamaya izin verir.
+ */
+ val fooRawString = """
+fun helloWorld(val name : String) {
+ println("Merhaba, dünya!")
+}
+"""
+ println(fooRawString)
+
+ /*
+ String değerler, ($) işareti ile birtakım deyimler ve değerler içererbilir
+ */
+ val fooTemplateString = "$fooString değerinin ${fooString.length} adet karakteri vardır."
+ println(fooTemplateString)
+
+ /*
+ Null atanabilen bir değişken nullable olarak tanımlanmalıdır.
+ Bu, deişken tipinin sonuna ? eklenerek yapılabilir.
+ Erişim ise '?.' operatörü ile yapılır.
+ Bir değişken null ise, yerine kullaılacak alternatif bir değer belirtmek için
+ '?:' operatörünü kullanırız.
+ */
+ var fooNullable: String? = "abc"
+ println(fooNullable?.length) // => 3
+ println(fooNullable?.length ?: -1) // => 3
+ fooNullable = null
+ println(fooNullable?.length) // => null
+ println(fooNullable?.length ?: -1) // => -1
+
+ /*
+ Metodlar "fun" anahtar kelimesi ile tanımlanır.
+ Metod argümanları, Metod adından sonra parantez içinde belirtilir.
+ Metod argümanlarının opsiyonel olarak default (varsayılan) değerleri olabilir.
+ Metodun dönüş tipi, gerekirse, metod parentezinden sonra ':' operatörü ile belirtilir.
+ */
+ fun hello(name: String = "dünya"): String {
+ return "Merhaba, $name!"
+ }
+ println(hello("foo")) // => Merhaba, foo!
+ println(hello(name = "bar")) // => Merhaba, bar!
+ println(hello()) // => Merhaba, dünya!
+
+ /*
+ Bir metoda çokca argüman göndermek için 'vararg' anahtar kelimesi
+ kullanılır.
+ */
+ fun varargExample(vararg names: Int) {
+ println("${names.size} adet arguman paslanmıştır")
+ }
+ varargExample() // => 0 adet arguman paslanmıştır
+ varargExample(1) // => 1 adet arguman paslanmıştır
+ varargExample(1, 2, 3) // => 3 adet arguman paslanmıştır
+
+ /*
+ Bir metod tek bir ifadeden oluşuyorsa
+ süslü parantezler yerine '=' kullanılabilir.
+ */
+ fun odd(x: Int): Boolean = x % 2 == 1
+ println(odd(6)) // => false
+ println(odd(7)) // => true
+
+ // Eğer dönüş tipi anlaşılabiliyorsa ayrıca belirtmemize gerek yoktur.
+ fun even(x: Int) = x % 2 == 0
+ println(even(6)) // => true
+ println(even(7)) // => false
+
+ // Metodlar, metodları arguman ve dönüş tipi olarak alabilir
+ fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)} // bu satırdaki !f.invoke(n) metodu !f(n) şeklinde sadeleştirilebilir.
+ }
+
+
+ // Bir metodu sadece '::' ön eki ile de arguman olarak çağırabiliriz
+ println(not(::odd)(4)) // ==> true
+
+ // Metodlar değişken gibi atanabilir.
+ val notOdd = not(::odd)
+ val notEven = not(::even)
+
+ // Lambda ifadeleri arguman olarak paslanabilir.
+ val notZero = not {n -> n == 0}
+ /*
+ Eğer bir lambda fonksiyonu sadece bir arguman alıyorsa,
+ '->' ifadesi atlanabilir, 'it' ifadesi ile belirtilebilir.
+ */
+ val notPositive = not { it > 0} // not(n -> n > 0) ifadesi ile aynı
+
+ for (i in 0..4) {
+ println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+ }
+
+ /*
+ * Diğer for döngüleri
+ * */
+ val myInt = 3
+ for (i in 1..100) { } // kapalı aralık. 100 dahil.
+ for (i in 1 until 100) { } // 100 dahil değil
+ for (x in 2..10 step 2) { } // ikişer adımlı
+ for (x in 10 downTo 1) { } // Ondan geriye doğru. 1 dahil.
+ if (myInt in 1..10) { }
+
+
+
+ /*
+ Bir sınıf tanımlamak için 'class' anahtar kelimesi kullanılır.
+ Kotlin'de bütün sınıflar varsayılan olarak 'final' tanımlanırlar.
+ * */
+ class ExampleClass(val x: Int) {
+
+ fun memberFunction(y: Int): Int {
+ return x + y
+ }
+
+ infix fun yTimes(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ * Bir sınıfı türetilebilir yapmak için 'open' anahtar kelimesi kullanılır.
+ * */
+ open class A
+
+ class B : A()
+
+
+ /*
+ Yeni bir instance oluşturmak için doğrudan constructor çağırılır.
+ Kotlinde 'new' anahtar kelimesi yoktur.
+ */
+ val fooExampleClass = ExampleClass(7)
+ // Bir sınıfa üye metodları . (nokta) ile çağırabiliriz.
+ println(fooExampleClass.memberFunction(4)) // => 11
+ /*
+ 'infix' ön eki ile tanımlanan metodlar
+ alışılan metod çağrısını daha kolay bir söz dizimine dönüştürür.
+ */
+ println(fooExampleClass yTimes 4) // => 28
+
+ /*
+ Data class lar sadece veri tutan sınıflar için uygun bir çözümdür.
+ Bu şekilde tanımlanan sınıfların "hashCode"/"equals" ve "toString" metodları
+ otomatik olarak oluşur.
+ */
+ data class DataClassExample (val x: Int, val y: Int, val z: Int)
+ val fooData = DataClassExample(1, 2, 4)
+ println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+ // Data class ların copy metodları olur.
+ val fooCopy = fooData.copy(y = 100)
+ println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+ // Destructuring Declarations, bir objeyi çoklu değişkenler ile ifade etme yöntemidir.
+ val (a, b, c) = fooCopy
+ println("$a $b $c") // => 1 100 4
+
+ // bir 'for' döngüsü içinde 'Destructuring' :
+ for ((a, b, c) in listOf(fooData)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapData = mapOf("a" to 1, "b" to 2)
+ // Map.Entry de destructurable gösterilebilir.
+ for ((key, value) in mapData) {
+ println("$key -> $value")
+ }
+
+ // 'with' metodu ile bir objeye bir lamda metodu uygulayabiliriz.
+ data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+ val fooMutableData = MutableDataClassExample(7, 4, 9)
+ with (fooMutableData) {
+ x -= 2
+ y += 2
+ z--
+ }
+
+ println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+ /*
+ 'listOf' metodu ile bir liste oluşturulabilir.
+ Oluşan liste immutable olacaktır, yani elaman eklenemez ve çıkarılamaz.
+ */
+ val fooList = listOf("a", "b", "c")
+ println(fooList.size) // => 3
+ println(fooList.first()) // => a
+ println(fooList.last()) // => c
+ // Elemanlara indexleri ile erişilebilir.
+ println(fooList[1]) // => b
+
+ // Mutable bir liste ise 'mutableListOf' metodu ile oluşturabilir.
+ val fooMutableList = mutableListOf("a", "b", "c")
+ fooMutableList.add("d")
+ println(fooMutableList.last()) // => d
+ println(fooMutableList.size) // => 4
+
+ // Bir 'set' oluşturmak için 'setOf' metodunu kullanabiliriz.
+ val fooSet = setOf("a", "b", "c")
+ println(fooSet.contains("a")) // => true
+ println(fooSet.contains("z")) // => false
+
+ // 'mapOf' metodu ile 'map' oluşturabiliriz.
+ val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Map değerlerine ulaşmak için :
+ println(fooMap["a"]) // => 8
+
+ /*
+ Sequence, Kotlin dilinde lazy-hesaplanan collection ları temsil eder.
+ Bunun için 'generateSequence' metodunu kullanabiliriz. Bu metod bir önceki değerden
+ bir sonraki değeri hesaplamak için gerekli bir lamda metodunu arguman olarak alır.
+ */
+ val fooSequence = generateSequence(1, { it + 1 })
+
+ val x = fooSequence.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Örneğin fibonacci serisi oluşturabilen bir 'Sequence' oluşturmak için:
+ fun fibonacciSequence(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun next(): Long {
+ val result = a + b
+ a = b
+ b = result
+ return a
+ }
+
+ return generateSequence(::next)
+ }
+ val y = fibonacciSequence().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+
+ // Kotlin Collection lar ile çalışmak için higher-order metodlar sağlar.
+ val z = (1..9)
+ .map {it * 3} // her bir elamanı 3 ile çarp
+ .filter {it < 20} // 20 den küçük değerleri ele
+ .groupBy {it % 2 == 0} // ikiye tam bölünen ve bölünmeyen şeklinde grupla (Map)
+ .mapKeys {if (it.key) "even" else "odd"} // oluşan map in boolen 'key' lerini String bir değere dönüştür.
+ println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+ // Bir 'for' döngüsü 'itearator' sağlayan her objeye uygulanabilir.
+ for (c in "merhaba") {
+ println(c)
+ }
+
+ // 'while' döngüsü diğer dillere benzer şekilde çalışır.
+ var ctr = 0
+ while (ctr < 5) {
+ println(ctr)
+ ctr++
+ }
+ do {
+ println(ctr)
+ ctr++
+ } while (ctr < 10)
+
+ /*
+ 'if' bir dönüş değeri olan deyim gibi de kullanılabilir.
+ Bu sebepten Kotlin, Java'da bulunan '?:' ifadesi içermez.
+ */
+ val num = 5
+ val message = if (num % 2 == 0) "even" else "odd"
+ println("$num is $message") // => 5 is odd
+
+ // 'if-else if' yapıları için 'when' kullanılabilir.
+ val i = 10
+ when {
+ i < 7 -> println("first block")
+ fooString.startsWith("hello") -> println("second block")
+ else -> println("else block")
+ }
+
+ // 'when' bir parametre ile de kullanılabilir.
+ when (i) {
+ 0, 21 -> println("0 or 21")
+ in 1..20 -> println("in the range 1 to 20")
+ else -> println("none of the above")
+ }
+
+ // 'when' dönüş değeri olan bir metod gibi de davranabilir.
+ var result = when (i) {
+ 0, 21 -> "0 or 21"
+ in 1..20 -> "in the range 1 to 20"
+ else -> "none of the above"
+ }
+ println(result)
+
+
+ /*
+ Bir objenin tipini 'is' operatörü ile tayin edebiliriz.
+ Eğer obje tip kontrolünü geçerse, cast etmeden doğrudan
+ o tipteymiş gibi kullanılabilir.
+ */
+ fun smartCastExample(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x otomatik olarak Boolean'a cast edilir.
+ return x
+ } else if (x is Int) {
+ // x otomatik olarak Int tipine cast edilir.
+ return x > 0
+ } else if (x is String) {
+ // x otomatik olarak String tipine cast edilir.
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(smartCastExample("Merhaba, dünya!")) // => true
+ println(smartCastExample("")) // => false
+ println(smartCastExample(5)) // => true
+ println(smartCastExample(0)) // => false
+ println(smartCastExample(true)) // => true
+
+ // Smartcast 'when' bloğu ile de çalışır.
+ fun smartCastWhenExample(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ Extension lar, bir sınıfa fonksinolalite eklemenin bir yoludur.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("Merhaba, dünya!".remove('a')) // => Merhb, düny!
+
+
+
+ //Biraz detaylı Kotlin
+
+
+ /*
+ * Delegated Properties, bir değişken tanımlarken kullanılan birkaç standart yöntemler içerir.
+ * https://kotlinlang.org/docs/reference/delegated-properties.html
+ * En bilinen delegate property metodları: lazy(), observable()
+ * */
+
+ /*
+ * Lazy, bir değişkeni ilk erişimde çalıştırılacak olan bir lambda ile tanımlama metodudur.
+ * Sonraki erişimlerde değişkene atanan değer hatırlanır.
+ * Lazy, synchronized bir delegation yöntemidir; değer sadece bir thread içinde hesaplanır,
+ * tüm thread ler aynı değere erişir. Eğer senkronizasyon gerekli değilse, lazy metodu içine
+ * LazyThreadSafetyMode.PUBLICATION paslanabilir.
+ * */
+
+ val lazyValue: String by lazy( {
+ println("bi sn... hesaplıyorum....")
+ "Selam!"
+ })
+
+ println(lazyValue)// bi sn... hesaplıyorum.... Selam!
+ println(lazyValue) // Selam!
+ /*
+ * Observable, bir değişkende olabilecek yeniden atama değişikliklerini dinleme yöntemidir.
+ * İki arguman alır; değişkenin ilk değeri, değiştiğinde çağrılan bir handler metodu. Handler
+ * metodu değişken her değiştiğinde çağırılır.
+ * */
+ var myObservableName: String by Delegates.observable("<isim yok>") {
+ prop, old, new ->
+ println("$old -> $new")
+ }
+ myObservableName = "Baha" //<isim yok> -> Baha
+ myObservableName = "Can" //Baha -> Can
+
+
+ /*
+ * Eğer değişkenin yeniden atanmasını denetlemek isterek vetoable()
+ * metodunu kullanabiliriz.
+ * */
+
+ var myVetoableName : String by Delegates.vetoable("<isim yok>"){
+ property, oldValue, newValue ->
+ if (newValue.length < 2) {
+ println("Tek harfli isim kabul etmiyoruz!")
+ false
+ } else {
+ println("$oldValue -> $newValue")
+ true
+ }
+ }
+
+ myVetoableName = "Baha" //<isim yok> -> Baha
+ myVetoableName = "C" //Tek harfli isim kabul etmiyoruz!
+ println(myVetoableName) //Baha
+
+
+ //singleton değişkene ulaşmak:
+ println(ObjectExample.hello()) // => Merhaba
+}
+
+// Enum class lar Java'daki enum lara benzerdir.
+enum class EnumExample {
+ A, B, C
+}
+
+/*
+'object' anahtar kelimesi ile singleton nesneler oluşturulabilir.
+Bu şekilde tanımlanan sınıflardan yeni nesneler oluşturulamaz, sadece adı ile refere edilebilir.
+*/
+object ObjectExample {
+ fun hello(): String {
+ return "Merhaba"
+ }
+}
+
+fun useObject() {
+ ObjectExample.hello()
+ val someRef: Any = ObjectExample
+}
+
+```
+
+### İlerisi için:
+
+* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser](http://try.kotlinlang.org/)
+* [A list of Kotlin resources](http://kotlin.link/)
+* [Kotlin Koans in your IDE](https://kotlinlang.org/docs/tutorials/koans.html/)