IOS Swift Language 3rd tutorial

IPhone Application Development
Week 3

Swift
• Basic Operators
• An operator is a special symbol or phrase that
you use to check, change, or combine values.
• For example, the addition operator (+) adds two
numbers together (as in let i = 1 + 2).
• More complex examples include the logical AND
operator && (as in if enteredDoorCode &&
passedRetinaScan) and the increment operator
++i, which is a shortcut to increase the value of i
by 1.

Swift
• Basic Operators
• Swift supports most standard C operators and
improves several capabilities to eliminate
common coding errors.
• The assignment operator (=) does not return a
value, to prevent it from being mistakenly
used when the equal to operator (==) is
intended.

Swift
• Basic Operators
• Arithmetic operators (+, - , *, / , % and so
forth) detect and disallow value overflow, to
avoid unexpected results when working with
numbers that become larger or smaller than
the allowed value range of the type that
stores them.
• You can opt in to value overflow behavior by
using Swift’s overflow operators.

Swift
• Basic Operators
• Unlike C, Swift lets you perform remainder (%)
calculations on floating-point numbers.
• Swift also provides two range operators (a..<b
and a...b) not found in C, as a shortcut for
expressing a range of values.

Swift
• Terminology
• Operators are Unary, Binary, or Ternary:
• Unary operators operate on a single target
(such as -a).
• Unary prefix operators appear immediately
before their target (such as !b), and unary
postfix operators appear immediately after
their target (such as i++).

Swift
• Terminology
• Operators are unary, binary, or ternary:
• Binary operators operate on two targets (such
as 2 + 3) and are infix because they appear in
between their two targets.

Swift
• Terminology
• Operators are unary, binary, or ternary:
• Ternary operators operate on three targets.
• Like C, Swift has only one ternary operator, the
ternary conditional operator (a ? b : c).
• The values that operators affect are operands.
• In the expression 1 + 2, the + symbol is a binary
operator and its two operands are the values 1
and 2.

Swift
• Assignment Operator
• The assignment operator (a = b) initializes or updates the value of a with the value of b:
• let b = 10
• var a = 5
• a = b
• // a is now equal to 10
• If the right side of the assignment is a tuple with multiple values, its elements can be decomposed
into multiple constants or variables at once:
• let (x, y) = (1, 2)
• // x is equal to 1, and y is equal to 2
• Unlike the assignment operator in C and Objective-C, the assignment operator in Swift does not
itself return a value. The following statement is not valid:
• if x = y {
• // this is not valid, because x = y does not return a value
• }
• This feature prevents the assignment operator (=) from being used by accident when the equal to
operator (==) is actually intended. By making if x = y invalid, Swift helps you to avoid these kinds of
errors in your code.

Swift
• Arithmetic Operators
• Swift supports the four standard arithmetic operators for all number types:
• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/)
• 1 + 2 // equals 3
• 5 - 3 // equals 2
• 2 * 3 // equals 6
• 10.0 / 2.5 // equals 4.0
• Unlike the arithmetic operators in C and Objective-C, the Swift arithmetic
operators do not allow values to overflow by default. You can opt in to value
overflow behavior by using Swift’s overflow operators (such as a &+ b).
• The addition operator is also supported for String concatenation:
• "hello, " + "world" // equals "hello, world”

Swift
• Remainder Operator
• The remainder operator (a % b) works out how
many multiples of b will fit inside a and returns
the value that is left over (known as the
remainder).
• NOTE
• The remainder operator (%) is also known as a
modulo operator in other languages. However, its
behavior in Swift for negative numbers means
that it is, strictly speaking, a remainder rather
than a modulo operation.

Swift
• Here’s how the remainder operator works. To
calculate 9 % 4, you first work out how many 4s
will fit inside 9:
• You can fit two 4s inside 9, and the remainder is 1
(shown in orange).
• In Swift, this would be written as:
• 9 % 4 // equals 1

Swift
• To determine the answer for a % b, the %
operator calculates the following equation and
returns remainder as its output:
• a = (b x some multiplier) + remainder
• where some multiplier is the largest number of
multiples of b that will fit inside a.
• Inserting 9 and 4 into this equation yields:
• 9 = (4 x 2) + 1

Swift
• The same method is applied when calculating the
remainder for a negative value of a:
• -9 % 4 // equals -1
• Inserting -9 and 4 into the equation yields:
• -9 = (4 x -2) + -1
• giving a remainder value of -1.
• The sign of b is ignored for negative values of b.
This means that a % b and a % -b always give the
same answer.

Swift
• Floating-Point Remainder Calculations
• Unlike the remainder operator in C and
Objective-C, Swift’s remainder operator can also
operate on floating-point numbers:
• 8 % 2.5 // equals 0.5
• In this example, 8 divided by 2.5 equals 3, with a
remainder of 0.5, so the remainder operator
returns a Double value of 0.5.

