Swift Tour
Swift အကြောင်း တစေ့တဆောင်း
WWDC 14 မှာ developer တွေ အံအားသင့် သွားခဲ့ရတာကတော့ New Programming Language Swift ကို ကြေငြာခဲ့လို့ပါပဲ။ Objective-C ဟာ stable ဖြစ်နေပြီး ဖြစ်တဲ့ အတွက်ကြောင့် programming language အသစ်ကို ကြေငြာမယ်လို့ မထင်ခဲ့မိကြပါဘူး။ Apple က Modern language အသစ်တစ်ခုကို ဖန်တီး ပြီး မိတ်ဆက်ခဲ့ပါတယ်။
ပထမဆုံး hello world လေး ရိုက်ထုတ်ပုံလေးက ရှင်းပါတယ်။
println("Hello, world")
Xcode 6 မှာ Play Ground ဆိုတာ ပါဝင်လာပါတယ်။ Swift အတွက် သီးသန့် project ဖန်တီး စရာမလိုပဲ တိုက်ရိုက် ရေးချပြီး စမ်းကြည့်နိုင်ပါတယ်။
variable ကို ကြေငြာသည့် အခါမှာတော့ let နဲ့ var ကို အသုံးပြုနိုင်ပါတယ်။
var myVariable = 42
myVariable = 50
let myConstant = 42
constant တွေ အတွက် let ကို အသုံးပြုပြီးတော့ variable တွေ အတွက် var ကို အသုံးပြုပါတယ်။ Swift မှာ Variable type ကို ကြေငြာစရာ မလိုပဲ အလိုအလျောက် သိပါတယ်။ ကျွန်တော်တို့တွေ 42 ဆိုပြီး ထည့်ထားတာကြောင့် myVariable ထဲမှာ integer value ကို မှတ်ထားပါလိမ့်မယ်။
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
ကျွန်တော်တို့တွေ double value ကို ဒီ အတိုင်း တိုက်ရိုက် ထည့်သွင်းလို့ ရသလို varilable name နောက်မှာ variable: Type ဆိုပြီး ထည့်သွင်းလည်း ရပါတယ်။
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
Variable တွေ ရဲ့ data type ကို လည်း လွယ်လင့်တကူ ပြောင်းနိုင်ပါတယ်။ variable ကို string ထဲမှာ ထည့်မယ်ဆိုရင် + sign အစား () ကို အသုံးပြုနိုင်ပါတယ်။
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
အဲဒါဆိုရင် appleSummary မှာ I have 3 apples. ရှိပြီးတော့ fruitSummary မှာတော့ I have I have 8 pieces of fruit ရှိပါလိမ့်မယ်။
Array တွေ dictionary အတွက် Swift မှာ brackets ([ ]) ကို အသုံးပြုနိုင်ပါတယ်။
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
shoppingList က Array ဖြစ်ပြီးတော့ ကျွန်တော်တို့တွေ အခန်း နံပတ်နဲ့ ခေါ်လို့ ရသလို အခန်း နံပတ် နဲ့ value ကို အစားထိုး လို့ရပါတယ်။
occupations ကတော့ Dictionary လို သိသွားပါတယ်။ Key , Value နဲ့ ခေါ်ရပါတယ်။
တကယ်လို့ empty array , dictionary စတာ တွေ ကြေငြာချင်ရင်တော့
let emptyArray = String[]()
let emptyDictionary = Dictionary<String, Float>()
တကယ်လို့ variable type မပါပဲ ကြေငြာချင်ရင်
shoppingList = [] //Went shopping and bought everything
if နှင့် swifth ကို condition အတွက် အသုံးပြုနိုင်ပြီးတော့ for-in , for, while နှင့် do-while စတာတွေကို တော့ Looping အတွက် အသုံးပြုနိုင်ပါတယ်။
Loop တွေ condition တွေ အတွက် braces (curly brackets ) ကြားထဲမှာ ထည့်ရေးရပါတယ်။
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
teamScore
teamScore အဖြေက ၁၁ ရပါလိမ့်မယ်။ code ကို Xcode 6 ရဲ့ Playground မှာ သွားပြီး စမ်းသပ်နိုင်ပါတယ်။
Code ထဲမှာ for loop ကို သုံးပြီးတော့ array ကို Loop ပတ်ထားပါတယ်။ individualScores က အခန်း တစ်ခု ခြင်းဆီဟာ score ကို ရောက်ပါလိမ့်မယ်။ ပထမဆုံး score က 75 ဖြစ်ပါတယ်။ Condition အနေနဲ့ အမှတ် ၅၀ ထက် ကျော်ခဲ့ရင် teamScore ကို ၃ မှတ် ပေါင်းပါတယ်။ တူနေရင် သို့မဟုတ် ငယ်ခဲ့ရင် ၁ မှတ် ပဲပေါင်းပါတယ်။ ဒါကြောင့် 75 က ၅၀ ထက် ကျော်လို့ ၃ မှတ်ပေါင်းပါတယ် ။ ဒုတိယ အကြိမ် loop မှာတော့ score ဟာ ၄၃ ဖြစ်သွားပါပြီ။ အမှတ် ၄၀ မကျော်သည့်အတွက် ၁ မှတ် ပဲ ပေါင်းတာကို တွေ့နိုင်ပါတယ်။
objective-c မှာ ကျွန်တော်တို့တွေ nil value ရှိမရှိ စစ်တယ်။ nil မဟုတ်ရင် value ထည့်တယ်။ အဲဒီလိုမျိုး nil ဟုတ်မဟုတ်စစ်တာကို swift မှာ if let ကို အသုံးပြုနိုင်ပါတယ်။
Swift မှာ nil value ကို ထည့်သွင်းဖို့အတွက် question mark(?) ကို အသုံးပြုရပါတယ်။ တနည်းအားဖြင့် ဒီ varilable ထဲမှာ optional value ပါမယ်လို့ ဆိုပါတယ်။
Condition နောက်တစ်ခုကတော့ switch ပါ။
let vegetable = "red pepper"
switch vegetable {
case "celery":
let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy \(x)?"
default:
let vegetableComment = "Everything tastes good in soup."
}
Objective-C မှာလို နံပတ် တစ်ခုပဲ case နဲ့ စစ်လို့ရတာ မဟုတ်ပဲ string တွေကို ပါ စစ်လို့ ရပါတယ်။ နောက်ပြီး case မှာ တစ်ခု ထက် မက စစ်လို့ ရတာကို တွေ့မှာပါ။ စာလုံးရဲ့ အစဟာ pepper ဖြစ်ခဲ့ရင် case အတွက် case let x where x.hasSuffix("pepper"): ကို သုံးထားတာကို တွေ့နိုင်ပါတယ်။
Dictionary တွေကို loop ပတ်တဲ့အခါမှာလည်း ကျွန်တော်တို့တွေ for-in ကို အောက်ကလို အသုံးပြုနိုင်ပါတယ်။
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
largest
for-in loop ထဲမှာ kind နဲ့ numbers နဲ့ ခွဲထားတာကို တွေ့မှာပါ။ kind ကတော့ key name ဖြစ်ပြီးတော့ numbers ကတော့ values ပါ။
while loop အတွက်ဆိုရင်တော့
var n = 2
while n < 100 {
n = n * 2
}
n
do-while loop အတွက်ကတော့
var m = 2
do {
m = m * 2
} while m < 100
m
while loop က condition ကို စစ်ပြီးမှသာ အလုပ်လုပ်ပါတယ်။ do while loop က အနည်းဆုံး ၁ ခါ အလုပ်လုပ်ပြီးမှသာ condition ကို စစ်ပြီး loop ပတ်ပါတယ်။
နောက်ပြီး ကျွန်တော်တို့တွေ loop ကို range အတွက် .. ကို အသုံးပြုနိုင်ပါတယ်။
var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop
var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop
firstForLoop နဲ့ secondForLoop က အတူတူ ရလဒ်ပဲ ထွက်ပါတယ်။ တကယ်လို့ နောက်ဆုံးက value အပါအဝင် လိုချင်ရင် ... ကို အသုံးပြုလည်း ရပါတယ်။
var firstForLoop = 0
for i in 0...4 {
firstForLoop += i
}
firstForLoop
Swift မှာ အသုံးပြုသည့် function ဟာ objective-c မှာ အသုံးပြုတာ နဲ့ ကွဲပြားသွားပါပြီ။ func နဲ့ စပြီးတော့ return အတွက် -> ကို အသုံးပြုပါတယ်။
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
နောက်ပြီးတော့ Swift မှာ multivalue ကို return ပြန်နိုင်ပါတယ်။
func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
let (val1,val2,val3) = getGasPrices()
val1
val2
val3
တကယ်လို့ တစ်ခု ထက် မက parameter ဖြစ်မယ်ဆိုရင် … ကို အသုံးပြုနိုင်ပါတယ်။
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42, 597, 12)
ဒါ့အပြင် function တွေဟာ nested ဖြစ်နိုင်ပါသေးတယ်။
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
နောက်ပြီးတော့ return value ကို function အနေနဲ့ ကျွန်တော်တို့တွေ ပြန် ပေးလို့ရပါတယ်။
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
ဒီ code မှာ -> (Int -> Int) က return value ကို In လက်ခံပြီးတော့ Int ပြန်မယ့် function ကို return ပြန်ထားတယ်လို့ ဆိုပါတယ်။
function ထဲမှာ အခြား function ကိုလည်း parameter အဖြစ် လက်ခံနိုင်ပါတယ်။
func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)
function တွေဟာ တကယ်တန်းတော့ closures တွေပါပဲ။ ဒါကြောင့် ကျွန်တော်တို့အနေနဲ့ closure ကို နာမည်မပါပဲ braces({}) ထဲမှာ code ထည့်ပြီး ရေးနိုင်ပါတယ်။ in ကို အသုံးပြုပြီးတော့ arguments နဲ့ return type ကို ခွဲခြားနိုင်ပါတယ်။
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
ဒီ code လေးက မရှင်းရင်တော့ ကျွန်တော်တို့ ဒီ ထက် နည်းနည်း ရှည်တဲ့ code လေးကို ကြည့်ရအောင်
func mySort(inout numbers:Int[],compare:((Int,Int)->Bool))
{
//Write your login to sort numbers using comparator method
var tmp:Int
var n = numbers.count
for(var i=0;i<n;i++)
{
for(var j=0;j<n-i-1;j++)
{
if(compare(numbers[j],numbers[j+1]))
{
tmp=numbers[j];
numbers[j]=numbers[j+1];
numbers[j+1]=tmp;
}
}
}
}
var numbers = [10,1,20,123,50]
mySort(&numbers,{
(num1:Int,num2:Int) -> Bool in
return num1 > num2
})
ဒီ code လေးကို ဖတ်ကြည့်ရင်တော့ closures ကို သဘောပေါက်သွားပါလိမ့်မယ်။
mysort ကိုပဲ ကျွန်တော်တို့ ပိုတိုအောင် ဒီလို ရေးလို့ရပါတယ်။
mySort(&numbers){ n1,n2 in n1 > n2}
ဒီထက် တိုတဲ့ နည်းလမ်းကတော့
mySort(&numbers){ $0 > $1}
ဒီလောက်ဆိုရင် closures ကို ဘယ်လို သုံးရလဲဆိုတာကို သိလောက်ပါပြီ။
နောက် လ မှ object , class , enum စတာတွေကို ဆက်ပြီး ရေးပေးပါအုံးမယ်။