豪冷的博客

手动修复签名，能 Build 成功！

You've made it to the end of the tenth part of this series, so let's summarize:

Swift must always know the type of each of your variables, but sometimes you know more information than Swift does. For example, here are three classes:

When talking about force unwrapping, I used this code:

Back when we were talking about throwing functions, we looked at this code:

Swift provides us with a shortcut when using optionals: if you want to access something like `a.b.c` and `b` is optional, you can write a question mark after it to enable optional chaining: `a.b?.c`.

The `nil coalescing` operator unwraps an optional and returns the value inside if there is one. If there *isn't* a value - if the optional was `nil` - then a default value is used instead. Either way, the result won't be optional: it will either by the val

Like regular optionals, implicitly unwrapped optionals might contain a value or they might be nil. However, unlike regular optionals you don't need to unwrap them in order to use them: you can use them as if they weren't optional at all.

Optionals represent data that may or may not be there, but sometimes you know for **sure** that a value isn't nil. In these cases, Swift lets you force unwrap the optional: convert it from an optional type to a non-optional type.

An alternative to if let is guard let, which also unwraps optionals. guard let will unwrap an optional for you, but if it finds nil inside it expects you to exit the function, loop, or condition you used it in.

Optional strings might `contain` a string like "Hello" or they might be `nil` - nothing at all.

We've used types such as `Int` to hold values like 5. But if you wanted to store an `age` property for users, what would you do if you didn't know someone's age?

You've made it to the end of the ninth part of this series, so let's summarize:

`Protocol extensions` can provide default implementations for our own protocol methods. This makes it easy for types to conform to a protocol, and allows a technique called "protocol-oriented programming" - crafting your code around protocols and protocol

`Protocols` let you describe what methods something should have, but don't provide the code inside. `Extensions` let you provide the code inside your methods, but only affect one data type - you can't add the method to lots of types at the same time.

Extensions allow you to add methods to existing types, to make them do things they weren't originally designed to do.

One protocol can `inherit` from another in a process known as protocol inheritance. Unlike with classes, you can inherit from `multiple` protocols at the same time before you add your own customizations on top.

`Protocols` are a way of describing what properties and methods something must have.You then tell Swift which types use that protocol - a process known as adopting or conforming to a protocol.

You’ve made it to the end of the eighth part of this series, so let’s summarize

The final difference between classes and structs is the way they deal with constants. If you have a constant struct with a variable property, that property can't be changed because the struct itself is constant.

The fourth difference between classes and structs is that classes can have `deinitializers` code that gets run when an instance of a class is destroyed.

The third difference between classes and structs is how they are copied. When you copy a struct, both the original and the copy are different things - changing one won’t change the other. When you copy a class, both the original and the copy point to the s

Although class is very useful - and in fact large parts of Apple’s platforms require you to use it - sometimes you want to other developers from building their own class based on yours.Swift gives us a keyword just for this purpose: when you declare a c

Child classes can replace parent methods with their own implementations - a process known as . Here’s a trivial class with a method:If we create a new class that inherits from , it will inherit the method. So, this will print “Woof!”.Method overridin

The second difference between classes and structs is that you can create a class based on an existing class - it all the properties and methods of the original class, and can add its own on top.This is called class or , the class you inherit from is call

Classes are to structs in that they allow you to create new types with properties and methods, but they have important and I’m going to walk you through each of those differences one at a time.The difference between classes and structs is that classes

You’ve made it to the end of the seventh part of this series, so let’s summarize.

Access control lets you restrict which code can use properties and methods. This is important because you might want to stop people reading a property directly, for example.We could create a struct that has an property to store their social security numb

All the properties and methods we’ve created so far have belonged to individual of structs, which means that if we had a Student struct we could create several student instances each with their own properties and methods:You can also ask Swift to share s

As a performance optimization, Swift lets you some properties only when they are . As an example, consider this struct - it doesn’t do much, but in theory creating a family tree for someone takes a long time:We might use that struct as a property insid

Inside methods you get a special constant called , which points to whatever of the struct is currently being used. This value is particularly useful when you create that have the same parameter names as your property.For example, if you create a struct

are special methods that provide different ways to create your struct. All structs come with one by default, called their - this asks you to provide a value for each property when you create the struct.You can see this if we create a struct that has one

are also structs, which means they too have their own methods and properties we can use to query and manipulate the array.Here’s a simple array to get us started:You can read the number of items in an array using its property:If you want to add a new it

We’ve used lots of strings so far, and it turns out they are - they have their own methods and properties we can use to query and manipulate the string.First, let’s create a test string:You can read the number of characters in a string using its propert

If a struct has a property but the instance of the struct was created as a . that property be changed - the struct is , so all its properties are also constant regardless of how they were created.The problem is that when you create the struct Swift has no

Structs can have functions inside them, and those functions can use the properties of the struct as they need to. Functions inside structs are called , but they still use the same keyword.We can demonstrate this with a City struct. This will have a popula

Property observers let you run code before or after any property changes. To demonstrate this, we’ll write a struct that tracks a task and a completion percentage:We can now create an instance of that struct and adjust its progress over time:What we wan

We just created a Sport struct like this:That has a name property that stores a . These are called properties, because Swift has a different kind of property called a property - a property that runs code to figure out its value.We’re going to add anothe

Swift lets you your own types in ways, of which the most common are called , or just . Structs can be given their own and , and their own , then created and used however you want.Let’s start with a simple example: we’re going to create a struct that st

You’ve made it to the end of the sixth part of this series, so let’s summarize:You can assign closures to variables, then call them later on.Closures can parameters and values, like regular functions.You can pass closures into functions as , and those cl