Swift
• Increment and Decrement Operators
• Like C, Swift provides an increment operator (++) and a decrement
operator (--) as a shortcut to increase or decrease the value of a
numeric variable by 1.
• You can use these operators with variables of any integer or
floating-point type.
• var i = 0
• ++i // i now equals 1
• Each time you call ++i, the value of i is increased by 1. Essentially,
++i is shorthand for saying i = i + 1. Likewise, --i can be used as
shorthand for i = i - 1.
• The ++ and -- symbols can be used as prefix operators or as postfix
operators. ++i and i++ are both valid ways to increase the value of i
by 1. Similarly, --i and i-- are both valid ways to decrease the value
of i by 1.

Swift
• Note that these operators modify i and also return a
value. If you only want to increment or decrement the
value stored in i, you can ignore the returned value.
However, if you do use the returned value, it will be
different based on whether you used the prefix or
postfix version of the operator, according to the
following rules:
• If the operator is written before the variable, it
increments the variable before returning its value.
• If the operator is written after the variable, it
increments the variable after returning its value.

Swift
• For example:
• var a = 0
• let b = ++a
• // a and b are now both equal to 1
• let c = a++
• // a is now equal to 2, but c has been set to the pre-increment value
of 1.
• In the example above, let b = ++a increments a before returning its value.
This is why both a and b are equal to the new value of 1.
• However, let c = a++ increments a after returning its value. This means
that c gets the old value of 1, and a is then updated to equal 2.
• Unless you need the specific behavior of i++, it is recommended that you
use ++i and --i in all cases, because they have the typical expected
behavior of modifying i and returning the result.

Swift
• Unary Minus Operator
• The sign of a numeric value can be toggled using a
prefixed -, known as the unary minus operator:
• let three = 3
• let minusThree = -three
// minusThree equals -3
• let plusThree = -minusThree
// plusThree equals 3, or "minus minus three"
• The unary minus operator (-) is prepended directly
before the value it operates on, without any white
space.

Swift
• Unary Plus Operator
• The unary plus operator (+) simply returns the
value it operates on, without any change:
• let minusSix = -6
• let alsoMinusSix = +minusSix
// alsoMinusSix equals -6
• Although the unary plus operator doesn’t actually
do anything, you can use it to provide symmetry
in your code for positive numbers when also
using the unary minus operator for negative
numbers.

Swift
• Compound Assignment Operators
• Like C, Swift provides compound assignment operators
that combine assignment (=) with another operation.
One example is the addition assignment operator (+=):
• var a = 1
• a += 2
• // a is now equal to 3
• The expression a += 2 is shorthand for a = a + 2.
Effectively, the addition and the assignment are
combined into one operator that performs both tasks
at the same time.

Swift
• Comparison Operators
• Swift supports all standard C comparison
operators:
• Equal to (a == b)
• Not equal to (a != b)
• Greater than (a > b)
• Less than (a < b)
• Greater than or equal to (a >= b)
• Less than or equal to (a <= b)

Swift
• Each of the comparison operators returns a Bool value
to indicate whether or not the statement is true:
• 1 == 1 // true, because 1 is equal to 1
• 2 != 1 // true, because 2 is not equal to 1
• 2 > 1 // true, because 2 is greater than 1
• 1 < 2 // true, because 1 is less than 2
• 1 >= 1 // true, because 1 is greater than or equal
to 1
• 2 <= 1 // false, because 2 is not less than or equal
to 1

Swift
• Comparison operators are often used in conditional
statements, such as the if statement:
• let name = "world"
• if name == "world" {
• print("hello, world")
• } else {
• print("I'm sorry (name), but I don't recognize you")
• }
• // prints "hello, world", because name is indeed equal
to "world"

Swift
• Ternary Conditional Operator
• The ternary conditional operator is a special operator with three
parts, which takes the form question ? answer1 : answer2. It is a
shortcut for evaluating one of two expressions based on whether
question is true or false. If question is true, it evaluates answer1
and returns its value; otherwise, it evaluates answer2 and returns
its value.
• The ternary conditional operator is shorthand for the code below:
• if question {
• answer1
• } else {
• answer2
• }

Swift
• Here’s an example, which calculates the height
for a table row. The row height should be 50
points taller than the content height if the row
has a header, and 20 points taller if the row
doesn’t have a header:
• let contentHeight = 40
• let hasHeader = true
• let rowHeight = contentHeight + (hasHeader ? 50 : 20)
• // rowHeight is equal to 90

Swift
• The preceding example is shorthand for the code below:
• let contentHeight = 40
• let hasHeader = true
• var rowHeight = contentHeight
• if hasHeader {
• rowHeight = rowHeight + 50
• } else {
• rowHeight = rowHeight + 20
• }
• // rowHeight is equal to 90
• The first example’s use of the ternary conditional operator means that rowHeight
can be set to the correct value on a single line of code. This is more concise than
the second example, and removes the need for rowHeight to be a variable,
because its value does not need to be modified within an if statement.

