Lưu trữ #ios - Phá Kén

Giới thiệu về Swift Ngôn ngữ lập trình Swift được Apple tạo ra vào năm 2014. Đây là ngôn ngữ chính thức hoạt động trên toàn bộ dòng Hệ điều hành của Apple: iOS, iPadOS, watchOS, macOS và tvOS. Swift là ngôn […]

Tagged #ios

Giới thiệu về Swift

Ngôn ngữ lập trình Swift được Apple tạo ra vào năm 2014. Đây là ngôn ngữ chính thức hoạt động trên toàn bộ dòng Hệ điều hành của Apple: iOS, iPadOS, watchOS, macOS và tvOS.

Swift là ngôn ngữ lập trình mã nguồn mở, đa năng, được biên dịch và có kiểu tĩnh.

Mỗi giá trị đều được gán một kiểu. Kiểu của giá trị luôn được kiểm tra khi được sử dụng làm đối số hoặc được trả về, tại thời điểm biên dịch. Nếu không khớp, chương trình sẽ không biên dịch.

Trình biên dịch của Swift là LLVM và được tích hợp trong Xcode, IDE chuẩn mà bạn sử dụng để phát triển phần mềm Apple.

Swift là ngôn ngữ lập trình hiện đại được thiết kế để “phù hợp” với hệ sinh thái trước đây được thiết kế cho ngôn ngữ lập trình khác có tên là Objective-C.

Hầu hết các phần mềm chạy trên iPhone và Mac hiện nay đều dựa trên mã Objective-C, ngay cả đối với các ứng dụng chính thức của Apple. Nhưng việc sử dụng Swift đang ngày càng phổ biến qua từng năm. Trong khi Objective-C sẽ được sử dụng trong nhiều năm để duy trì và cải thiện các ứng dụng hiện có, thì các ứng dụng mới có khả năng sẽ được tạo bằng Swift.

Trước khi Apple giới thiệu Swift, Objective-C đã được phát triển mạnh mẽ để giới thiệu các khả năng và tính năng mới. Nhưng trong những năm gần đây, nỗ lực này đã giảm đi rất nhiều để ủng hộ sự phát triển của Swift.

Điều này không có nghĩa là Objective-C đã chết hoặc không đáng học: Objective-C vẫn là một công cụ thiết yếu cho bất kỳ nhà phát triển Apple nào.

Tuy nhiên, tôi sẽ không đề cập đến Objective-C ở đây vì chúng ta sẽ tập trung vào Swift – nền tảng hiện tại và tương lai của Apple.

Chỉ trong 6 năm, Swift đã trải qua 5 phiên bản chính và hiện tại (tại thời điểm viết bài) chúng ta đang ở phiên bản thứ 5.

Swift nổi tiếng là ngôn ngữ sản phẩm của Apple, nhưng nó không phải là ngôn ngữ chỉ dành cho Apple. Bạn có thể sử dụng nó trên nhiều nền tảng khác.

