Swift — Обзор

Swift 4 — это новый язык программирования, разработанный Apple Inc для iOS и OS X. Swift 4 принимает лучшее из C и Objective-C, без ограничений совместимости с C.

• Swift 4 использует безопасные шаблоны программирования.

• Swift 4 предоставляет современные функции программирования.

• Swift 4 обеспечивает Objective-C подобный синтаксис.

• Swift 4 — это фантастический способ написания приложений для iOS и OS X.

• Swift 4 обеспечивает беспрепятственный доступ к существующим платформам Cocoa.

• Swift 4 объединяет процедурные и объектно-ориентированные части языка.

• Swift 4 не требует отдельного импорта библиотеки для поддержки таких функций, как ввод / вывод или обработка строк.

Swift 4 использует безопасные шаблоны программирования.

Swift 4 предоставляет современные функции программирования.

Swift 4 обеспечивает Objective-C подобный синтаксис.

Swift 4 — это фантастический способ написания приложений для iOS и OS X.

Swift 4 обеспечивает беспрепятственный доступ к существующим платформам Cocoa.

Swift 4 объединяет процедурные и объектно-ориентированные части языка.

Swift 4 не требует отдельного импорта библиотеки для поддержки таких функций, как ввод / вывод или обработка строк.

Swift 4 использует ту же среду выполнения, что и существующая система Obj-C в Mac OS и iOS, что позволяет программам Swift 4 работать на многих существующих платформах iOS 6 и OS X 10.8.

Swift 4 поставляется с функцией игровой площадки, где программисты Swift 4 могут написать свой код и выполнить его, чтобы сразу увидеть результаты.

Первый публичный релиз Swift был выпущен в 2010 году. Крису Латтнеру потребовалось почти 14 лет, чтобы создать первую официальную версию, а позже ее поддержали многие другие участники. Swift 4 был включен в бета-версию Xcode 6.

Дизайнеры Swift взяли идеи из других популярных языков, таких как Objective-C, Rust, Haskell, Ruby, Python, C # и CLU.

Свифт — Окружающая среда

Настройка локальной среды

Swift 4 предоставляет игровую платформу для учебных целей, и мы собираемся настроить то же самое. Вам нужно программное обеспечение xCode, чтобы начать кодирование Swift 4 в Playground. Если вы знакомы с концепциями Swift 4, вы можете использовать xCode IDE для разработки приложений для iOS / OS x.

Для начала мы считаем, что у вас уже есть учетная запись на веб-сайте Apple Developer. После входа в систему перейдите по следующей ссылке — Загрузить для разработчиков Apple

Это перечислит количество программного обеспечения, доступного следующим образом —

Теперь выберите xCode и загрузите его, нажав на данную ссылку рядом с изображением диска. После загрузки файла dmg вы можете установить его, просто дважды щелкнув по нему и следуя приведенным инструкциям. Наконец, следуйте приведенным инструкциям и поместите значок xCode в папку «Приложение».

Теперь на вашем компьютере установлен xCode. Затем откройте Xcode из папки приложения и продолжите после принятия условий. Если все в порядке, вы получите следующий экран —

Выберите « Начать с игровой площадки», введите имя детской площадки и выберите «iOS» в качестве платформы. Наконец, вы получите окно Playground следующим образом:

Ниже приведен код, взятый из стандартного окна Swift 4 Playground.

import UIKit
var str = "Hello, playground"

Если вы создадите ту же программу для программы OS X, то она будет включать импорт Какао, и программа будет выглядеть следующим образом:

import Cocoa
var str = "Hello, playground"

Когда вышеуказанная программа загружается, она должна отобразить следующий результат в области результатов Playground (правая сторона).

Hello, playground

Поздравляем, у вас есть готовая среда программирования Swift 4, и вы можете приступить к обучению «Учебное пособие».

Swift — основной синтаксис