Swift
• The ternary conditional operator provides an
efficient shorthand for deciding which of two
expressions to consider. Use the ternary
conditional operator with care, however. Its
conciseness can lead to hard-to-read code if
overused. Avoid combining multiple instances
of the ternary conditional operator into one
compound statement.

Swift
• Nil Coalescing Operator
• The nil coalescing operator (a ?? b) unwraps
an optional a if it contains a value, or returns a
default value b if a is nil.
• The expression a is always of an optional type.
The expression b must match the type that is
stored inside a.

Swift
• The nil coalescing operator is shorthand for the code
below:
• a != nil ? a! : b
• The code above uses the ternary conditional operator
and forced unwrapping (a!) to access the value
wrapped inside a when a is not nil, and to return b
otherwise.
• The nil coalescing operator provides a more elegant
way to encapsulate this conditional checking and
unwrapping in a concise and readable form.

Swift
• The example below uses the nil coalescing
operator to choose between a default color
name and an optional user-defined color
name:
• let defaultColorName = "red"
• var userDefinedColorName: String ? // defaults to nil
• var colorNameToUse = userDefinedColorName ?? defaultColorName
• // userDefinedColorName is nil, so colorNameToUse is set to the default
of "red"

Swift
• The userDefinedColorName variable is defined as an
optional String, with a default value of nil.
• Because userDefinedColorName is of an optional type,
you can use the nil coalescing operator to consider its
value.
• In the example above, the operator is used to
determine an initial value for a String variable called
colorNameToUse.
• Because userDefinedColorName is nil, the expression
userDefinedColorName ?? defaultColorName returns
the value of defaultColorName, or "red".

Swift
• If you assign a non-nil value to userDefinedColorName and perform the nil
coalescing operator check again, the value wrapped inside userDefinedColorName
is used instead of the default:
• userDefinedColorName = "green"
• colorNameToUse = userDefinedColorName ?? defaultColorName
• // userDefinedColorName is not nil, so colorNameToUse is set to "green”
• The userDefinedColorName variable is defined as an optional String, with a default
value of nil.
• Because userDefinedColorName is of an optional type, you can use the nil
coalescing operator to consider its value.
• In the example above, the operator is used to determine an initial value for a
String variable called colorNameToUse.
• Because userDefinedColorName is nil, the expression userDefinedColorName ??
defaultColorName returns the value of defaultColorName, or "red”.

Swift
• Range Operators
• Swift includes two range operators, which are shortcuts for expressing a range of
values.
• Closed Range Operator
• The closed range operator (a...b) defines a range that runs from a to b, and
includes the values a and b. The value of a must not be greater than b.
• The closed range operator is useful when iterating over a range in which you want
all of the values to be used, such as with a for-in loop:
• for index in 1...5 {
• print("(index) times 5 is (index * 5)")
• }
• // 1 times 5 is 5
• // 2 times 5 is 10
• // 3 times 5 is 15
• // 4 times 5 is 20
• // 5 times 5 is 25

Swift
• Range Operators
• Half-Open Range Operator
• The half-open range operator (a..<b) defines a range that runs from a to b, but does not include b.
It is said to be half-open because it contains its first value, but not its final value. As with the closed
range operator, the value of a must not be greater than b. If the value of a is equal to b, then the
resulting range will be empty.
• Half-open ranges are particularly useful when you work with zero-based lists such as arrays, where
it is useful to count up to (but not including) the length of the list:
• let names = ["Anna", "Alex", "Brian", "Jack"]
• let count = names.count
• for i in 0..<count {
• print("Person (i + 1) is called (names[i])")
• }
• // Person 1 is called Anna
• // Person 2 is called Alex
• // Person 3 is called Brian
• // Person 4 is called Jack
• Note that the array contains four items, but 0..<count only counts as far as 3 (the index of the last
item in the array), because it is a half-open range.

Swift
• Logical Operators
• Logical operators modify or combine the
Boolean logic values true and false. Swift
supports the three standard logical operators
found in C-based languages:
• Logical NOT (!a)
• Logical AND (a && b)
• Logical OR (a || b)

Swift
• Logical NOT Operator
• The logical NOT operator (!a) inverts a Boolean value so that true becomes false,
and false becomes true.
• The logical NOT operator is a prefix operator, and appears immediately before the
value it operates on, without any white space. It can be read as “not a”, as seen in
the following example:
• let allowedEntry = false
• if !allowedEntry {
• print("ACCESS DENIED")
• }
• // prints "ACCESS DENIED"
• The phrase if !allowedEntry can be read as “if not allowed entry.” The subsequent
line is only executed if “not allowed entry” is true; that is, if allowedEntry is false.
• As in this example, careful choice of Boolean constant and variable names can help
to keep code readable and concise, while avoiding double negatives or confusing
logic statements.