Ngôn ngữ này là mã nguồn mở, do đó việc chuyển ngôn ngữ này sang các nền tảng khác không yêu cầu bất kỳ sự cho phép hoặc cấp phép nào và bạn có thể tìm thấy các dự án Swift để tạo máy chủ web và API ( https://github.com/vapor/vapor ) cũng như các dự án để tương tác với bộ vi điều khiển.

Swift là ngôn ngữ đa năng, được xây dựng dựa trên các khái niệm hiện đại và có tương lai tươi sáng.

Những gì chúng tôi sẽ đề cập ở đây

Mục tiêu của cuốn sách này là giúp bạn bắt đầu sử dụng Swift từ con số 0.

Nếu bạn có máy Mac hoặc iPad, tôi khuyên bạn nên tải xuống ứng dụng Playgrounds do Apple phát hành từ App Store.

Ứng dụng này cho phép bạn chạy các đoạn mã Swift mà không cần phải tạo ứng dụng đầy đủ trước. Đây là cách rất tiện lợi để kiểm tra mã của bạn, không chỉ khi bạn bắt đầu học mà còn bất cứ khi nào bạn cần thử một số mã.

Ngoài ra, nó còn chứa một loạt các ví dụ và hướng dẫn tuyệt vời giúp bạn mở rộng kiến thức về Swift và iOS.

Lưu ý: Bạn có thể tải xuống phiên bản PDF và ePub của Sổ tay hướng dẫn dành cho người mới bắt đầu sử dụng Swift này

Biến trong Swift

Biến cho phép chúng ta gán giá trị cho nhãn. Chúng ta định nghĩa chúng bằng vartừ khóa:

var name = "Roger"
var age = 8

Sau khi một biến được định nghĩa, chúng ta có thể thay đổi giá trị của nó:

age = 9

Các biến mà bạn không muốn thay đổi có thể được định nghĩa là hằng số bằng cách sử dụng lettừ khóa:

let name = "Roger"
let age = 8

Việc thay đổi giá trị của hằng số là bị cấm.

Bạn không thể thay đổi giá trị của hằng số nếu không bạn sẽ nhận được lỗi này

Khi bạn định nghĩa một biến và gán cho nó một giá trị, Swift sẽ ngầm suy ra kiểu của biến đó.

8là một Intgiá trị.

"Roger"là một Stringgiá trị.

Một số thập phân giống như 3.14một Doublegiá trị.

Bạn cũng có thể chỉ định loại tại thời điểm khởi tạo:

let age: Int = 8

Nhưng thông thường Swift sẽ tự suy ra điều đó và điều này thường được thực hiện khi bạn khai báo một biến mà không khởi tạo nó.

Bạn có thể khai báo một hằng số và khởi tạo nó sau:

let age : Int
age = 8

Khi một biến được định nghĩa, nó được liên kết với kiểu đó. Bạn không thể gán cho nó một kiểu khác, trừ khi bạn chuyển đổi nó một cách rõ ràng.

Bạn không thể làm điều này:

var age = 8
age = "nine"

Lỗi không thể gán giá trị kiểu ‘String’ cho kiểu ‘Int’

Intvà Stringchỉ là hai trong số các kiểu dữ liệu tích hợp được Swift cung cấp.

Đối tượng trong Swift

Trong Swift, mọi thứ đều là đối tượng. Ngay cả 8giá trị chúng ta gán cho agebiến cũng là đối tượng.

Trong một số ngôn ngữ, đối tượng là một kiểu đặc biệt. Nhưng trong Swift, mọi thứ đều là đối tượng và điều này dẫn đến một tính năng cụ thể: mọi giá trị đều có thể nhận được tin nhắn .

Mỗi loại có thể có nhiều hàm liên quan đến nó, mà chúng ta gọi là phương thức .

Ví dụ, khi nói về 8giá trị số, chúng ta có thể gọi isMultiplephương thức của nó để kiểm tra xem số đó có phải là bội số của một số khác hay không:

isMultiplephương pháp

Giá trị String có một tập hợp phương thức khác.

Một kiểu cũng có các biến thể hiện. Ví dụ, kiểu String có biến thể hiện count, cho bạn biết số ký tự trong một chuỗi:

biến thể hiệncount

Swift có 3 kiểu đối tượng khác nhau , chúng ta sẽ tìm hiểu chi tiết hơn sau: lớp , cấu trúc và enum .

Chúng rất khác nhau, nhưng chúng có một điểm chung: với kiểu đối tượng, chúng ta có thể thêm phương thức và với bất kỳ giá trị nào, của bất kỳ kiểu đối tượng nào, chúng ta có thể gửi tin nhắn .

Các toán tử trong Swift

Chúng ta có thể sử dụng nhiều toán tử khác nhau để thao tác trên các giá trị.

Chúng ta có thể chia toán tử thành nhiều loại. Loại đầu tiên là số mục tiêu: 1 cho toán tử một ngôi , 2 cho toán tử hai ngôi hoặc 3 cho toán tử ba ngôi duy nhất .

Sau đó, chúng ta có thể phân chia các toán tử dựa trên loại hoạt động mà chúng thực hiện:

toán tử gán
toán tử số học
toán tử gán hợp chất
Toán tử so sánh
toán tử phạm vi
toán tử logic

cộng thêm một số toán tử nâng cao hơn, bao gồm nil-coalescing, điều kiện ba ngôi, tràn, toán tử bitwise và pointwise.

Lưu ý: Swift cho phép bạn tạo các toán tử của riêng mình và xác định cách các toán tử hoạt động trên các kiểu dữ liệu do bạn xác định.

Toán tử gán trong Swift

Bạn sử dụng toán tử gán để gán giá trị cho một biến:

var age = 8

Hoặc để gán giá trị biến cho một biến khác:

var age = 8
var another = age

Toán tử số học trong Swift

Swift có một số toán tử số học nhị phân: +, -, *, /(phép chia), %(phép dư):

1 + 1 //2
2 - 1 //1
2 * 2 //4
4 / 2 //2
4 % 3 //1
4 % 2 //0

-cũng hoạt động như một toán tử trừ một ngôi:

let hotTemperature = 20
let freezingTemperature = -20

Bạn cũng có thể sử dụng +để nối các giá trị String:

"Roger" + " is a good dog"

Toán tử gán hợp chất trong Swift

Các toán tử gán hợp chất kết hợp toán tử gán với các toán tử số học:

+=
-=
*=
/=
%=

Ví dụ:

var age = 8
age += 1

Toán tử so sánh trong Swift

Swift định nghĩa một số toán tử so sánh:

==
!=
>
<
>=
<=

Bạn có thể sử dụng các toán tử đó để lấy giá trị boolean ( truehoặc false) tùy thuộc vào kết quả:

let a = 1
let b = 2
a == b //false
a != b //true
a > b // false
a <= b //true

Toán tử phạm vi trong Swift

Toán tử phạm vi được sử dụng trong vòng lặp. Chúng cho phép chúng ta xác định phạm vi:

0...3 //4 times
0..<3 //3 times
0...count //"count" times
0..<count //"count-1" times

Sau đây là một ví dụ sử dụng:

let count = 3
for i in 0...count {
//loop body
}

Toán tử logic trong Swift

Swift cung cấp cho chúng ta các toán tử logic sau:

!, toán tử một ngôi KHÔNG
&&, toán tử nhị phân AND
||, toán tử nhị phân OR

Sử dụng mẫu:

let condition1 = true
let condition2 = false
!condition1 //false
condition1 && condition2 //false
condition1 || condition2 //true

Chúng chủ yếu được sử dụng trong ifviệc đánh giá biểu thức điều kiện:

if condition1 && condition2 {
//if body
}

Điều kiện trong Swift

`if`các câu lệnh trong Swift

ifstatement là cách phổ biến nhất để thực hiện kiểm tra có điều kiện. Chúng ta sử dụng từ ifkhóa theo sau là một biểu thức boolean, theo sau là một khối chứa mã được chạy nếu điều kiện là đúng:

let condition = true
if condition == true {
// code executed if the condition is true
}

Một elsekhối sẽ được thực thi nếu điều kiện là sai:

let condition = true
if condition == true {
// code executed if the condition is true
} else {
// code executed if the condition is false
}

Bạn có thể tùy chọn bọc xác thực điều kiện vào trong dấu ngoặc đơn nếu bạn muốn:

if (condition == true) {
// ...
}

Và bạn cũng có thể chỉ cần viết:

if condition {
// runs if `condition` is `true`
}

hoặc

if !condition {
// runs if `condition` is `false`
}

Một điều khiến Swift khác biệt so với nhiều ngôn ngữ khác là nó ngăn chặn lỗi do thực hiện sai lệnh gán thay vì so sánh. Điều này có nghĩa là bạn không thể làm điều này:

if condition = true {
// The program does not compile
}

Lý do là toán tử gán không trả về bất cứ thứ gì, nhưng điều ifkiện phải là một biểu thức boolean.

`switch`các câu lệnh trong Swift

Câu lệnh switch là một cách tiện dụng để tạo điều kiện có nhiều tùy chọn:

var name = "Roger"
switch name {
case "Roger":
print("Hello, mr. Roger!")
default: 
print("Hello, \(name)")
}

Khi mã của một trường hợp kết thúc, công tắc sẽ tự động thoát.

Một lệnh chuyển đổi trong Swift cần bao gồm tất cả các trường hợp. Nếu thẻ , trong nametrường hợp này, là một chuỗi có thể có bất kỳ giá trị nào, chúng ta cần thêm một defaulttrường hợp, bắt buộc.

Nếu không, với phép liệt kê, bạn có thể liệt kê tất cả các tùy chọn:

enum Animal {
case dog
case cat
}
var animal: Animal = .dog
switch animal {
case .dog:
print("Hello, dog!")
case .cat:
print("Hello, cat!")
}

Một trường hợp có thể là một phạm vi:

var age = 20
switch age {
case 0..<18:
print("You can't drive!!")
default: 
print("You can drive")
}

Toán tử điều kiện ba ngôi trong Swift

Toán tử điều kiện ba ngôi là phiên bản rút gọn của một ifbiểu thức. Nó cho phép chúng ta thực hiện một biểu thức nếu điều kiện là đúng và một biểu thức khác nếu điều kiện là sai.

Sau đây là cú pháp:

`condition` ? `value if true` : `value if false`

Ví dụ:

let num1 = 1
let num2 = 2
let smallerNumber = num1 < num2 ? num1 : num2 
// smallerNumber == 1

Cú pháp ngắn hơn một ifcâu lệnh và đôi khi có thể hợp lý hơn khi sử dụng cú pháp này.

Vòng lặp trong Swift

`for-in`vòng lặp trong Swift

Bạn có thể sử dụng for-invòng lặp để lặp lại một số lần cụ thể bằng cách sử dụng toán tử phạm vi:

for index in 0...3 {
//iterate 4 times, `index` is: 0, 1, 2, 3
}

Bạn có thể lặp lại các phần tử của một mảng hoặc tập hợp:

let list = ["a", "b", "c"]
for item in list {
// `item` contains the element value
}

Và về các thành phần của một từ điển:

let list = ["a": 1, "b": 2, "c": 2]
for (key, value) in list {
// `key` contains the item key
// `value` contains the item value
}

`while`vòng lặp trong Swift

Vòng whilelặp có thể được sử dụng để lặp lại bất cứ điều gì và sẽ chạy khi điều kiện là true:

while [condition] {
//statements...
}

Điều kiện được kiểm tra khi bắt đầu, trước khi khối vòng lặp được thực thi.

Ví dụ:

var item = 0
while item <= 3 { //repeats 3 times
print(item)
item += 1
}

`repeat-while`vòng lặp trong Swift

Vòng repeat-whilelặp trong Swift tương tự như whilevòng lặp. Nhưng trong trường hợp này, điều kiện được kiểm tra ở cuối, sau khối vòng lặp, do đó khối vòng lặp được thực thi ít nhất một lần. Sau đó, điều kiện được kiểm tra và nếu được đánh giá là true, khối vòng lặp được lặp lại:

repeat {
//statements...
} while [condition]

Ví dụ:

var item = 0
repeat { //repeats 3 times
print(item)
item += 1
} while item < 3

`continue`và `break`các câu lệnh trong Swift

Swift cung cấp cho bạn 2 câu lệnh mà bạn có thể sử dụng để kiểm soát luồng bên trong vòng lặp: continuevà break.

Bạn sử dụng continueđể dừng vòng lặp hiện tại và chạy vòng lặp tiếp theo.

breakkết thúc vòng lặp, không thực hiện bất kỳ lần lặp nào khác.

Ví dụ:

let list = ["a", "b", "c"]
for item in list {
if (item == "b") {
break
}
//do something
}

Cách viết bình luận trong Swift

Trong Swift, chú thích có thể có 2 dạng: chú thích một dòng và chú thích nhiều dòng.

Một bình luận một dòng trông như thế này:

//this is a comment

và bạn có thể đặt nó vào cuối dòng mã:

let a = 1 //this is a comment

Một bình luận nhiều dòng được viết bằng cú pháp sau:

/* this
is
a multi-line
comment
*/

Swift cho phép bạn lồng các chú thích nhiều dòng:

/* this
is
a /* nested */ multi-line
comment
*/

Điều này đặc biệt hữu ích khi chú thích những phần lớn mã đã chứa chú thích nhiều dòng.

Dấu chấm phẩy trong Swift

Trong Swift, dấu chấm phẩy thường là tùy chọn.

Bạn có thể viết các câu lệnh trên các dòng riêng biệt và không cần phải thêm dấu chấm phẩy:

let list = ["a", "b", "c"]
var a = 2

Bạn có thể thêm dấu chấm phẩy, nhưng nó không có ý nghĩa gì trong trường hợp này:

let list = ["a", "b", "c"];
var a = 2;

Nhưng nếu bạn muốn viết nhiều hơn một câu lệnh trên cùng một dòng, thì bạn cần thêm dấu chấm phẩy:

var a = 2; let b = 3

Số trong Swift

Trong Swift, số có 2 kiểu chính: Intvà Double.

An Intlà số không có dấu thập phân. A Doublelà số có dấu thập phân.

Cả hai đều sử dụng 64 bit trên các máy tính hiện đại chạy 64 bit và 32 bit trên nền tảng 32 bit.

Phạm vi giá trị mà chúng có thể lưu trữ phụ thuộc vào nền tảng được sử dụng và có thể được truy xuất bằng cách sử dụng intthuộc tính của từng loại:

Phạm vi giá trị int

Sau đó, ngoài Intvà Double, chúng ta có rất nhiều kiểu số khác. Chúng chủ yếu được sử dụng để tương tác với các API được xây dựng trong quá khứ và cần tương tác với C hoặc Objective-C, và bạn phải biết rằng chúng ta có chúng:

Int8là một số nguyên có 8 bit
Int16là một số nguyên có 16 bit
Int32là một số nguyên có 32 bit
Int64là một số nguyên có 64 bit
UInt8là một số nguyên không dấu có 8 bit
UInt16là một số nguyên không dấu có 16 bit
UInt32là một số nguyên không dấu có 32 bit
UInt64là một số nguyên không dấu có 64 bit
UIntgiống như Int, nhưng không có dấu và nằm trong khoảng từ 0 đến Int.max * 2.
Floatlà số thập phân có 32 bit.

Sau đó, khi sử dụng Cocoa API, bạn có thể sử dụng các kiểu số khác như CLong, CGFloat, v.v.

Bạn sẽ luôn sử dụng Inthoặc Doubletrong mã của mình và chỉ sử dụng những kiểu cụ thể đó trong những trường hợp cụ thể.

Hãy nhớ rằng bạn luôn có thể chuyển đổi bất kỳ kiểu nào trong số đó thành kiểu Intvà Double, khởi tạo một số truyền giá trị bên trong dấu ngoặc đơn thành Double()hoặc Int():

let age : UInt8 = 3
let intAge = Int(age)

Bạn cũng có thể chuyển đổi một số từ Doublethành Int:

let age = Double(3)
let count = Int(3.14)

Làm thế nào để chuyển đổi một số từ DoublesangInt

Chuỗi trong Swift

Chuỗi là một trong những công cụ phổ biến nhất trong lập trình.

Trong Swift, bạn có thể định nghĩa một chuỗi bằng cú pháp chuỗi ký tự:

let name = "Roger"

Chúng tôi sử dụng dấu ngoặc kép. Dấu ngoặc đơn không phải là dấu phân cách chuỗi hợp lệ.

Một chuỗi có thể trải dài trên nhiều dòng bằng cách sử dụng 3 dấu ngoặc kép:

let description = """
a long
long 
long description
"""

Bạn có thể sử dụng nội suy chuỗi để nhúng một biểu thức vào chuỗi:

let age = 8
let name = """
Roger, age \(age)
Next year he will be \(age + 1)
"""

Bạn có thể nối hai chuỗi bằng +toán tử:

var name = "Roger"
name = name + " The Dog"

Và bạn có thể thêm văn bản vào chuỗi bằng toán +=tử:

var name = "Roger"
name += " The Dog"

Hoặc sử dụng append(_:)phương pháp:

var name = "Roger"
name.append(" The Dog")

Bạn có thể đếm số ký tự trong một chuỗi bằng cách sử dụng countthuộc tính chuỗi:

let name = "Roger"
name.count //5

Bất kỳ chuỗi nào cũng đi kèm với một tập hợp các phương thức hữu ích, ví dụ:

removeFirst()để xóa ký tự đầu tiên
removeLast()để xóa ký tự cuối cùng
lowercased()để có một chuỗi mới, viết thường
uppercased()để có một chuỗi mới, viết hoa
starts(with:)trả về true nếu chuỗi bắt đầu bằng một chuỗi con cụ thể
contains()trả về true nếu chuỗi chứa một ký tự cụ thể

Và nhiều nhiều hơn nữa.

Khi bạn cần tham chiếu đến một mục trong chuỗi, vì chuỗi trong Swift là unicode, chúng ta không thể chỉ tham chiếu đến chữ cái obằng let name = "Roger"cách sử dụng name[1]. Bạn cần làm việc với các chỉ mục.

Bất kỳ chuỗi nào cũng cung cấp chỉ mục bắt đầu với startIndexthuộc tính:

let name = "Roger"
name.startIndex //0

Để tính toán một chỉ số cụ thể trong chuỗi, bạn tính toán nó bằng index(i:offsetBy:)phương pháp:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name[i] //"g"

Bạn cũng có thể sử dụng chỉ mục để lấy chuỗi con:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name.suffix(from: i) //"ger"
//Or using the subscript:
name[i...] //"ger"

Khi bạn lấy một chuỗi con từ một chuỗi, kiểu của kết quả là Substring, không phải String.

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
print(type(of: name.suffix(from: i))) 
//Substring

Chuỗi con hiệu quả hơn về mặt bộ nhớ, vì bạn không nhận được chuỗi mới, nhưng cùng một cấu trúc bộ nhớ được sử dụng đằng sau hậu trường. Nhưng bạn cần phải cẩn thận khi xử lý nhiều chuỗi, vì có những tối ưu hóa mà bạn có thể triển khai.

Chuỗi là tập hợp và có thể được lặp lại trong các vòng lặp.

Boolean trong Swift

Swift cung cấp Boolkiểu dữ liệu có thể có hai giá trị: truevà false.

var done = false
done = true

Boolean đặc biệt hữu ích với các cấu trúc điều khiển có điều kiện như ifcâu lệnh hoặc toán tử điều kiện ba ngôi:

var done = true
if done == true {
//code
}

Mảng trong Swift

Chúng tôi sử dụng mảng để tạo ra một tập hợp các mục.

Trong ví dụ này, chúng ta tạo một mảng chứa 3 số nguyên:

var list = [1, 2, 3]

Chúng ta có thể truy cập mục đầu tiên bằng cú pháp list[0], mục thứ hai bằng list[1], v.v.

Các phần tử trong mảng trong Swift phải có cùng kiểu.

Kiểu có thể được suy ra nếu bạn khởi tạo mảng tại thời điểm khai báo, như trong trường hợp trên.

Nếu không, kiểu giá trị mà một mảng có thể bao gồm phải được khai báo theo cách này:

var list: [Int] = []

Một cú pháp viết tắt khác là:

var list = [Int]()

Bạn cũng có thể khai báo rõ ràng kiểu khi khởi tạo như sau:

var list: [Int] = [1, 2, 3]

Một cách nhanh chóng để khởi tạo một mảng là sử dụng toán tử phạm vi:

var list = Array(1...4) //[1, 2, 3, 4]

Để lấy số lượng phần tử trong mảng, hãy sử dụng countthuộc tính:

var list = [1, 2, 3]
list.count //3

Nếu mảng rỗng thì isEmptythuộc tính của nó là true.

var list = [1, 2, 3]
list.isEmpty //false

Bạn có thể thêm một mục vào cuối mảng bằng phương append()pháp:

var list: [Int] = [1, 2, 3]
list.append(4)

hoặc bạn có thể chèn một mục vào bất kỳ vị trí nào của mảng bằng cách sử dụng insert(newElement: <Type> at: Int):

var list: [Int] = [1, 2, 3]
list.insert(17, at: 2)
//list is [1, 2, 17, 3]

Mảng phải được khai báo là varcó thể sửa đổi. Nếu được khai báo bằng let, bạn không thể sửa đổi nó bằng cách thêm hoặc xóa các phần tử.

Để xóa một mục khỏi mảng, hãy sử dụng remove(at:)lệnh truyền chỉ mục của phần tử cần xóa:

var list: [Int] = [1, 2, 3]
list.remove(1)
//list is [1, 3]

removeLast()và removeFirst()có hai cách tiện dụng để loại bỏ phần tử cuối cùng và phần tử đầu tiên.

Để xóa tất cả các mục khỏi mảng, bạn có thể sử dụng removeAll()hoặc gán một mảng trống:

var list: [Int] = [1, 2, 3]
list.removeAll()
//or
list = []

Phương sort()pháp sắp xếp mảng:

var list = [3, 1, 2]
list.sort()
//list is [1, 2, 3]

Còn nhiều phương pháp khác nữa, nhưng đây là những phương pháp cơ bản.

Các mảng được coi là bằng nhau khi chúng chứa các phần tử giống nhau, cùng loại:

[1, 2, 3] == [1, 2, 3] //true

Mảng được truyền theo giá trị, nghĩa là nếu bạn truyền một mảng cho một hàm hoặc trả về mảng đó từ một hàm, mảng đó sẽ được sao chép.

Mảng là tập hợp và có thể được lặp lại trong các vòng lặp.

Bộ trong Swift

Bạn sử dụng tập hợp để tạo ra các bộ sưu tập các mục không lặp lại.

Mặc dù một mảng có thể chứa nhiều phần tử giống nhau, nhưng bạn chỉ có các phần tử duy nhất trong một tập hợp.

Bạn có thể khai báo một tập hợp Intgiá trị theo cách này:

let set: Set<Int> = [1, 2, 3]

hoặc bạn có thể khởi tạo nó từ một mảng:

let set = Set([1, 2, 3])

Bạn có thể thêm các mục vào bộ bằng cách sử dụng insert():

var set = Set([1, 2, 3])
set.insert(17)

Không giống như mảng, không có thứ tự hoặc vị trí trong một tập hợp. Các mục được lấy ra và chèn vào một cách ngẫu nhiên.

Cách in nội dung của một tập hợp theo thứ tự là chuyển đổi nó thành một mảng bằng phương sorted()pháp:

var set = Set([2, 1, 3])
let orderedList = set.sorted()

Để kiểm tra xem một tập hợp có chứa phần tử nào không, hãy sử dụng phương contains()thức:

var set = Set([1, 2, 3])
set.contains(2) //true

Để lấy số lượng phần tử trong tập hợp, hãy sử dụng countthuộc tính:

let set = Set([1, 2, 3])
set.count //3

Nếu một tập hợp rỗng thì isEmptytính chất của nó là true.

let set = Set([1, 2, 3])
set.isEmpty //false

Để xóa một mục khỏi mảng, hãy sử dụng remove()lệnh truyền giá trị của phần tử:

var set = Set([1, 2, 3])
set.remove(1)
//set is [2, 3]

Để xóa tất cả các mục khỏi bộ, bạn có thể sử dụng removeAll():

set.removeAll()

Các tập hợp, giống như mảng, được truyền theo giá trị. Điều này có nghĩa là nếu bạn truyền nó cho một hàm hoặc trả về nó từ một hàm, tập hợp sẽ được sao chép.

Tập hợp rất hữu ích để thực hiện các phép toán tập hợp như giao, hợp, trừ, v.v.

Những phương pháp sau đây có thể giúp ích:

intersection(_:)
symmetricDifference(_:)
union(_:)
subtracting(_:)
isSubset(of:)
isSuperset(of:)
isStrictSubset(of:)
isStrictSuperset(of:)
isDisjoint(with:)

Tập hợp là những bộ sưu tập và có thể được lặp lại theo vòng lặp.

Từ điển trong Swift

Chúng tôi sử dụng từ điển để tạo ra một bộ sưu tập các cặp khóa-giá trị.

Sau đây là cách tạo một từ điển với 1 cặp khóa-giá trị, trong đó khóa là String và giá trị là Int:

var dict = ["Roger": 8, "Syd": 7]

Trong trường hợp này, kiểu được suy ra. Bạn cũng có thể thiết lập rõ ràng kiểu tại thời điểm khai báo:

var dict: [String: Int] = ["Roger": 8, "Syd": 7]

Trong ví dụ này, chúng ta tạo một từ điển rỗng gồm các khóa Int và giá trị String:

var dict = [String: Int]()
//or
var dict: [String: Int] = [:]

Bạn có thể truy cập giá trị được gán cho khóa bằng cú pháp này:

var dict = ["Roger": 8, "Syd": 7]
dict["Roger"] //8
dict["Syd"] //7

Bạn có thể thay đổi giá trị được gán cho khóa theo cách này:

dict["Roger"] = 9

Từ điển phải được khai báo là varcó thể sửa đổi. Nếu được khai báo bằng let, bạn không thể sửa đổi bằng cách thêm hoặc xóa các phần tử.

Sử dụng cú pháp tương tự để thêm cặp khóa/giá trị mới:

dict["Tina"] = 4

Để xóa cặp khóa/giá trị, hãy gán giá trị cho nil:

dict["Tina"] = nil

Hoặc gọi removeValue(forKey:)phương thức:

dict.removeValue(forKey: "Tina")

Để lấy số lượng mục trong từ điển, hãy sử dụng countthuộc tính:

var dict = ["Roger": 8, "Syd": 7]
dict.count //2

Nếu một từ điển trống, isEmptythuộc tính của nó là true.

var dict = [String: Int]()
dict.isEmpty //true

Có rất nhiều phương pháp liên quan đến từ điển, nhưng đây là những phương pháp cơ bản.

Từ điển được truyền theo giá trị, nghĩa là nếu bạn truyền nó cho một hàm hoặc trả về nó từ một hàm, thì từ điển sẽ được sao chép.

Từ điển là các bộ sưu tập và có thể được lặp lại theo vòng lặp.

Tuple trong Swift

Bạn sử dụng tuple để nhóm nhiều giá trị vào một bộ sưu tập duy nhất. Ví dụ, bạn có thể khai báo một biến dogchứa một giá trị String và một giá trị Int:

let dog : (String, Int)

Và bạn có thể khởi tạo chúng bằng tên và tuổi

let dog : (String, Int) = ("Roger", 8)

Nhưng giống như bất kỳ biến nào khác, kiểu có thể được suy ra trong quá trình khởi tạo:

let dog = ("Roger", 8)

Bạn có thể sử dụng các phần tử được đặt tên:

let dog = (name: "Roger", age: 8)
dog.name //"Roger"
dog.age //8

Sau khi một bộ được định nghĩa, bạn có thể phân tích nó thành các biến riêng lẻ theo cách này:

let dog = ("Roger", 8)
let (name, age) = dog

và nếu bạn chỉ cần lấy một trong các giá trị, bạn có thể sử dụng từ khóa gạch dưới đặc biệt để bỏ qua các giá trị khác:

let dog = ("Roger", 8)
let (name, _) = dog

Tuple là một công cụ tuyệt vời cho nhiều nhu cầu khác nhau.

Điều rõ ràng nhất là chúng là cách ngắn gọn để nhóm các dữ liệu tương tự nhau.

Một nhu cầu khác là trả về nhiều mục từ một hàm. Một hàm chỉ có thể trả về một mục duy nhất, do đó, một tuple là một cấu trúc thuận tiện cho việc đó.

Một chức năng tiện dụng khác được cho phép bởi tuple là hoán đổi các phần tử:

var a = 1
var b = 2
(a, b) = (b, a)
//a == 2
//b == 1

Tùy chọn và `nil`trong Swift

Tùy chọn là một tính năng chính của Swift.

Khi bạn không biết giá trị nào đó sẽ có hay không, bạn hãy khai báo kiểu dữ liệu đó là tùy chọn.

Optional sẽ bao bọc một giá trị khác bằng kiểu riêng của nó. Hoặc có thể không.

Chúng ta khai báo một tùy chọn bằng cách thêm dấu chấm hỏi sau kiểu của nó, như thế này:

var value: Int? = 10

Now valuekhông phải là giá trị Int. Nó là giá trị tùy chọn bao bọc giá trị Int.

Để tìm hiểu xem tùy chọn có gói một giá trị hay không, bạn phải mở gói đó.

Bạn thực hiện điều đó bằng cách sử dụng dấu chấm than:

var value: Int? = 10
print(value!) //10

Các phương thức Swift thường trả về một tùy chọn. Ví dụ, Inttrình khởi tạo kiểu chấp nhận một chuỗi và trả về một Int tùy chọn:

Bộ khởi tạo kiểu Int lấy một chuỗi và trả về một int tùy chọn

Nguyên nhân là do máy tính không biết liệu chuỗi ký tự có thể chuyển đổi thành số được hay không.

Nếu phần tùy chọn không chứa giá trị, nó sẽ được đánh giá là nil, và bạn không thể mở gói nó:

Đánh giá đểnil

nillà một giá trị đặc biệt không thể gán cho một biến. Chỉ có thể gán cho một tùy chọn:

Bạn chỉ có thể gán nilcho một tùy chọn (không phải int)

Bạn thường sử dụng ifcác câu lệnh để mở gói các giá trị trong mã của mình, như thế này:

var value: Int? = 2
if let age = value {
print(age)
}

Liệt kê trong Swift

Liệt kê là một cách để nhóm một tập hợp các tùy chọn khác nhau dưới một tên chung.

Ví dụ:

enum Animal {
case dog
case cat
case mouse
case horse
}

Enum này Animalhiện là một kiểu .

Một kiểu mà giá trị của nó chỉ có thể là một trong các trường hợp được liệt kê.

Nếu bạn định nghĩa một biến có kiểu Animal:

var animal: Animal

sau đó bạn có thể quyết định giá trị nào sẽ được gán cho nó bằng cú pháp này:

var animal: Animal
animal = .dog

Chúng ta có thể sử dụng phép liệt kê trong các cấu trúc điều khiển như công tắc:

enum Animal {
case dog
case cat
case mouse
case horse
}
let animal = Animal.dog
switch animal {
case .dog: print("dog")
case .cat: print("cat")
default: print("another animal")
}

Giá trị liệt kê có thể là chuỗi, ký tự hoặc số.

Bạn cũng có thể định nghĩa enum trên một dòng:

enum Animal {
case dog, cat, mouse, horse
}

Và bạn cũng có thể thêm khai báo kiểu vào phép liệt kê và mỗi trường hợp có một giá trị của kiểu đó được gán:

enum Animal: Int {
case dog = 1
case cat = 2
case mouse = 3
case horse = 4
}

Khi bạn có một biến, bạn có thể lấy giá trị này bằng cách sử dụng rawValuethuộc tính của nó:

enum Animal: Int {
case dog = 1
case cat = 2
case mouse = 3
case horse = 4
}
var animal: Animal
animal = .dog
animal.rawValue //1

Enumerations là một kiểu giá trị. Điều này có nghĩa là chúng được sao chép khi được truyền vào một hàm hoặc khi được trả về từ một hàm. Và khi chúng ta gán một biến trỏ đến một enumeration cho một biến khác.

Cấu trúc trong Swift

Cấu trúc là một khái niệm thiết yếu của Swift.

Cấu trúc có ở khắp mọi nơi trong Swift. Ngay cả các kiểu tích hợp cũng là cấu trúc.

Chúng ta có thể tạo ra các thể hiện của cấu trúc, mà chúng ta gọi là đối tượng .

Trong hầu hết các ngôn ngữ, đối tượng chỉ có thể được tạo từ các lớp. Swift cũng có các lớp, nhưng bạn cũng có thể tạo đối tượng từ các cấu trúc. Tài liệu chính thức thực sự khuyên bạn nên ưu tiên các cấu trúc vì chúng dễ sử dụng hơn.

Cấu trúc là phiên bản nhẹ hơn của lớp.

Một struct có thể:

có tính chất
có phương pháp (chức năng)
định nghĩa chỉ số dưới
định nghĩa các trình khởi tạo
tuân thủ theo các giao thức
Gia tăng

Một điều quan trọng mà các lớp cho phép là tính kế thừa, vì vậy nếu bạn cần điều đó, bạn có các lớp.

Một struct được định nghĩa bằng cú pháp sau:

struct Dog {
}

Bên trong một cấu trúc, bạn có thể xác định các thuộc tính được lưu trữ :

struct Dog {
var age = 8
var name = "Roger"
}

Định nghĩa cấu trúc này định nghĩa một kiểu . Để tạo một thể hiện mới với kiểu này, chúng ta sử dụng cú pháp này:

let roger = Dog()

Khi bạn có một phiên bản, bạn có thể truy cập các thuộc tính của nó bằng cú pháp dấu chấm:

let roger = Dog()
roger.age
roger.name

Cú pháp dấu chấm tương tự được sử dụng để cập nhật giá trị thuộc tính:

roger.age = 9

Bạn cũng có thể tạo một thể hiện struct bằng cách truyền các giá trị của thuộc tính:

let syd = Dog(age: 7, name: "Syd")
syd.age
syd.name

Để làm như vậy, các thuộc tính phải được định nghĩa là các biến với var, không phải là hằng số (với let). Điều quan trọng nữa là phải tôn trọng thứ tự các thuộc tính đó được định nghĩa.

Cấu trúc có thể có các phương thức thể hiện : các hàm thuộc về một thể hiện của cấu trúc.

struct Dog {
var age = 8
var name = "Roger"
func bark() {
print("\(name): wof!")
}
}

Và chúng ta cũng có các phương thức kiểu :

struct Dog {
var age = 8
var name = "Roger"
func bark() {
print("\(name): wof!")
}
static func hello() {
print("Hello I am the Dog struct")
}
}

Điều này được gọi là Dog.hello().

Cấu trúc là một kiểu giá trị. Điều này có nghĩa là chúng được sao chép khi được truyền vào một hàm hoặc khi được trả về từ một hàm. Và khi chúng ta gán một biến trỏ đến một cấu trúc cho một biến khác.

Điều này cũng có nghĩa là nếu chúng ta muốn cập nhật các thuộc tính của một cấu trúc, chúng ta phải định nghĩa nó bằng cách sử dụng varvà không phải là let.

Tất cả các kiểu trong Swift đều được định nghĩa là cấu trúc: Int, Double, String, mảng và từ điển, v.v. đều là cấu trúc.

Các lớp trong Swift

Các lớp có phần giống với cấu trúc, nhưng chúng có một số điểm khác biệt chính.

Một lớp được định nghĩa bằng cú pháp sau:

class Dog {
}

Bên trong một lớp, bạn có thể định nghĩa các thuộc tính được lưu trữ:

class Dog {
var age = 0
}

Định nghĩa lớp định nghĩa một kiểu . Để tạo một thể hiện mới với kiểu này, chúng ta sử dụng cú pháp này:

let roger = Dog()

Khi bạn có một phiên bản, bạn có thể truy cập các thuộc tính của nó bằng cú pháp dấu chấm:

let roger = Dog()
roger.age

Bạn sử dụng cú pháp dấu chấm tương tự để cập nhật giá trị thuộc tính:

roger.age = 9

Một điểm khác biệt lớn là các lớp là kiểu tham chiếu. Cấu trúc (và liệt kê) là kiểu giá trị.

Điều này có nghĩa là việc gán một thể hiện lớp cho một biến khác không sao chép thể hiện đó. Cả hai biến đều trỏ đến cùng một thể hiện:

class Dog {
var age = 0
}
let roger = Dog()
let syd = roger
roger.age = 9
//syd.age == 9

Điều này cũng có nghĩa là chúng ta có thể định nghĩa tham chiếu đến một lớp bằng cách sử dụng let, và chúng ta có thể thay đổi các thuộc tính của nó, như bạn đã thấy trong ví dụ trên.

Chúng ta có thể tạo ra các thể hiện của lớp và gọi chúng là đối tượng .

Giống như struct, lớp có thể có thuộc tính, phương thức và nhiều thứ khác.

Ngược lại với struct, chúng ta phải định nghĩa một trình khởi tạo để khởi tạo các giá trị khi chúng ta tạo một thể hiện:

class Dog {
var age : Int
init(age: Int) {
self.age = age
}
}
let roger = Dog(age: 9)

Bạn chỉ có thể khai báo thuộc tính mà không cần khởi tạo chúng nếu bạn có trình khởi tạo.

Xem cách sử dụng self. Chúng ta cần nó vì agenó vừa là thuộc tính thể hiện vừa là tham init(age:)số phương thức. self.agetham chiếu đến agethuộc tính thể hiện.

Các lớp có thể có các phương thức thể hiện : các hàm thuộc về một thể hiện của lớp.

class Dog {
var age = 8
var name = "Roger"
func bark() {
print("\(name): wof!")
}
}

Và chúng ta cũng có các phương thức kiểu :

class Dog {
var age = 8
var name = "Roger"
func bark() {
print("\(name): wof!")
}
static func hello() {
print("Hello I am the Dog struct")
}
}

Được gọi là Dog.hello().

Một điều quan trọng mà các lớp cho phép là tính kế thừa.

Một lớp có thể kế thừa tất cả các thuộc tính và phương thức từ một lớp khác.

Giả sử chúng ta có một lớp Animal. Mỗi con vật có một độ tuổi:

class Animal {
var age: Int
}

Không phải mọi loài động vật đều có tên. Chó có tên. Vì vậy, chúng ta tạo một Doglớp mở rộng từ Animal:

class Dog: Animal {
var name: String
}

Bây giờ chúng ta phải thêm một trình khởi tạo cho cả hai lớp. Trong trường hợp Dog, sau khi chúng ta thực hiện khởi tạo cụ thể cho lớp, chúng ta có thể gọi trình khởi tạo lớp cha bằng cách sử dụng super.init():

class Animal {
var age: Int
init(age: Int) {
self.age = age
}
}
class Dog: Animal {
var name: String
init(age: Int, name: String) {
self.name = name
super.init(age: age)
}
}
var horse = Animal(age: 8)
var roger = Dog(age: 8, name: "Roger")

Animalbây giờ là một siêu lớp và Doglà một lớp con .

Còn nhiều điều cần nói về các lớp học, nhưng đây là phần giới thiệu hay rồi.

Các hàm trong Swift

Mã chương trình của bạn được tổ chức thành các hàm.

Bạn có thể khai báo một hàm bằng cách sử dụng functừ khóa:

func bark() {
print("woof!")
}

Các hàm có thể được gán cho các cấu trúc, lớp và phép liệt kê và trong trường hợp này chúng ta gọi chúng là phương thức.

Một hàm được gọi bằng cách sử dụng tên của nó:

bark()

Một hàm có thể trả về một giá trị:

func bark() -> String {
print("woof!")
return "barked successfully"
}

Và bạn có thể gán nó cho một biến:

let result = bark()

Một hàm có thể chấp nhận các tham số. Mỗi tham số có một tên và một kiểu:

func bark(times: Int) {
for index in 0..<times {
print("woof!")
}
}

Tên của tham số nằm bên trong hàm.

Chúng ta sử dụng tên của tham số khi gọi hàm để truyền giá trị của nó:

bark(times: 3)

Khi chúng ta gọi hàm, chúng ta phải truyền tất cả các tham số đã xác định.

Sau đây là một hàm chấp nhận nhiều tham số:

func bark(times: Int, repeatBark: Bool) {
for index in 0..<times {
if repeatBark == true {
print("woof woof!")
} else {
print("woof!")
}            
}
}

Trong trường hợp này bạn gọi nó theo cách này:

bark(times: 3, repeat: true)

Khi chúng ta nói về hàm này, chúng ta không gọi nó là bark(). Chúng ta gọi nó là bark(times:repeat:).

Điều này là do chúng ta có thể có nhiều hàm có cùng tên nhưng có bộ tham số khác nhau.

Bạn có thể tránh sử dụng nhãn bằng cách sử dụng _từ khóa:

func bark(_ times: Int, repeatBark: Bool) {
//...the function body
}

Vì vậy, bạn có thể gọi nó theo cách này:

bark(3, repeat: true)

Trong Swift và API iOS, thông thường tham số đầu tiên không có nhãn và các tham số khác có nhãn.

Nó tạo nên một API đẹp và biểu cảm khi bạn thiết kế tên hàm và các tham số một cách hợp lý.

Bạn chỉ có thể trả về một giá trị từ một hàm. Nếu bạn cần trả về nhiều giá trị, thông thường trả về một bộ:

func bark() -> (String, Int) {
print("woof!")
return ("barked successfully", 1)
}

Và bạn có thể gán kết quả cho một tuple:

let (result, num) = bark()
print(result) //"barked successfully"
print(num) //1

Bạn có thể lồng các hàm bên trong các hàm khác. Khi điều này xảy ra, hàm bên trong sẽ vô hình với bên ngoài hàm bên ngoài.

Giao thức trong Swift

Giao thức là một cách để các đối tượng khác nhau, thuộc nhiều loại khác nhau, có một tập hợp chức năng chung.

Bạn định nghĩa một giao thức như thế này:

protocol Mammal {
}

Các cấu trúc và lớp có thể áp dụng giao thức theo cách này:

struct Dog: Mammal {
}
class Cat: Mammal {
}

Một giao thức có thể định nghĩa các thuộc tính và phương thức mà không cung cấp giá trị và triển khai, và một struct/class phải triển khai chúng:

protocol Mammal {
var age: Int { get set }
func walk()
}

Thuộc tính có thể được định nghĩa là gethoặc get set. Nếu là get, thuộc tính phải được triển khai ở chế độ chỉ đọc, với một hàm lấy dữ liệu.

Bất kỳ loại nào áp dụng giao thức đều phải tuân thủ giao thức bằng cách triển khai các phương pháp đó hoặc cung cấp các thuộc tính đó:

struct Dog: Mammal {
var age: Int = 0
func walk() {
print("The dog is walking")
}
}
class Cat: Mammal {
var age: Int = 0
func walk() {
print("The cat is walking")
}
}

Cấu trúc và lớp có thể áp dụng nhiều giao thức:

struct Dog: Mammal, Animal {
}
class Cat: Mammal, Animal {
}

Lưu ý rằng đối với các lớp, đây là cú pháp tương tự được sử dụng để định nghĩa siêu lớp. Nếu có siêu lớp, hãy liệt kê nó là mục đầu tiên trong danh sách, sau dấu hai chấm.

Phần Kết

Tôi hy vọng cuốn sổ tay nhỏ này hữu ích trong việc làm sáng tỏ cách bắt đầu với Swift. Và tôi hy vọng bây giờ bạn quan tâm đến việc tìm hiểu thêm về nó!

Bây giờ tôi có thể chỉ cho bạn một vài địa điểm để tìm hiểu thêm:

Bạn có thể tải xuống phiên bản PDF và ePub của Sổ tay hướng dẫn sử dụng Swift cho người mới bắt đầu tại đây .

Ngoài ra, các bạn có thể tham khảo thêm về cách lưu trữ dữ liệu cục bộ trong react native 1 cách cool và Bộ câu hỏi Phỏng vấn Swift auto pass :

70 Swift interview questions

Cách lưu trữ dữ liệu cục bộ trong React Native Expo

70 Swift interview questions

Lập Trình

Lập Trình Mobile

Swift - IOS

73 min
2 năm ago
12

Swift Fundamentals OOP trong Swift Câu 11: Làm thế nào để định nghĩa một class trong Swift? Để định nghĩa một class trong Swift, bạn sử dụng từ khóa class theo sau là tên của class và cặp ngoặc nhọn chứa các […]

Tagged #ios

Sự khác biệt giữa let và var trong Swift?

let được sử dụng để khai báo một hằng số, giá trị của nó không thể thay đổi sau khi đã được gán lần đầu.
var được sử dụng để khai báo một biến, giá trị của nó có thể thay đổi trong suốt vòng đời của biến.

 let constantValue = 10 // constantValue = 20 // Lỗi: không thể thay đổi giá trị của hằng số var variableValue = 10 variableValue = 20 // Hợp lệ: giá trị của biến có thể thay đổi

Làm thế nào để định nghĩa một hằng số được tính toán tại runtime trong Swift?

Để định nghĩa một hằng số được tính toán tại runtime, bạn có thể sử dụng lazy và một closure để tính giá trị của nó.

 lazy var runtimeComputedConstant: Int = { return 2 * 10 }()

Bạn có thể giải thích mục đích của optional trong Swift không?

Optionals được sử dụng để xử lý các giá trị có thể không tồn tại (nil). Một biến optional có thể chứa một giá trị hoặc nil.

 var optionalValue: Int? = nil optionalValue = 10 if let value = optionalValue { print("Giá trị là \(value)") } else { print("Không có giá trị") }

Tuples là gì và chúng hữu ích như thế nào trong Swift?

Tuples là một nhóm các giá trị được gộp lại với nhau thành một giá trị duy nhất. Chúng hữu ích khi bạn muốn trả về nhiều giá trị từ một hàm.

 let tuple = (404, "Not Found") let (statusCode, statusMessage) = tuple print("Mã trạng thái là \(statusCode) và thông báo là \(statusMessage)")

Mô tả các loại collection khác nhau có sẵn trong Swift.

Swift cung cấp ba loại collection chính: Array, Set, và Dictionary.

 // Array var array: [Int] = [1, 2, 3] // Set var set: Set<Int> = [1, 2, 3] // Dictionary var dictionary: [String: Int] = ["one": 1, "two": 2, "three": 3]

Làm thế nào để bạn xử lý điều khiển luồng trong Swift với vòng lặp và điều kiện?

Swift cung cấp các cấu trúc điều khiển như for, while, if, và switch để điều khiển luồng chương trình.

 // For loop for i in 1...5 { print(i) } // While loop var i = 1 while i <= 5 { print(i) i += 1 } // If condition let number = 10 if number > 5 { print("\(number) lớn hơn 5") } else { print("\(number) không lớn hơn 5") }

Enumerations trong Swift là gì và chúng hỗ trợ các giá trị liên kết như thế nào?

Enumerations (enum) trong Swift là một kiểu dữ liệu xác định một nhóm các giá trị liên quan. Chúng có thể lưu trữ các giá trị liên kết.

 enum CompassPoint { case north case south case east case west } enum Barcode { case upc(Int, Int, Int, Int) case qrCode(String) } var productBarcode = Barcode.upc(8, 85909, 51226, 3) productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

Trong Swift, làm thế nào các câu lệnh switch mạnh mẽ hơn so với các ngôn ngữ khác?

Swift’s switch statements mạnh mẽ hơn vì chúng không cần break, có thể xử lý nhiều điều kiện trong một case, và hỗ trợ các pattern matching phức tạp.

 let value = 42 switch value { case 0...10: print("Trong khoảng từ 0 đến 10") case 11...20: print("Trong khoảng từ 11 đến 20") case 21...30: print("Trong khoảng từ 21 đến 30") case 31...40: print("Trong khoảng từ 31 đến 40") default: print("Ngoài khoảng từ 0 đến 40") }

Mô tả khái niệm type inference trong Swift.

Type inference là khả năng của Swift để tự động suy luận kiểu dữ liệu của biến hoặc hằng số dựa trên giá trị được gán ban đầu.

 let integerValue = 42 // Swift tự động suy luận kiểu Int let stringValue = "Hello, Swift" // Swift tự động suy luận kiểu String

Type casting trong Swift là gì và nó được triển khai như thế nào?
- Type casting được sử dụng để kiểm tra kiểu của một đối tượng hoặc để chuyển đổi kiểu của đối tượng đó. Swift cung cấp as? và as! cho mục đích này.

let someValue: Any = "Hello" if let stringValue = someValue as? String { print("Giá trị là chuỗi: \(stringValue)") } else { print("Giá trị không phải là chuỗi") } // Cưỡng bức chuyển đổi kiểu let forcedStringValue = someValue as! String print("Giá trị cưỡng bức chuyển đổi: \(forcedStringValue)")

OOP trong Swift

Câu 11: Làm thế nào để định nghĩa một class trong Swift?

Để định nghĩa một class trong Swift, bạn sử dụng từ khóa class theo sau là tên của class và cặp ngoặc nhọn chứa các thuộc tính và phương thức của class đó. Ví dụ:

class Person { var name: String var age: Int init(name: String, age: Int) { self.name = name self.age = age } func sayHello() { print("Hello, my name is \(name) and I am \(age) years old.") } } let person = Person(name: "John", age: 30) person.sayHello()

Câu 12: Giải thích sự khác biệt giữa classes và structures trong Swift.

Classes và structures trong Swift có nhiều điểm khác biệt quan trọng.

Classes là kiểu tham chiếu (reference type), có thể kế thừa từ các class khác, kiểm tra và ép kiểu (type casting), có thể có deinitializer để giải phóng tài nguyên, và hỗ trợ tính đa hình (polymorphism). Ví dụ:

class MyClass { var value: Int = 0 } let classA = MyClass() let classB = classA classB.value = 10 print(classA.value) // Output: 10 (vì classA và classB đều tham chiếu đến cùng một instance)

Structures là kiểu giá trị (value type), không hỗ trợ kế thừa, không có deinitializer, và chủ yếu được sử dụng để tạo các kiểu dữ liệu đơn giản, không yêu cầu các tính năng nâng cao của class. Ví dụ:

struct MyStruct { var value: Int = 0 } var structA = MyStruct() var structB = structA structB.value = 10 print(structA.value) // Output: 0 (vì structA và structB là hai instance khác nhau)

Câu 13: Những nguyên tắc chính của kế thừa trong Swift là gì?

Kế thừa cho phép một class thừa hưởng các thuộc tính và phương thức từ một class khác. Class con có thể ghi đè (override) các phương thức của class cha và thêm các thuộc tính và phương thức mới. Ví dụ:

class Animal { func makeSound() { print("Some generic sound") } } class Dog: Animal { override func makeSound() { print("Woof!") } } let dog = Dog() dog.makeSound() // Output: Woof!

Câu 14: Swift cho phép đóng gói (encapsulation) trong các class và struct như thế nào?

Encapsulation được thực hiện thông qua việc kiểm soát quyền truy cập (access control) bằng các từ khóa như private, fileprivate, internal, public, và open. Ví dụ:

class Encapsulated { private var privateVariable = 0 func setVariable(value: Int) { privateVariable = value } func getVariable() -> Int { return privateVariable } } let encapsulated = Encapsulated() encapsulated.setVariable(value: 10) print(encapsulated.getVariable()) // Output: 10

Câu 15: Class trong Swift có thể có đa kế thừa không?

Không, Swift không hỗ trợ đa kế thừa. Một class chỉ có thể kế thừa từ một class cha. Tuy nhiên, một class có thể tuân theo nhiều protocol. Ví dụ:

protocol A { func methodA() } protocol B { func methodB() } class MyClass: A, B { func methodA() { print("Method A") } func methodB() { print("Method B") } }

Câu 16: Mô tả method overloading và method overriding trong Swift.

Method overloading là khi hai hoặc nhiều phương thức có cùng tên nhưng khác tham số (số lượng hoặc kiểu dữ liệu tham số) trong cùng một class hoặc struct. Method overriding là khi một phương thức trong class con ghi đè (override) phương thức của class cha. Ví dụ:

// Method Overloading class OverloadingExample { func printMessage() { print("No parameters") } func printMessage(withText text: String) { print(text) } } // Method Overriding class ParentClass { func greet() { print("Hello from Parent") } } class ChildClass: ParentClass { override func greet() { print("Hello from Child") } } let overloadingExample = OverloadingExample() overloadingExample.printMessage() // Output: No parameters overloadingExample.printMessage(withText: "Hello!") // Output: Hello! let child = ChildClass() child.greet() // Output: Hello from Child

Câu 17: Convenience initializer trong Swift là gì?

Convenience initializer là một loại initializer phụ, được định nghĩa bằng từ khóa convenience. Nó gọi một initializer khác của cùng một class để khởi tạo tất cả các thuộc tính. Ví dụ:

class MyClass { var value: Int init(value: Int) { self.value = value } convenience init() { self.init(value: 0) } } let myObject = MyClass() // Gọi convenience initializer print(myObject.value) // Output: 0

Câu 18: Final classes hoặc methods có lợi ích gì trong Swift?

final class hoặc method ngăn chặn việc ghi đè hoặc kế thừa. Điều này giúp bảo vệ sự toàn vẹn của class hoặc method và có thể cải thiện hiệu suất. Ví dụ:

final class FinalClass { func greet() { print("Hello") } } // Không thể kế thừa từ FinalClass // class SubClass: FinalClass {} class AnotherClass { final func greet() { print("Hello") } } class SubClass: AnotherClass { // Không thể ghi đè method greet // override func greet() {} }

Protocol-Programing Orientation

Câu 19: Định nghĩa một protocol trong Swift và giải thích các trường hợp sử dụng thông thường của nó.

Protocol trong Swift định nghĩa một bản mẫu về các thuộc tính và phương thức mà một class, struct, hoặc enum phải tuân theo. Protocol không cung cấp thực thi, chỉ định nghĩa. Đây là cách định nghĩa một protocol:

protocol Greetable { var name: String { get } func greet() }

Trường hợp sử dụng thông thường của protocol bao gồm:

Định nghĩa các hành vi chung cho nhiều loại đối tượng khác nhau.
Tạo các giao diện chuẩn cho các thành phần để chúng có thể làm việc với nhau.

Câu 20: Làm thế nào để tuân theo một protocol trong Swift?

Để tuân theo một protocol, bạn khai báo rằng class, struct, hoặc enum của bạn tuân theo protocol đó và cung cấp thực thi cho tất cả các thuộc tính và phương thức yêu cầu.

class Person: Greetable { var name: String init(name: String) { self.name = name } func greet() { print("Hello, my name is \(name).") } } let person = Person(name: "John") person.greet() // Output: Hello, my name is John.

Câu 21: Giải thích cách sử dụng extensions trong Swift.

Extensions trong Swift cho phép bạn thêm các chức năng mới vào một class, struct, enum hoặc protocol hiện có mà không cần truy cập vào mã nguồn gốc. Đây là cách sử dụng extensions:

extension Int { func square() -> Int { return self * self } } let number = 4 print(number.square()) // Output: 16

Câu 22: Protocol extensions là gì và chúng khác biệt như thế nào so với extensions truyền thống?

Protocol extensions cho phép bạn cung cấp thực thi mặc định cho các phương thức và thuộc tính được định nghĩa trong protocol. Điều này khác với extensions truyền thống ở chỗ bạn có thể thêm thực thi vào protocol thay vì chỉ định nghĩa các phương thức và thuộc tính.

protocol Greetable { func greet() } extension Greetable { func greet() { print("Hello from protocol extension!") } } struct Person: Greetable {} let person = Person() person.greet() // Output: Hello from protocol extension!

Câu 23: Làm thế nào các protocol có thể được sử dụng để đạt được tính đa hình (polymorphism) trong Swift?

Protocol cho phép bạn đạt được tính đa hình bằng cách định nghĩa một giao diện chung mà nhiều loại đối tượng khác nhau có thể tuân theo. Bạn có thể sử dụng các đối tượng này mà không cần biết chính xác kiểu của chúng, chỉ cần biết rằng chúng tuân theo protocol đó.

protocol Drivable { func drive() } class Car: Drivable { func drive() { print("Driving a car") } } class Bike: Drivable { func drive() { print("Riding a bike") } } let vehicles: [Drivable] = [Car(), Bike()] for vehicle in vehicles { vehicle.drive() } // Output: // Driving a car // Riding a bike

Câu 24: Thảo luận về khái niệm composition protocol trong Swift.

Composition protocol cho phép bạn kết hợp nhiều protocol lại với nhau để tạo thành một yêu cầu duy nhất. Bạn sử dụng từ khóa & để kết hợp các protocol.

protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } struct Person: Named, Aged { var name: String var age: Int } func wishHappyBirthday(to celebrator: Named & Aged) { print("Happy birthday, \(celebrator.name), you are \(celebrator.age) years old!") } let birthdayPerson = Person(name: "John", age: 30) wishHappyBirthday(to: birthdayPerson) // Output: Happy birthday, John, you are 30 years old!

