// Integers
echo 1 1; // 0
echo 1 2; // -1
echo 2 1; // 1
// Floats
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
// Strings
echo "a" "a"; // 0
echo "a" "b"; // -1
echo "b" "a"; // 1
echo "a" "aa"; // -1
echo "zz" "aa"; // 1
// Arrays
echo [] []; // 0
echo [1, 2, 3] [1, 2, 3]; // 0
echo [1, 2, 3] []; // 1
echo [1, 2, 3] [1, 2, 1]; // 1
echo [1, 2, 3] [1, 2, 4]; // -1
// Objects
$a = [object] ["a" => "b"];
$b = [object] ["a" => "b"];
echo $a $b; // 0
$a = [object] ["a" => "b"];
$b = [object] ["a" => "c"];
echo $a $b; // -1
$a = [object] ["a" => "c"];
$b = [object] ["a" => "b"];
echo $a $b; // 1
________số 8
?>
Swift là ngôn ngữ lập trình mới để phát triển ứng dụng iOS, macOS, watchOS và tvOS. Tuy nhiên, nhiều phần của Swift sẽ quen thuộc với kinh nghiệm phát triển của bạn trong C và Objective-C
Swift cung cấp các phiên bản riêng của tất cả các loại C và Objective-C cơ bản, bao gồm // Floats
0 cho số nguyên,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
1 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
2 cho giá trị dấu phẩy động,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
3 cho giá trị Boolean và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 cho dữ liệu văn bản. Swift cũng cung cấp các phiên bản mạnh mẽ của ba loại bộ sưu tập chính,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
5,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
6 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
7, như được mô tả trong Các loại bộ sưu tập .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Giống như C, Swift sử dụng các biến để lưu trữ và tham chiếu đến các giá trị bằng một tên xác định. Swift cũng sử dụng rộng rãi các biến có giá trị không thể thay đổi. Chúng được gọi là hằng số và mạnh hơn nhiều so với hằng số trong C. Các hằng số được sử dụng xuyên suốt Swift để làm cho mã an toàn hơn và rõ ràng hơn khi bạn làm việc với các giá trị không cần thay đổi
Ngoài các kiểu quen thuộc, Swift giới thiệu các kiểu nâng cao không có trong Objective-C, chẳng hạn như bộ dữ liệu. Bộ dữ liệu cho phép bạn tạo và chuyển qua các nhóm giá trị. Bạn có thể sử dụng một bộ để trả về nhiều giá trị từ một hàm dưới dạng một giá trị phức hợp duy nhất
Swift cũng giới thiệu các loại tùy chọn, xử lý việc không có giá trị. Các tùy chọn cho biết "có một giá trị và nó bằng x" hoặc "không có giá trị nào cả". Sử dụng tùy chọn tương tự như sử dụng // Floats
8 với con trỏ trong Mục tiêu-C, nhưng chúng hoạt động với bất kỳ loại nào, không chỉ các lớp. Các tùy chọn không chỉ an toàn hơn và biểu cảm hơn so với con trỏ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8 trong Mục tiêu-C, chúng còn là trung tâm của nhiều tính năng mạnh mẽ nhất của Swift
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Swift là một ngôn ngữ an toàn về kiểu, có nghĩa là ngôn ngữ này giúp bạn hiểu rõ về các loại giá trị mà mã của bạn có thể làm việc với. Nếu một phần mã của bạn yêu cầu một // Floats
4, loại an toàn ngăn bạn vượt qua nó một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 do nhầm lẫn. Tương tự như vậy, an toàn loại ngăn bạn vô tình chuyển một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 tùy chọn sang một đoạn mã yêu cầu một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 không tùy chọn. Loại an toàn giúp bạn phát hiện và sửa lỗi sớm nhất có thể trong quá trình phát triển
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Hằng và biến
Các hằng số và biến liên kết một tên [chẳng hạn như // Floats
14 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
15] với một giá trị của một loại cụ thể [chẳng hạn như số
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
16 hoặc chuỗi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
17]. Giá trị của một hằng số không thể thay đổi sau khi nó được đặt, trong khi một biến có thể được đặt thành một giá trị khác trong tương lai
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Khai báo hằng và biến
Hằng và biến phải được khai báo trước khi sử dụng. Bạn khai báo hằng với từ khóa // Floats
18 và biến với từ khóa
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
19. Dưới đây là ví dụ về cách có thể sử dụng các hằng số và biến để theo dõi số lần thử đăng nhập mà người dùng đã thực hiện
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let số lần đăng nhập tối đa = 10
- var currentLoginAttempt = 0
Mã này có thể được đọc là
“Khai báo một hằng số mới có tên là // Floats
14 và đặt cho nó một giá trị là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
16. Sau đó, khai báo một biến mới có tên là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
22 và đặt cho nó giá trị ban đầu là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
23. ”
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Trong ví dụ này, số lần thử đăng nhập được phép tối đa được khai báo là một hằng số vì giá trị tối đa không bao giờ thay đổi. Bộ đếm số lần đăng nhập hiện tại được khai báo là một biến, vì giá trị này phải được tăng lên sau mỗi lần đăng nhập không thành công
Bạn có thể khai báo nhiều hằng hoặc nhiều biến trên một dòng, cách nhau bởi dấu phẩy
- var x = 0. 0 , y = 0. 0 , z = 0. 0
Ghi chú
Nếu giá trị được lưu trữ trong mã của bạn không thay đổi, hãy luôn khai báo giá trị đó là hằng số với từ khóa // Floats
18. Chỉ sử dụng các biến để lưu trữ các giá trị cần có khả năng thay đổi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Loại chú thích
Bạn có thể cung cấp chú thích kiểu khi khai báo một hằng hoặc biến, để hiểu rõ về loại giá trị mà hằng hoặc biến có thể lưu trữ. Viết chú thích kiểu bằng cách đặt dấu hai chấm sau tên hằng hoặc tên biến, theo sau là khoảng trắng, sau đó là tên của kiểu sẽ sử dụng
Ví dụ này cung cấp một chú thích kiểu cho một biến có tên là // Floats
15, để chỉ ra rằng biến đó có thể lưu trữ các giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- var tin nhắn chào mừng . Chuỗi
Dấu hai chấm trong phần khai báo có nghĩa là “…loại…,” vì vậy đoạn mã trên có thể được đọc là
“Khai báo một biến tên là // Floats
15 có kiểu là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4. ”
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Cụm từ “thuộc loại // Floats
4” có nghĩa là “có thể lưu trữ bất kỳ giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 nào. ” Hãy nghĩ nó có nghĩa là “loại đồ vật” [hoặc “loại đồ vật”] có thể được lưu trữ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Biến // Floats
15 hiện có thể được đặt thành bất kỳ giá trị chuỗi nào mà không gặp lỗi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- welcomeMessage = "Xin chào"
Bạn có thể xác định nhiều biến liên quan cùng loại trên một dòng, được phân tách bằng dấu phẩy, với một chú thích loại duy nhất sau tên biến cuối cùng
- var đỏ , xanh , blue: Gấp đôi
Ghi chú
Rất hiếm khi bạn cần viết chú thích loại trong thực tế. Nếu bạn cung cấp một giá trị ban đầu cho một hằng số hoặc biến tại thời điểm mà nó được xác định, Swift hầu như luôn có thể suy ra loại được sử dụng cho hằng số hoặc biến đó, như được mô tả trong. Trong ví dụ về // Floats
15 ở trên, không có giá trị ban đầu nào được cung cấp và do đó, loại biến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
15 được chỉ định bằng chú thích loại thay vì được suy ra từ giá trị ban đầu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Đặt tên cho hằng và biến
Tên hằng và tên biến có thể chứa hầu hết mọi ký tự, kể cả ký tự Unicode
- hãy π = 3. 14159
- let 你好 = "你好世界"
- let 🐶🐮 = "dogcow"
Tên hằng và tên biến không được chứa ký tự khoảng trắng, ký hiệu toán học, mũi tên, giá trị vô hướng Unicode sử dụng riêng hoặc ký tự vẽ đường và hộp. Họ cũng không thể bắt đầu bằng một số, mặc dù các số có thể được bao gồm ở nơi khác trong tên
Khi bạn đã khai báo một hằng số hoặc biến thuộc một loại nhất định, bạn không thể khai báo lại nó với cùng tên hoặc thay đổi nó để lưu trữ các giá trị của một loại khác. Bạn cũng không thể thay đổi hằng thành biến hoặc biến thành hằng
Ghi chú
Nếu bạn cần đặt một hằng số hoặc biến có cùng tên với từ khóa Swift dành riêng, hãy bao quanh từ khóa đó bằng dấu gạch ngược [// Floats
34] khi sử dụng từ khóa đó làm tên. Tuy nhiên, tránh sử dụng từ khóa làm tên trừ khi bạn hoàn toàn không có lựa chọn nào khác
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bạn có thể thay đổi giá trị của biến hiện có thành giá trị khác của loại tương thích. Trong ví dụ này, giá trị của // Floats
35 được thay đổi từ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
36 thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
37
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- var thân thiệnChào mừng = "Xin chào. "
- thân thiệnChào mừng = "Bonjour. "
- // thân thiệnChào mừng giờ là "Bonjour. "
Không giống như biến, giá trị của hằng số không thể thay đổi sau khi nó được đặt. Cố gắng làm như vậy được thông báo là có lỗi khi mã của bạn được biên dịch
- let languageName = "Swift"
- languageName = "Swift++"
- // Đây là lỗi thời gian biên dịch. languageName không thể thay đổi
In Hằng và Biến
Bạn có thể in giá trị hiện tại của hằng hoặc biến bằng hàm // Floats
38
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- in [ chào mừng thân thiện ]
- // Bản in "Bonjour. "
Hàm // Floats
38 là một hàm toàn cầu in một hoặc nhiều giá trị thành một đầu ra thích hợp. Ví dụ, trong Xcode, hàm
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
38 in đầu ra của nó trong ngăn “bảng điều khiển” của Xcode. Tham số
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
41 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
42 có giá trị mặc định, vì vậy bạn có thể bỏ qua chúng khi gọi hàm này. Theo mặc định, hàm kết thúc dòng mà nó in bằng cách thêm dấu ngắt dòng. Để in một giá trị mà không ngắt dòng sau nó, hãy chuyển một chuỗi trống làm dấu kết thúc—ví dụ:
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
43. Để biết thông tin về các tham số có giá trị mặc định, hãy xem
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Swift sử dụng phép nội suy chuỗi để bao gồm tên của hằng hoặc biến làm trình giữ chỗ trong chuỗi dài hơn và để nhắc Swift thay thế bằng giá trị hiện tại của hằng hoặc biến đó. Gói tên trong ngoặc đơn và thoát nó bằng dấu gạch chéo ngược trước dấu ngoặc đơn mở
- print [ "Giá trị hiện tại của friendlyWelcome là \ [friendlyWelcome]"]
- // In ra "Giá trị hiện tại của thân thiệnWelcome là Bonjour. "
Ghi chú
Tất cả các tùy chọn bạn có thể sử dụng với phép nội suy chuỗi được mô tả trong
Bình luận
Sử dụng nhận xét để bao gồm văn bản không thể thực thi được trong mã của bạn, như một ghi chú hoặc lời nhắc nhở cho chính bạn. Nhận xét bị trình biên dịch Swift bỏ qua khi mã của bạn được biên dịch
Nhận xét trong Swift rất giống với nhận xét trong C. Nhận xét một dòng bắt đầu bằng hai dấu gạch chéo [// Floats
44]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- // Đây là một bình luận
Nhận xét nhiều dòng bắt đầu bằng dấu gạch chéo lên, theo sau là dấu hoa thị [// Floats
45] và kết thúc bằng dấu hoa thị, sau đó là dấu gạch chéo lên [
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
46]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- /* Đây cũng là một chú thích
- nhưng được viết trên nhiều dòng. */
Không giống như chú thích nhiều dòng trong C, chú thích nhiều dòng trong Swift có thể được lồng vào bên trong chú thích nhiều dòng khác. Bạn viết các chú thích lồng nhau bằng cách bắt đầu một khối chú thích nhiều dòng và sau đó bắt đầu một chú thích nhiều dòng thứ hai trong khối đầu tiên. Khối thứ hai sau đó được đóng lại, tiếp theo là khối thứ nhất
- /* Đây là điểm bắt đầu của chú thích nhiều dòng đầu tiên
- /* Đây là chú thích nhiều dòng lồng nhau thứ hai. */
- Đây là phần cuối của bình luận nhiều dòng đầu tiên. */
Nhận xét nhiều dòng lồng nhau cho phép bạn nhận xét các khối mã lớn một cách nhanh chóng và dễ dàng, ngay cả khi mã đã chứa nhận xét nhiều dòng
dấu chấm phẩy
Không giống như nhiều ngôn ngữ khác, Swift không yêu cầu bạn viết dấu chấm phẩy [// Floats
47] sau mỗi câu lệnh trong mã của bạn, mặc dù bạn có thể làm như vậy nếu muốn. Tuy nhiên, dấu chấm phẩy là bắt buộc nếu bạn muốn viết nhiều câu lệnh riêng biệt trên một dòng
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- hãy mèo = "🐱" ; print[cat]
- // In ra "🐱"
số nguyên
Số nguyên là số nguyên không có thành phần phân số, chẳng hạn như // Floats
48 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
49. Số nguyên có dấu [dương, 0 hoặc âm] hoặc không dấu [dương hoặc 0]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Swift cung cấp số nguyên có dấu và không dấu ở dạng 8, 16, 32 và 64 bit. Các số nguyên này tuân theo quy ước đặt tên tương tự như C, trong đó số nguyên không dấu 8 bit thuộc loại // Floats
50 và số nguyên có dấu 32 bit thuộc loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
51. Giống như tất cả các kiểu trong Swift, các kiểu số nguyên này có tên được viết hoa
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
giới hạn số nguyên
Bạn có thể truy cập các giá trị tối thiểu và tối đa của từng loại số nguyên với các thuộc tính // Floats
52 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
53 của nó
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let minValue = UInt8 . min // minValue bằng 0 và thuộc loại UInt8
- let maxValue = UInt8 . max // maxValue bằng 255 và thuộc loại UInt8
Các giá trị của các thuộc tính này thuộc loại số có kích thước phù hợp [chẳng hạn như // Floats
50 trong ví dụ trên] và do đó có thể được sử dụng trong các biểu thức cùng với các giá trị khác cùng loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
số nguyên
Trong hầu hết các trường hợp, bạn không cần chọn kích thước số nguyên cụ thể để sử dụng trong mã của mình. Swift cung cấp một loại số nguyên bổ sung, // Floats
0, có cùng kích thước với kích thước từ gốc của nền tảng hiện tại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Trên nền tảng 32-bit,
// Floats
0 có cùng kích thước với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
51
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1Trên nền tảng 64 bit,
// Floats
0 có cùng kích thước với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
59
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Trừ khi bạn cần làm việc với kích thước số nguyên cụ thể, hãy luôn sử dụng // Floats
0 cho các giá trị số nguyên trong mã của bạn. Điều này hỗ trợ tính nhất quán của mã và khả năng tương tác. Ngay cả trên nền tảng 32 bit,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 có thể lưu trữ bất kỳ giá trị nào trong khoảng từ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
62 đến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
63 và đủ lớn cho nhiều phạm vi số nguyên
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
UInt
Swift cũng cung cấp một loại số nguyên không dấu, // Floats
64, có cùng kích thước với kích thước từ gốc của nền tảng hiện tại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Trên nền tảng 32 bit,
// Floats
64 có cùng kích thước với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
66
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1Trên nền tảng 64 bit,
// Floats
64 có cùng kích thước với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
68
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
Chỉ sử dụng // Floats
64 khi bạn đặc biệt cần một loại số nguyên không dấu có cùng kích thước với kích thước từ gốc của nền tảng. Nếu đây không phải là trường hợp, thì
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 được ưu tiên hơn, ngay cả khi các giá trị được lưu trữ được biết là không âm. Việc sử dụng nhất quán
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 cho các giá trị số nguyên hỗ trợ khả năng tương tác của mã, tránh nhu cầu chuyển đổi giữa các loại số khác nhau và phù hợp với suy luận loại số nguyên, như được mô tả trong
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Số dấu phẩy động
Số dấu phẩy động là số có thành phần phân số, chẳng hạn như // Floats
72,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
73 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
74
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Các loại dấu phẩy động có thể biểu thị phạm vi giá trị rộng hơn nhiều so với các loại số nguyên và có thể lưu trữ các số lớn hơn hoặc nhỏ hơn nhiều so với có thể được lưu trữ trong một // Floats
0. Swift cung cấp hai loại số dấu phẩy động có dấu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
// Floats
1 đại diện cho số dấu phẩy động 64 bit
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
2 đại diện cho số dấu phẩy động 32 bit
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
// Floats
1 có độ chính xác ít nhất là 15 chữ số thập phân, trong khi độ chính xác của
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
2 có thể ít nhất là 6 chữ số thập phân. Loại dấu phẩy động thích hợp để sử dụng tùy thuộc vào bản chất và phạm vi giá trị bạn cần làm việc với mã của mình. Trong các tình huống mà một trong hai loại sẽ phù hợp, thì
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
1 được ưu tiên hơn
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Loại an toàn và loại suy luận
Swift là ngôn ngữ an toàn kiểu. Ngôn ngữ an toàn loại khuyến khích bạn hiểu rõ về các loại giá trị mà mã của bạn có thể làm việc với. Nếu một phần mã của bạn yêu cầu một // Floats
4, bạn không thể chuyển nó thành một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 do nhầm lẫn
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Vì Swift là loại an toàn nên nó thực hiện kiểm tra loại khi biên dịch mã của bạn và đánh dấu mọi loại không khớp là lỗi. Điều này cho phép bạn phát hiện và sửa lỗi sớm nhất có thể trong quá trình phát triển
Kiểm tra kiểu giúp bạn tránh lỗi khi làm việc với các kiểu giá trị khác nhau. Tuy nhiên, điều này không có nghĩa là bạn phải chỉ định kiểu của mọi hằng và biến mà bạn khai báo. Nếu bạn không chỉ định loại giá trị mình cần, Swift sẽ sử dụng suy luận kiểu để tìm ra loại phù hợp. Suy luận kiểu cho phép trình biên dịch tự động suy ra kiểu của một biểu thức cụ thể khi nó biên dịch mã của bạn, chỉ bằng cách kiểm tra các giá trị bạn cung cấp
Do suy luận kiểu, Swift yêu cầu khai báo kiểu ít hơn nhiều so với các ngôn ngữ như C hoặc Objective-C. Các hằng số và biến vẫn được nhập rõ ràng, nhưng phần lớn công việc xác định loại của chúng đã được thực hiện cho bạn
Suy luận kiểu đặc biệt hữu ích khi bạn khai báo một hằng hoặc biến có giá trị ban đầu. Điều này thường được thực hiện bằng cách gán một giá trị theo nghĩa đen [hoặc theo nghĩa đen] cho hằng số hoặc biến tại thời điểm bạn khai báo nó. [Giá trị theo nghĩa đen là giá trị xuất hiện trực tiếp trong mã nguồn của bạn, chẳng hạn như // Floats
48 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
72 trong các ví dụ bên dưới. ]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ví dụ: nếu bạn gán một giá trị bằng chữ là // Floats
48 cho một hằng số mới mà không nói đó là loại gì, Swift sẽ suy ra rằng bạn muốn hằng số đó là một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0, bởi vì bạn đã khởi tạo nó bằng một số trông giống như một số nguyên
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let meaningOfLife = 42
- // meaningOfLife được suy ra là kiểu Int
Tương tự như vậy, nếu bạn không chỉ định loại cho ký tự dấu chấm động, Swift sẽ suy ra rằng bạn muốn tạo một // Floats
1
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let pi = 3. 14159
- // pi được suy ra là kiểu Double
Swift luôn chọn // Floats
1 [chứ không phải
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
2] khi suy ra loại số dấu phẩy động
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nếu bạn kết hợp các ký tự số nguyên và dấu phẩy động trong một biểu thức, một loại // Floats
1 sẽ được suy ra từ ngữ cảnh
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let anotherPi = 3 + 0.14159
- // AnotherPi cũng được suy ra là kiểu Double
Giá trị bằng chữ của // Floats
81 không có kiểu rõ ràng trong và của chính nó, và do đó, kiểu đầu ra thích hợp của
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
1 được suy ra từ sự hiện diện của một dấu chấm động bằng chữ như một phần của phép cộng
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
chữ số
Chữ số nguyên có thể được viết là
Một số thập phân, không có tiền tố
Số nhị phân, có tiền tố
// Floats
83
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1Một số bát phân, có tiền tố
// Floats
84
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1Một số thập lục phân, có tiền tố
// Floats
85
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Tất cả các số nguyên này có giá trị thập phân là // Floats
86
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let decimalInteger = 17
- let binaryInteger = 0b10001 // 17 ở dạng nhị phân
- let octalInteger = 0o21 // 17 trong bát phân
- let hexadecimalInteger = 0x11 // 17 ở dạng thập lục phân
Các chữ số dấu phẩy động có thể là số thập phân [không có tiền tố] hoặc thập lục phân [có tiền tố // Floats
85]. Chúng phải luôn có một số [hoặc số thập lục phân] ở cả hai bên của dấu thập phân. Số thập phân float cũng có thể có một số mũ tùy chọn, được biểu thị bằng chữ hoa hoặc chữ thường
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
88;
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Đối với các số thập phân có số mũ là // Floats
100, cơ số được nhân với 10 lần
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
// Floats
101 có nghĩa là 1. 25 x 102 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
102
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
103 có nghĩa là 1. 25 x 10-2, hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
104
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Đối với các số thập lục phân có số mũ là // Floats
100, cơ số được nhân với 2 lần
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
// Floats
106 có nghĩa là 15 x 22 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
107
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
108 có nghĩa là 15 x 2-2 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
109
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Tất cả các chữ số dấu phẩy động này có giá trị thập phân là // Floats
110
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let decimalDouble = 12. 1875
- let exponentDouble = 1. 21875e1
- let hexadecimalDouble = 0xC. 3p0
Chữ số có thể chứa định dạng bổ sung để giúp chúng dễ đọc hơn. Cả số nguyên và số float đều có thể được đệm thêm số 0 và có thể chứa dấu gạch dưới để giúp dễ đọc. Cả hai loại định dạng đều không ảnh hưởng đến giá trị cơ bản của nghĩa đen
- let paddedDouble = 000123. 456
- hãy oneMillion = 1_000_000
- let justOverOneMillion = 1_000_000. 000_000_1
Chuyển đổi kiểu số
Sử dụng loại // Floats
0 cho tất cả các biến và hằng số nguyên có mục đích chung trong mã của bạn, ngay cả khi chúng được biết là không âm. Sử dụng kiểu số nguyên mặc định trong các tình huống hàng ngày có nghĩa là các hằng và biến số nguyên có thể tương tác ngay lập tức trong mã của bạn và sẽ khớp với kiểu được suy ra cho các giá trị số nguyên
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Chỉ sử dụng các loại số nguyên khác khi chúng đặc biệt cần thiết cho tác vụ hiện tại, do dữ liệu có kích thước rõ ràng từ nguồn bên ngoài hoặc để thực hiện, sử dụng bộ nhớ hoặc tối ưu hóa cần thiết khác. Sử dụng các loại có kích thước rõ ràng trong những tình huống này giúp nắm bắt bất kỳ giá trị vô tình nào bị tràn và ghi lại bản chất của dữ liệu đang được sử dụng
Chuyển đổi số nguyên
Phạm vi của các số có thể được lưu trữ trong một hằng hoặc biến số nguyên là khác nhau đối với từng loại số. Hằng hoặc biến // Floats
112 có thể lưu các số trong khoảng từ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
113 đến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
114, trong khi hằng hoặc biến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
50 có thể lưu các số trong khoảng từ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
23 đến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
117. Một số không vừa với hằng số hoặc biến của loại số nguyên có kích thước được báo cáo là lỗi khi mã của bạn được biên dịch
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let cannotBeNegative . UInt8 = -1
- // UInt8 không lưu được số âm nên sẽ báo lỗi
- hãy tooBig . Int8 = Int8 . tối đa + 1
- // Int8 không thể lưu số lớn hơn giá trị lớn nhất của nó,
- // và vì vậy điều này cũng sẽ báo lỗi
Vì mỗi loại số có thể lưu trữ một phạm vi giá trị khác nhau nên bạn phải chọn tham gia chuyển đổi loại số trong từng trường hợp cụ thể. Phương pháp chọn tham gia này ngăn ngừa các lỗi chuyển đổi ẩn và giúp làm rõ ý định chuyển đổi loại trong mã của bạn
Để chuyển đổi một loại số cụ thể sang loại số khác, bạn khởi tạo một số mới của loại mong muốn với giá trị hiện có. Trong ví dụ bên dưới, hằng số // Floats
118 thuộc loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119, trong khi hằng số
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
120 thuộc loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
50. Chúng không thể được cộng trực tiếp với nhau vì chúng không cùng loại. Thay vào đó, ví dụ này gọi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
122 để tạo một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119 mới được khởi tạo với giá trị là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
120 và sử dụng giá trị này thay cho giá trị ban đầu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- hãy hai nghìn . UInt16 = 2_000
- hãy một . UInt8 = 1
- let twoThousandAndOne = twoThousand + UInt16[one]
Bởi vì cả hai bên của phần bổ sung hiện thuộc loại // Floats
119, phần bổ sung được cho phép. Hằng số đầu ra [
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
126] được suy ra là thuộc loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119, bởi vì nó là tổng của hai giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
// Floats
129 là cách mặc định để gọi trình khởi tạo của loại Swift và chuyển vào giá trị ban đầu. Đằng sau hậu trường,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119 có một bộ khởi tạo chấp nhận giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
50 và do đó, bộ khởi tạo này được sử dụng để tạo một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119 mới từ một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
50 hiện có. Tuy nhiên, bạn không thể nhập bất kỳ loại nào ở đây—nó phải là loại mà
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119 cung cấp trình khởi tạo. Mở rộng các loại hiện có để cung cấp trình khởi tạo chấp nhận các loại mới [bao gồm cả định nghĩa loại của riêng bạn] được đề cập trong Tiện ích mở rộng .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Chuyển đổi số nguyên và dấu phẩy động
Chuyển đổi giữa các loại số nguyên và số dấu phẩy động phải được thực hiện rõ ràng
- hãy ba = 3
- let pointOneFourOneFiveNine = 0. 14159
- let pi = Gấp đôi [ three] + pointOneFourOneFiveNine
- // pi bằng 3. 14159 và được suy ra là loại Double
Ở đây, giá trị của hằng số // Floats
135 được sử dụng để tạo một giá trị mới kiểu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
1, sao cho cả hai vế của phép cộng đều cùng kiểu. Nếu không có chuyển đổi này tại chỗ, việc bổ sung sẽ không được phép
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Chuyển đổi dấu phẩy động thành số nguyên cũng phải được thực hiện rõ ràng. Một kiểu số nguyên có thể được khởi tạo với giá trị // Floats
1 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
2
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let integerPi = Int [ pi]
- // integerPi bằng 3 và được suy ra là kiểu Int
Các giá trị dấu phẩy động luôn bị cắt bớt khi được sử dụng để khởi tạo một giá trị số nguyên mới theo cách này. Điều này có nghĩa là // Floats
139 trở thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
140 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
141 trở thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
142
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
Quy tắc kết hợp hằng số và biến số khác với quy tắc kết hợp chữ số. Giá trị bằng chữ // Floats
81 có thể được thêm trực tiếp vào giá trị bằng chữ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
144, bởi vì các chữ số không có kiểu rõ ràng trong chính chúng. Loại của chúng chỉ được suy ra khi chúng được trình biên dịch đánh giá
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nhập bí danh
Loại bí danh xác định tên thay thế cho loại hiện có. Bạn xác định bí danh loại với từ khóa // Floats
145
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bí danh loại hữu ích khi bạn muốn tham chiếu đến một loại hiện có bằng tên phù hợp hơn theo ngữ cảnh, chẳng hạn như khi làm việc với dữ liệu có kích thước cụ thể từ nguồn bên ngoài
- typealias AudioSample = UInt16
Khi bạn xác định bí danh loại, bạn có thể sử dụng bí danh ở bất kỳ đâu mà bạn có thể sử dụng tên gốc
- var maxAmplitudeFound = AudioSample . phút
- // maxAmplitudeFound bây giờ là 0
Ở đây, // Floats
146 được định nghĩa là bí danh cho
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
119. Bởi vì nó là một bí danh, lệnh gọi tới
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
148 thực sự gọi tới
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
149, cung cấp giá trị ban đầu là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
23 cho biến
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
151
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Booleans
Swift có một kiểu Boolean cơ bản, được gọi là // Floats
3. Các giá trị Boolean được gọi là logic, bởi vì chúng chỉ có thể đúng hoặc sai. Swift cung cấp hai giá trị hằng số Boolean,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
153 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
154
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let orangesAreOrange = true
- let củ cải ngon = false
Các loại // Floats
155 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
156 đã được suy ra là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
3 từ thực tế là chúng được khởi tạo với các giá trị bằng chữ Boolean. Như với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
1 ở trên, bạn không cần khai báo hằng hoặc biến là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
3 nếu bạn đặt chúng thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
153 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
154 ngay khi tạo chúng. Suy luận kiểu giúp làm cho mã Swift ngắn gọn và dễ đọc hơn khi nó khởi tạo các hằng hoặc biến với các giá trị khác có kiểu đã biết
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Các giá trị Boolean đặc biệt hữu ích khi bạn làm việc với các câu lệnh có điều kiện, chẳng hạn như câu lệnh // Floats
163
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- if củ cải ngon {
- in [ "Mmm, củ cải ngon. " ]
- } khác {
- print [ "Eww, củ cải thật kinh khủng. " ]
- }
- // Bản in "Eww, củ cải thật kinh khủng. "
Các câu lệnh có điều kiện như câu lệnh // Floats
163 được đề cập chi tiết hơn trong Luồng điều khiển .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Loại an toàn của Swift ngăn các giá trị không phải Boolean được thay thế cho // Floats
3. Ví dụ sau báo cáo lỗi thời gian biên dịch
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- hãy i = 1
- nếu i {
- // ví dụ này sẽ không biên dịch và sẽ báo lỗi
- }
Tuy nhiên, ví dụ thay thế dưới đây là hợp lệ
- hãy i = 1
- if i == 1 {
- // ví dụ này sẽ biên dịch thành công
- }
Kết quả của phép so sánh // Floats
166 thuộc loại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
3, vì vậy ví dụ thứ hai này vượt qua kiểm tra loại. Các phép so sánh như
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
166 được thảo luận trong Toán tử cơ bản .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Cũng như các ví dụ khác về an toàn kiểu trong Swift, cách tiếp cận này tránh được các lỗi ngẫu nhiên và đảm bảo rằng mục đích của một đoạn mã cụ thể luôn rõ ràng
bộ dữ liệu
Bộ dữ liệu nhóm nhiều giá trị thành một giá trị ghép duy nhất. Các giá trị trong một bộ có thể thuộc bất kỳ loại nào và không nhất thiết phải cùng loại với nhau
Trong ví dụ này, // Floats
169 là một bộ mô tả mã trạng thái HTTP. Mã trạng thái HTTP là một giá trị đặc biệt được máy chủ web trả về bất cứ khi nào bạn yêu cầu một trang web. Mã trạng thái
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
170 được trả về nếu bạn yêu cầu một trang web không tồn tại
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let Lỗi http404 = [ 404 , "Not Found"]
- // http404Error thuộc loại [Int, String] và bằng [404, "Not Found"]
Bộ dữ liệu // Floats
169 nhóm một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 và một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 lại với nhau để cung cấp cho mã trạng thái HTTP hai giá trị riêng biệt. một con số và một mô tả mà con người có thể đọc được. Nó có thể được mô tả là “một bộ kiểu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
174”
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bạn có thể tạo các bộ dữ liệu từ bất kỳ hoán vị nào của các loại và chúng có thể chứa bao nhiêu loại khác nhau tùy thích. Không có gì ngăn cản bạn có một bộ dữ liệu kiểu // Floats
175, hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
176, hoặc thực sự là bất kỳ hoán vị nào khác mà bạn yêu cầu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bạn có thể phân tách nội dung của bộ dữ liệu thành các hằng số hoặc biến riêng biệt, sau đó bạn truy cập như bình thường
- hãy [ Mã trạng thái , Thông báo trạng thái] = http404Error
- in [ "Mã trạng thái là \ [statusCode]"]
- // In ra "Mã trạng thái là 404"
- in [ "Thông báo trạng thái là \ [statusMessage]"]
- // In ra "Thông báo trạng thái không tìm thấy"
Nếu bạn chỉ cần một số giá trị của bộ dữ liệu, hãy bỏ qua các phần của bộ dữ liệu có dấu gạch dưới [// Floats
177] khi bạn phân tách bộ dữ liệu
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- let [ justTheStatusCode , _] = http404Error
- in [ "Mã trạng thái là \ [justTheStatusCode]"]
- // In ra "Mã trạng thái là 404"
Ngoài ra, truy cập các giá trị phần tử riêng lẻ trong một bộ bằng cách sử dụng các số chỉ mục bắt đầu từ 0
- in [ "Mã trạng thái là \ [ . http404Error.0]" ]
- // In ra "Mã trạng thái là 404"
- in [ "Thông báo trạng thái là \ [ . http404Error.1]" ]
- // In ra "Thông báo trạng thái không tìm thấy"
Bạn có thể đặt tên cho các phần tử riêng lẻ trong một bộ khi bộ được xác định
- let http200Status = [ statusCode . 200 , mô tả . "OK" ]
Nếu bạn đặt tên cho các phần tử trong một bộ, bạn có thể sử dụng tên phần tử để truy cập các giá trị của các phần tử đó
- in [ "Mã trạng thái là \ [ . http200Status.mã trạng thái]" ]
- // In ra "Mã trạng thái là 200"
- in [ "Thông báo trạng thái là \ [ . http200Status.mô tả]" ]
- // In ra "Thông báo trạng thái là OK"
Các bộ dữ liệu đặc biệt hữu ích như các giá trị trả về của các hàm. Một chức năng cố gắng truy xuất một trang web có thể trả về loại bộ dữ liệu // Floats
174 để mô tả thành công hay thất bại của việc truy xuất trang. Bằng cách trả về một bộ có hai giá trị riêng biệt, mỗi giá trị thuộc một loại khác nhau, hàm cung cấp nhiều thông tin hữu ích hơn về kết quả của nó so với việc nó chỉ có thể trả về một giá trị của một loại duy nhất. Để biết thêm thông tin, xem
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
Bộ dữ liệu hữu ích cho các nhóm giá trị liên quan đơn giản. Chúng không phù hợp với việc tạo cấu trúc dữ liệu phức tạp. Nếu cấu trúc dữ liệu của bạn có thể phức tạp hơn, hãy mô hình hóa nó dưới dạng một lớp hoặc cấu trúc, thay vì dưới dạng một bộ. Để biết thêm thông tin, hãy xem Cấu trúc và lớp .
tùy chọn
Bạn sử dụng tùy chọn trong trường hợp có thể không có giá trị. Một tùy chọn đại diện cho hai khả năng. Có một giá trị và bạn có thể mở tùy chọn để truy cập giá trị đó hoặc không có giá trị nào cả
Ghi chú
Khái niệm về tùy chọn không tồn tại trong C hoặc Objective-C. Điều gần nhất trong Mục tiêu-C là khả năng trả về // Floats
8 từ một phương thức mà nếu không sẽ trả về một đối tượng, với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8 có nghĩa là “sự vắng mặt của một đối tượng hợp lệ. ” Tuy nhiên, điều này chỉ hoạt động đối với các đối tượng—nó không hoạt động đối với cấu trúc, kiểu C cơ bản hoặc giá trị liệt kê. Đối với các loại này, các phương thức Objective-C thường trả về một giá trị đặc biệt [chẳng hạn như
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
181] để biểu thị sự vắng mặt của một giá trị. Cách tiếp cận này giả định rằng người gọi phương thức biết có một giá trị đặc biệt để kiểm tra và nhớ kiểm tra nó. Các tùy chọn của Swift cho phép bạn chỉ ra sự vắng mặt của một giá trị cho bất kỳ loại nào mà không cần các hằng số đặc biệt
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Đây là một ví dụ về cách tùy chọn có thể được sử dụng để đối phó với việc không có giá trị. Loại // Floats
0 của Swift có một trình khởi tạo cố gắng chuyển đổi giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4 thành giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0. Tuy nhiên, không phải chuỗi nào cũng có thể chuyển thành số nguyên. Chuỗi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
185 có thể được chuyển đổi thành giá trị số
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
186, nhưng chuỗi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
187 không có giá trị số rõ ràng để chuyển đổi thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ví dụ bên dưới sử dụng trình khởi tạo để cố gắng chuyển đổi một // Floats
4 thành một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- hãy Số có thể = "123"
- let convertedNumber = Int [ possibleNumber]
- // convertNumber được suy ra là kiểu "Int?", hoặc "Int tùy chọn"
Bởi vì trình khởi tạo có thể bị lỗi, nên nó trả về một // Floats
0 tùy chọn, thay vì một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0. Một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 tùy chọn được viết là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
193, không phải
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0. Dấu chấm hỏi cho biết rằng giá trị mà nó chứa là tùy chọn, nghĩa là nó có thể chứa một số giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0 hoặc có thể không chứa giá trị nào cả. [Nó không được chứa bất kỳ thứ gì khác, chẳng hạn như giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
3 hoặc giá trị
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
4. Đó là một
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
0, hoặc chẳng là gì cả. ]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
không
Bạn đặt biến tùy chọn thành trạng thái vô giá trị bằng cách gán cho nó giá trị đặc biệt // Floats
8
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- var serverResponseCode . Int ? 404
- // serverResponseCode chứa giá trị Int thực là 404
- serverResponseCode = không
- // serverResponseCode bây giờ không chứa giá trị
Ghi chú
Bạn không thể sử dụng // Floats
8 với các hằng số và biến không bắt buộc. Nếu một hằng số hoặc biến trong mã của bạn cần hoạt động mà không có giá trị trong một số điều kiện nhất định, hãy luôn khai báo nó dưới dạng giá trị tùy chọn thuộc loại thích hợp
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nếu bạn xác định một biến tùy chọn mà không cung cấp giá trị mặc định, thì biến đó sẽ tự động được đặt thành // Floats
8 cho bạn
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- var câu trả lời khảo sát . Chuỗi ?
- // SurveyAnswer được tự động đặt thành không
Ghi chú
// Floats
8 của Swift không giống như
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8 trong Objective-C. Trong Objective-C,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8 là một con trỏ tới một đối tượng không tồn tại. Trong Swift,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8 không phải là một con trỏ—đó là sự vắng mặt của một giá trị thuộc một loại nhất định. Tùy chọn của bất kỳ loại nào có thể được đặt thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8, không chỉ các loại đối tượng
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Câu lệnh If và Unwrapping bắt buộc
Bạn có thể sử dụng câu lệnh // Floats
163 để tìm hiểu xem tùy chọn có chứa giá trị hay không bằng cách so sánh tùy chọn với
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
8. Bạn thực hiện phép so sánh này với toán tử “bằng” [
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
209] hoặc toán tử “không bằng” [
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
210]
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nếu một tùy chọn có giá trị, nó được coi là “không bằng” // Floats
8
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- if convertedNumber . = không {
- print [ "convertedNumber chứa một số giá trị số nguyên. " ]
- }
- // In "convertedNumber chứa một số giá trị số nguyên. "
Khi bạn chắc chắn rằng tùy chọn có chứa giá trị, bạn có thể truy cập giá trị cơ bản của nó bằng cách thêm dấu chấm than [// Floats
212] vào cuối tên của tùy chọn. Dấu chấm than nói một cách hiệu quả, “Tôi biết rằng tùy chọn này chắc chắn có giá trị; . ” Điều này được gọi là bắt buộc mở giá trị của tùy chọn
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- if convertedNumber . = không {
- print [ "convertedNumber có giá trị nguyên là \ [convertedNumber!]. " ]
- }
- // In ra "convertedNumber có giá trị nguyên là 123. "
Để biết thêm về câu lệnh // Floats
163, hãy xem Luồng điều khiển .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
Cố gắng sử dụng // Floats
212 để truy cập giá trị tùy chọn không tồn tại sẽ gây ra lỗi thời gian chạy. Luôn đảm bảo rằng một tùy chọn chứa giá trị không phải ____18 trước khi sử dụng
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
212 để buộc mở gói giá trị của nó
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ràng buộc tùy chọn
Bạn sử dụng liên kết tùy chọn để tìm hiểu xem tùy chọn có chứa giá trị hay không và nếu có, để cung cấp giá trị đó dưới dạng hằng số hoặc biến tạm thời. Liên kết tùy chọn có thể được sử dụng với các câu lệnh // Floats
163 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
218 để kiểm tra một giá trị bên trong một tùy chọn và để trích xuất giá trị đó thành một hằng số hoặc biến, như một phần của một hành động. Câu lệnh
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
163 và
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
218 được mô tả chi tiết hơn trong Luồng điều khiển .
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Viết ràng buộc tùy chọn cho câu lệnh // Floats
163 như sau
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- if let constantName = someOptional {
- các câu lệnh
- }
Bạn có thể viết lại ví dụ // Floats
222 từ phần này để sử dụng ràng buộc tùy chọn thay vì buộc phải mở gói
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- if let actualNumber = Int[possibleNumber] {
- in [ "Chuỗi \" \ [possibleNumber]\" has an integer value of \[actualNumber]"]
- } khác {
- in [ "Chuỗi \" \ [possibleNumber]\" couldn't be converted to an integer"]
- }
- // In ra "Chuỗi "123" có giá trị nguyên là 123"
Mã này có thể được đọc là
“Nếu // Floats
0 tùy chọn được trả về bởi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
224 có chứa một giá trị, hãy đặt một hằng số mới có tên là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
225 thành giá trị có trong tùy chọn. ”
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nếu chuyển đổi thành công, hằng số // Floats
225 sẽ có sẵn để sử dụng trong nhánh đầu tiên của câu lệnh
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
163. Nó đã được khởi tạo với giá trị chứa trong phần tùy chọn và vì vậy bạn không sử dụng hậu tố
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
212 để truy cập giá trị của nó. Trong ví dụ này,
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
225 chỉ đơn giản được sử dụng để in kết quả chuyển đổi
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Nếu bạn không cần tham chiếu đến hằng số hoặc biến tùy chọn ban đầu sau khi truy cập giá trị mà nó chứa, bạn có thể sử dụng cùng một tên cho hằng số hoặc biến mới
- let myNumber = Int [ possibleNumber]
- // Ở đây, myNumber là một số nguyên tùy chọn
- if let myNumber = myNumber {
- // Ở đây, myNumber là một số nguyên không bắt buộc
- in [ "Số của tôi là \ [= 0, "A person's age can't be less than zero." ]
- // Khẳng định này không thành công vì -3 không >= 0
Trong ví dụ này, việc thực thi mã tiếp tục nếu // Floats
288 ước tính thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
153, tức là nếu giá trị của
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
290 không âm. Nếu giá trị của
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
290 là âm, như trong đoạn mã trên, thì
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
288 ước tính thành
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
154 và xác nhận không thành công, chấm dứt ứng dụng
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bạn có thể bỏ qua thông báo xác nhận—ví dụ: khi nó chỉ lặp lại điều kiện dưới dạng văn xuôi
- khẳng định [ tuổi >= 0]
Nếu mã đã kiểm tra điều kiện, bạn sử dụng hàm // Floats
294 để chỉ ra rằng một xác nhận không thành công. Ví dụ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- nếu tuổi > 10 {
- print [ "Bạn có thể đi tàu lượn siêu tốc hoặc đu quay. " ]
- } khác nếu tuổi >= 0 {
- print [ "Bạn có thể đi vòng đu quay. " ]
- } khác {
- assertionFailure [ "Tuổi của một người không được nhỏ hơn 0. " ]
- }
Thực thi các điều kiện tiên quyết
Sử dụng điều kiện tiên quyết bất cứ khi nào điều kiện có khả năng sai, nhưng chắc chắn phải đúng để mã của bạn tiếp tục thực thi. Ví dụ: sử dụng điều kiện tiên quyết để kiểm tra xem chỉ số dưới có nằm ngoài giới hạn hay không hoặc để kiểm tra xem một hàm đã được chuyển một giá trị hợp lệ chưa
Bạn viết một điều kiện tiên quyết bằng cách gọi hàm // Floats
295. Bạn chuyển vào hàm này một biểu thức có giá trị là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
153 hoặc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
154 và một thông báo sẽ hiển thị nếu kết quả của điều kiện là
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
154. Ví dụ
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
- // Trong quá trình triển khai một chỉ số
- điều kiện tiên quyết [ chỉ mục > 0, "Index must be greater than zero." ]
Bạn cũng có thể gọi hàm // Floats
299 để cho biết đã xảy ra lỗi—ví dụ: nếu trường hợp mặc định của một công tắc được thực hiện, nhưng tất cả dữ liệu đầu vào hợp lệ phải được xử lý bởi một trong các trường hợp khác của công tắc
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Ghi chú
Nếu bạn biên dịch ở chế độ không được chọn [______1300], các điều kiện tiên quyết sẽ không được chọn. Trình biên dịch giả định rằng các điều kiện tiên quyết luôn đúng và nó sẽ tối ưu hóa mã của bạn cho phù hợp. Tuy nhiên, chức năng // Floats
301 luôn tạm dừng thực thi, bất kể cài đặt tối ưu hóa
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1
Bạn có thể sử dụng hàm // Floats
301 trong quá trình tạo mẫu và phát triển ban đầu để tạo sơ khai cho chức năng chưa được triển khai, bằng cách viết
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1// Floats
303 dưới dạng triển khai sơ khai. Bởi vì các lỗi nghiêm trọng không bao giờ được tối ưu hóa, không giống như các xác nhận hoặc điều kiện tiên quyết, bạn có thể chắc chắn rằng quá trình thực thi luôn bị dừng nếu nó gặp phải một triển khai sơ khai
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1