Мы уже видели фрагмент программы Swift 4 при настройке среды. Давайте начнем еще раз со следующего Hello, World! Программа, созданная для игровой площадки OS X, которая включает импорт Какао, как показано ниже —

/* My first program in Swift 4 */
var myString = "Hello, World!"

print(myString)

Если вы создадите ту же программу для iOS игровой площадки, то она будет включать импорт UIKit и программа будет выглядеть следующим образом —

import UIKit
var myString = "Hello, World!"
print(myString)

Когда мы запустим вышеуказанную программу, используя соответствующую игровую площадку, мы получим следующий результат —

Hello, World!

Давайте теперь посмотрим на базовую структуру программы Swift 4, чтобы вам было легко понять основные строительные блоки языка программирования Swift 4.

Импорт в Свифт 4

Вы можете использовать оператор import, чтобы импортировать любую среду Objective-C (или библиотеку C) непосредственно в вашу программу Swift 4. Например, приведенный выше оператор импорта какао делает все библиотеки Какао, API и среды выполнения, которые формируют уровень разработки для всей OS X, доступными в Swift 4.

Какао реализовано в Objective-C, который является надмножеством C, поэтому легко смешивать C и даже C ++ в ваших приложениях Swift 4.

Жетоны в Свифт 4

Программа Swift 4 состоит из различных токенов, и токен — это либо ключевое слово, идентификатор, константа, строковый литерал, либо символ. Например, следующий оператор Swift 4 состоит из трех токенов:

print("test!")
The individual tokens are:
print("test!")

Комментарии

Комментарии подобны текстам помощи в вашей программе Swift 4. Они игнорируются компилятором. Многострочные комментарии начинаются с / * и заканчиваются символами * /, как показано ниже —

/* My first program in Swift 4 */

Многострочные комментарии могут быть вложены в Swift 4. Ниже приведен действительный комментарий в Swift 4 —

/* My first program in Swift 4 is Hello, World!
/* Where as second program is Hello, Swift 4! */ */

Однострочные комментарии пишутся с использованием // в начале комментария.

// My first program in Swift 4

Точка с запятой

Swift 4 не требует от вас вводить точку с запятой (;) после каждого оператора в вашем коде, хотя это необязательно; и если вы используете точку с запятой, то компилятор не будет жаловаться на это.

Однако, если вы используете несколько операторов в одной строке, необходимо использовать точку с запятой в качестве разделителя, в противном случае компилятор вызовет синтаксическую ошибку. Вы можете написать выше Привет, Мир! Запрограммируйте следующим образом —

/* My first program in Swift 4 */
var myString = "Hello, World!"; print(myString)

Идентификаторы

Идентификатор Swift 4 — это имя, используемое для идентификации переменной, функции или любого другого определенного пользователем элемента. Идентификатор начинается с алфавита от A до Z или от a до z или подчеркивания _, за которым следуют ноль или более букв, подчеркиваний и цифр (от 0 до 9).

Swift 4 не допускает использование специальных символов, таких как @, $ и% в идентификаторах. Swift 4 — это чувствительный к регистру язык программирования. Таким образом, рабочая сила и рабочая сила — это два разных идентификатора в Swift 4. Вот несколько примеров допустимых идентификаторов:

Azad        zara   abc   move_name   a_123
myname50    _temp  j     a23b9       retVal

