官术网_书友最值得收藏!

Defining constants and variables

Constants and variables must be defined prior to using them. To define a constant, you use the keyword let, and to define a variable, you use the keyword var. The following are some examples of constants and variables:

// Constants
let freezingTemperatureOfWaterCelsius = 0
let speedOfLightKmSec = 300000

// Variables
var currentTemperature = 22
var currentSpeed = 55

We can declare multiple constants or variables in a single line by separating them with a comma. For example, we could shrink the preceding four lines of code down to two lines like this:

// Constants
let freezingTempertureOfWaterCelsius = 0, speedOfLightKmSec = 300000

// Variables
var currentTemperture = 22, currentSpeed = 55

We can change the value of a variable to another value of a compatible type; however, as we noted earlier, we cannot change the value of a constant. Let's look at the following Playground. Can you tell what is wrong with the code from the error message that is shown in the following screenshot:

Did you figure out what was wrong with the code? Any physicist can tell you that we cannot change the speed of light, and in our code, the speedOfLightKmSec variable is a constant, and so we cannot change it either. Therefore, when we try to change the speedOfLIightKmSec constant, an error is reported by the compiler. We are able to change the value of the highTemperture variable without an error. We mentioned the difference between variables and constants a couple of times because it is a very important concept to grasp, especially when we define mutable and nonmutable collection types later in Chapter 3, Using Collections and Cocoa Data Types.

Type safety

Swift is a type-safe language. In a type-safe language, we are required to be clear on the types of values we store in a variable. We will get an error if we attempt to assign a value to a variable that is of a wrong type. The following Playground shows what happens if we attempt to put a string value into a variable that expects int values. Note that we will go over the most popular types a little later in the chapter.

Swift performs a type check when it compiles code; therefore, it will flag any mismatched types with an error. The error message in this Playground explains pretty clearly that we are trying to insert a string literal into an int variable.

So the question is, how does Swift know that integerVar is an int type? Swift uses type inference to figure out the appropriate type. Let's take a look at what type inference is.

Type inference

Type inference allows us to omit the variable type when we define it. The compiler will infer the type based on the initial value. For example, in Objective-C, we would define an integer like this:

int myInt = 1;

This tells the compiler that the myInt variable is of type int and the initial value is the number 1. In Swift, we would define the same integer like this:

var myInt = 1

Swift infers that the variable type is an integer because the initial value is an integer. Let's take a look at a couple more examples:

var x = 3.14      // Double type
var y = "Hello"   // String type
var z = true      // Boolean type

In the preceding example, the compiler will correctly infer that variable x is a Double, variable y is a String, and variable z is a Boolean based on the initial values.

Explicit types

Type inference is a very nice feature in Swift and one that you will probably get used to very quickly; however, there are times that we would like to explicitly define a variable's type. For example, in the preceding example, variable x is inferred to be a Double, but what if we wanted the variable type to be a Float? We can explicitly define a variable type like this:

var x : Float = 3.14

Notice the: Float is after the variable identifier; this tells the compiler to define the variable type to be a float type and gives it an initial value of 3.14. When we define a variable in the manner, we need to make sure that the initial value is of the same type we are defining the variable to be. If we try to give a variable an initial value that is a different type than we are defining it as, we will receive an error.

We would also explicitly define the variable type if we were not setting an initial value. For example, the following line of code is invalid because the compiler does not know what type to set variable x to:

var x

If we use this code in our application, we will receive a Type annotation missing in pattern error. If we are not setting an initial value for a variable, we are required to define the type like this:

var x : Int

Now that we have seen how to explicitly define a variable type, let's take a look at some of the most commonly used types.

主站蜘蛛池模板: 涡阳县| 阳信县| 土默特右旗| 香河县| 南木林县| 蒙阴县| 哈密市| 兴国县| 天水市| 扶余县| 乌兰浩特市| 会泽县| 镇原县| 多伦县| 淳安县| 平阴县| 清远市| 栾川县| 凤凰县| 水城县| 龙陵县| 台中市| 西乡县| 临夏市| 延安市| 响水县| 彰武县| 通化县| 文登市| 平顺县| 伊宁市| 高邮市| 普洱| 邢台市| 淅川县| 拜城县| 江川县| 太白县| 中山市| 石城县| 来安县|