Swift
• Logical NOT Operator
• Logical AND Operator
• The logical AND operator (a && b) creates logical expressions where both values must be true for
the overall expression to also be true.
• If either value is false, the overall expression will also be false. In fact, if the first value is false, the
second value won’t even be evaluated, because it can’t possibly make the overall expression equate
to true. This is known as short-circuit evaluation.
• This example considers two Bool values and only allows access if both values are true:
• let enteredDoorCode = true
• let passedRetinaScan = false
• if enteredDoorCode && passedRetinaScan {
• print("Welcome!")
• } else {
• }
• // prints "ACCESS DENIED”

Swift
• Logical OR Operator
• The logical OR operator (a || b) is an infix operator made from two adjacent pipe characters. You
use it to create logical expressions in which only one of the two values has to be true for the overall
expression to be true.
• Like the Logical AND operator above, the Logical OR operator uses short-circuit evaluation to
consider its expressions. If the left side of a Logical OR expression is true, the right side is not
evaluated, because it cannot change the outcome of the overall expression.
• In the example below, the first Bool value (hasDoorKey) is false, but the second value
(knowsOverridePassword) is true. Because one value is true, the overall expression also evaluates
to true, and access is allowed:
• let hasDoorKey = false
• let knowsOverridePassword = true
• if hasDoorKey || knowsOverridePassword {
• } else {
• }
• // prints "Welcome!"

Swift
• Combining Logical Operators
• You can combine multiple logical operators to create longer compound expressions:
• if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
• } else {
• }
• This example uses multiple && and || operators to create a longer compound expression. However,
the && and || operators still operate on only two values, so this is actually three smaller
expressions chained together. The example can be read as:
• If we’ve entered the correct door code and passed the retina scan, or if we have a valid door key, or
if we know the emergency override password, then allow access.
• Based on the values of enteredDoorCode, passedRetinaScan, and hasDoorKey, the first two
subexpressions are false. However, the emergency override password is known, so the overall
compound expression still evaluates to true.

Swift
• Explicit Parentheses
• It is sometimes useful to include parentheses when they are not strictly needed, to make the
intention of a complex expression easier to read. In the door access example above, it is useful to
add parentheses around the first part of the compound expression to make its intent explicit:
• if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
• } else {
• }
• The parentheses make it clear that the first two values are considered as part of a separate possible
state in the overall logic. The output of the compound expression doesn’t change, but the overall
intention is clearer to the reader. Readability is always preferred over brevity; use parentheses
where they help to make your intentions clear.

Swift
• Strings and Characters
• A string is a series of characters, such as "hello, world"
or "albatross".
• Swift strings are represented by the String type. The
contents of a String can be accessed in various ways,
including as a collection of Character values.
• Swift’s String and Character types provide a fast,
Unicode-compliant way to work with text in your code.
• The syntax for string creation and manipulation is
lightweight and readable, with a string literal syntax
that is similar to C.

Swift
• String concatenation is as simple as adding together two strings
with the + operator, and string mutability is managed by choosing
between a constant or a variable, just like any other value in Swift.
• You can also use strings to insert constants, variables, literals, and
expressions into longer strings, in a process known as string
interpolation. This makes it easy to create custom string values for
display, storage, and printing.
• Despite this simplicity of syntax, Swift’s String type is a fast, modern
string implementation. Every string is composed of encoding-
independent Unicode characters, and provides support for
accessing those characters in various Unicode representations.

Swift
• String Literals
• You can include predefined String values within your
code as string literals. A string literal is a fixed
sequence of textual characters surrounded by a pair of
double quotes ("").
• Use a string literal as an initial value for a constant or
variable:
• let someString = "Some string literal value"
• Note that Swift infers a type of String for the
someString constant, because it is initialized with a
string literal value.

Swift
• Initializing an Empty String
• To create an empty String value as the starting point for building a longer
string, either assign an empty string literal to a variable, or initialize a new
String instance with initializer syntax:
• var emptyString = "" // empty string literal
• var anotherEmptyString = String() // initializer syntax
• // these two strings are both empty, and are equivalent to each
other
• Find out whether a String value is empty by checking its Boolean isEmpty
property:
• if emptyString.isEmpty {
• print("Nothing to see here")
• }
• // prints "Nothing to see here"

Swift
• String Mutability
• You indicate whether a particular String can be modified (or
mutated) by assigning it to a variable (in which case it can be
modified), or to a constant (in which case it cannot be modified):
• var variableString = "Horse"
• variableString += " and carriage"
• // variableString is now "Horse and carriage"
•
• let constantString = "Highlander"
• constantString += " and another Highlander"
• // this reports a compile-time error - a constant string cannot
be modified

Swift
• Strings Are Value Types
• Swift’s String type is a value type. If you create
a new String value, that String value is copied
when it is passed to a function or method, or
when it is assigned to a constant or variable.
• In each case, a new copy of the existing String
value is created, and the new copy is passed
or assigned, not the original version.

Swift
• Swift’s copy-by-default String behavior ensures
that when a function or method passes you a
String value, it is clear that you own that exact
String value, regardless of where it came from.
• You can be confident that the string you are
passed will not be modified unless you modify it
yourself.

