Swift

Reference count

Basics

Introduction

Classes

If statements

Arrays

Variables

Retain cycles

Generic functions

Implementing protocols

Inheritance

Structs

Function arguments

Ranges

Accessing elements

Mutability

Xcode

Weak reference

Lesson Challenge

Protocol inheritance

Overrides

Properties

Closures

Higher order functions

Iterations

Integers

Swift Playground

Initializers

Methods

Switch statements

Dictionaries

Strings

Protocol Extensions

Deinitializers

Extensions

Sets

Floating Numbers

Bool

Tuples

Enums

Optionals

Write Missing

Write missing so that result will be <Bold><Selected>The final score is 40</Selected></Bold>

Create a variable

Create a variable named <Bold>age </Bold>which value is <Bold>24</Bold>

Fill missing

Create a constant with value <Bold><HighLightColor>Tom</HighLightColor></Bold>

Create variable named <Bold><HighLightColor>age</HighLightColor></Bold>

Fill Missing

Declare a tuple with the first value named <Bold><HighLightColor>width</HighLightColor></Bold>, and the second name <Bold><HighLightColor>height</HighLightColor></Bold>

Select Correct Answer

What’s the difference between <Bold><HighLightColor>Double</HighLightColor></Bold> and <Bold><HighLightColor>Float</HighLightColor></Bold>?

Write missing comparison operator so that <Bold>isCountGreaterThanFour</Bold> constant is <Bold><HighLightColor>true</HighLightColor></Bold>

What is a <Bold><HighLightColor>weak</HighLightColor></Bold> reference?

Swift provides two ways to resolve strong reference cycles when you work with properties of class type: <HighLightColor><Bold>weak</Bold></HighLightColor> references and <HighLightColor><Bold>unowned</Bold></HighLightColor> references.

A <HighLightColor><Bold>weak</Bold></HighLightColor> reference is a reference that does not keep a strong hold on the instance it refers to, and so does not stop <HighLightColor><Bold>ARC</Bold></HighLightColor> from disposing of the referenced instance. This behavior prevents the reference from becoming part of a strong reference cycle.

A strong reference prevents the class instance it points to from being deallocated and that introduces a memory leak.

This can happen if two class instances hold a strong reference to each other, such that each instance keeps the other alive.

Memory Management

Every time you <Bold>initialize</Bold> an object the app should allocate some amount of memory. And once <Bold>deinit</Bold> that object it should be removed from memory.

<Bold>Memory management</Bold> is a process of controlling and coordinating the way apps access computer memory.

The Problem

Here’s a standard, nongeneric function called <Bold><HighLightColor>isEqualInts(_:_:)</HighLightColor></Bold>, which compares two <Bold>Int</Bold> values:

The <Bold><HighLightColor>isEqualInts(_:_:)</HighLightColor></Bold> function is useful, but it can only be used with <Bold>Int</Bold> values. If you want to compare two <Bold>String</Bold> values or two <Bold>Double</Bold> values, you have to write more functions, such as the <Bold><HighLightColor>isEqualStrings(_:_:)</HighLightColor></Bold> and <Bold><HighLightColor>isEqualDoubles(_:_:)</HighLightColor></Bold> functions shown below:

You may have noticed that the bodies of the <Bold><HighLightColor>isEqualInts(_:_:)</HighLightColor></Bold>, <Bold><HighLightColor>isEqualStrings(_:_:)</HighLightColor></Bold>, and <Bold><HighLightColor>isEqualDoubles(_:_:)</HighLightColor></Bold> functions are identical. The only difference is the type of the values that they accept (Int, String, and Double).

Generics

Generic code enables you to write flexible, reusable functions and types that can work with any type, subject to requirements that you define.

You can write code that avoids duplication and expresses its intent in a clear, abstracted manner.

<Bold><HighLightColor>DataManager</HighLightColor></Bold> should conform to <Bold><HighLightColor>DataProvider</HighLightColor></Bold> protocol.

Protocols can be extended to provide a method, initializer, subscript, and computed property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.

The <HighLightColor><Bold>RandomNumberGenerator</Bold></HighLightColor> protocol can be extended to provide a <HighLightColor><Bold>randomBool()</Bold></HighLightColor> method, which uses the result of the required <HighLightColor><Bold>randomNumber()</Bold></HighLightColor> method to return a random Bool value:

Just like classes, protocols can inherit the requirements of another protocol, making it possible to form hierarchies, with the added flexibility.

Unlike classes, protocols are able to inherit from multiple parents. This is especially useful when one protocol will most often require properties or methods from a parent protocol when used.

Protocols can be adopted by classes, structs, and enums.

Here’s an example of a simple structure that adopts and conforms to the <HighLightColor><Bold>FullyNamed</Bold></HighLightColor> protocol:

Protocols

A <HighLightColor><Bold>protocol</Bold></HighLightColor> defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.

The protocol can then be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements. Any type that satisfies the requirements of a protocol is said to conform to that protocol.

Write a <Bold>convenience </Bold>initializer for <Bold><HighLightColor>Point</HighLightColor></Bold> class.

Deinitialization

A <Bold>deinitializer</Bold> is called immediately before a class instance is deallocated. You write deinitializers with the <Bold><HighLightColor>deinit</HighLightColor></Bold> keyword, similar to how initializers are written with the <Bold><HighLightColor>init</HighLightColor></Bold> keyword.

Deinitializers are only available on class types.

Class definitions can have at most one deinitializer per class. The deinitializer does not take any parameters and is written without parentheses:

Initialization

<Bold>Initialization</Bold> is the process of preparing an instance of a class, structure, or enumeration for use. This process involves setting an <Bold>initial value for each stored property</Bold> on that instance and performing any other setup or initialization that is required before the new instance is ready for use.

You implement this initialization process by defining <Bold>initializers</Bold>, which are like special methods that can be called to create a new instance of a particular type.

Initializers are called to create a new instance of a particular type. In its simplest form, an initializer is like an instance method with no parameters, written using the <HighLightColor><Bold>init</Bold></HighLightColor> keyword:

Overriding

A subclass can provide its own <Bold>custom implementation</Bold> of an instance method, type method, instance property, type property, or subscript that it would otherwise inherit from a superclass. This is known as <Bold>overriding</Bold>.

To override a characteristic that would otherwise be inherited, you prefix your overriding definition with the <HighLightColor><Bold>override</Bold></HighLightColor> keyword:

A class can <Bold>inherit</Bold> methods, properties, and other characteristics from another class. When one class inherits from another, the inheriting class is known as a <Bold>subclass</Bold>, and the class it inherits from is known as its <Bold>superclass.</Bold>

Inheritance is a fundamental behavior that differentiates classes from other types in Swift.

Any class that does not inherit from another class is known as a <Bold>base class.</Bold>

The example below defines a base class called <HighLightColor><Bold>Vehicle</Bold></HighLightColor>. This base class defines a stored property called <HighLightColor><Bold>currentSpeed</Bold></HighLightColor>, with a default value of 0

Subclassing is the act of basing a new class on an existing class. The subclass inherits characteristics from the existing class, which you can then refine. You can also add new characteristics to the subclass. To indicate that a subclass has a superclass, write the subclass name before the superclass name, separated by a colon:

The following example defines a subclass called <HighLightColor><Bold>Ferrari</Bold></HighLightColor>, with a superclass of <HighLightColor><Bold>Car</Bold></HighLightColor>:

The new <HighLightColor><Bold>Ferrari</Bold></HighLightColor> class automatically gains all of the characteristics of <HighLightColor><Bold>Car</Bold></HighLightColor>, such as its <HighLightColor><Bold>currentSpeed</Bold></HighLightColor> property. In addition to the characteristics it inherits, the <HighLightColor><Bold>Ferrari</Bold></HighLightColor> class defines a method called <HighLightColor><Bold>drive()</Bold></HighLightColor>

Object-Oriented programming

Object-Oriented Programming (OOP) is a programming paradigm that relies on the concept of <Bold>classes and objects</Bold>. It is used to structure a software program into simple, reusable pieces of code blueprints, which are used to create individual instances of objects.

Extensions add new functionality to an existing class, structure, enumeration, or protocol type. This includes the ability to extend types for which you do not have access to the original source code (known as retroactive modeling).

<Bold>• </Bold>Add computed instance properties and computed type properties

<Bold>• </Bold>Define instance methods and type methods

<Bold>• </Bold>Provide new initializers

<Bold>• </Bold>Define and use new nested types

<Bold>• </Bold>Make an existing type conform to a protocol

Extensions can add new functionality to a type, but they cannot override existing functionality.

<Bold>Instance methods</Bold> are functions that belong to instances of a particular class, structure, or enumeration. They support the functionality of those instances, either by providing ways to access and modify instance properties, or by providing functionality related to the instance’s purpose. Instance methods have exactly the same syntax as functions.

You write an instance method within the opening and closing braces of the type it belongs to. An instance method has implicit access to all other instance methods and properties of that type.

The <HighLightColor><Bold>Counter</Bold></HighLightColor> class defines two instance methods: 
 <HighLightColor><Bold>increment()</Bold></HighLightColor> increments the counter by 1.  
 <HighLightColor><Bold>reset()</Bold></HighLightColor> resets the counter to zero.

The Counter class also declares a variable property, <HighLightColor><Bold>count</Bold></HighLightColor>, to keep track of the current counter value. You call instance methods with the same <Bold>dot syntax</Bold> as properties:

Computed Properties

In addition to stored properties, classes, structures, and enumerations can define <Bold>computed properties</Bold>, which do not actually store a value. Instead, they provide a getter and an optional setter to retrieve and set other properties and values indirectly.

The example above has a computed property named <HighLightColor><Bold>fullName</Bold></HighLightColor> which combines the <HighLightColor><Bold>name</Bold></HighLightColor> and <HighLightColor><Bold>lastName</Bold></HighLightColor> strings.

Structures or <HighLightColor><Bold>structs</Bold></HighLightColor>, are one of the named types in Swift that allow you to encapsulate related properties and behaviors. You can define it, give it a name and then use it in your code.

Similar to classes the structs have the same basic syntax. But instead of the <HighLightColor><Bold>class</Bold></HighLightColor> keyword, you use the <HighLightColor><Bold>struct</Bold></HighLightColor> keyword to declare a struct.

What is a class?

Classes are general-purpose, flexible constructs that become the building blocks of your program’s code.

Classes are a blueprint or a set of instructions to build a specific type of object.

You define properties and methods to add functionality to your classes using the same syntax you use to define constants, variables, and functions.

Declare a function that takes <Bold><HighLightColor>x</HighLightColor></Bold> and <Bold><HighLightColor>y</HighLightColor></Bold> <Bold>Int</Bold> arguments.

<Bold>Closures</Bold> are self-contained blocks of functionality that can be passed around and used in your code.

Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.

Closure expression syntax has the following general form:

Function Parameters

When you define a function, you can optionally define one or more named, typed values that the function takes as input, known as <Bold>parameters</Bold>. To make a function accept a parameter, you will need to add to function parentheses a parameter name, and a parameter data type. Below is a code example of a function that accepts two parameters of String data type.

Take care not to confuse the terms “parameter” and “argument”. A function declares its parameters in its parameter list. When you call a function, you provide values as arguments for the functions’ parameters.

What is a function?

Functions are a core part of many programming languages. Simply put, a function lets you define a block of code that performs a task.

You give a function a name that identifies what it does, and this name is used to “call” the function to perform its task when needed.

Write a <Bold>reduce </Bold>function that combines all elements in <Bold><HighLightColor>words</HighLightColor></Bold> array and outputs <Selected> <Bold>&quot;Hello World!&quot; </Bold></Selected>

Switch statement

A <Bold><HighLightColor>switch</HighLightColor></Bold> statement considers a value and compares it against several possible matching patterns. It then executes an appropriate block of code, based on the first pattern that matches successfully. A <Bold><HighLightColor>switch</HighLightColor></Bold> statement provides an alternative to the if statement for responding to multiple potential states.

In its simplest form, a <HighLightColor><Bold>switch</Bold></HighLightColor> statement compares a value against one or more values of the same type.

Higher-Order Functions

<Bold>Higher-order functions</Bold> are functions that take other functions or closures as arguments and that return a function or a closure. These functions are used with arrays, sets, and dictionaries and act on the elements they contain.

Some of the best-known functions are<Bold> <HighLightColor>map</HighLightColor>, <HighLightColor>compactMap</HighLightColor>, <HighLightColor>flatMap</HighLightColor>, <HighLightColor>reduce</HighLightColor>, <HighLightColor>filter</HighLightColor>, <HighLightColor>contains</HighLightColor>, <HighLightColor>sorted</HighLightColor>, <HighLightColor>forEach</HighLightColor>, </Bold>and<Bold> <HighLightColor>removeAll</HighLightColor>.</Bold>

Range Operators

Swift includes several <Bold><HighLightColor>range</HighLightColor></Bold> operators, which are shortcuts for expressing a range of values.

<SubHeaderFont>Closed Range Operator</SubHeaderFont>

The <Bold>closed range operator</Bold> (a...b) defines a range that runs from <Bold><Italic>a</Italic></Bold> to <Bold><Italic>b</Italic></Bold>, and includes the values <Bold><Italic>a</Italic></Bold> and <Bold><Italic>b</Italic></Bold>. The value of <Bold><Italic>a</Italic></Bold> must not be greater than <Bold><Italic>b</Italic></Bold>

The <Bold>closed range operator</Bold> is useful when iterating over a range in which you want all of the values to be used, such as with a <Bold><HighLightColor>for-in</HighLightColor></Bold> loop:

If statement

Swift provides two ways to add conditional branches to your code: the <HighLightColor><Bold>if</Bold></HighLightColor> statement and the <HighLightColor><Bold>switch</Bold></HighLightColor> statement.

In its simplest form, the <HighLightColor><Bold>if</Bold></HighLightColor> statement has a single if condition. It executes a set of statements only if that condition is <Bold>true</Bold>.

Write <Bold><HighLightColor>For-In</HighLightColor></Bold> loop that iterates through <Bold>planets</Bold> array.

A <Bold><HighLightColor>Set</HighLightColor></Bold> stores distinct values of the same type in a collection with no defined ordering. You can use a set instead of an array when the order of items is not important, or when you need to ensure that an item only appears once.

The type of a Swift set is written as <HighLightColor><Bold>Set&lt;Element&gt;</Bold></HighLightColor>, where Element is the type that the set is allowed to store. Unlike arrays, sets do not have an equivalent shorthand form.

A <Bold>dictionary</Bold> stores associations between keys of the same type and values of the same type in a collection with no defined ordering.

Each value is associated with a unique <Bold>key</Bold>, which acts as an identifier for that value within the dictionary.

Unlike items in an array, items in a dictionary do not have a specified order

For-In Loops

Loops let you describe repetitive processes.

<Bold>For-in</Bold> loops are used to run a set of tasks for a certain number of times. These loops iterate over any sequences such as items in an array, range, or characters in a string.

Accessing Values

You can access elements of an array by using <Bold>subscript</Bold> syntax. You need to include an index of the value you want to access within square brackets <Bold><HighLightColor>[]</HighLightColor></Bold> immediately after the name of the array.

<Bold>Swift</Bold> <Bold>starts counting at</Bold> <Bold>0</Bold>. This means the first item is 0, the second item is 1, the third is 2, and so on.

If you try and read <HighLightColor><Bold>shoppingList[3]</Bold></HighLightColor> your playground will stop working – and if you tried that in a real app it would crash!

An <Bold>Array</Bold> stores values of the same type in an ordered list. The same value can appear in an array <Bold>multiple times at different positions</Bold>.

An array, for example, could be created to store a list of String values.

What are Optionals?

An <Bold>optional</Bold> in Swift is a type that can hold either a <Bold>value</Bold> or <Bold>no value</Bold>. Optionals are written by appending a <Bold><HighLightColor>?</HighLightColor></Bold> to any type:

Once created, an <Bold>Optional</Bold> instance can be in one of <Bold>two</Bold> states – it either wraps a single instance of the specified wrapped type or it is empty. An empty optional is equivalent to <Bold><HighLightColor>nil</HighLightColor></Bold>, which is a special literal representing the absence of a value.

You can declare constants with Optional types but since you can&#x27;t change the value, the whole optional meaning becomes pointless.

An enumeration or <HighLightColor><Bold>Enum </Bold></HighLightColor>for short<HighLightColor><Bold> </Bold></HighLightColor>is a user-defined data type which consists of set of related values.

You can also define an enum multiple cases on a single line, separated by commas:

A tuple is a group of different values represented as one. The values within a tuple can be of any type and don’t have to be of the same type as each other.

The <HighLightColor><Bold>(404, &quot;Not Found&quot;)</Bold></HighLightColor> tuple groups together an <Bold>Int</Bold> and a <Bold>String</Bold>

What is a Bool?

Swift has a data type called <Bold><HighLightColor>Bool</HighLightColor></Bold>, which is short for Boolean, after George Boole who invented an entire field of mathematics around the concept of true and false.

Bools can have either <HighLightColor><Bold>true</Bold></HighLightColor> or <HighLightColor><Bold>false</Bold></HighLightColor> value.

Floating-Point Numbers

Floating-point numbers are numbers with a fractional component, such as <Bold>3.14159</Bold>, <Bold>0.1</Bold>, and <Bold>-273.15</Bold>

Floating-point types can represent a much wider range of values than integer types and can store numbers that are much larger or smaller than can be stored in an Int. Swift provides two signed floating-point number types:

<HighLightColor><Bold>Double</Bold></HighLightColor> represents a 64-bit floating-point number.

<HighLightColor><Bold>Float</Bold></HighLightColor> represents a 32-bit floating-point number.

<Bold>Double</Bold> has a precision of at least <Bold><HighLightColor>15</HighLightColor></Bold> decimal digits, whereas the precision of <Bold>Float</Bold> can be as little as <Bold><HighLightColor>6</HighLightColor></Bold> decimal digits.

Strings are a data type that represents text. String values always start and end with <HighLightColor><Bold>&quot;</Bold></HighLightColor>

Swift supports UTF-8 which means you can use all Unicode characters including emojis.

What is Int?

Integers or <Bold><HighLightColor>Ints</HighLightColor></Bold> types represent whole numbers.

Integers are either <Italic><HighLightColor><HighLightSecondColor>signed</HighLightSecondColor></HighLightColor></Italic> (positive, zero, or negative) or <Italic><HighLightSecondColor>unsigned</HighLightSecondColor></Italic> (positive or zero).

What is mutability?

Mutable means that a value can change once initially set, whereas immutable means that a value cannot change.

We use the <Bold><HighLightColor>var</HighLightColor> </Bold>keyword when we create a mutable variable.

For non-mutable values, we use the <Bold><HighLightColor>let</HighLightColor></Bold> keyword.

If you try to change property declared with <Bold>let</Bold> keyword you will get a compiler error.

What are variables?

Variables are like containers that hold data in the memory, which can be changed later.

<SubHeaderFont>Declaring a variable</SubHeaderFont>

Suppose we are building a game, and we want to keep track of players. We can declare variable named <Bold>players </Bold>like this.

• <Bold>var</Bold> is a keyword used to declare variables.

• <Bold>players</Bold> is the name of the variable.

<Bold>=</Bold> is the assignment operator.

<Bold>3</Bold> is the initial value of the variable.

What is Swift Playground?

The Swift Playground is an interactive development environment to play and test your Swift code. It allows you to see the result of your code in real-time.

Swift Playground doesn&#x27;t allow to build real apps.

What is Xcode?

Xcode is an Integrated Development Environment for building applications for macOS, iOS, watchOS, and tvOS platforms developed by Apple.

Integrated Development Environment or IDE is a program that is used to build other programs.

The Certificate

Learn programming and get hired