From a270849823677f27fca8fd7253913472fe22e01e Mon Sep 17 00:00:00 2001 From: baha Date: Fri, 28 Jul 2017 11:54:58 +0300 Subject: [kotlin/tr] kotlin turkish document --- tr-tr/kotlin-tr.html.markdown | 406 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 406 insertions(+) create mode 100644 tr-tr/kotlin-tr.html.markdown diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown new file mode 100644 index 00000000..62756468 --- /dev/null +++ b/tr-tr/kotlin-tr.html.markdown @@ -0,0 +1,406 @@ +--- +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" keyword works in the same way as in Java. +// "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) { + /* + 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)}") + } + + /* + 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") + } + + // The "with" function is similar to the JavaScript "with" statement. + // '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 { + 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) + + fun myFun(x:Int) : Any { + if (x>10) return "b" + else return 1 + } + + /* + 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! + + println(EnumExample.A) // => A + 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/) -- cgit v1.2.3 From 2858d077827308b8ca4ba7a8185715461503bee6 Mon Sep 17 00:00:00 2001 From: baha Date: Mon, 31 Jul 2017 15:53:26 +0300 Subject: [kotlin/tr] removed unused code --- tr-tr/kotlin-tr.html.markdown | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown index 62756468..cc8815a7 100644 --- a/tr-tr/kotlin-tr.html.markdown +++ b/tr-tr/kotlin-tr.html.markdown @@ -326,10 +326,6 @@ fun helloWorld(val name : String) { } println(result) - fun myFun(x:Int) : Any { - if (x>10) return "b" - else return 1 - } /* Bir objenin tipini 'is' operatörü ile tayin edebiliriz. -- cgit v1.2.3 From 04c0ccb2ae6326edc4f17e41ff82fe8af9fa7b4a Mon Sep 17 00:00:00 2001 From: baha Date: Mon, 31 Jul 2017 16:05:22 +0300 Subject: [kotlin/tr] for loops added --- tr-tr/kotlin-tr.html.markdown | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown index cc8815a7..2dcb92e0 100644 --- a/tr-tr/kotlin-tr.html.markdown +++ b/tr-tr/kotlin-tr.html.markdown @@ -14,7 +14,6 @@ Java %100 birlikte çalışabilir. Birkaç satırı yoruma almak için */ -// "package" keyword works in the same way as in Java. // "package" anahtar kelimesi tıpkı Java'da olduğu gibidir. package com.learnxinyminutes.kotlin @@ -141,6 +140,18 @@ fun helloWorld(val name : String) { 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. -- cgit v1.2.3 From ef1cf7d71ecb3f9879397c0893bb8803b427240f Mon Sep 17 00:00:00 2001 From: baha Date: Mon, 31 Jul 2017 17:24:58 +0300 Subject: [kotlin/tr] Delegated properties added --- tr-tr/kotlin-tr.html.markdown | 57 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown index 2dcb92e0..e549ef8e 100644 --- a/tr-tr/kotlin-tr.html.markdown +++ b/tr-tr/kotlin-tr.html.markdown @@ -381,6 +381,63 @@ fun helloWorld(val name : String) { println(EnumExample.A) // => A println(ObjectExample.hello()) // => Merhaba + + //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("") { + prop, old, new -> + println("$old -> $new") + } + myObservableName = "Baha" // -> Baha + myObservableName = "Can" //Baha -> Can + + + /* + * Eğer değişkenin yeniden atanmasını denetlemek isterek vetoable() + * metodunu kullanabiliriz. + * */ + + var myVetoableName : String by Delegates.vetoable(""){ + property, oldValue, newValue -> + if (newValue.length < 2) { + println("Tek harfli isim kabul etmiyoruz!") + false + } else { + println("$oldValue -> $newValue") + true + } + } + + myVetoableName = "Baha" // -> Baha + myVetoableName = "C" //Tek harfli isim kabul etmiyoruz! + println(myVetoableName) //Baha } // Enum class lar Java'daki enum lara benzerdir. -- cgit v1.2.3 From 8b3b05a48cd0a49cbf009430ab965b26d92040d0 Mon Sep 17 00:00:00 2001 From: baha Date: Thu, 10 Aug 2017 14:38:03 +0300 Subject: [kotlin/tr] some cleanup --- tr-tr/kotlin-tr.html.markdown | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown index e549ef8e..043cf31f 100644 --- a/tr-tr/kotlin-tr.html.markdown +++ b/tr-tr/kotlin-tr.html.markdown @@ -215,7 +215,6 @@ fun helloWorld(val name : String) { println("$key -> $value") } - // The "with" function is similar to the JavaScript "with" statement. // '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) @@ -379,8 +378,7 @@ fun helloWorld(val name : String) { } println("Merhaba, dünya!".remove('a')) // => Merhb, düny! - println(EnumExample.A) // => A - println(ObjectExample.hello()) // => Merhaba + //Biraz detaylı Kotlin @@ -438,6 +436,10 @@ fun helloWorld(val name : String) { myVetoableName = "Baha" // -> 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. -- cgit v1.2.3