Swift
• Behind the scenes, Swift’s compiler optimizes
string usage so that actual copying takes place
only when absolutely necessary.
• This means you always get great performance
when working with strings as value types.

Swift
• Working with Characters
• You can access the individual Character values for a String
by iterating over its characters property with a for-in loop:
• for character in "Dog!?".characters {
• print(character)
• }
• // D
• // o
• // g
• // !
• // ?

Swift
• Working with Characters
• Alternatively, you can create a stand-alone Character
constant or variable from a single-character string literal by
providing a Character type annotation:
• let exclamationMark: Character = "!"
• String values can be constructed by passing an array of
Character values as an argument to its initializer:
• let catCharacters: [Character] = ["C", "a", "t", "!", "?"]
• let catString = String(catCharacters)
• print(catString)
• // prints "Cat!?"

Swift
• Concatenating Strings and Characters
• String values can be added together (or concatenated) with the addition operator (+) to create a
new String value:
• let string1 = "hello"
• let string2 = " there"
• var welcome = string1 + string2
• // welcome now equals "hello there"
• You can also append a String value to an existing String variable with the addition assignment
operator (+=):
• var instruction = "look over"
• instruction += string2
• // instruction now equals "look over there"
• You can append a Character value to a String variable with the String type’s append() method:
• let exclamationMark: Character = "!"
• welcome.append(exclamationMark)
• // welcome now equals "hello there!"

Swift
• Concatenating Strings and Characters
• String Interpolation
• String interpolation is a way to construct a new String value from a mix of constants, variables,
literals, and expressions by including their values inside a string literal.
• Each item that you insert into the string literal is wrapped in a pair of parentheses, prefixed by a
backslash:
• let multiplier = 3
• let message = "(multiplier) times 2.5 is (Double(multiplier) * 2.5)"
• // message is "3 times 2.5 is 7.5"
• In the example above, the value of multiplier is inserted into a string literal as (multiplier). This
placeholder is replaced with the actual value of multiplier when the string interpolation is
evaluated to create an actual string.
• The value of multiplier is also part of a larger expression later in the string. This expression
calculates the value of Double(multiplier) * 2.5 and inserts the result (7.5) into the string. In this
case, the expression is written as (Double(multiplier) * 2.5) when it is included inside the string
literal.

Swift
• Unicode
• Unicode is an international standard for encoding,
representing, and processing text in different
writing systems.
• It enables you to represent almost any character
from any language in a standardized form, and to
read and write those characters to and from an
external source such as a text file or web page.
• Swift’s String and Character types are fully
Unicode-compliant.

Swift
• Unicode
• Unicode Scalars
• Behind the scenes, Swift’s native String type is
built from Unicode scalar values.
• A Unicode scalar is a unique 21-bit number for a
character or modifier, such as U+0061 for LATIN
SMALL LETTER A ("a"), or U+1F425 for FRONT-
FACING BABY CHICK ("🐥").

Swift
• Unicode
• Unicode Scalars
• A Unicode scalar is any Unicode code point in the
range U+0000 to U+D7FF inclusive or U+E000 to
U+10FFFF inclusive.
• Unicode scalars do not include the Unicode
surrogate pair code points, which are the code
points in the range U+D800 to U+DFFF inclusive.

Swift
• Unicode
• Unicode Scalars
• Note that not all 21-bit Unicode scalars are
assigned to a character—some scalars are
reserved for future assignment. Scalars that have
been assigned to a character typically also have a
name, such as LATIN SMALL LETTER A and
FRONT-FACING BABY CHICK in the examples
above.

Swift
• Special Characters in String Literals
• String literals can include the following special
characters:
• The escaped special characters 0 (null
character), (backslash), t (horizontal tab), n
(line feed), r (carriage return), " (double quote)
and ' (single quote)
• An arbitrary Unicode scalar, written as u{n},
where n is a 1–8 digit hexadecimal number with a
value equal to a valid Unicode code point.

Swift
• Special Characters in String Literals
• The code below shows four examples of these special characters.
The wiseWords constant contains two escaped double quote
characters. The dollarSign, blackHeart, and sparklingHeart constants
demonstrate the Unicode scalar format:
• let wiseWords = ""Imagination is more important than
knowledge" - Einstein"
• // "Imagination is more important than knowledge" - Einstein
• let dollarSign = "u{24}" // $, Unicode scalar U+0024
• let blackHeart = "u{2665}" // ♥, Unicode scalar U+2665
• let sparklingHeart = "u{1F496}" // ?, Unicode scalar U+1F496

Swift
• Extended Grapheme Clusters
• Every instance of Swift’s Character type
represents a single extended grapheme
cluster.
• An extended grapheme cluster is a sequence
of one or more Unicode scalars that (when
combined) produce a single human-readable
character.

