While it's likely you'll develop Swift applications exclusively on 64-bit platforms, it's important to know that Swift is available on both 32-bit and 64-bit platforms. When using a generic integer numeric type ( Int or UInt), the generic type will be mapped to an underlying, specific equivalent that matches the current platform's word size. For example, on a 64-bit platform, Int is mapped to Int64; on a 32-bit platform, the same Int type is mapped to an Int32.

The following table summarizes the available Swift numeric data types:

Conceptually, a UInt64 variable will consume four times more RAM than a UInt8 variable, so you may ask, " Should I tune my variables by selecting the smallest number of bits needed to meet requirements?"

While it may seem intuitive to select the numeric type that uses the least RAM to store the variable's expected range of values, it's usually preferable to use the generic integer types (for example, Int when declaring integers and Double when declaring floating-point numbers).

Integer values may be instantiated using base 10 (decimal), base 2 (binary), base 8 (octal), or base 16 (hexadecimal) literal values, or by assigning another Int variable of the same type to the new variable.

For example, assigning the number 100 to a new Int variable holding a duration in minutes can be done in any of the following ways:

let minutes = 100         // decimal
let minutes = 0b1100100   // binary
let minutes = 0o144       // octal
let minutes = 0x64        // hexadecimal

Floating-point numbers are represented by either Float or Double data types. In general, you should use Double—and employ Float only when specific circumstances require using the smaller, 32-bit numeric variable.

Declaring and assigning value to floating-point variables follows the same syntax rules as with integer variables. For example, the following statement creates a new Double variable interestRate, and assigns an initial value to it:

var interestRate = 5.34

When assigning constant values to numeric types, Swift provides a handy format to make code more readable: the underscore character is ignored when parsing numeric literals.

This feature is most commonly used to provide groupings of thousands in a large integer or floating-point assignments, but actually can be used to provide any grouping separation that makes code more readable. For example, the following statements all assign the value 100,000 to the variable minutes:

var minutes = 100000
var minutes = 100_000
var minutes = 10_00_00
var minutes = 0b110_000110_101000_00

Using the underscore for readability can also be used for floating-point literal values. For example, the following statements are equivalent:

var balance = 10000.44556
var balance = 10_000.44_556

Like many fully compiled languages, Swift is a strongly typed language, and requires explicit type conversions (or casts) when assigning the value from one variable type to a variable of a different type.

Many new Swift programmers find that Swift is even stricter than languages they've used before. In many programming languages, the compiler will implicitly convert between data types during an assignment so long as the value contained within the variable being assigned (on the right of the equals sign) could not overflow the variable being assigned to (on the left of the equals sign).

In other words, in many languages, the following code would be legal, since an Int8 is known to always fit into an Int16 without a numeric overflow:

Int8 smallNumber = 3;
Int16 mediumNumber = smallNumber;

However, this equivalent code in Swift would result in a compile-time error:

var smallNumber: Int8 = 3
var mediumNumber: Int16 = smallNumber

This code would generate the following error:

error: cannot convert value of type 'Int8' to specified type 'Int16'

In Swift, it's always the programmer's responsibility to ensure that assignments have the same data type on the left and right of the assignment operator (that is, the equals sign). The following code corrects the compile-time error:

var smallNumber: Int8 = 100
var mediumNumber: Int16 = Int16(smallNumber)

The following are two examples creating new Character variables, and assigning literal values:

let ch1:Character = "A"
let ch2:Character = "😎"

Note the following regarding this assignment:

To construct a Character type using Unicode values, you can assign an escape sequence, or use the UnicodeScalar struct to create a Character using numeric Unicode values as input.

The following line of code creates a UnicodeScalar from the value 65 (the ASCII value for the English letter A), and then assigns it to the immutable variable ch1:

let ch1 = Character(UnicodeScalar(65))

In this case, there is no ambiguity with regards to double quotation marks, so it's not necessary to explicitly assign the Character type during this assignment.

It's also common to construct a Character using a UnicodeScalar escape sequence within double quotation marks. The following creates a character variable containing an emoji character represented by the UnicodeScalar 1F601:

let ch3 = "\u{1F601}"  // sets ch3 to "😁"

While Unicode scalars are conceptually similar to ASCII/ANSI value encoding, Swift Characters may be made of more than one numeric value, while ASCII and ANSI use only one numeric value to represent each character.

For example, an accented Western letter is expressed by providing a UnicodeScalar containing two character values.

We can construct the Unicode representation of an accented e character as follows:

let ch4 = "e\u{301}"   // é

The expression on the right of the assignment contains the literal letter e, followed by the escaped value for the accent modifier (301). The Swift compiler combines these two elements into a single extended grapheme cluster.

Instantiating a string variable is highly intuitive. The following statements create string variables:

var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let macCharacters = "⌘⌃⌥⇧ ⏎⌫⇪⎋⇥"
let emoji = "😎😂🎃🐳🍎😜😆"

As in many languages, Swift strings can be concatenated using the plus (+) operator:

let alphaMac = alphabet + macCharacters

String also supports the unary addition operator:

alphabet += macCharacters

One difference between Swift strings and strings in many languages is how individual elements of strings are accessed. Specifically, the following syntax with Swift strings is illegal:

let ch = alphabet[4]
error: 'subscript' is unavailable: cannot subscript String with an Int, see the documentation comment for discussion

In Swift, the input to the subscript operator (that is, what's between the [] characters) is expected to be of type String.Index, not Int.

In practice, you will construct an Index, then pass the index to the substring operator, for example:

let idx = alphabet.index(alphabet.startIndex, offsetBy: 4)
let ch = alphabet[idx]  // ch is assigned the character "E"

Obtaining the length of string is quite easy—simply call the count property of a string:

var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let alphabetLength = alphabet.count  // 26

We have now reached the end of this section. Here, we worked with the different data types in Swift, specifically numeric, Boolean, character, and string data types.