Sự khác biệt c và c ++

// 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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 cho số nguyên, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 12 cho giá trị dấu phẩy động, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13 cho giá trị Boolean và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 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, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 15, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 16 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 17, như được mô tả trong Các loại bộ sưu tập .

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 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ỏ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14, loại an toàn ngăn bạn vượt qua nó một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 tùy chọn sang một đoạn mã yêu cầu một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 114 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115) với một giá trị của một loại cụ thể (chẳng hạn như số // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 116 hoặc chuỗi // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 117). 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 118 và biến với từ khóa // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 119. 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 114 và đặt cho nó một giá trị là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 116. Sau đó, khai báo một biến mới có tên là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 122 và đặt cho nó giá trị ban đầu là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 123. ”

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 118. Chỉ sử dụng các biến để lưu trữ các giá trị cần có khả năng thay đổi

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115, để chỉ ra rằng biến đó có thể lưu trữ các giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115 có kiểu là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14. ”

Cụm từ “thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14” có nghĩa là “có thể lưu trữ bất kỳ giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 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ữ

Biến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115 hiện có thể được đặt thành bất kỳ giá trị chuỗi nào mà không gặp lỗi

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115 ở trên, không có giá trị ban đầu nào được cung cấp và do đó, loại biến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 115 được chỉ định bằng chú thích loại thay vì được suy ra từ giá trị ban đầu

Đặ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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 134) 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 135 được thay đổi từ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 136 thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 137

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 138

in ( chào mừng thân thiện )
// Bản in "Bonjour. "

Hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 138 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 138 in đầu ra của nó trong ngăn “bảng điều khiển” của Xcode. Tham số // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 141 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 142 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ụ: // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 143. Để biết thông tin về các tham số có giá trị mặc định, hãy xem

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 144)

// Đâ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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 145) và kết thúc bằng dấu hoa thị, sau đó là dấu gạch chéo lên (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 146)