Swift
• Here’s an example. The letter é can be represented as the
single Unicode scalar é (LATIN SMALL LETTER E WITH
ACUTE, or U+00E9).
• However, the same letter can also be represented as a pair
of scalars—a standard letter e (LATIN SMALL LETTER E, or
U+0065), followed by the COMBINING ACUTE ACCENT
scalar (U+0301).
• The COMBINING ACUTE ACCENT scalar is graphically
applied to the scalar that precedes it, turning an e into an é
when it is rendered by a Unicode-aware text-rendering
system.

Swift
• In both cases, the letter é is represented as a single
Swift Character value that represents an extended
grapheme cluster.
• In the first case, the cluster contains a single scalar; in
the second case, it is a cluster of two scalars:
• let eAcute: Character = "u{E9}" // é
• let combinedEAcute: Character = "u{65}u{301}" // e
followed by ́
• // eAcute is é, combinedEAcute is é

Swift
• Extended grapheme clusters are a flexible way to represent
many complex script characters as a single Character value.
For example, Hangul syllables from the Korean alphabet
can be represented as either a precomposed or
decomposed sequence.
• Both of these representations qualify as a single Character
value in Swift:
• let precomposed: Character = "u{D55C}" // 한
• let decomposed: Character = "u{1112}u{1161}u{11AB}" // ᄒ, ᅡ,
ᆫ
• // precomposed is 한, decomposed is 한

Swift
• Extended grapheme clusters enable scalars for enclosing marks
(such as COMBINING ENCLOSING CIRCLE, or U+20DD) to enclose
other Unicode scalars as part of a single Character value:
• let enclosedEAcute: Character = "u{E9}u{20DD}"
• // enclosedEAcute is é⃝
• Unicode scalars for regional indicator symbols can be combined in
pairs to make a single Character value, such as this combination of
REGIONAL INDICATOR SYMBOL LETTER U (U+1F1FA) and REGIONAL
INDICATOR SYMBOL LETTER S (U+1F1F8):
• let regionalIndicatorForUS: Character = "u{1F1FA}u{1F1F8}"
• // regionalIndicatorForUS is ??

Swift
• Counting Characters
• To retrieve a count of the Character values in a string, use
the count property of the string’s characters property:
• let unusualMenagerie = "Koala ?, Snail ?, Penguin ?, Dromedary ?"
• print("unusualMenagerie has (unusualMenagerie.characters.count) characters")
• // prints "unusualMenagerie has 40 characters"
• Note that Swift’s use of extended grapheme clusters for
Character values means that string concatenation and
modification may not always affect a string’s character
count.

Swift
• For example, if you initialize a new string with the four-character word cafe, and
then append a COMBINING ACUTE ACCENT (U+0301) to the end of the string, the
resulting string will still have a character count of 4, with a fourth character of é,
not e:
• var word = "cafe"
• print("the number of characters in (word) is (word.characters.count)")
• // prints "the number of characters in cafe is 4"
•
• word += "u{301}" // COMBINING ACUTE ACCENT, U+0301
•
• print("the number of characters in (word) is (word.characters.count)")
• // prints "the number of characters in café is 4"

Swift
• Extended grapheme clusters can be composed of one or
more Unicode scalars.
• This means that different characters—and different
representations of the same character—can require
different amounts of memory to store.
• Because of this, characters in Swift do not each take up the
same amount of memory within a string’s representation.
• As a result, the number of characters in a string cannot be
calculated without iterating through the string to
determine its extended grapheme cluster boundaries.

Swift
• If you are working with particularly long string values, be
aware that the characters property must iterate over the
Unicode scalars in the entire string in order to determine
the characters for that string.
• The count of the characters returned by the characters
property is not always the same as the length property of
an NSString that contains the same characters. The length
of an NSString is based on the number of 16-bit code units
within the string’s UTF-16 representation and not the
number of Unicode extended grapheme clusters within the
string.

Swift
• Accessing and Modifying a String
• You access and modify a string through its methods and properties,
or by using subscript syntax.
• String Indices
• Each String value has an associated index type, String.Index, which
corresponds to the position of each Character in the string.
• As mentioned above, different characters can require different
amounts of memory to store, so in order to determine which
Character is at a particular position, you must iterate over each
Unicode scalar from the start or end of that String.
• For this reason, Swift strings cannot be indexed by integer values.

Swift
• String Indices
• Use the startIndex property to access the position of the first
Character of a String. The endIndex property is the position after
the last character in a String. As a result, the endIndex property isn’t
a valid argument to a string’s subscript. If a String is empty,
startIndex and endIndex are equal.
• A String.Index value can access its immediately preceding index by
calling the predecessor() method, and its immediately succeeding
index by calling the successor() method. Any index in a String can
be accessed from any other index by chaining these methods
together, or by using the advancedBy(_:) method. Attempting to
access an index outside of a string’s range will trigger a runtime
error.