Câu 25: Các kiểu liên kết (associated types) trong protocol Swift là gì?

Các kiểu liên kết trong protocol Swift cho phép bạn định nghĩa một placeholder cho một kiểu mà sẽ được xác định khi protocol được tuân theo. Bạn sử dụng từ khóa associatedtype để định nghĩa kiểu liên kết.

protocol Container { associatedtype Item var items: [Item] { get } mutating func add(item: Item) } struct IntContainer: Container { var items: [Int] = [] mutating func add(item: Int) { items.append(item) } } var container = IntContainer() container.add(item: 5) print(container.items) // Output: [5]

Câu 26: Mô tả việc sử dụng closures trong Swift.

Closures trong Swift là những khối mã có thể được truyền và sử dụng trong mã của bạn. Chúng tương tự như các hàm vô danh (anonymous functions) trong các ngôn ngữ lập trình khác. Closures có thể chụp và lưu trữ các tham chiếu tới bất kỳ hằng số và biến nào từ ngữ cảnh mà chúng được định nghĩa. Dưới đây là một ví dụ về closure:

let greetingClosure = { print("Hello, World!") } greetingClosure() // Output: Hello, World!

Closures có thể chấp nhận tham số và trả về giá trị:

let sumClosure: (Int, Int) -> Int = { (a, b) in return a + b } let result = sumClosure(3, 5) print(result) // Output: 8

