Swift: An Introduction

Khái quát

Swift là một ngôn ngữ lập trình mới được Apple trình diễn ở sự kiện WWDC 2014. Nó được Apple giới thiệu như một ngôn ngữ hiện đại, nhanh và mạnh, được thiết kế để tránh các lỗi xảy ra do lập trình viên như quên khởi tạo biến, cast từ kiểu này thành kiểu kia, tràn bộ nhớ blah blah, hỗ trợ viết code và xem kết quả ngay lập tức. Nói tóm lại Swift được quảng cáo là kết hợp được những cái tốt nhất của C và Objective-C

Blog này sẽ giới thiệu một số concept cơ bản trong Swift, so sánh nó một chút với Objective-C để mọi người kết luận được là ngôn ngữ nào dễ dùng với developer hơn.

Biến và Hằng trong Swift

Để khai báo 1 biến trong Swift thì ta sử dụng từ khoá var

var someInt = 69

Để khai báo 1 hằng số thì ta sử dụng từ khoá let

let unchanged = 96
let π = 3.14159

Nếu như các bạn cố tình thay đổi giá trị của hằng số thì complier sẽ cho bạn 1 lỗi ví dụ như là “Cannot assign to ‘let’ value”
Bạn có thể sử dụng gần như là tất cả các ký tự để đặt tên biến hoặc hằng, kể cả các ký tự Unicode

Trong Swift thì bạn không cần thiết phải định nghĩa chính xác kiểu của biến bởi vì compiler có thể tự suy ra kiểu của biến dựa vào giá trị khởi tạo của nó. Ví dụ như ở khai báo phía trên

let unchanged = 96

thì compiler sẽ tự định nghĩa kiểu của hằng unchanged là Int

Tuy nhiên bạn cũng có thể tự định nghĩa kiểu biến khi khai báo như sau

// - Swift
let unchanged : Int = 96
// - Objective-C
// -- Constant
NSInteger const someInt = 96
// -- Variable
NSInteger otherInt = 69

Các kiểu biến cơ bản trong Swift là

• Float, Double (nếu như bạn không khai báo chính xác biến là compiler sẽ tự gán kiểu biến là Double)
• Bool
• String
• Array
• Dictionary

Nếu như bạn cần chuyển từ kiểu này sang kiểu khác, bạn phải tạo một đối tượng mới

let label = "The height is"
let height = 568
let heightLabel = label + String(height) // Nếu như bỏ String đi thì compiler sẽ báo lỗi

Để đặt một giá trị vào string thì có thể dùng 1 cách khác đơn giản hơn

 let heightLabel = "The height is \(height)"

Để khởi tạo array hoặc dictionary ta sử dụng [], lấy giá trị bằng cách viết index hoặc key trong []

//- Swift
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
 ]
occupations["Jayne"] = "Public Relations"

So với Objective-C thì Swift đã không còn phân biệt Mutable và Non-mutable đối với mảng và dictionary mà vẫn đảm bảo được hiệu suất của code

// Objective-C
NSArray * shoppingList = @["catfish", "water", "tulips", "blue paint"]; // bạn không thể thay đổi giá trị hay thêm bớt mảng này
NSMutableArray * mShoppingList = @["catfish", "water", "tulips", "blue paint"];
[mShoppingList replaceObjectAtIndex:1 withObject:"bottle of water"];

NSMutableDictionary * occupations = @[
    "Malcolm": "Captain",
    "Kaylee": "Mechanic"];
[occupations setObject:"Public Relations" forKey:"Jayne"];

Lớp và phương thức

Để tạo một class, gõ từ khoá class và tên của class. Phần triển khai của class được đặt trong dấu ngoặc nhọn {}
Nếu bạn muốn 1 class là class con của một class nào đó

class subClass : parentClass {
}

Để khai báo một phương thức, chúng ta dùng từ khoá func, tiếp theo đến danh sách các parameter với kiểu biến. Cuối cùng là giá trị trả về theo sau dấu “->”
Khi khai báo một phương thức, ta có thể khai báo 1 external parameter để phương thức trở nên dễ hiểu. Ví dụ