Swift
• You can use subscript syntax to access the Character at a particular String
index.
• let greeting = "Guten Tag!"
• greeting[greeting.startIndex]
• // G
• greeting[greeting.endIndex.predecessor()]
• // !
• greeting[greeting.startIndex.successor()]
• // u
• let index = greeting.startIndex.advancedBy(7)
• greeting[index]
• // a

Swift
• Attempting to access a Character at an index outside of a string’s
range will trigger a runtime error.
• greeting[greeting.endIndex] // error
• greeting.endIndex.successor() // error
• Use the indices property of the characters property to create a
Range of all of the indexes used to access individual characters in a
string.
• for index in greeting.characters.indices {
• print("(greeting[index]) ", terminator: "")
• }
• // prints "G u t e n T a g !"

Swift
• Inserting and Removing
• To insert a character into a string at a specified index, use the insert(_:atIndex:) method.
• var welcome = "hello"
• welcome.insert("!", atIndex: welcome.endIndex)
• // welcome now equals "hello!"
• To insert the contents of another string at a specified index, use the insertContentsOf(_:at:)
method.
• welcome.insertContentsOf(" there".characters, at: welcome.endIndex.predecessor())
• // welcome now equals "hello there!"
• To remove a character from a string at a specified index, use the removeAtIndex(_:) method.
• welcome.removeAtIndex(welcome.endIndex.predecessor())
• // welcome now equals "hello there"
• To remove a substring at a specified range, use the removeRange(_:) method:
• let range = welcome.endIndex.advancedBy(-6)..<welcome.endIndex
• welcome.removeRange(range)
• // welcome now equals "hello"

Swift
• Comparing Strings
• Swift provides three ways to compare textual values: string and
character equality, prefix equality, and suffix equality.
• String and Character Equality
• String and character equality is checked with the “equal to”
operator (==) and the “not equal to” operator (!=)
• let quotation = "We're a lot alike, you and I."
• let sameQuotation = "We're a lot alike, you and I."
• if quotation == sameQuotation {
• print("These two strings are considered equal")
• }
• // prints "These two strings are considered equal"

Swift
• Two String values (or two Character values) are
considered equal if their extended grapheme
clusters are canonically equivalent.
• Extended grapheme clusters are canonically
equivalent if they have the same linguistic
meaning and appearance, even if they are
composed from different Unicode scalars behind
the scenes.

Swift
• For example, LATIN SMALL LETTER E WITH ACUTE (U+00E9) is canonically equivalent to LATIN
SMALL LETTER E (U+0065) followed by COMBINING ACUTE ACCENT (U+0301).
• Both of these extended grapheme clusters are valid ways to represent the character é, and so they
are considered to be canonically equivalent:
• // "Voulez-vous un café?" using LATIN SMALL LETTER E WITH ACUTE
• let eAcuteQuestion = "Voulez-vous un cafu{E9}?"
•
• // "Voulez-vous un café?" using LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
• let combinedEAcuteQuestion = "Voulez-vous un cafu{65}u{301}?"
•
• if eAcuteQuestion == combinedEAcuteQuestion {
• print("These two strings are considered equal")
• }
• // prints "These two strings are considered equal”

Swift
• Prefix and Suffix Equality
• To check whether a string has a particular string prefix or suffix, call the string’s hasPrefix(_:) and hasSuffix(_:)
methods, both of which take a single argument of type String and return a Boolean value.
• The examples below consider an array of strings representing the scene locations from the first two acts of
Shakespeare’s Romeo and Juliet:
• let romeoAndJuliet = [
• "Act 1 Scene 1: Verona, A public place",
• "Act 1 Scene 2: Capulet's mansion",
• "Act 1 Scene 3: A room in Capulet's mansion",
• "Act 1 Scene 4: A street outside Capulet's mansion",
• "Act 1 Scene 5: The Great Hall in Capulet's mansion",
• "Act 2 Scene 1: Outside Capulet's mansion",
• "Act 2 Scene 2: Capulet's orchard",
• "Act 2 Scene 3: Outside Friar Lawrence's cell",
• "Act 2 Scene 4: A street in Verona",
• "Act 2 Scene 5: Capulet's mansion",
• "Act 2 Scene 6: Friar Lawrence's cell"
• ]

Swift
• You can use the hasPrefix(_:) method with the romeoAndJuliet
array to count the number of scenes in Act 1 of the play:
• var act1SceneCount = 0
• for scene in romeoAndJuliet {
• if scene.hasPrefix("Act 1 ") {
• ++act1SceneCount
• }
• }
• print("There are (act1SceneCount) scenes in Act 1")
• // prints "There are 5 scenes in Act 1"

Swift
• Similarly, use the hasSuffix(_:) method to count the number of scenes that take
place in or around Capulet’s mansion and Friar Lawrence’s cell:
• var mansionCount = 0
• var cellCount = 0
• for scene in romeoAndJuliet {
• if scene.hasSuffix("Capulet's mansion") {
• ++mansionCount
• } else if scene.hasSuffix("Friar Lawrence's cell") {
• ++cellCount
• }
• }
• print("(mansionCount) mansion scenes; (cellCount) cell scenes")
• // prints "6 mansion scenes; 2 cell scenes"

Swift
• Unicode Representations of Strings
• When a Unicode string is written to a text file or some
other storage, the Unicode scalars in that string are
encoded in one of several Unicode-defined encoding
forms.
• Each form encodes the string in small chunks known as
code units. These include the UTF-8 encoding form
(which encodes a string as 8-bit code units), the UTF-16
encoding form (which encodes a string as 16-bit code
units), and the UTF-32 encoding form (which encodes a
string as 32-bit code units).

Swift
• Swift provides several different ways to access Unicode
representations of strings. You can iterate over the string with a for-
in statement, to access its individual Character values as Unicode
extended grapheme clusters. Alternatively, access a String value in
one of three other Unicode-compliant representations:
• A collection of UTF-8 code units (accessed with the string’s utf8
property)
• A collection of UTF-16 code units (accessed with the string’s utf16
property)
• A collection of 21-bit Unicode scalar values, equivalent to the
string’s UTF-32 encoding form (accessed with the string’s
unicodeScalars property)

Swift
• Each example below shows a different
representation of the following string, which is
made up of the characters D, o, g, ‼ (DOUBLE
EXCLAMATION MARK, or Unicode scalar
U+203C), and the 🐶 character (DOG FACE, or
Unicode scalar U+1F436):
• let dogString = "Dog‼🐶”

Swift
• UTF-8 Representation
• You can access a UTF-8 representation of a
String by iterating over its utf8 property. This
property is of type String.UTF8View, which is a
collection of unsigned 8-bit (UInt8) values,
one for each byte in the string’s UTF-8
representation:

Swift

Swift
• for codeUnit in dogString.utf8 {
• print("(codeUnit) ", terminator: "")
• }
• print("")
• // 68 111 103 226 128 188 240 159 144 182
• In the example above, the first three decimal codeUnit values (68, 111,
103) represent the characters D, o, and g, whose UTF-8 representation is
the same as their ASCII representation.
• The next three decimal codeUnit values (226, 128, 188) are a three-byte
UTF-8 representation of the DOUBLE EXCLAMATION MARK character.
• The last four codeUnit values (240, 159, 144, 182) are a four-byte UTF-8
representation of the DOG FACE character.

Swift
• You can access a UTF-16 representation of a
String by iterating over its utf16 property.
• This property is of type String.UTF16View,
which is a collection of unsigned 16-bit
(UInt16) values, one for each 16-bit code unit
in the string’s UTF-16 representation:

Swift

Swift
• for codeUnit in dogString.utf16 {
• print("(codeUnit) ", terminator: "")
• }
• print("")
• // 68 111 103 8252 55357 56374
• Again, the first three codeUnit values (68, 111, 103) represent the characters D, o, and g, whose
UTF-16 code units have the same values as in the string’s UTF-8 representation (because these
Unicode scalars represent ASCII characters).
• The fourth codeUnit value (8252) is a decimal equivalent of the hexadecimal value 203C, which
represents the Unicode scalar U+203C for the DOUBLE EXCLAMATION MARK character. This
character can be represented as a single code unit in UTF-16.
• The fifth and sixth codeUnit values (55357 and 56374) are a UTF-16 surrogate pair representation
of the DOG FACE character. These values are a high-surrogate value of U+D83D (decimal value
55357) and a low-surrogate value of U+DC36 (decimal value 56374).

Swift
• Unicode Scalar Representation
• You can access a Unicode scalar representation of a
String value by iterating over its unicodeScalars
property.
• This property is of type UnicodeScalarView, which is a
collection of values of type UnicodeScalar.
• Each UnicodeScalar has a value property that returns
the scalar’s 21-bit value, represented within a UInt32
value:

Swift

Swift
• for scalar in dogString.unicodeScalars {
• print("(scalar.value) ", terminator: "")
• }
• print("")
• // 68 111 103 8252 128054
• The value properties for the first three UnicodeScalar values (68, 111, 103) once
again represent the characters D, o, and g.
• The fourth codeUnit value (8252) is again a decimal equivalent of the hexadecimal
value 203C, which represents the Unicode scalar U+203C for the DOUBLE
EXCLAMATION MARK character.
• The value property of the fifth and final UnicodeScalar, 128054, is a decimal
equivalent of the hexadecimal value 1F436, which represents the Unicode scalar
U+1F436 for the DOG FACE character.

Swift
• As an alternative to querying their value properties, each UnicodeScalar
value can also be used to construct a new String value, such as with string
interpolation:
• for scalar in dogString.unicodeScalars {
• print("(scalar) ")
• }
• // D
• // o
• // g
• // ‼
• // ?

IOS Swift Language 3rd tutorial

Recommended

More Related Content

What's hot (19)

Similar to IOS Swift Language 3rd tutorial (20)

Recently uploaded (20)

IOS Swift Language 3rd tutorial