Câu 27: Làm thế nào để xử lý escaping và non-escaping closures trong Swift?

Escaping closures là các closures có thể được gọi sau khi hàm mà chúng được truyền vào kết thúc thực thi. Để đánh dấu một closure là escaping, bạn sử dụng từ khóa @escaping.

func performAsyncTask(completion: @escaping () -> Void) { DispatchQueue.global().async { // Thực hiện một tác vụ không đồng bộ completion() } }

Non-escaping closures là các closures phải được gọi trước khi hàm mà chúng được truyền vào kết thúc thực thi. Mặc định, closures trong Swift là non-escaping.

func performTask(completion: () -> Void) { // Thực hiện một tác vụ đồng bộ completion() }

Câu 28: Higher-order functions trong Swift là gì? Cho một ví dụ.

Higher-order functions là các hàm có thể chấp nhận một hoặc nhiều hàm khác làm tham số và/hoặc trả về một hàm khác. Một ví dụ phổ biến về higher-order functions trong Swift là map, filter, và reduce.

Ví dụ, sử dụng map để chuyển đổi các phần tử của một mảng:

let numbers = [1, 2, 3, 4, 5] let squaredNumbers = numbers.map { $0 * $0 } print(squaredNumbers) // Output: [1, 4, 9, 16, 25]

Câu 29: Giải thích cách bạn có thể sử dụng các hàm map, filter, và reduce trong Swift.

map: Dùng để chuyển đổi từng phần tử trong một collection thành một giá trị mới, và trả về một collection mới chứa các giá trị đã được chuyển đổi.

let numbers = [1, 2, 3, 4, 5] let doubledNumbers = numbers.map { $0 * 2 } print(doubledNumbers) // Output: [2, 4, 6, 8, 10]

filter: Dùng để lọc các phần tử trong một collection dựa trên một điều kiện nào đó, và trả về một collection mới chứa các phần tử thỏa mãn điều kiện đó.

let numbers = [1, 2, 3, 4, 5] let evenNumbers = numbers.filter { $0 % 2 == 0 } print(evenNumbers) // Output: [2, 4]

reduce: Dùng để kết hợp tất cả các phần tử trong một collection thành một giá trị duy nhất bằng cách áp dụng một hàm kết hợp.

let numbers = [1, 2, 3, 4, 5] let sum = numbers.reduce(0) { $0 + $1 } print(sum) // Output: 15

Function Programing Feature

Câu 26: Mô tả việc sử dụng closures trong Swift.

let greetingClosure = { print("Hello, World!") } greetingClosure() // Output: Hello, World!

Closures có thể chấp nhận tham số và trả về giá trị:

let sumClosure: (Int, Int) -> Int = { (a, b) in return a + b } let result = sumClosure(3, 5) print(result) // Output: 8

Câu 27: Làm thế nào để xử lý escaping và non-escaping closures trong Swift?

func performAsyncTask(completion: @escaping () -> Void) { DispatchQueue.global().async { // Thực hiện một tác vụ không đồng bộ completion() } }

Non-escaping closures là các closures phải được gọi trước khi hàm mà chúng được truyền vào kết thúc thực thi. Mặc định, closures trong Swift là non-escaping.

func performTask(completion: () -> Void) { // Thực hiện một tác vụ đồng bộ completion() }

Câu 28: Higher-order functions trong Swift là gì? Cho một ví dụ.

Ví dụ, sử dụng map để chuyển đổi các phần tử của một mảng:

let numbers = [1, 2, 3, 4, 5] let squaredNumbers = numbers.map { $0 * $0 } print(squaredNumbers) // Output: [1, 4, 9, 16, 25]

Câu 29: Giải thích cách bạn có thể sử dụng các hàm map, filter, và reduce trong Swift.

map: Dùng để chuyển đổi từng phần tử trong một collection thành một giá trị mới, và trả về một collection mới chứa các giá trị đã được chuyển đổi.

let numbers = [1, 2, 3, 4, 5] let doubledNumbers = numbers.map { $0 * 2 } print(doubledNumbers) // Output: [2, 4, 6, 8, 10]

filter: Dùng để lọc các phần tử trong một collection dựa trên một điều kiện nào đó, và trả về một collection mới chứa các phần tử thỏa mãn điều kiện đó.

let numbers = [1, 2, 3, 4, 5] let evenNumbers = numbers.filter { $0 % 2 == 0 } print(evenNumbers) // Output: [2, 4]

reduce: Dùng để kết hợp tất cả các phần tử trong một collection thành một giá trị duy nhất bằng cách áp dụng một hàm kết hợp.

let numbers = [1, 2, 3, 4, 5] let sum = numbers.reduce(0) { $0 + $1 } print(sum) // Output: 15

Swift Stand Library

Câu 30: Liệt kê một số thuật toán thường được sử dụng cung cấp bởi thư viện chuẩn của Swift.

Thư viện chuẩn của Swift cung cấp nhiều thuật toán hữu ích, bao gồm:

sort() và sorted(): Sắp xếp các phần tử trong một collection.

 var numbers = [5, 3, 1, 4, 2] numbers.sort() print(numbers) // Output: [1, 2, 3, 4, 5]

map(): Áp dụng một hàm tới từng phần tử của một collection và trả về một collection mới với các phần tử đã được biến đổi.

 let doubled = numbers.map { $0 * 2 } print(doubled) // Output: [2, 4, 6, 8, 10]

filter(): Lọc các phần tử của một collection dựa trên một điều kiện.

 let evenNumbers = numbers.filter { $0 % 2 == 0 } print(evenNumbers) // Output: [2, 4]

reduce(): Kết hợp các phần tử của một collection thành một giá trị duy nhất.

 let sum = numbers.reduce(0) { $0 + $1 } print(sum) // Output: 15

contains(): Kiểm tra xem một collection có chứa một giá trị cụ thể hay không.

 let containsThree = numbers.contains(3) print(containsThree) // Output: true

Câu 31: Swift xử lý thao tác chuỗi trong thư viện chuẩn của nó như thế nào?

Swift cung cấp nhiều phương thức và thuộc tính mạnh mẽ để thao tác chuỗi trong thư viện chuẩn của nó. Một số thao tác phổ biến bao gồm:

Concatenation (nối chuỗi): Sử dụng toán tử + hoặc phương thức append().

 var greeting = "Hello, " greeting += "World!" print(greeting) // Output: Hello, World!

Interpolation (nội suy): Sử dụng cú pháp \(expression) để chèn giá trị của biến hoặc biểu thức vào trong chuỗi.

 let name = "John" let age = 30 let message = "My name is \(name) and I am \(age) years old." print(message) // Output: My name is John and I am 30 years old.

Substring (trích xuất chuỗi con): Sử dụng cú pháp prefix(), suffix(), hoặc phạm vi chỉ số.

 let fullName = "John Doe" let firstName = fullName.prefix(4) print(firstName) // Output: John

Replacing and removing: Sử dụng phương thức replacingOccurrences() và remove().

 var greeting = "Hello, World!" greeting = greeting.replacingOccurrences(of: "World", with: "Swift") print(greeting) // Output: Hello, Swift!

Câu 32: Mô tả mục đích của kiểu Optional trong thư viện chuẩn của Swift.

Kiểu Optional trong Swift được sử dụng để xử lý các giá trị có thể không tồn tại (nil). Một biến Optional có thể chứa một giá trị hoặc nil, giúp tránh các lỗi null reference phổ biến trong các ngôn ngữ khác. Cú pháp của một biến Optional sử dụng dấu hỏi (?) để chỉ ra rằng nó có thể là nil.

var optionalValue: Int? = nil optionalValue = 10 if let value = optionalValue { print("Giá trị là \(value)") } else { print("Không có giá trị") }

Câu 33: Lợi ích của việc sử dụng Array trong Swift so với NSArray trong Objective-C là gì?

Swift’s Array mang lại nhiều lợi ích so với NSArray trong Objective-C:

Type Safety (an toàn kiểu dữ liệu): Swift’s Array là kiểu generic, điều này có nghĩa là nó yêu cầu tất cả các phần tử trong mảng phải có cùng kiểu. Điều này giúp phát hiện lỗi tại thời gian biên dịch thay vì thời gian chạy.

 var intArray: [Int] = [1, 2, 3] // intArray.append("4") // Lỗi: không thể thêm chuỗi vào mảng số nguyên

Performance (hiệu suất): Swift’s Array được tối ưu hóa cho hiệu suất và cung cấp các phương thức mạnh mẽ như map, filter, và reduce.
Bridging (cầu nối): Swift’s Array có thể dễ dàng cầu nối với NSArray, cho phép sử dụng các API của Objective-C một cách mượt mà.
Syntax (cú pháp): Swift’s Array cung cấp cú pháp đơn giản và rõ ràng hơn so với NSArray.

 let swiftArray = [1, 2, 3, 4, 5] let nsArray: NSArray = [1, 2, 3, 4, 5]

Error Handling in Swift

Câu 34: Minh họa cách xử lý lỗi bằng cách sử dụng các khối do-try-catch trong Swift.

Swift cung cấp cơ chế xử lý lỗi mạnh mẽ thông qua các khối do-try-catch. Bạn có thể ném lỗi từ một hàm sử dụng từ khóa throw, và sau đó xử lý lỗi đó trong khối do-catch. Dưới đây là một ví dụ:

enum FileError: Error { case fileNotFound case unreadable case encodingFailed } func readFile(at path: String) throws -> String { guard path == "validPath" else { throw FileError.fileNotFound } return "File content" } do { let content = try readFile(at: "invalidPath") print(content) } catch FileError.fileNotFound { print("File not found.") } catch FileError.unreadable { print("File is unreadable.") } catch FileError.encodingFailed { print("Failed to encode the file content.") } catch { print("An unexpected error occurred: \(error).") }

Câu 35: Làm thế nào bạn có thể định nghĩa các loại lỗi của riêng bạn bằng cách sử dụng enumerations trong Swift?

Bạn có thể định nghĩa các loại lỗi của riêng mình bằng cách sử dụng enum và tuân theo giao thức Error. Dưới đây là một ví dụ về cách tạo một loại lỗi tùy chỉnh:

enum NetworkError: Error { case badURL case requestFailed case unknown } func fetchData(from urlString: String) throws { guard urlString == "validURL" else { throw NetworkError.badURL } // Perform network request... }

Câu 36: Giải thích mục đích của từ khóa throws trong khai báo hàm.

Từ khóa throws trong khai báo hàm được sử dụng để chỉ ra rằng hàm này có thể ném lỗi trong quá trình thực thi của nó. Khi một hàm có từ khóa throws, bạn phải gọi hàm đó bằng cách sử dụng từ khóa try và xử lý lỗi bằng do-catch. Dưới đây là một ví dụ:

func canThrowErrors() throws { // Code that might throw an error } do { try canThrowErrors() } catch { print("An error occurred: \(error)") }

Câu 65: Bạn có thể giải thích các cách khác nhau để truyền lỗi trong Swift không?

Trong Swift, có ba cách chính để truyền lỗi:

Propagate the error using throws:
Hàm có thể ném lỗi bằng cách sử dụng từ khóa throws. Người gọi hàm phải xử lý lỗi bằng cách sử dụng do-try-catch.

 func processFile(at path: String) throws { // Code that might throw an error } do { try processFile(at: "invalidPath") } catch { print("An error occurred: \(error)") }

Handle the error locally with do-catch:
Bạn có thể xử lý lỗi ngay tại nơi nó xảy ra bằng cách sử dụng do-catch.

 func performTask() { do { try processFile(at: "invalidPath") } catch { print("An error occurred: \(error)") } }

Convert the error to an optional value using try?:
Sử dụng try? để chuyển đổi một hàm có thể ném lỗi thành một giá trị optional. Nếu hàm ném lỗi, giá trị trả về sẽ là nil.

 let result = try? processFile(at: "invalidPath") if result == nil { print("An error occurred.") }

Suppress the error using try!:
Sử dụng try! để đảm bảo rằng lỗi sẽ không xảy ra. Nếu hàm ném lỗi, chương trình sẽ crash.

 let result = try! processFile(at: "validPath")

Swift and Memory Management

Câu 37: Thảo luận về cách hoạt động của Automatic Reference Counting (ARC) trong Swift.

Automatic Reference Counting (ARC) trong Swift là một cơ chế quản lý bộ nhớ tự động để theo dõi và quản lý việc sử dụng bộ nhớ của các đối tượng. ARC đếm số lượng tham chiếu mạnh (strong references) tới mỗi instance của class. Khi không còn bất kỳ tham chiếu mạnh nào tới một instance, ARC sẽ giải phóng bộ nhớ của instance đó.

Ví dụ:

class Person { var name: String init(name: String) { self.name = name print("\(name) is initialized") } deinit { print("\(name) is being deinitialized") } } var person1: Person? = Person(name: "John") var person2: Person? = person1 person1 = nil person2 = nil // Output: John is initialized // Output: John is being deinitialized

Câu 38: Làm thế nào để ngăn chặn retain cycles trong Swift khi sử dụng closures?

Retain cycles xảy ra khi hai hoặc nhiều đối tượng giữ tham chiếu mạnh tới nhau, ngăn cản ARC giải phóng bộ nhớ. Khi sử dụng closures, bạn có thể ngăn chặn retain cycles bằng cách sử dụng capture list với từ khóa weak hoặc unowned.

Ví dụ:

class Person { var name: String var apartment: Apartment? init(name: String) { self.name = name } deinit { print("\(name) is being deinitialized") } } class Apartment { var unit: String weak var tenant: Person? init(unit: String) { self.unit = unit } deinit { print("Apartment \(unit) is being deinitialized") } } var john: Person? = Person(name: "John") var unit4A: Apartment? = Apartment(unit: "4A") john?.apartment = unit4A unit4A?.tenant = john john = nil unit4A = nil // Output: John is being deinitialized // Output: Apartment 4A is being deinitialized

Câu 39: Giải thích khái niệm weak và unowned references trong Swift.

weak và unowned là hai loại tham chiếu yếu (weak references) giúp ngăn chặn retain cycles.

weak: Tham chiếu yếu không giữ đối tượng mà nó tham chiếu tới. Tham chiếu yếu có thể trở thành nil nếu đối tượng mà nó tham chiếu tới bị giải phóng. weak luôn được khai báo như một optional.

class Person { var name: String weak var friend: Person? init(name: String) { self.name = name } }

unowned: Tham chiếu không sở hữu không giữ đối tượng mà nó tham chiếu tới và không bao giờ trở thành nil. Sử dụng unowned khi bạn chắc chắn rằng tham chiếu sẽ luôn tồn tại trong suốt vòng đời của đối tượng.

class Customer { var name: String var card: CreditCard? init(name: String) { self.name = name } deinit { print("\(name) is being deinitialized") } } class CreditCard { let number: Int unowned let customer: Customer init(number: Int, customer: Customer) { self.number = number self.customer = customer } deinit { print("Card #\(number) is being deinitialized") } } var john: Customer? = Customer(name: "John") john?.card = CreditCard(number: 1234_5678_9012_3456, customer: john!) john = nil // Output: John is being deinitialized // Output: Card #1234567890123456 is being deinitialized

Câu 66: Cho một ví dụ nơi bạn sẽ sử dụng unowned thay vì weak.

Sử dụng unowned khi bạn chắc chắn rằng tham chiếu sẽ không bao giờ là nil trong suốt vòng đời của đối tượng. Một ví dụ điển hình là mối quan hệ giữa một khách hàng và thẻ tín dụng của họ. Một thẻ tín dụng không thể tồn tại mà không có một khách hàng liên kết với nó.

class Customer { var name: String var card: CreditCard? init(name: String) { self.name = name } deinit { print("\(name) is being deinitialized") } } class CreditCard { let number: Int unowned let customer: Customer init(number: Int, customer: Customer) { self.number = number self.customer = customer } deinit { print("Card #\(number) is being deinitialized") } } var john: Customer? = Customer(name: "John") john?.card = CreditCard(number: 1234_5678_9012_3456, customer: john!) john = nil // Output: John is being deinitialized // Output: Card #1234567890123456 is being deinitialized

Concurrency and Parallelism

Câu 40: Vai trò của Grand Central Dispatch (GCD) trong Swift là gì?

Grand Central Dispatch (GCD) trong Swift là một API mạnh mẽ được sử dụng để quản lý concurrency và thực thi các tác vụ trên các queue. GCD giúp bạn dễ dàng thực thi mã không đồng bộ, quản lý các queue, và tối ưu hóa hiệu suất của ứng dụng. GCD cung cấp một số queue chính, bao gồm:

Main Queue: Thực thi các tác vụ trên main thread, thường được sử dụng để cập nhật giao diện người dùng.
Global Queue: Các queue toàn cục với mức độ ưu tiên khác nhau, được sử dụng để thực thi các tác vụ nền.

Ví dụ về việc sử dụng GCD để thực thi mã trên một queue nền:

DispatchQueue.global(qos: .background).async { // Thực thi tác vụ nền print("Running on background queue") DispatchQueue.main.async { // Cập nhật giao diện người dùng print("Back to main queue") } }

Câu 41: Giải thích dispatch queues và khái niệm dispatch groups trong Swift.

Dispatch queues là các queue được sử dụng để quản lý việc thực thi các block của mã. Có hai loại dispatch queue chính:

Serial Queue: Thực thi các tác vụ theo thứ tự tuần tự, đảm bảo rằng chỉ có một tác vụ được thực thi tại một thời điểm.
Concurrent Queue: Thực thi nhiều tác vụ đồng thời, nhưng vẫn đảm bảo thứ tự các tác vụ.

Ví dụ về việc tạo một serial queue và thêm các tác vụ vào nó:

let serialQueue = DispatchQueue(label: "com.example.serialQueue") serialQueue.async { print("Task 1") } serialQueue.async { print("Task 2") }

Dispatch groups cho phép bạn nhóm nhiều tác vụ lại với nhau và nhận được thông báo khi tất cả các tác vụ trong nhóm đã hoàn thành. Điều này rất hữu ích khi bạn cần đồng bộ hóa các tác vụ không đồng bộ.

Ví dụ về việc sử dụng dispatch group:

let group = DispatchGroup() group.enter() DispatchQueue.global().async { print("Task 1") group.leave() } group.enter() DispatchQueue.global().async { print("Task 2") group.leave() } group.notify(queue: DispatchQueue.main) { print("All tasks are done") }

Câu 42: Async/await đã đơn giản hóa concurrency trong Swift như thế nào?

Async/await là cú pháp mới trong Swift giúp đơn giản hóa việc viết mã không đồng bộ bằng cách làm cho nó trông giống như mã đồng bộ. Với async/await, bạn có thể gọi các hàm không đồng bộ và đợi kết quả mà không cần sử dụng callback hoặc completion handler, giúp mã trở nên dễ đọc và dễ bảo trì hơn.

Ví dụ về việc sử dụng async/await:

func fetchData() async throws -> String { // Giả lập một tác vụ không đồng bộ return "Data fetched" } Task { do { let data = try await fetchData() print(data) } catch { print("Error fetching data: \(error)") } }

Câu 67: Làm thế nào để bạn đồng bộ hóa truy cập tới một tài nguyên chia sẻ trong Swift?

Để đồng bộ hóa truy cập tới một tài nguyên chia sẻ trong Swift, bạn có thể sử dụng các cơ chế đồng bộ hóa như DispatchQueue và DispatchSemaphore.

Ví dụ sử dụng DispatchQueue:

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent) var sharedResource = 0 concurrentQueue.async(flags: .barrier) { sharedResource += 1 print("Incremented to \(sharedResource)") } concurrentQueue.async { print("Shared resource value: \(sharedResource)") }

Ví dụ sử dụng DispatchSemaphore:

let semaphore = DispatchSemaphore(value: 1) var sharedResource = 0 DispatchQueue.global().async { semaphore.wait() sharedResource += 1 print("Incremented to \(sharedResource)") semaphore.signal() } DispatchQueue.global().async { semaphore.wait() print("Shared resource value: \(sharedResource)") semaphore.signal() }

Swift Interoperability with OJC

Câu 43: Làm thế nào để sử dụng mã Objective-C trong một dự án Swift?

Để sử dụng mã Objective-C trong một dự án Swift, bạn cần thực hiện các bước sau:

Thêm tệp Objective-C vào dự án Swift của bạn: Khi bạn thêm một tệp Objective-C vào dự án Swift lần đầu tiên, Xcode sẽ hỏi bạn có muốn tạo một tệp bridging header hay không. Chọn “Yes”.
Tạo tệp bridging header (nếu chưa có): Nếu bạn không thấy lời nhắc hoặc bạn cần tạo một tệp bridging header thủ công, bạn có thể tạo một tệp header mới (đặt tên là YourProjectName-Bridging-Header.h) và sau đó cấu hình nó trong mục “Build Settings” -> “Objective-C Bridging Header”.
Khai báo các tệp Objective-C cần thiết trong tệp bridging header: Thêm các tệp header Objective-C mà bạn muốn sử dụng trong dự án Swift vào tệp bridging header.

// YourProjectName-Bridging-Header.h #import "YourObjectiveCFile.h"

Sử dụng mã Objective-C trong Swift: Sau khi cấu hình xong, bạn có thể sử dụng các lớp và phương thức Objective-C trực tiếp trong mã Swift của bạn.

// Swift file let objCObject = YourObjectiveCClass() objCObject.someMethod()

Câu 44: Bridging header là gì và khi nào bạn cần nó?

Bridging header là một tệp header đặc biệt cho phép bạn kết nối mã Objective-C với Swift. Bạn cần bridging header khi bạn muốn sử dụng các lớp, phương thức, và biến của Objective-C trong mã Swift của mình. Bridging header chứa các khai báo của các tệp Objective-C mà bạn muốn truy cập từ Swift.

Câu 45: Có bất kỳ hạn chế nào khi sử dụng các API Objective-C trong Swift không?

Khi sử dụng các API Objective-C trong Swift, có một số hạn chế cần lưu ý:

Nullability: Objective-C không hỗ trợ nullability rõ ràng như Swift. Để tránh lỗi, bạn cần chú ý đến các kiểu nullable và non-nullable trong các API Objective-C.
Generics: Objective-C không hỗ trợ generics, trong khi Swift hỗ trợ mạnh mẽ. Điều này có thể làm cho mã Swift sử dụng các API Objective-C trở nên ít an toàn hơn.
Enums: Enums trong Objective-C không mạnh mẽ như Swift. Trong Objective-C, enums thường chỉ là các giá trị nguyên (integers), trong khi Swift hỗ trợ enums với các giá trị liên kết và các phương thức.
Properties and Methods: Một số tính năng nâng cao của Swift như properties tính toán, hàm static, và initializers thuận tiện có thể không có trong các lớp Objective-C.
Extensions: Extensions của Swift không thể được sử dụng để thêm các phương thức hoặc thuộc tính vào các lớp Objective-C.

Tuy nhiên, mặc dù có những hạn chế này, việc sử dụng các API Objective-C trong Swift vẫn rất mạnh mẽ và linh hoạt, giúp bạn tận dụng mã cũ mà không cần phải viết lại toàn bộ trong Swift.

Advance Swift

Câu 46: Generics hoạt động như thế nào trong Swift?

Generics trong Swift cho phép bạn định nghĩa các hàm, kiểu dữ liệu, và cấu trúc dữ liệu hoạt động với bất kỳ kiểu dữ liệu nào, thay vì một kiểu dữ liệu cụ thể. Điều này giúp mã của bạn linh hoạt và tái sử dụng cao hơn. Bạn sử dụng cú pháp dấu ngoặc nhọn (<T>) để định nghĩa một kiểu dữ liệu chung.

Ví dụ về một hàm generic:

func swapTwoValues<T>(_ a: inout T, _ b: inout T) { let temporaryA = a a = b b = temporaryA } var firstInt = 3 var secondInt = 107 swapTwoValues(&firstInt, &secondInt) print("firstInt is now \(firstInt), and secondInt is now \(secondInt)")

Câu 47: Tại sao bạn nên sử dụng associated types trong protocol của bạn?

Associated types trong protocol cho phép bạn định nghĩa các placeholder cho các kiểu dữ liệu mà sẽ được xác định khi protocol được tuân theo. Điều này rất hữu ích khi bạn muốn một protocol hoạt động với nhiều kiểu dữ liệu khác nhau mà không cần phải biết trước các kiểu cụ thể.

Ví dụ:

protocol Container { associatedtype Item var items: [Item] { get } mutating func add(item: Item) } struct IntContainer: Container { var items: [Int] = [] mutating func add(item: Int) { items.append(item) } }

Câu 48: Custom operators là gì và làm thế nào bạn có thể định nghĩa chúng trong Swift?

Custom operators cho phép bạn tạo các toán tử tùy chỉnh để thực hiện các phép toán cụ thể cho các kiểu dữ liệu của bạn. Bạn định nghĩa các toán tử mới bằng cách sử dụng từ khóa operator và sau đó định nghĩa hàm thực hiện phép toán đó.

Ví dụ:

infix operator **: MultiplicationPrecedence func ** (base: Int, power: Int) -> Int { return Int(pow(Double(base), Double(power))) } let result = 2 ** 3 print(result) // Output: 8

Câu 49: Giải thích khái niệm conditional conformance trong Swift.

Conditional conformance cho phép một kiểu dữ liệu tuân theo một protocol chỉ khi nó thỏa mãn một điều kiện nhất định. Điều này rất hữu ích khi bạn muốn một kiểu dữ liệu chỉ tuân theo một protocol trong một số tình huống cụ thể.

Ví dụ:

extension Array: Equatable where Element: Equatable {} let array1 = [1, 2, 3] let array2 = [1, 2, 3] print(array1 == array2) // Output: true

Trong ví dụ trên, Array chỉ tuân theo Equatable khi các phần tử của nó cũng tuân theo Equatable.

Câu 68: Thảo luận về việc sử dụng và lợi ích của opaque return types trong Swift.

Opaque return types cho phép bạn trả về một giá trị mà tuân theo một giao thức cụ thể mà không cần tiết lộ kiểu cụ thể của giá trị đó. Điều này giúp giữ cho các chi tiết triển khai của bạn được ẩn giấu và giúp mã của bạn linh hoạt hơn.

Ví dụ:

protocol Shape { func draw() -> String } struct Circle: Shape { func draw() -> String { return "Drawing a circle" } } func makeShape() -> some Shape { return Circle() } let shape = makeShape() print(shape.draw()) // Output: Drawing a circle

Câu 69: Làm thế nào bạn sẽ sử dụng property wrappers trong Swift để quản lý truy cập vào một thuộc tính?

Property wrappers cho phép bạn định nghĩa logic quản lý trạng thái và hành vi của một thuộc tính một cách tập trung và tái sử dụng được. Bạn sử dụng property wrappers bằng cách tạo một struct hoặc class với thuộc tính wrappedValue.

Ví dụ:

@propertyWrapper struct Capitalized { private var value: String = "" var wrappedValue: String { get { value } set { value = newValue.capitalized } } } struct User { @Capitalized var name: String } var user = User() user.name = "john doe" print(user.name) // Output: John Doe

SwìtUI and UI Development

Câu 50: Làm thế nào để khai báo một giao diện người dùng bằng SwiftUI?

Trong SwiftUI, bạn khai báo giao diện người dùng bằng cách sử dụng các view, là các cấu trúc (struct) tuân theo giao thức View. Bạn sử dụng các view cơ bản như Text, Image, Button, và các container view như VStack, HStack, ZStack để tạo layout.

Ví dụ:

import SwiftUI struct ContentView: View { var body: some View { VStack { Text("Hello, World!") .font(.largeTitle) .padding() Button(action: { print("Button tapped!") }) { Text("Tap me") .padding() .background(Color.blue) .foregroundColor(.white) .cornerRadius(10) } } } } struct ContentView_Previews: PreviewProvider { static var previews: some View { ContentView() } }

Câu 51: ViewModifier trong SwiftUI là gì và khi nào nên sử dụng nó?

ViewModifier là một giao thức trong SwiftUI cho phép bạn tạo các thay đổi hoặc bổ sung chung cho các view. Bạn sử dụng ViewModifier khi bạn có một hoặc nhiều thay đổi cần áp dụng cho nhiều view khác nhau để giữ mã của bạn DRY (Don’t Repeat Yourself).

Ví dụ:

struct CustomModifier: ViewModifier { func body(content: Content) -> some View { content .padding() .background(Color.yellow) .cornerRadius(10) } } extension View { func customStyle() -> some View { self.modifier(CustomModifier()) } } struct ContentView: View { var body: some View { VStack { Text("Hello, World!") .customStyle() Button(action: { print("Button tapped!") }) { Text("Tap me") } .customStyle() } } }

Câu 52: Minh họa cách xử lý input người dùng như các tap trong SwiftUI.

Bạn có thể xử lý input người dùng như các tap bằng cách sử dụng các closure được liên kết với các view tương tác như Button hoặc các gesture recognizer như TapGesture.

Ví dụ sử dụng Button:

struct ContentView: View { var body: some View { Button(action: { print("Button tapped!") }) { Text("Tap me") .padding() .background(Color.blue) .foregroundColor(.white) .cornerRadius(10) } } }

Ví dụ sử dụng TapGesture:

struct ContentView: View { var body: some View { Text("Tap me") .padding() .background(Color.blue) .foregroundColor(.white) .cornerRadius(10) .onTapGesture { print("Text tapped!") } } }

Câu 53: Giải thích khái niệm quản lý trạng thái (state management) trong SwiftUI.

Quản lý trạng thái trong SwiftUI liên quan đến việc theo dõi và cập nhật trạng thái của các view. SwiftUI cung cấp nhiều công cụ để quản lý trạng thái như @State, @Binding, @ObservedObject, @EnvironmentObject, và @StateObject.

Ví dụ sử dụng @State:

struct ContentView: View { @State private var counter = 0 var body: some View { VStack { Text("Counter: \(counter)") Button(action: { counter += 1 }) { Text("Increment") } } } }

Câu 54: Làm thế nào để điều hướng giữa các view trong SwiftUI?

Bạn có thể điều hướng giữa các view trong SwiftUI bằng cách sử dụng NavigationView và NavigationLink.

Ví dụ:

struct ContentView: View { var body: some View { NavigationView { VStack { NavigationLink(destination: DetailView()) { Text("Go to Detail View") .padding() .background(Color.blue) .foregroundColor(.white) .cornerRadius(10) } } .navigationTitle("Home") } } } struct DetailView: View { var body: some View { Text("Detail View") .navigationTitle("Detail") } }

Câu 55: Mục đích của ObservedObject và EnvironmentObject trong SwiftUI là gì?

@ObservedObject: Được sử dụng để theo dõi các đối tượng tuân theo giao thức ObservableObject. Khi một thuộc tính được đánh dấu với @Published trong đối tượng đó thay đổi, view sẽ tự động cập nhật.

class UserData: ObservableObject { @Published var name = "John Doe" } struct ContentView: View { @ObservedObject var userData = UserData() var body: some View { VStack { Text("Name: \(userData.name)") Button(action: { userData.name = "Jane Doe" }) { Text("Change Name") } } } }

@EnvironmentObject: Được sử dụng để chia sẻ dữ liệu giữa nhiều view trong một hierarchy. Bạn cần phải đặt đối tượng vào môi trường sử dụng environmentObject(_:).

class UserData: ObservableObject { @Published var name = "John Doe" } struct ContentView: View { @EnvironmentObject var userData: UserData var body: some View { VStack { Text("Name: \(userData.name)") Button(action: { userData.name = "Jane Doe" }) { Text("Change Name") } } } } @main struct MyApp: App { var userData = UserData() var body: some Scene { WindowGroup { ContentView().environmentObject(userData) } } }

Câu 56: SwiftUI sử dụng cú pháp khai báo để xây dựng giao diện người dùng như thế nào?

SwiftUI sử dụng cú pháp khai báo để mô tả giao diện người dùng và hành vi của nó trong một cách dễ đọc và dễ bảo trì. Thay vì mô tả từng bước cách vẽ giao diện người dùng, bạn chỉ cần khai báo giao diện và trạng thái của nó. SwiftUI sẽ tự động cập nhật giao diện khi trạng thái thay đổi.

Ví dụ:

struct ContentView: View { @State private var counter = 0 var body: some View { VStack { Text("Counter: \(counter)") .font(.largeTitle) .padding() Button(action: { counter += 1 }) { Text("Increment") .padding() .background(Color.blue) .foregroundColor(.white) .cornerRadius(10) } } } }

Câu 57: Nêu tên một vài framework phổ biến để phát triển ứng dụng server-side bằng Swift.

Một số framework phổ biến để phát triển ứng dụng server-side bằng Swift bao gồm:

Vapor: Một framework mạnh mẽ và linh hoạt cho phép bạn xây dựng các ứng dụng web và API một cách dễ dàng.
Kitura: Một framework mã nguồn mở của IBM cho phép bạn xây dựng các ứng dụng web và API RESTful.
Perfect: Một framework mạnh mẽ để xây dựng các ứng dụng web và dịch vụ web với Swift.

Câu 58: Swift Package Manager giúp phát triển Swift server-side như thế nào?

Swift Package Manager (SPM) là một công cụ tích hợp để quản lý các gói phụ thuộc trong dự án Swift. SPM giúp bạn dễ dàng thêm, cập nhật, và quản lý các thư viện và framework bên ngoài, đảm bảo rằng tất cả các phụ thuộc của dự án của bạn được quản lý một cách nhất quán.

Câu 59: Thảo luận các thách thức của việc sử dụng Swift trong môi trường server-side.

Sử dụng Swift trong môi trường server-side gặp một số thách thức như:

Tính khả dụng của thư viện: Mặc dù Swift đã có nhiều thư viện cho server-side, nhưng không phong phú bằng các ngôn ngữ như JavaScript hoặc Python.
Hỗ trợ cộng đồng: Cộng đồng phát triển Swift cho server-side nhỏ hơn so với các ngôn ngữ server-side phổ biến khác, điều này có thể làm giảm tốc độ phát triển và hỗ trợ.
Hiệu suất: Mặc dù Swift có hiệu suất tốt, nhưng tối ưu hóa ứng dụng server-side có thể phức tạp hơn do ngôn ngữ còn mới trong lĩnh vực này.

Best practice & Design Pattern

Câu 60: Các design pattern nào thường được sử dụng trong Swift và tại sao?

Trong Swift, một số design pattern phổ biến thường được sử dụng bao gồm:

Singleton: Đảm bảo rằng một class chỉ có một instance duy nhất và cung cấp một điểm truy cập toàn cục tới instance đó. Được sử dụng khi bạn cần một nguồn tài nguyên chung, như trình quản lý cấu hình hoặc bộ nhớ cache.
MVVM (Model-View-ViewModel): Tách biệt logic của giao diện người dùng (UI) khỏi logic kinh doanh, giúp mã dễ bảo trì và kiểm thử. Model quản lý dữ liệu, View hiển thị dữ liệu, và ViewModel kết nối Model và View.
Delegation: Cho phép một đối tượng ủy quyền trách nhiệm của nó cho một đối tượng khác. Được sử dụng rộng rãi trong các API của Apple như UITableView và UICollectionView.
Observer: Cho phép một đối tượng thông báo cho các đối tượng khác về các thay đổi trạng thái. Được sử dụng trong các cơ chế thông báo và KVO (Key-Value Observing).
Factory: Tạo đối tượng mà không cần chỉ định chính xác lớp cụ thể nào sẽ được tạo. Hữu ích khi bạn cần tạo các đối tượng linh hoạt dựa trên dữ liệu đầu vào.

Câu 61: Làm thế nào để đạt được dependency injection trong Swift?

Dependency injection là kỹ thuật cung cấp các phụ thuộc của một đối tượng từ bên ngoài thay vì để đối tượng tự tạo ra chúng. Có nhiều cách để thực hiện dependency injection trong Swift:

Constructor Injection: Cung cấp các phụ thuộc thông qua hàm khởi tạo của đối tượng.

class NetworkManager { // Implementation } class ViewModel { let networkManager: NetworkManager init(networkManager: NetworkManager) { self.networkManager = networkManager } } let networkManager = NetworkManager() let viewModel = ViewModel(networkManager: networkManager)

Property Injection: Cung cấp các phụ thuộc thông qua thuộc tính của đối tượng.

class ViewModel { var networkManager: NetworkManager? init() {} } let viewModel = ViewModel() viewModel.networkManager = NetworkManager()

Method Injection: Cung cấp các phụ thuộc thông qua một phương thức của đối tượng.

class ViewModel { private var networkManager: NetworkManager? func setNetworkManager(networkManager: NetworkManager) { self.networkManager = networkManager } } let viewModel = ViewModel() viewModel.setNetworkManager(networkManager: NetworkManager())

Câu 62: Giải thích mô hình Model-View-ViewModel (MVVM) trong ngữ cảnh của Swift.

MVVM là một mẫu thiết kế giúp tách biệt logic giao diện người dùng (UI) khỏi logic kinh doanh. Nó bao gồm ba thành phần chính:

Model: Chứa dữ liệu và logic kinh doanh. Các model thường là các struct hoặc class đơn giản.
View: Hiển thị dữ liệu từ ViewModel và phản hồi lại các tương tác của người dùng.
ViewModel: Cầu nối giữa Model và View, cung cấp dữ liệu cho View và xử lý các tương tác từ View.

Ví dụ về MVVM trong SwiftUI:

struct User: Identifiable { var id = UUID() var name: String } class UserViewModel: ObservableObject { @Published var users: [User] = [] func fetchUsers() { // Giả lập dữ liệu self.users = [ User(name: "John Doe"), User(name: "Jane Smith") ] } } struct ContentView: View { @StateObject var viewModel = UserViewModel() var body: some View { List(viewModel.users) { user in Text(user.name) } .onAppear { viewModel.fetchUsers() } } }

Câu 63: SwiftLint là gì và tại sao nên sử dụng nó?

SwiftLint là một công cụ kiểm tra mã nguồn để đảm bảo mã của bạn tuân thủ theo các quy tắc và phong cách mã hóa tốt. SwiftLint phân tích mã Swift của bạn và đưa ra cảnh báo hoặc lỗi khi phát hiện mã không tuân theo các quy tắc đã định nghĩa.

Lợi ích của việc sử dụng SwiftLint bao gồm:

Giảm lỗi cú pháp: Giúp bạn phát hiện sớm các lỗi cú pháp hoặc các thực hành mã hóa không tốt.
Đồng nhất mã nguồn: Đảm bảo tất cả mã nguồn của dự án tuân theo cùng một phong cách và quy tắc mã hóa.
Dễ dàng bảo trì: Mã nguồn được viết theo phong cách nhất quán sẽ dễ đọc và bảo trì hơn.

Câu 64: Mô tả một số best practices để quản lý các phụ thuộc trong các dự án Swift.

Một số best practices để quản lý các phụ thuộc trong các dự án Swift bao gồm:

Sử dụng Swift Package Manager (SPM): SPM là công cụ tích hợp của Swift để quản lý các phụ thuộc một cách hiệu quả và đồng bộ.
Sử dụng CocoaPods hoặc Carthage: Đây là hai công cụ phổ biến khác để quản lý các thư viện bên ngoài.
Đặt phiên bản cụ thể cho các phụ thuộc: Luôn xác định phiên bản cụ thể của các thư viện để đảm bảo tính ổn định và tránh các vấn đề tương thích.
Kiểm tra thường xuyên các cập nhật: Thường xuyên kiểm tra và cập nhật các phiên bản mới của các thư viện để tận dụng các tính năng mới và các bản sửa lỗi.
Kiểm soát các phụ thuộc trực tiếp: Tránh việc các thư viện kéo theo quá nhiều phụ thuộc không cần thiết bằng cách chỉ định rõ các thư viện mà bạn thực sự cần.

Câu 70: Singleton pattern là gì và làm thế nào để triển khai nó trong Swift?

Singleton pattern đảm bảo rằng một class chỉ có một instance duy nhất và cung cấp một điểm truy cập toàn cục tới instance đó. Singleton thường được sử dụng cho các dịch vụ dùng chung như trình quản lý cấu hình hoặc bộ nhớ cache.

Ví dụ triển khai Singleton pattern trong Swift:

class Singleton { static let shared = Singleton() private init() { // Private initialization để ngăn chặn việc tạo instance mới từ bên ngoài } func doSomething() { print("Singleton instance is doing something") } } let singletonInstance = Singleton.shared singletonInstance.doSomething() // Output: Singleton instance is doing something

ObservedObject,EnvironmentObject Và StateObject Trong Swift. Tất Tần Tật Về Cách Sử Dụng!

Lập Trình

Lập Trình Mobile

Swift - IOS

Tài Liệu - Khóa Học Free

8 min
2 năm ago

@ObservedObject Khái Niệm @ObservedObject là một property wrapper trong SwiftUI được sử dụng để theo dõi các đối tượng được đánh dấu là ObservableObject. Khi một thuộc tính bên trong đối tượng được đánh dấu là @Published thay đổi, SwiftUI tự động […]

Tagged #ios

Khái Niệm

@ObservedObject là một property wrapper trong SwiftUI được sử dụng để theo dõi các đối tượng được đánh dấu là ObservableObject. Khi một thuộc tính bên trong đối tượng được đánh dấu là @Published thay đổi, SwiftUI tự động cập nhật giao diện người dùng.

Khi nào sử dụng

Sử dụng @ObservedObject khi bạn muốn tạo một view có khả năng phản ứng với các thay đổi từ một đối tượng mà không sở hữu đối tượng đó. Điều này thường xảy ra khi bạn truyền một đối tượng từ một view cha sang một view con.

Cách sử dụng hiệu quả

Không sử dụng @ObservedObject cho các đối tượng mà view sở hữu trực tiếp và chịu trách nhiệm khởi tạo.
Sử dụng @ObservedObject khi bạn muốn chia sẻ một nguồn sự thật giữa nhiều view.

Ví dụ

import SwiftUI import Combine // Một class tuân theo ObservableObject class UserData: ObservableObject { @Published var username = "Binh" } struct ContentView: View { @ObservedObject var userData = UserData() var body: some View { Text("Username: \(userData.username)") } }

@StateObject

Khái Niệm

@StateObject cũng là một property wrapper được sử dụng cho các đối tượng ObservableObject, nhưng được sử dụng khi view đó chịu trách nhiệm khởi tạo đối tượng. SwiftUI sẽ tự động theo dõi và cập nhật view khi có bất kỳ thay đổi nào từ đối tượng.

Khi nào sử dụng

Sử dụng @StateObject khi bạn muốn view của bạn sở hữu và khởi tạo một đối tượng ObservableObject. Điều này đảm bảo rằng đối tượng chỉ được tạo một lần và duy trì qua các lần tái tạo view.

Cách sử dụng hiệu quả

Sử dụng @StateObject cho các đối tượng mà view sở hữu và cần theo dõi sự thay đổi.
Tránh sử dụng @StateObject khi đối tượng được truyền từ bên ngoài, thay vào đó sử dụng @ObservedObject.

Ví dụ

import SwiftUI // Sử dụng giống như ví dụ @ObservedObject, nhưng thay @ObservedObject bằng @StateObject struct ContentView: View { @StateObject var userData = UserData() var body: some View { Text("Username: \(userData.username)") } }

Sự Giống và Khác Biệt giữa @ObservedObject và @StateObject

Giống Nhau

Cả hai đều được sử dụng để theo dõi sự thay đổi trong các đối tượng ObservableObject và cập nhật UI một cách tự động khi có sự thay đổi.

Khác Biệt

@StateObject nên được sử dụng khi view đó chịu trách nhiệm khởi tạo đối tượng. SwiftUI sẽ quản lý vòng đời của đối tượng và đảm bảo rằng nó không bị tái tạo lại mỗi lần view được tải lại.
@ObservedObject được sử dụng khi đối tượng được truyền từ một view khác hoặc khi view không chịu trách nhiệm khởi tạo đối tượng. Điều này có

`EnvironmentObject`

Trong Swift, EnvironmentObjectlà một trong các phần của SwiftUI. Nó là một cách để chia sẻ dữ liệu giữa nhiều view trong một ứng dụng SwiftUI. Khi một đối tượng được đánh dấu là EnvironmentObject, SwiftUI sẽ tự động chuyển nó xuống qua các view con mà không cần phải truyền nó qua các tham số hàm. Điều này giúp giảm sự phức tạp của mã và làm cho việc quản lý dữ liệu trở nên dễ dàng hơn.

Ví dụ, bạn có thể sử dụng EnvironmentObjectđể chia sẻ một đối tượng dữ liệu như một đối tượng xử lý dữ liệu, cài đặt ngôn ngữ hoặc cài đặt giao diện người dùng trong toàn bộ ứng dụng của mình mà không cần phải truyền chúng qua các tham số hàm.

Dưới đây là một ví dụ về cách sử dụng EnvironmentObject:

import SwiftUI // Define a class to hold your data class MyData: ObservableObject { @Published var value: String = "Hello, World!" } // Define your first view struct ContentView: View { // Declare an @EnvironmentObject variable to hold the shared data @EnvironmentObject var data: MyData var body: some View { VStack { Text(data.value) // Display the shared data SubView() // Embed another view } } } // Define another view struct SubView: View { // Declare an @EnvironmentObject variable to hold the shared data @EnvironmentObject var data: MyData var body: some View { TextField("Enter new value", text: $data.value) // Modify the shared data .padding() } } // Define the entry point of your app @main struct MyApp: App { // Create an instance of your data class let myData = MyData() var body: some Scene { WindowGroup { // Pass the instance to the environment ContentView().environmentObject(myData) } } }

Trong ví dụ trên, MyDatalà một class chứa dữ liệu cần chia sẻ. ContentViewvà SubViewđều sử dụng @EnvironmentObject để truy cập đối tượng MyDatamà không cần truyền nó qua các tham số hàm. Trong MyApp, chúng ta sử dụng .environmentObject(myData) để đưa myDatavào môi trường của ứng dụng, để những view trong ứng dụng có thể truy cập và sử dụng nó.

Protocol Là Gì Trong Swift? Cách Sử Dụng Và Ví Dụ Cụ Thể?

Lập Trình

Lập Trình Mobile

Swift - IOS

Tài Liệu - Khóa Học Free

8 min
2 năm ago

Khái Niệm Trong lập trình Swift, một protocol là một tập hợp các yêu cầu về phương thức, thuộc tính, và các thành phần khác mà một kiểu cụ thể (class, structure, hoặc enumeration) phải thực hiện nếu nó “tuân thủ” (adopts) […]

Tagged #ios

Khái Niệm

Trong lập trình Swift, một protocol là một tập hợp các yêu cầu về phương thức, thuộc tính, và các thành phần khác mà một kiểu cụ thể (class, structure, hoặc enumeration) phải thực hiện nếu nó “tuân thủ” (adopts) protocol đó. Protocol giống như một bản hợp đồng: một khi một kiểu tuân thủ một protocol, kiểu đó phải thực hiện tất cả các yêu cầu mà protocol đó đặt ra.

Khi nào sử dụng Protocol?

Protocol thường được sử dụng trong các tình huống như:

Định nghĩa một bộ yêu cầu mà các kiểu khác nhau phải thực hiện: Điều này giúp đảm bảo rằng các kiểu khác nhau có thể được sử dụng một cách linh hoạt trong cùng một context, chẳng hạn như trong các hàm hoặc các kiểu chứa chúng.
Delegate pattern: Một cách phổ biến để truyền dữ liệu hoặc sự kiện giữa các đối tượng mà không cần chúng biết về nhau một cách cụ thể.
Đa hình: Protocol cho phép bạn tạo ra các kiểu có các phương thức và thuộc tính giống nhau nhưng được triển khai khác nhau.

Ví dụ về Protocol

Dưới đây là một ví dụ đơn giản về cách định nghĩa và sử dụng protocol trong Swift:

// Định nghĩa một protocol với một phương thức protocol Printable { func printDescription() } // Một class tuân thủ protocol Printable class Person: Printable { var name: String init(name: String) { self.name = name } // Thực hiện phương thức của protocol func printDescription() { print("Tên của tôi là \(name).") } } // Sử dụng protocol let john = Person(name: "John") john.printDescription() // "Tên của tôi là John."

Phương án thay thế cho Protocol

Mặc dù protocol là một công cụ mạnh mẽ và linh hoạt trong Swift, nhưng cũng có một số cách tiếp cận khác có thể sử dụng để đạt được các mục tiêu tương tự, bao gồm:

Kế thừa (Inheritance): Trong một số trường hợp, bạn có thể sử dụng kế thừa class để chia sẻ hoặc mở rộng hành vi giữa các kiểu. Tuy nhiên, Swift không hỗ trợ đa kế thừa cho các class, nên điều này giới hạn ở việc một class chỉ có thể kế thừa từ một class khác.
Extension: Swift cho phép bạn mở rộng tính năng của một kiểu (bao gồm cả những kiểu bạn không sở hữu) thông qua cơ chế extension. Điều này có thể được sử dụng để thêm các phương thức và tính toán thuộc tính vào một kiểu mà không cần tạo một protocol.
Type Erasure: Đây là một kỹ thuật giúp bạn làm việc với các kiểu generic một cách linh hoạt hơn, cho phép bạn sử dụng các kiểu tuân thủ một protocol mà không cần chỉ định chính xác kiểu của chúng.

Mỗi cách tiếp cận có ưu và nhược điểm của riêng mình, và lựa chọn giữa chúng phụ thuộc vào yêu cầu cụ thể của dự án bạn đang làm việc.

Ngoài những điểm cơ bản về protocol đã đề cập, có một số khía cạnh quan trọng khác về protocol trong Swift mà bạn cần biết để sử dụng chúng một cách hiệu quả.

Protocol Property Requirements

Protocol có thể yêu cầu bất kỳ kiểu nào tuân thủ nó phải có một hoặc nhiều thuộc tính cụ thể. Các thuộc tính này có thể được yêu cầu là có thể đọc được hoặc có thể đọc và ghi được.

protocol FullyNamed { var fullName: String { get } } struct Person: FullyNamed { var fullName: String } let john = Person(fullName: "John Appleseed") print(john.fullName) // In ra "John Appleseed"

Protocol Method Requirements

Protocol cũng có thể yêu cầu các phương thức cụ thể phải được thực hiện.

protocol RandomNumberGenerator { func random() -> Double } class LinearCongruentialGenerator: RandomNumberGenerator { func random() -> Double { // Thực hiện một thuật toán để trả về một giá trị ngẫu nhiên return 0.42 // Giả sử đây là kết quả ngẫu nhiên } }

Protocol Inheritance

Một protocol có thể kế thừa một hoặc nhiều protocol khác và thêm yêu cầu của riêng mình vào sự kết hợp của yêu cầu.

protocol Inflatable { func inflate() } protocol Deflatable { func deflate() } // Một protocol có thể kế thừa từ nhiều protocol protocol InflatableAndDeflatable: Inflatable, Deflatable { // Một protocol kế thừa không cần thêm bất kỳ yêu cầu mới nào } class Ball: InflatableAndDeflatable { func inflate() { print("Đang bơm...") } func deflate() { print("Đang xả hơi...") } }

Protocol Extensions

Extension cho phép bạn cung cấp một triển khai mặc định cho phương thức hoặc tính toán thuộc tính của protocol, cho phép các kiểu tuân thủ không cần phải cung cấp một triển khai của riêng họ.

protocol Greetable { func greet() } extension Greetable { func greet() { print("Hello, there!") } } struct Person: Greetable { // Không cần cung cấp một triển khai cho `greet` vì đã có trong extension } let person = Person() person.greet() // In ra "Hello, there!"

Phá Kén

Thẻ: #ios

Sổ tay Swift – Học Swift cho người mới bắt đầu A-Z

70 Swift interview questions

ObservedObject,EnvironmentObject Và StateObject Trong Swift. Tất Tần Tật Về Cách Sử Dụng!

Protocol Là Gì Trong Swift? Cách Sử Dụng Và Ví Dụ Cụ Thể?