func doSomethingWithParamA(paramA : Int, withParamB paramB : Int) -> Int {
     return paramA + paramB
}

// Goi phương thức
let a = 100
let b = 200
doSomethingWithParamA(a, withParamB: b) // 300

Dưới đây là ví dụ về 1 class hoàn chỉnh

// 1
class TipCalculator {

  // 2
  let total: Double
  let taxPct: Double
  let subtotal: Double

  // 3
  init(total:Double, taxPct:Double) {
    self.total = total
    self.taxPct = taxPct
    subtotal = total / (taxPct + 1)
  }

  // 4
  func calcTipWithTipPct(tipPct:Double) -> Double {
    return subtotal * tipPct
  }

  // 5
  func printPossibleTips() {
    println("15%: \(calcTipWithTipPct(0.15))")
    println("18%: \(calcTipWithTipPct(0.18))")
    println("20%: \(calcTipWithTipPct(0.20))")
  }
}

// 6
let tipCalc = TipCalculator(total: 33.25, taxPct: 0.06)
tipCalc.printPossibleTips()

Control Flow

For loop

Vòng for in dùng để duyệt qua tất cả các phần tử của tập hợp như là khoảng số, phần tử của mảng hay các ký tự trong chuỗi. 1…5 tương đương với [1…5]

for index in 1...5 {
    println("\(index) times 5 is \(index*5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

Nếu như bạn không cần dùng giá trị trong khoảng số thì ta có thể dùng dấu gạch dưới thay cho tên biến

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
println("\(base) to the power of \(power) is \(answer)")
// prints "3 to the power of 10 is 59049"

Dùng for-in để duyệt qua mảng và duyệt qua dictionary

let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names {
    println("Hello, \(name)!")
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
    println("\(animalName)s have \(legCount) legs")
}
// spiders have 8 legs
// ants have 6 legs
// cats have 4 legs

Cấu trúc vòng for-condition-increment thì tương tự các ngôn ngữ lập trình khác

for var index = 0; index < 3; ++index {
    println("index is \(index)")
}
// index is 0
// index is 1
// index is 2

Vòng lặp while

while condition {
    statements
}

do {
    statements
} while condition

If else

temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {     println("It's very cold. Consider wearing a scarf.") } else if temperatureInFahrenheit >= 86 {
    println("It's really warm. Don't forget to wear sunscreen.")
} else {
    println("It's not that cold. Wear a t-shirt.")
}

Switch-case

switch some value to consider {
case value 1:
    respond to value 1
case value 2,
value 3:
    respond to value 2 or 3
default:
    otherwise, do something else
}

Trong Swift, mỗi case có thể chứa nhiều giá trị và không còn bị giới hạn chỉ giá trị Integer nữa. Mỗi giá trị có thể là ký tự, số, khoảng, enum...

// Nhiều giá trị
let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    println("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    println("\(someCharacter) is a consonant")
default:
    println("\(someCharacter) is not a vowel or a consonant")
}

// Khoảng số
let count = 3_000_000_000_000
let countedThings = "stars in the Milky Way"
var naturalCount: String
switch count {
case 0:
    naturalCount = "no"
case 1...3:
    naturalCount = "a few"
case 4...9:
    naturalCount = "several"
case 10...99:
    naturalCount = "tens of"
case 100...999:
    naturalCount = "hundreds of"
case 1000...999_999:
    naturalCount = "thousands of"
default:
    naturalCount = "millions and millions of"
}
println("There are \(naturalCount) \(countedThings).")
// prints "There are millions and millions of stars in the Milky Way."

Một case trong switch có thể gán 1 hoặc nhiều giá trị của case cho 1 biến hoặc 1 hằng tạm thời để sử dụng trong phần thân của case

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    println("on the x-axis with an x value of \(x)")
case (0, let y):
    println("on the y-axis with a y value of \(y)")
case let (x, y):
    println("somewhere else at (\(x), \(y))")
}
// prints "on the x-axis with an x value of 2"

Trong case có thể sử dụng where để kiểm tra thêm 1 điều kiện bổ sung

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    println("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    println("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    println("(\(x), \(y)) is just some arbitrary point")
}
// prints "(1, -1) is on the line x == -y"

To be continued...