/* Đâ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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 147) 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 148 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 149. Số nguyên có dấu (dương, 0 hoặc âm) hoặc không dấu (dương hoặc 0)

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150 và số nguyên có dấu 32 bit thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 151. 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 152 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 153 của nó

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10, 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

Trên nền tảng 32-bit, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 có cùng kích thước với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 151
Trên nền tảng 64 bit, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 có cùng kích thước với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 159

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 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, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 có thể lưu trữ bất kỳ giá trị nào trong khoảng từ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 162 đến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 163 và đủ lớn cho nhiều phạm vi số nguyên

UInt

Swift cũng cung cấp một loại số nguyên không dấu, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 164, 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

Trên nền tảng 32 bit, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 164 có cùng kích thước với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 166
Trên nền tảng 64 bit, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 164 có cùng kích thước với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 168

Ghi chú

Chỉ sử dụng // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 164 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ì // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 đượ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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 172, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 173 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 174

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10. Swift cung cấp hai loại số dấu phẩy động có dấu

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 đại diện cho số dấu phẩy động 64 bit
// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 12 đại diện cho số dấu phẩy động 32 bit

Ghi chú

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 có độ chính xác ít nhất là 15 chữ số thập phân, trong khi độ chính xác của // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 12 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ì // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 được ưu tiên hơn

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14, bạn không thể chuyển nó thành một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 do nhầm lẫn

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 148 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 172 trong các ví dụ bên dưới. )

Ví dụ: nếu bạn gán một giá trị bằng chữ là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 148 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10, 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11

let pi = 3. 14159
// pi được suy ra là kiểu Double

Swift luôn chọn // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 (chứ không phải // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 12) khi suy ra loại số dấu phẩy động

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 sẽ được suy ra từ ngữ cảnh

let anotherPi = 3 + 0.14159
// AnotherPi cũng được suy ra là kiểu Double

Giá trị bằng chữ của // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 181 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 đượ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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 183
Một số bát phân, có tiền tố // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 184
Một số thập lục phân, có tiền tố // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 185

Tất cả các số nguyên này có giá trị thập phân là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 186

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 185). 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 188;

Đối với các số thập phân có số mũ là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1100, cơ số được nhân với 10 lần

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1101 có nghĩa là 1. 25 x 102 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1102
// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1103 có nghĩa là 1. 25 x 10-2, hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1104

Đối với các số thập lục phân có số mũ là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1100, cơ số được nhân với 2 lần

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1106 có nghĩa là 15 x 22 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1107
// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1108 có nghĩa là 15 x 2-2 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1109

Tất cả các chữ số dấu phẩy động này có giá trị thập phân là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1110

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1112 có thể lưu các số trong khoảng từ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1113 đến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1114, trong khi hằng hoặc biến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150 có thể lưu các số trong khoảng từ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 123 đến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1117. 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1118 thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119, trong khi hằng số // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1120 thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150. 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1122 để tạo một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119 mới được khởi tạo với giá trị là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1120 và sử dụng giá trị này thay cho giá trị ban đầu

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119, phần bổ sung được cho phép. Hằng số đầu ra (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1126) được suy ra là thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119, bởi vì nó là tổng của hai giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1129 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, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119 có một bộ khởi tạo chấp nhận giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150 và do đó, bộ khởi tạo này được sử dụng để tạo một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119 mới từ một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 150 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à // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119 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 .

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1135 được sử dụng để tạo một giá trị mới kiểu // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11, 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 12

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1139 trở thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1140 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1141 trở thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1142

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 181 có thể được thêm trực tiếp vào giá trị bằng chữ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1144, 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á

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1145

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1146 được định nghĩa là bí danh cho // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1119. Bởi vì nó là một bí danh, lệnh gọi tới // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1148 thực sự gọi tới // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1149, cung cấp giá trị ban đầu là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 123 cho biến // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1151

Booleans

Swift có một kiểu Boolean cơ bản, được gọi là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13. 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, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154

let orangesAreOrange = true
let củ cải ngon = false

Các loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1155 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1156 đã được suy ra là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 11 ở trên, bạn không cần khai báo hằng hoặc biến là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13 nếu bạn đặt chúng thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 được đề cập chi tiết hơn trong Luồng điều khiển .

Loại an toàn của Swift ngăn các giá trị không phải Boolean được thay thế cho // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13. Ví dụ sau báo cáo lỗi thời gian biên dịch

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1166 thuộc loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13, 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ư // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1166 được thảo luận trong Toán tử cơ bản .

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1169 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1170 được trả về nếu bạn yêu cầu một trang web không tồn tại

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1169 nhóm một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 và một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1174”

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1175, hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1176, hoặc thực sự là bất kỳ hoán vị nào khác mà bạn yêu cầu

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1177) khi bạn phân tách bộ dữ liệu

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1174 để 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 từ một phương thức mà nếu không sẽ trả về một đối tượng, với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 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ư // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1181) để 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

Đâ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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 của Swift có một trình khởi tạo cố gắng chuyển đổi giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 thành giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10. Tuy nhiên, không phải chuỗi nào cũng có thể chuyển thành số nguyên. Chuỗi // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1185 có thể được chuyển đổi thành giá trị số // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1186, nhưng chuỗi // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1187 không có giá trị số rõ ràng để chuyển đổi thành

Ví dụ bên dưới sử dụng trình khởi tạo để cố gắng chuyển đổi một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 thành một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 tùy chọn, thay vì một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10. Một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 tùy chọn được viết là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1193, không phải // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10. 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ị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 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ị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 13 hoặc giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14. Đó là một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10, hoặc chẳng là gì cả. )

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 cho bạn

var câu trả lời khảo sát . Chuỗi ?
// SurveyAnswer được tự động đặt thành không

Ghi chú

// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 của Swift không giống như // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 trong Objective-C. Trong Objective-C, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 là một con trỏ tới một đối tượng không tồn tại. Trong Swift, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18, không chỉ các loại đối tượng

Câu lệnh If và Unwrapping bắt buộc

Bạn có thể sử dụng câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 để 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18. Bạn thực hiện phép so sánh này với toán tử “bằng” (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1209) hoặc toán tử “không bằng” (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1210)

Nếu một tùy chọn có giá trị, nó được coi là “không bằng” // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1212) 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163, hãy xem Luồng điều khiển .

Ghi chú

Cố gắng sử dụng // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1212 để 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1212 để buộc mở gói giá trị của nó

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1218 để 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 và // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1218 được mô tả chi tiết hơn trong Luồng điều khiển .

Viết ràng buộc tùy chọn cho câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 như sau

if let constantName = someOptional {
các câu lệnh
}

Bạn có thể viết lại ví dụ // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1222 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 10 tùy chọn được trả về bởi // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1224 có chứa một giá trị, hãy đặt một hằng số mới có tên là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1225 thành giá trị có trong tùy chọn. ”

Nếu chuyển đổi thành công, hằng số // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1225 sẽ có sẵn để sử dụng trong nhánh đầu tiên của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163. 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ố // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1212 để truy cập giá trị của nó. Trong ví dụ này, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1225 chỉ đơn giản được sử dụng để in kết quả chuyển đổi

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à \ (<myNumber)")
}
// In ra "Số của tôi là 123"

Mã này bắt đầu bằng cách kiểm tra xem // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 có chứa giá trị hay không, giống như mã trong ví dụ trước. Nếu // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 có một giá trị, thì giá trị của một hằng số mới có tên là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 được đặt thành giá trị đó. Bên trong phần thân của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163, viết // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 đề cập đến hằng số không bắt buộc mới đó. Trước khi bắt đầu câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 và sau khi kết thúc, viết // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 đề cập đến hằng số nguyên tùy chọn

Vì loại mã này rất phổ biến nên bạn có thể sử dụng cách viết ngắn hơn để mở khóa một giá trị tùy chọn. chỉ viết tên của hằng số hoặc biến mà bạn đang mở gói. Hằng số hoặc biến mới, chưa được bao bọc hoàn toàn sử dụng cùng tên với giá trị tùy chọn

if let myNumber {
in ( "Số của tôi là \ (<myNumber)")
}
// In ra "Số của tôi là 123"

Bạn có thể sử dụng cả hằng và biến với liên kết tùy chọn. Nếu bạn muốn thao tác giá trị của // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 trong nhánh đầu tiên của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163, thay vào đó, bạn có thể viết // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1239 và giá trị chứa trong tùy chọn sẽ được cung cấp dưới dạng biến thay vì hằng số. Những thay đổi bạn thực hiện đối với // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1230 bên trong phần nội dung của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 chỉ áp dụng cho biến cục bộ đó, không áp dụng cho biến gốc, hằng số tùy chọn hoặc biến mà bạn đã mở gói

Bạn có thể bao gồm bao nhiêu ràng buộc tùy chọn và điều kiện Boolean trong một câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 nếu bạn cần, được phân tách bằng dấu phẩy. Nếu bất kỳ giá trị nào trong các ràng buộc tùy chọn là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 hoặc bất kỳ điều kiện Boolean nào ước tính là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154, thì toàn bộ điều kiện của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 được coi là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154. Các câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 sau đây là tương đương

if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
in ( " \ (firstNumber) < \(secondNumber) < 100")
}
// In ra "4 < 42 < 100"
if let firstNumber = Int("4") {
if let secondNumber = Int("42") {
if Số thứ nhất < Số thứ hai && secondNumber < 100 {
in ( " \ (firstNumber) < \(secondNumber) < 100")
}
}
}
// In ra "4 < 42 < 100"

Ghi chú

Các hằng số và biến được tạo với liên kết tùy chọn trong câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 chỉ có sẵn trong phần nội dung của câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163. Ngược lại, các hằng và biến được tạo bằng câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1250 có sẵn trong các dòng mã tuân theo câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1250, như được mô tả trong

Các tùy chọn được mở hoàn toàn

Như đã mô tả ở trên, tùy chọn chỉ ra rằng một hằng số hoặc biến được phép có “không có giá trị”. Có thể kiểm tra các tùy chọn bằng câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1163 để xem giá trị có tồn tại hay không và có thể được mở khóa theo điều kiện bằng liên kết tùy chọn để truy cập giá trị của tùy chọn nếu nó tồn tại

Đôi khi, rõ ràng từ cấu trúc của chương trình rằng một tùy chọn sẽ luôn có một giá trị, sau khi giá trị đó được đặt lần đầu tiên. Trong những trường hợp này, sẽ rất hữu ích nếu bạn loại bỏ nhu cầu kiểm tra và mở gói giá trị của tùy chọn mỗi khi nó được truy cập, bởi vì nó có thể được coi là luôn có giá trị một cách an toàn

Các loại tùy chọn này được định nghĩa là các tùy chọn không được bao bọc hoàn toàn. Bạn viết một tùy chọn không được bao bọc hoàn toàn bằng cách đặt dấu chấm than (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1253) thay vì dấu chấm hỏi (// Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1254) sau loại mà bạn muốn đặt tùy chọn. Thay vì đặt dấu chấm than sau tên của tùy chọn khi bạn sử dụng nó, bạn đặt dấu chấm than sau loại tùy chọn khi bạn khai báo nó

Các tùy chọn được mở hoàn toàn hữu ích khi giá trị của một tùy chọn được xác nhận là tồn tại ngay sau khi tùy chọn được xác định lần đầu và chắc chắn có thể được coi là tồn tại ở mọi thời điểm sau đó. Việc sử dụng chính các tùy chọn được mở hoàn toàn trong Swift là trong quá trình khởi tạo lớp, như được mô tả trong

Tùy chọn chưa mở gói hoàn toàn là một tùy chọn bình thường ẩn sau hậu trường, nhưng cũng có thể được sử dụng như một giá trị không phải tùy chọn mà không cần mở gói giá trị tùy chọn mỗi khi nó được truy cập. Ví dụ sau đây cho thấy sự khác biệt trong hành vi giữa một chuỗi tùy chọn và một chuỗi tùy chọn không được bao bọc hoàn toàn khi truy cập giá trị được bao bọc của chúng dưới dạng một // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 rõ ràng

let possibleString . Chuỗi ? . " "An optional string."
let forcedString . Chuỗi = possibleString . // yêu cầu dấu chấm than
let chuỗi giả định . Chuỗi . = "Một chuỗi tùy chọn chưa được mở hoàn toàn. "
let implicitString . Chuỗi = asssumedString // không cần dấu chấm than

Bạn có thể nghĩ về một tùy chọn được mở hoàn toàn khi cho phép tùy chọn được mở ra nếu cần. Khi bạn sử dụng một giá trị tùy chọn không bao bọc hoàn toàn, trước tiên Swift sẽ cố gắng sử dụng nó như một giá trị tùy chọn thông thường; . Trong đoạn mã trên, giá trị tùy chọn // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1256 bị buộc mở trước khi gán giá trị của nó cho // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1257 vì // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1257 có loại // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 14 rõ ràng, không tùy chọn. Trong mã bên dưới, // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1260 không có loại rõ ràng nên đây là tùy chọn thông thường

let OptionalString = AssumedString
// Loại tùy chọnString là "Chuỗi?"

Nếu một tùy chọn chưa được bao bọc hoàn toàn là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 và bạn cố gắng truy cập giá trị được bao bọc của nó, thì bạn sẽ gây ra lỗi thời gian chạy. Kết quả hoàn toàn giống như khi bạn đặt dấu chấm than sau một tùy chọn thông thường không chứa giá trị

Bạn có thể kiểm tra xem một tùy chọn không bao bọc hoàn toàn có phải là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 hay không giống như cách bạn kiểm tra một tùy chọn thông thường

if AssumedString . = không {
in ( chuỗi giả định . )
}
// In ra "Chuỗi tùy chọn chưa được mở hoàn toàn. "

Bạn cũng có thể sử dụng một tùy chọn được mở hoàn toàn với ràng buộc tùy chọn, để kiểm tra và mở giá trị của nó trong một câu lệnh

if let definiteString = asssumedString {
in ( definiteString )
}
// In ra "Chuỗi tùy chọn chưa được mở hoàn toàn. "

Ghi chú

Không sử dụng một tùy chọn không được bao bọc hoàn toàn khi có khả năng một biến trở thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 sau đó. Luôn sử dụng loại tùy chọn thông thường nếu bạn cần kiểm tra giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 18 trong suốt thời gian tồn tại của biến

Xử lý lỗi

Bạn sử dụng xử lý lỗi để phản hồi các điều kiện lỗi mà chương trình của bạn có thể gặp phải trong quá trình thực thi

Ngược lại với các tùy chọn, có thể sử dụng sự hiện diện hoặc vắng mặt của một giá trị để thông báo thành công hay thất bại của một chức năng, việc xử lý lỗi cho phép bạn xác định nguyên nhân cơ bản của lỗi và, nếu cần, truyền lỗi đến một phần khác của chương trình của bạn

Khi một hàm gặp điều kiện lỗi, nó sẽ báo lỗi. Sau đó, người gọi chức năng đó có thể bắt lỗi và phản hồi một cách thích hợp

func canThrowAnError () ném {
// hàm này có thể báo lỗi hoặc không
}

Một hàm chỉ ra rằng nó có thể đưa ra lỗi bằng cách đưa từ khóa // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1265 vào phần khai báo của nó. Khi bạn gọi một hàm có thể đưa ra lỗi, bạn thêm từ khóa // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1266 vào trước biểu thức

Swift tự động lan truyền lỗi ra khỏi phạm vi hiện tại của chúng cho đến khi chúng được xử lý bởi mệnh đề // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1267

làm {
thử canThrowAnError ()
// không có lỗi nào được ném ra
} bắt {
// một lỗi đã được đưa ra
}

Một câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1268 tạo ra một phạm vi chứa mới, cho phép các lỗi được lan truyền đến một hoặc nhiều mệnh đề // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1267

Dưới đây là một ví dụ về cách xử lý lỗi có thể được sử dụng để đáp ứng các điều kiện lỗi khác nhau

func makeASandwich () ném {
//
}
làm {
thử makeASandwich ()
eatASandwich ()
} bắt SandwichError . outOfCleanDishes {
rửa bát đĩa ()
} bắt SandwichError . thiếuIngredients ( let ingredients )
mua hàng tạp hóa ( nguyên liệu )
}

Trong ví dụ này, hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1270 sẽ đưa ra lỗi nếu không có đĩa sạch hoặc nếu thiếu bất kỳ thành phần nào. Bởi vì // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1270 có thể đưa ra lỗi, lệnh gọi hàm được bao bọc trong biểu thức // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1266. Bằng cách gói lệnh gọi hàm trong câu lệnh // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1268, bất kỳ lỗi nào được đưa ra sẽ được chuyển đến mệnh đề // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1267 được cung cấp

Nếu không có lỗi xảy ra, hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1275 được gọi. Nếu một lỗi được đưa ra và nó khớp với trường hợp // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1276, thì hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1277 sẽ được gọi. Nếu một lỗi được đưa ra và nó khớp với trường hợp // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1278, thì hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1279 được gọi với giá trị // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1280 được liên kết được bắt bởi mẫu // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1267

Việc ném, bắt và lan truyền lỗi được trình bày chi tiết hơn trong Xử lý lỗi .

Khẳng định và điều kiện tiên quyết

Các xác nhận và điều kiện tiên quyết là các kiểm tra xảy ra trong thời gian chạy. Bạn sử dụng chúng để đảm bảo một điều kiện thiết yếu được thỏa mãn trước khi thực hiện bất kỳ mã nào khác. Nếu điều kiện Boolean trong xác nhận hoặc điều kiện tiên quyết ước tính là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153, quá trình thực thi mã sẽ tiếp tục như bình thường. Nếu điều kiện đánh giá là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154, thì trạng thái hiện tại của chương trình không hợp lệ;

Bạn sử dụng các xác nhận và điều kiện tiên quyết để diễn đạt các giả định mà bạn đưa ra và các kỳ vọng mà bạn có trong khi viết mã, vì vậy bạn có thể đưa chúng vào như một phần của mã của mình. Các xác nhận giúp bạn tìm ra các lỗi và giả định không chính xác trong quá trình phát triển và các điều kiện tiên quyết giúp bạn phát hiện các vấn đề trong quá trình sản xuất

Ngoài việc xác minh kỳ vọng của bạn trong thời gian chạy, các xác nhận và điều kiện tiên quyết cũng trở thành một dạng tài liệu hữu ích trong mã. Không giống như các điều kiện lỗi được thảo luận ở trên, các xác nhận và điều kiện tiên quyết không được sử dụng cho các lỗi có thể khôi phục hoặc dự kiến. Vì một xác nhận hoặc điều kiện tiên quyết không thành công cho biết trạng thái chương trình không hợp lệ, nên không có cách nào để bắt một xác nhận không thành công

Việc sử dụng các xác nhận và điều kiện tiên quyết không phải là sự thay thế cho việc thiết kế mã của bạn theo cách mà các điều kiện không hợp lệ khó có thể phát sinh. Tuy nhiên, việc sử dụng chúng để thực thi dữ liệu và trạng thái hợp lệ sẽ khiến ứng dụng của bạn chấm dứt dễ đoán hơn nếu xảy ra trạng thái không hợp lệ và giúp gỡ lỗi vấn đề dễ dàng hơn. Dừng thực thi ngay khi phát hiện trạng thái không hợp lệ cũng giúp hạn chế thiệt hại do trạng thái không hợp lệ đó gây ra

Sự khác biệt giữa các xác nhận và điều kiện tiên quyết là khi chúng được kiểm tra. Các xác nhận chỉ được kiểm tra trong các bản dựng gỡ lỗi, nhưng các điều kiện tiên quyết được kiểm tra trong cả bản dựng gỡ lỗi và sản xuất. Trong các bản dựng sản xuất, điều kiện bên trong một xác nhận không được đánh giá. Điều này có nghĩa là bạn có thể sử dụng bao nhiêu xác nhận tùy thích trong quá trình phát triển của mình mà không ảnh hưởng đến hiệu suất trong sản xuất

Gỡ lỗi với các xác nhận

Bạn viết một xác nhận bằng cách gọi hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1284 từ thư viện chuẩn Swift. Bạn chuyển vào hàm này một biểu thức có giá trị là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154 và một thông báo sẽ hiển thị nếu kết quả của điều kiện là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154. Ví dụ

hãy tuổi = -3
khẳng định ( tuổi >= 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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1288 ước tính thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153, tức là nếu giá trị của // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1290 không âm. Nếu giá trị của // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1290 là âm, như trong đoạn mã trên, thì // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1288 ước tính thành // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154 và xác nhận không thành công, chấm dứt ứng dụng

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1294 để chỉ ra rằng một xác nhận không thành công. Ví dụ

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1295. Bạn chuyển vào hàm này một biểu thức có giá trị là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1153 hoặc // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154 và một thông báo sẽ hiển thị nếu kết quả của điều kiện là // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1154. Ví dụ

// 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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1299 để 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

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 echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1301 luôn tạm dừng thực thi, bất kể cài đặt tối ưu hóa

Bạn có thể sử dụng hàm // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1301 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 // Floats echo 1.5 <=> 1.5; // 0 echo 1.5 <=> 2.5; // -1 echo 2.5 <=> 1.5; // 1303 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

programming c++

Sự khác biệt c và c ++

Hằng và biến

Khai báo hằng và biến

Loại chú thích

Đặt tên cho hằng và biến

In Hằng và Biến

Bình luận

dấu chấm phẩy

số nguyên

giới hạn số nguyên

số nguyên

UInt

Số dấu phẩy động

Loại an toàn và loại suy luận

chữ số

Chuyển đổi kiểu số

Chuyển đổi số nguyên

Chuyển đổi số nguyên và dấu phẩy động

Nhập bí danh

Booleans

bộ dữ liệu

tùy chọn

không

Câu lệnh If và Unwrapping bắt buộc

Ràng buộc tùy chọn

Các tùy chọn được mở hoàn toàn

Xử lý lỗi

Khẳng định và điều kiện tiên quyết

Gỡ lỗi với các xác nhận

Thực thi các điều kiện tiên quyết

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội