Swift Basics

Swift 4 offers the programmer a rich assortment of built-in as well as user-defined data types. The following types of basic data types are most frequently when declaring variables −

Type : Bit Width | Range

Int8 : 1byte | -127 to 127

UInt8 : 1byte | 0 to 255

Int32 : 4bytes | -2147483648 to 2147483647

UInt32 : 4bytes | 0 to 4294967295

Int64 : 8bytes | -9223372036854775808 to 9223372036854775807

UInt64 : 8bytes | 0 to 18446744073709551615

Float : 4bytes | 1.2E-38 to 3.4E+38 (~6 digits)

Double : 8bytes | 2.3E-308 to 1.7E+308 (~15 digits)

Swift has two ways of declaring variables, One by assigning value in the variable and another one by using type annotation. Example:

The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Swift 4 is a case-sensitive programming language. We can even use unicode characters as well

Printing Variables

You can interpolate a variable value by wrapping the name in parentheses and escape it with a backslash before the opening parenthesis:

    var varA = "Godzilla"
    var varB = 1000.00

    print("Value of \(varA) is more than \(varB) millions")

Swift 4 also introduces Optionals type, which handles the absence of a value. Optionals say either "there is a value, and it equals x" or "there isn’t a value at all".

Here’s an optional Integer & String declarations

    var perhapsInt: Int?
    var perhapsStr: String?

Above statements are equivalent to

Forced Unwrapping :

If you defined a variable as optional, then to get the value from this variable, you will have to unwrap it. This just means putting an exclamation mark at the end of the variable.

Let’s take a simple example −

    var myString:String?
    myString = "Hello, Swift 4!"

    if myString != nil {
        print(myString)
        print(myString!) //unwrapping applied here

    } else {
        print("myString has nil value")
    }

When we run the above program using playground, we get the following result −

Automatic Unwrapping :

You can declare optional variables using exclamation mark instead of a question mark. Such optional variables will unwrap automatically and you do not need to use any further exclamation mark at the end of the variable to get the assigned value. Let’s take a simple example −

    var myString:String!
    myString = "Hello, Swift 4!"

    if myString != nil {
    print(myString)
    } else {
    print("myString has nil value")
    }

When we run the above program using playground, we get the following result −

Optional Binding :

Use optional binding to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

An optional binding for the if statement is as follows −

    if let constantName = someOptional {
    statements
    }

Let’s take a simple example to understand the usage of optional binding −

    var myString:String?
    myString = "Hello, Swift 4!"

    if let yourString = myString {
    print("Your string has - \(yourString)")
    } else {
    print("Your string does not have a value")
    }

When we run the above program using playground, we get the following result −

Swift 4 also introduces Tuples type, which are used to group multiple values in a single compound Value. The values in a tuple can be of any type, and do not need to be of same type.

For example, ("Tutorials Point", 123) is a tuple with two values, one of string Type, and other is integer type. It is a legal command.

You can create tuples from as many values as you want and from any number of different data types.

Here’s a Tuple declaration −

You can access the values of tuple using the index numbers that start from 0.

    print("The code is\(error501.0)")
    print("The definition of error is\(error501.1)")

You can name the variables of a tuple while declaring , and you can call them using their names

    var error501 = (errorCode: 501, description: "Not Implemented")
    print(error501.errorCode)   // prints 501.

Tuples are helpful in returning multiple values from a function. By returning different values in a tuple we can make decisions depending on different tuple types.

Note: Tuples are useful for temporary values and are not suited for complex data.

Constants Declaration

Before you use constants, you must declare them using let keyword as follows

    let constA = 42
    print(constA)

    let constB:Float = 3.14159
    print(constB)

Integer Literals

An integer literal can be a decimal, binary, octal, or hexadecimal constant. Binary literals begin with 0b, octal literals begin with 0o, and hexadecimal literals begin with 0x and nothing for decimal.

    let decimalInteger = 17         // 17 in decimal notation

    let binaryInteger = 0b10001     // 17 in binary notation

    let octalInteger = 0o21         // 17 in octal notation

    let hexadecimalInteger = 0x11   // 17 in hexadecimal notation

Floating-point Literals

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or hexadecimal form.

    let decimalDouble = 12.1875
    let exponentDouble = 1.21875e1
    let hexadecimalDouble = 0xC.3p0

String Literals

String literals cannot contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed. Special characters can be included in string literals using the following escape sequences −

Sample string literal usage :

    let stringL = "Hello\tWorld\n\nHello\'Swift 4\'"
    print(stringL)

The Result would be

Comparison Operators :   ==   !=   >   <   >=   ⇐

Logical Operators:   &&   ||   !

Bitwise Operators :   &   |   ^   ~   <<   >>

Assume A = 60; and B = 13;
In binary format, they will be as follows:

Assignment Operators :   =   +=   -=   *=   /=   %=   >>=   <⇐   &=   ^=   |=

Note: C << = 2 is same as `C = C << 2`

For in :

    var someInts:[Int] = [10, 20, 30]

    for index in someInts {
    print( "Value of index is \(index)")
    }

While loop :

    var index = 10

    while index < 20 {
    print( "Value of index is \(index)")
    index = index + 1
    }

Repeat while :

    var index = 10

    repeat {
        print( "Value of index is \(index)")
        index = index + 1
    }
    while index < 20

Continue statement :

    var index = 10

    repeat {
        index = index + 1
        if( index == 15 ){
            continue
        }
        print( "Value of index is \(index)")
    } while index < 20

Here number 15 will be skipped printing

Break Statement :

    var index = 10

    repeat {
        index = index + 1
        if( index == 15 ){
            break
        }
        print( "Value of index is \(index)")
    } while index < 20

Here numbers after 15 will be skipped printing

Switch fallthrough :

If we do not use fallthrough statement, then the program will come out of the switch statement after executing the matching case statement.

EXAMPLE1:

    var index = 10

    switch index {
    case 100 :
        print( "Value of index is 100")
    case 10,15 :
        print( "Value of index is either 10 or 15")
    case 5 :
        print( "Value of index is 5")
    default :
        print( "default case")
    }

OUTPUT:

EXAMPLE2:

    var index = 10

    switch index {
        case 100 :
            print( "Value of index is 100")
            fallthrough
        case 10,15 :
            print( "Value of index is either 10 or 15")
            fallthrough
        case 5 :
            print( "Value of index is 5")
        default :
            print( "default case")
    }

OUTPUT:

EXAMPLE:

    // String creation using String literal

    var stringA = "Hello, Swift 4!"
    print( stringA )

    // String creation using String instance

    var stringB = String("Hello, Swift 4!")
    print( stringB )

    //Multiple line string


    let stringC = """
    Hey this is a
    example of multiple Line
    string by tutorialsPoint 

    """
    print(stringC)

OUTPUT:

Empty String:

    // Empty string creation using String instance

    let stringB = String()

    if stringB.isEmpty {
        print( "stringB is empty" )
    } else {
        print( "stringB is not empty" )
    }

String Constants:

    // stringB can not be modified

    let stringB = String("Hello, Swift 4!")
    stringB + = "--Readers--"
    print( stringB )

OUTPUT:

String Interpolation:

OUTPUT:

String iteration:

Unicode strings:

You can access a UTF-8 and UTF-16 representation of a String by iterating over its utf8 and utf16 properties