Чтобы использовать зарезервированное слово в качестве идентификатора, вам необходимо поставить обратную косую черту (`) до и после него. Например, класс не является допустимым идентификатором, но `класс` является действительным.

Ключевые слова

Следующие ключевые слова зарезервированы в Swift 4. Эти зарезервированные слова не могут использоваться в качестве констант или переменных или любых других имен идентификаторов, если они не экранированы обратными чертами —

Ключевые слова, используемые в объявлениях

Ключевые слова, используемые в утверждениях

Ключевые слова, используемые в выражениях и типах

Ключевые слова, используемые в определенных контекстах

Пробелы

Строка, содержащая только пробел, возможно, с комментарием, называется пустой строкой, и компилятор Swift 4 полностью игнорирует ее.

Пробел — это термин, используемый в Swift 4 для описания пробелов, вкладок, символов новой строки и комментариев. Пробелы отделяют одну часть оператора от другой и позволяют компилятору определить, где заканчивается один элемент в выражении, например int, и начинается следующий элемент. Поэтому в следующем утверждении —

var age

Должен быть хотя бы один символ пробела (обычно пробел) между var и age, чтобы компилятор мог их различать. С другой стороны, в следующем утверждении —

int fruit = apples + oranges   //get the total fruits

Никаких пробельных символов между фруктами и = или между = и яблоками не требуется, хотя вы можете включить некоторые из них для лучшей читаемости.

Пространство по обе стороны от оператора должно быть одинаковым, например, для.

int fruit = apples +oranges    //is a wrong statement
int fruit = apples + oranges   //is a Correct statement

литералы

Литерал — это представление исходного кода значения целого числа, числа с плавающей точкой или типа строки. Ниже приведены примеры литералов —

92               // Integer literal
4.24159          // Floating-point literal
"Hello, World!"  // String literal

Печать в Swift

Чтобы напечатать что-нибудь в swift, у нас есть ключевое слово «print».

Печать имеет три разных свойства.

Предметы — предметы для печати

Разделитель — разделитель между элементами

Терминатор — значение, которым должна заканчиваться строка, давайте рассмотрим пример и синтаксис того же.

print("Items to print", separator: "Value " , terminator: "Value")
// E.g. of print statement.

print("Value one")
// prints "Value one \n" Adds, \n as terminator and " " as separator by
default.

print("Value one","Value two", separator: " Next Value" , terminator: " End")
//prints "Value one Next Value Value two End"

В приведенном выше коде первый оператор печати добавляет \ n, перевод строки новой строки в качестве терминатора по умолчанию, где, как и во втором операторе печати, мы указали «Конец» в качестве терминатора, поэтому он будет печатать «Конец» вместо \ n.

Мы можем предоставить наш собственный разделитель и терминаторы в соответствии с нашими требованиями.

Swift — Типы данных

Выполняя программирование на любом языке программирования, вы должны использовать различные типы переменных для хранения информации. Переменные — это не что иное, как зарезервированные области памяти для хранения значений. Это означает, что когда вы создаете переменную, вы резервируете некоторое пространство в памяти.

Вам может потребоваться хранить информацию различных типов данных, таких как строка, символ, широкий символ, целое число, число с плавающей запятой, логическое значение и т. Д. На основе типа данных переменной операционная система выделяет память и решает, что можно сохранить в зарезервированном объем памяти.

Встроенные типы данных

Swift 4 предлагает программисту богатый ассортимент как встроенных, так и определяемых пользователем типов данных. Следующие типы базовых типов данных чаще всего используются при объявлении переменных:

• Int или UInt — используется для целых чисел. Более конкретно, вы можете использовать Int32, Int64 для определения 32- или 64-разрядного целого числа со знаком, тогда как UInt32 или UInt64 для определения 32- или 64-разрядных целочисленных переменных без знака. Например, 42 и -23.

• Число с плавающей запятой — используется для представления 32-разрядного числа с плавающей запятой и чисел с меньшими десятичными точками. Например, 3,14159, 0,1 и -273,158.

• Double — используется для представления 64-битного числа с плавающей запятой и используется, когда значения с плавающей запятой должны быть очень большими. Например, 3,14159, 0,1 и -273,158.

• Bool — Это представляет логическое значение, которое является или истиной или ложью.

• Строка — это упорядоченная коллекция символов. Например, «Привет, мир!»

• Символ — это односимвольный строковый литерал. Например, «С»

• Необязательно — представляет переменную, которая может содержать либо значение, либо отсутствие значения.

• Кортежи — это используется для группировки нескольких значений в одно составное значение.

Int или UInt — используется для целых чисел. Более конкретно, вы можете использовать Int32, Int64 для определения 32- или 64-разрядного целого числа со знаком, тогда как UInt32 или UInt64 для определения 32- или 64-разрядных целочисленных переменных без знака. Например, 42 и -23.

Число с плавающей запятой — используется для представления 32-разрядного числа с плавающей запятой и чисел с меньшими десятичными точками. Например, 3,14159, 0,1 и -273,158.

Double — используется для представления 64-битного числа с плавающей запятой и используется, когда значения с плавающей запятой должны быть очень большими. Например, 3,14159, 0,1 и -273,158.

Bool — Это представляет логическое значение, которое является или истиной или ложью.

Строка — это упорядоченная коллекция символов. Например, «Привет, мир!»

Символ — это односимвольный строковый литерал. Например, «С»

Необязательно — представляет переменную, которая может содержать либо значение, либо отсутствие значения.

Кортежи — это используется для группировки нескольких значений в одно составное значение.

Мы перечислили здесь несколько важных моментов, связанных с целочисленными типами —

• На 32-битной платформе Int имеет тот же размер, что и Int32.

• На 64-битной платформе Int имеет тот же размер, что и Int64.

• На 32-битной платформе UInt имеет тот же размер, что и UInt32.

• На 64-битной платформе UInt имеет тот же размер, что и UInt64.

• Int8, Int16, Int32, Int64 могут использоваться для представления 8-битных, 16-битных, 32-битных и 64-битных форм целого числа со знаком.

• UInt8, UInt16, UInt32 и UInt64 могут использоваться для представления 8-битных, 16-битных, 32-битных и 64-битных форм целых чисел без знака.

На 32-битной платформе Int имеет тот же размер, что и Int32.

На 64-битной платформе Int имеет тот же размер, что и Int64.

На 32-битной платформе UInt имеет тот же размер, что и UInt32.

На 64-битной платформе UInt имеет тот же размер, что и UInt64.

Int8, Int16, Int32, Int64 могут использоваться для представления 8-битных, 16-битных, 32-битных и 64-битных форм целого числа со знаком.

UInt8, UInt16, UInt32 и UInt64 могут использоваться для представления 8-битных, 16-битных, 32-битных и 64-битных форм целых чисел без знака.

Связанные значения

В следующей таблице показан тип переменной, сколько памяти требуется для хранения значения в памяти, а также какое максимальное и минимальное значение можно сохранить в переменных такого типа.

Введите псевдонимы

Вы можете создать новое имя для существующего типа, используя typealias . Вот простой синтаксис для определения нового типа с помощью typealias —

typealias newname = type

Например, следующая строка указывает компилятору, что Feet — это другое имя для Int —

typealias Feet = Int

Теперь следующее объявление является абсолютно допустимым и создает целочисленную переменную с именем distance —

Live Demo

typealias Feet = Int
var distance: Feet = 100
print(distance)

100

var varA = 42
varA = "This is hello"
print(varA)

main.swift:2:8: error: cannot assign value of type 'String' to type 'Int'
varA = "This is hello"

// varA is inferred to be of type Int
var varA = 42
print(varA)

// varB is inferred to be of type Double
var varB = 3.14159
print(varB)

// varC is also inferred to be of type Double
var varC = 3 + 0.14159
print(varC)

42
3.14159
3.14159

var variableName = <initial value>

var varA = 42
print(varA)

42

var variableName:<data type> = <optional initial value>

var varA = 42
print(varA)

var varB:Float

varB = 3.14159
print(varB)

42
3.1415901184082

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

var 你好 = "你好世界"
print(你好)

Hello, Swift 4!
你好世界

var varA = "Godzilla"
var varB = 1000.00

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

Value of Godzilla is more than 1000.0 millions

var perhapsInt: Int?

var perhapsStr: String?

var perhapsStr: String? = nil

var myString:String? = nil

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

myString has nil value

var myString:String?

myString = "Hello, Swift 4!"

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

Optional("Hello, Swift 4!")

var myString:String?

myString = "Hello, Swift 4!"

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

Hello, Swift 4!

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

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

Hello, Swift 4!

if let constantName = someOptional {
   statements
}

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")
}

Your string has - Hello, Swift 4!

var TupleName = (Value1, value2,… any number of values)

var error501 = (501, “Not implemented”)

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

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

let constantName = <initial value>

let constA = 42
print(constA)

42

var constantName:<data type> = <optional initial value>

let constA = 42
print(constA)

let constB:Float = 3.14159
print(constB)

42
3.1415901184082

let _const = "Hello, Swift 4!"
print(_const)

let 你好 = "你好世界"
print(你好)

Hello, Swift 4!
你好世界

let constA = "Godzilla"
let constB = 1000.00

print("Value of \(constA) is more than \(constB) millions")

Value of Godzilla is more than 1000.0 millions

42                // Integer literal
3.14159           // Floating-point literal
"Hello, world!"   // String literal

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

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

"characters"

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

Hello World

Hello'Swift 4'

Assume A = 60; and B = 13;

In binary format, they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

Exp1 ? Exp2 : Exp3;

// 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)

Hello, Swift 4!
Hello, Swift 4!
Hey this is a
example of multiple Line
string by tutorialsPoint

// Empty string creation using String literal
var stringA = ""

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

// Empty string creation using String instance
let stringB = String()

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

stringA is empty
stringB is empty

// stringA can be modified
var stringA = "Hello, Swift 4!"
stringA + = "--Readers--"
print( stringA )

// stringB can not be modified
let stringB = String("Hello, Swift 4!")
stringB + = "--Readers--"
print( stringB )

Playground execution failed: error: <EXPR>:10:1: error: 'String' is not
convertible to '@lvalue UInt8'
stringB + = "--Readers--"

var varA = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) times \(constA) is equal to \(varC * 100)"
print( stringA )

20 times 100 is equal to 2000.0

let constA = "Hello,"
let constB = "World!"

var stringA = constA + constB
print( stringA )

Hello,World!

var varA = "Hello, Swift 4!"

print( "\(varA), length is \((varA.count))" )

Hello, Swift 4!, length is 15

var varA = "Hello, Swift 4!"
var varB = "Hello, World!"

if varA == varB {
   print( "\(varA) and \(varB) are equal" )
} else {
   print( "\(varA) and \(varB) are not equal" )
}

Hello, Swift 4! and Hello, World! are not equal

for chars in "ThisString" {
   print(chars, terminator: " ")
}

T h i s S t r i n g

var unicodeString = "Dog???"

print("UTF-8 Codes: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 Codes: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}

UTF-8 Codes: 
68 
111 
103 
63 
63 
63 


UTF-16 Codes: 
68 
111 
103 
63 
63 
63 

let char1: Character = "A"
let char2: Character = "B"

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

Value of char1 A
Value of char2 B

// Following is wrong in Swift 4
let char: Character = "AB"

print("Value of char \(char)")

// Following is wrong in Swift 4
let char1: Character = ""
var char2: Character = ""

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

for ch in "Hello" {
   print(ch)
}

H
e
l
l
o

var varA:String = "Hello "
let varB:Character = "G"

varA.append( varB )

print("Value of varC = \(varA)")

Value of varC = Hello G

var someArray = [SomeType]()

var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)

var someInts = [Int](count: 3, repeatedValue: 0)

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

var someVar = someArray[index]

var someInts = [Int](count: 3, repeatedValue: 10)

var someVar = someInts[0]
print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 10
Value of second element is 10
Value of third element is 10

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 20
Value of second element is 30
Value of third element is 40

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

// Modify last element
someInts[2] = 50

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 20
Value of second element is 30
Value of third element is 50

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]
for item in someStrs {
   print(item)
}

Apple
Amazon
Google

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]

for (index, item) in someStrs.enumerated() {
   print("Value at index = \(index) is \(item)")
}

Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB
for item in intsC {
   print(item)
}

2
2
1
1
1

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB

print("Total items in intsA = \(intsA.count)")
print("Total items in intsB = \(intsB.count)")
print("Total items in intsC = \(intsC.count)")

Total items in intsA = 2
Total items in intsB = 3
Total items in intsC = 5

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()

print("intsA.isEmpty = \(intsA.isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")

intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true

var someSet = Set<Character>()     //Character can be replaced by data type of set.

someSet.count        // prints the number of elements

someSet.insert("c")   // adds the element to Set.

someSet.isEmpty       // returns true or false depending on the set Elements.

someSet.remove("c")     // removes a element , removeAll() can be used to remove all elements

someSet.contains("c")     // to check if set contains this value.

for items in someSet {
   print(someSet)
}

//Swift sets are not in an ordered way, to iterate over a set in ordered way use

for items in someSet.sorted() {
   print(someSet)
}  

let evens: Set = [10,12,14,16,18]
let odds: Set = [5,7,9,11,13]
let primes = [2,3,5,7]
odds.union(evens).sorted()
// [5,7,9,10,11,12,13,14,16,18]
odds.intersection(evens).sorted()
//[]
odds.subtracting(primes).sorted()
//[9, 11, 13]

var someDict = [KeyType: ValueType]()

var someDict = [Int: String]()

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

var cities = [“Delhi”,”Bangalore”,”Hyderabad”]

var Distance = [2000,10, 620]

let cityDistanceDict = Dictionary(uniqueKeysWithValues: zip(cities, Distance))

var closeCities = cityDistanceDict.filter { $0.value < 1000 }

["Bangalore" : 10 , "Hyderabad" : 620]

var cities = ["Delhi","Bangalore","Hyderabad","Dehradun","Bihar"]

var GroupedCities = Dictionary(grouping: cities ) { $0.first! }

["D" :["Delhi","Dehradun"], "B" : ["Bengaluru","Bihar"], "H" : ["Hyderabad"]]

var someVar = someDict[key]

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someVar = someDict[1]

print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("New value of one", forKey: 1)
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict[1]
someDict[1] = "New value of one"
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var removedValue = someDict.removeValue(forKey: 2)

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

someDict[2] = nil

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (index, keyValue) in someDict.enumerated() {
   print("Dictionary key \(index) - Dictionary value \(keyValue)")
}

Dictionary key 2 - Dictionary value Two
Dictionary key 3 - Dictionary value Three
Dictionary key 1 - Dictionary value One

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
   print("Dictionary key \(key) - Dictionary value \(value)")
}

Dictionary key 0 - Dictionary value (key: 2, value: "Two")
Dictionary key 1 - Dictionary value (key: 3, value: "Three")
Dictionary key 2 - Dictionary value (key: 1, value: "One")

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

print("Print Dictionary Keys")

for (key) in dictKeys {
   print("\(key)")
}
print("Print Dictionary Values")

for (value) in dictValues {
   print("\(value)")
}

Print Dictionary Keys
2
3
1
Print Dictionary Values
Two
Three
One

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]

print("Total items in someDict1 = \(someDict1.count)")
print("Total items in someDict2 = \(someDict2.count)")

Total items in someDict1 = 3
Total items in someDict2 = 2

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()

print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")

someDict1 = false
someDict2 = false
someDict3 = true

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

First Program
About Functions

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

100
200

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

40
45
120

func funcname() -> datatype {
   return datatype
}

func votersname() -> String {
   return "Alice"
}
print(votersname()) 

Alice

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

Largest number is: 98 and smallest number is: -5

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

30 20
50 40
30 24

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

min is -6 and max is 109

func sample(number: Int) {
   print(number)
}

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

1
2
3

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

125

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

Swapped values are 10, 2

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

2
6

Func inputstr(name: String) -> String {
   return name
}

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

Swift 4 Functions
Types and its Usage

var addition: (Int, Int) -> Int = sum

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

Result: 129

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

Result: 129
Result: 30

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

-30

{
   (parameters) −> return type in
   statements
}

let studname = { print("Welcome to Swift Closures") }
studname()

Welcome to Swift Closures

{     
   (Int, Int) −> Bool in
   Statement1
   Statement 2
   ---
   Statement n
}

let divide = {
   (val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}

let result = divide(200, 20)
print (result)

10

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

true

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

30

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

-10

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

200

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

[-30, -20, 18, 35, 42, 98]

reversed = sorted(names) { $0 > $1}

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

[NO, EA, WE, SO]

let decrem = calcDecrement(forDecrement: 18)
decrem()

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

82
64
46

enum enumname {
   // enumeration values are described here
}

enum DaysofaWeek {
   case Sunday
   case Monday
   ---
   case Saturday
}

enum names {
   case Swift
   case Closures
}

var lang = names.Closures
lang = .Closures

switch lang {
   case .Swift:
      print("Welcome to Swift")
   case .Closures:
      print("Welcome to Closures")
   default:
      print("Introduction")
}

Welcome to Closures

var weekDay = DaysofaWeek.Sunday 

enum Climate {
   case India
   case America
   case Africa
   case Australia
}

var season = Climate.America
season = .America
switch season {
   case .India:
      print("Climate is Hot")
   case .America:
      print("Climate is Cold")
   case .Africa:
      print("Climate is Moderate")
   case .Australia:
      print("Climate is Rainy")
   
}

Climate is Cold

enum Student {
   case Name(String)
   case Mark(Int,Int,Int)
}

var studDetails = Student.Name("Swift 4")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
   case .Name(let studName):
      print("Student name is: \(studName).")
   case .Mark(let Mark1, let Mark2, let Mark3):
      print("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")
}

Student Marks are: 98,97,95.

var studDetails = Student.Name("Swift")
var studMarks = Student.Mark(98,97,95)

enum Month: Int {
   case January = 1, February, March, April, May, June, July, August,
      September, October, November, December
}

let yearMonth = Month.May.rawValue
print("Value of the Month is: \(yearMonth).")

Value of the Month is: 5.

Structures are defined with a 'Struct' Keyword.
struct nameStruct {
   Definition 1
   Definition 2
   ---
   Definition N
}

struct MarkStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
}

struct studentMarks {
   var mark1 = 100
   var mark2 = 200
   var mark3 = 300
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Mark1 is 100
Mark2 is 200
Mark3 is 300

struct MarksStruct {
   var mark: Int

   init(mark: Int) {
      self.mark = mark
   }
}

var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct     // aStruct and bStruct are two structs with the same value!
bStruct.mark = 97

print(aStruct.mark)      // 98
print(bStruct.mark)      // 97

98
97

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int

   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var marks = markStruct(mark1: 98, mark2: 96, mark3:100)
print(marks.mark1)
print(marks.mark2)
print(marks.mark3)

98
96
100

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
   
   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var fail = markStruct(mark1: 34, mark2: 42, mark3: 13)

print(fail.mark1)
print(fail.mark2)
print(fail.mark3)

34
42
13

Class classname {
   Definition 1
   Definition 2
   --- 
   Definition N
}

class student {
   var studname: String
   var mark: Int 
   var mark2: Int 
}

let studrecord = student()

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark = 300
}

let marks = studentMarks()
print("Mark is \(marks.mark)")

Mark is 300

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark1 = 300
   var mark2 = 400
   var mark3 = 900
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")