Swift for JavaScript Developers

Variables

let num = 1
console.log(num) // 1
num = 2
console.log(num) // 2

var num = 1
print(num) // 1
num = 2
print(num) // 2

Constants

const num = 1
console.log(num) // 1

let num = 1
print(num) // 1

Strings

const name = "Ali"
const signature = `
 Signed by ${name}
`
console.log(name.length) // 3
console.log(name.toUpperCase()) // "ALI"
console.log(name.startsWith("Al")) // true
console.log(name.endsWith("li")) // true
console.log("x + " + 1) // "x + 1"
console.log(`2 + 2 = ${2 + 2}`) // "2 + 2 = 4"

let name = "Ali"
let signature = """
 Signed by \(name)
"""
print(name.count) // 3
print(name.uppercased()) // "ALI"
print(name.hasPrefix("Al")) // true
print(name.hasSuffix("li")) // true
print("x + " + String(1)) // x + 1
print("2 + 2 = \(2 + 2)") // 2 + 2 = 4

Numbers

let num = 1_000
num += 1
console.log(num) // 1001
Number.prototype.isMultiple = function({ of = 1 }) {
 return this % of === 0
}
console.log(num.isMultiple({ of: 2 })) // false
console.log(4..isMultiple({ of: 2 })) // true

var num = 1_000
num += 1
print(num) // 1001
print(num.isMultiple(of: 2)) // false
print(4.isMultiple(of: 2)) // true

Decimal Numbers

const num = 0.1 + 0.2
console.log(num) // 0.30000000000000004
let x = 1.5
const y = 2
console.log(x + y) // 3.5
console.log(Math.floor(x) + y) // 3
x *= 2
console.log(x) // 3

let num = 0.1 + 0.2
print(num) // 0.30000000000000004
var x = 1.5
let y = 2
print(x + Double(y)) // 3.5
print(Int(x) + y) // 3
x *= 2
print(x) // 3.0

Booleans

let isAdmin = false
isAdmin = !isAdmin
console.log(isAdmin) // true

var isAdmin = false
isAdmin = !isAdmin
print(isAdmin) // true
isAdmin.toggle()
print(isAdmin) // false

Arrays

const numbers = [1, 2, 3]
numbers.push(4)
const names = new Array()
names.push("Ali")
console.log(names[0]) // "Ali"
const grades = []
grades.push(73)
let alphabet = ["a", "b", "c", "d"]
console.log(alphabet.length) // 4
console.log(alphabet.splice(2, 1)) // ["c"]
alphabet.length = 0
alphabet = ["c", "a", "d", "b"]
console.log(alphabet.includes("e")) // false
console.log([...alphabet].sort()) // ["a", "b", "c", "d"]
console.log([...alphabet].reverse()) // ["b", "d", "a", "c"]

var numbers = [1, 2, 3]
numbers.append(4)
var names = Array<String>()
names.append("Ali")
print(names[0]) // "Ali"
var grades = [Int]()
grades.append(73)
var alphabet: [String] = ["a", "b", "c", "d"]
print(alphabet.count) // 4
print(alphabet.remove(at: 2)) // "c"
alphabet.removeAll()
alphabet = ["c", "a", "d", "b"]
print(alphabet.contains("e")) // false
print(alphabet.sorted()) // ["a", "b", "c", "d"]
print(alphabet.reversed()) // ReversedCollection<Array<String>>(_base: ["c", "a", "d", "b"])

Dictionaries

const ali = {
 name: "Ali",
 surname: "Veli",
 age: "20",
}
console.log(ali.name) // "Ali"
console.log(ali.surname) // "Veli"
console.log(ali.age) // "20"
const olympics = new Map()
olympics.set(2012, "London")
olympics.set(2016, "Rio")
olympics.set(2016, "Rio de Janeiro")
olympics.set(2021, "Tokyo")
console.log(olympics.get(2012)) // "London"
console.log(olympics.size) // 3

let ali = [
 "name": "Ali",
 "surname": "Veli",
 "age": "20",
]
print(ali["name", default: "Unknown"]) // Optional("Ali")
print(ali["surname", default: "Unknown"]) // Optional("Veli")
print(ali["age", default: "Unknown"]) // Optional("20")
var olympics = [Int: String]()
olympics[2012] = "London"
olympics[2016] = "Rio"
olympics[2016] = "Rio de Janeiro"
olympics[2021] = "Tokyo"
print(olympics[2012, default: "World"]) // Optional("London")
print(olympics.count) // 3

Sets

const names = new Set(["Ali", "Veli", "Ahmet"])
console.log(names) // Set { "Ali", "Veli", "Ahmet" }
const cities = new Set()
cities.add("İstanbul")
cities.add("İstanbul")
console.log(cities.has("İstanbul")) // true
console.log(cities.size) // 1
cities.add("Ankara")
console.log(Array.from(cities).sort()) // ["Ankara", "İstanbul"]

let names = Set(["Ali", "Veli", "Ahmet"])
print(names) // ["Ali", "Veli", "Ahmet"]
var cities = Set<String>()
cities.insert("İstanbul")
cities.insert("İstanbul")
print(cities.contains("İstanbul")) // true
print(cities.count) // 1
cities.insert("Ankara")
print(cities.sorted()) // ["Ankara", "İstanbul"]

Enums

const Weekday = Object.freeze({
 monday: Symbol("monday"),
 tuesday: Symbol("tuesday"),
 wednesday: Symbol("wednesday"),
 thursday: Symbol("thursday"),
 friday: Symbol("friday"),
})

enum Weekday {
 case monday
 case tuesday
 case wednesday
 case thursday
 case friday
}
var day = Weekday.monday
day = Weekday.tuesday
day = .wednesday
enum Weekend {
 case saturday, sunday
}

Type Annonations

const name: string = "Ali"
const score: number = 0
const pi: number = 3.141
const isAdmin: boolean = true
const albums: string[] = ["Century Child", "Human. :II: Nature."]
const olympics: Map<number, string> = new Map([
 [2012, "London"],
 [2016, "Rio"],
 [2021, "Tokyo"],
])
const books: Set<string> = new Set(["The Name of the Wind", "The Wise Man's Fear"])

let name: String = "Ali"
let score: Double = 0
let pi: Double = 3.141
let isAdmin: Bool = true
let albums: [String] = ["Century Child", "Human. :II: Nature."]
let olympics: [Int: String] = [2012: "London", 2016: "Rio", 2021: "Tokyo"]
let books: Set<String> = Set(["The Name of the Wind", "The Wise Man's Fear"])

Conditions

if/else

const age = 18
const isAdmin = true
if (age >= 18 && isAdmin) {
 console.log("You're authenticated")
} else if (age < 18) {
 console.log("You're not an adult")
} else if (!isAdmin) {
 console.log("Contact with an admin")
} else {
 console.log("You're unauthenticated")
}

let age = 18
let isAdmin = true
if age >= 18 && isAdmin {
 print("You're authenticated")
} else if age < 18 {
 print("You're not an adult")
} else if !isAdmin {
 print("Contact with an admin")
} else {
 print("You're unauthenticated")
}

switch/case

const num = 2
switch (num) {
 case 1:
 console.log("one")
 break
 case 2:
 console.log("two") // "two"
 case 3:
 console.log("three") // "three"
 default:
 console.log("4,5,6,...") // "4,5,6,..."
}

let num = 2
switch num {
case 1:
 print("one")
case 2:
 print("two") // "two"
 fallthrough
case 3:
 print("three") // "three"
 fallthrough
default:
 print("4,5,6,...") // "4,5,6,..."
}

Ternary Conditional Operator: ?:

const age = 18
const canVote = age >= 18 ? "Y" : "N"
console.log(canVote) // "Y"

let age = 18
let canVote = age >= 18 ? "Y" : "N"
print(canVote) // "Y"

Loops

for Loop

const alphabet = ["a", "b", "c"]
for (const char of alphabet) {
 console.log(char) // "a", "b", "c"
}
const range = (from, to, { inclusive = true } = {}) => 
 Array(to - from + Number(inclusive)).fill(null).map((_, i) => i + from)
// range(3, 5) = 3...5
for (const num of range(3, 5)) {
 if (num === 5) break
 if (num % 2 === 1) continue
 console.log(num) // 2, 4
}
// range(3, 5, { inclusive: false }) = 3..<5
for (const num of range(3, 5, { inclusive: false })) {
 console.log(num) // 3, 4
}

let alphabet = ["a", "b", "c"]
for char in alphabet {
 print(char) // "a", "b", "c"
}
for num in 1...10 {
 if num == 5 {
 break
 }
 if num % 2 == 1 {
 continue
 }
 print(num) // 2, 4
}
for num in 3..<5 {
 print(num) // 3, 4
}

while Loop

let num = 0
while (num !== 4) {
 num = Math.ceil(Math.random() * 10)
 console.log(num) // 1 to 10
}

var num = 0
while num != 4 {
 num = Int.random(in: 1...10)
 print(num) // 1 to 10
}

Functions

const isEven = ({ num }) => {
 const res = num % 2 === 0
 return res
}
console.log(isEven({ num: 3 })) // false

func isEven(num: Int) -> Bool {
 let res = num % 2 == 0
 return res
}
print(isEven(num: 3)) // false

Return Multiple Values

const getUserArray = () => ["Floor", "Jansen"]
const userArray = getUserArray()
console.log(`${userArray[0]} ${userArray[1]}`) // "Floor Jansen"
const getUserDict = () => ({ name: "Floor", surname: "Jansen" })
const userDict = getUserDict()
console.log(`${userDict.name} ${userDict.surname}`) // "Floor Jansen"
const getUserTuple = () => ["Floor", "Jansen"]
const userTuple = getUserTuple()
console.log(`${userArray[0]} ${userArray[1]}`) // "Floor Jansen"
const getUserNamedTuple = () => ({ name: "Floor", surname: "Jansen" })
const { name, surname } = getUserNamedTuple()
console.log(`${name} ${surname}`) // "Floor Jansen"

func getUserArray() -> [String] {
 ["Floor", "Jansen"]
}
let userArray = getUserArray()
print("\(userArray[0])\(userArray[1])") // "Floor Jansen"
func getUserDict() -> [String: String] {
 ["name": "Floor", "surname": "Jansen"]
}
let userDict = getUserDict()
print("\(userDict["name", default: "Ali"])\(userDict["surname", default: "Veli"])") // "Floor Jansen
func getUserTuple() -> (String, String) {
 ("Floor", "Jansen")
}
let userTuple = getUserTuple()
print("\(userTuple.0)\(userTuple.1)") // "Floor Jansen"
func getUserNamedTuple() -> (name: String, surname: String) {
 // ("Floor", "Jansen") // This is valid also
 (name: "Floor", surname: "Jansen")
}
let (name, _) = getUserNamedTuple()
let (_, surname) = getUserNamedTuple()
print("\(name)\(surname)") // "Floor Jansen"

Customize Parameter Labels

const isOdd = (num) => {
 return num % 2 === 1
}
console.log(isOdd(3)) // true
const printTimesTable = ({ for: num }) => {
 for (let i = 1; i <= 3; i++) {
 console.log(`${i} x ${num} = ${i * num}`)
 }
}
printTimesTable({ for: 5 }) // "1 x 5 = 5", "2 x 5 = 10", "3 x 5 = 15"

func isOdd(_ num: Int) -> Bool {
 num % 2 == 1
}
print(isOdd(3)) // true
func printTimesTable(for num: Int) {
 for i in 1...3 {
 print("\(i) x \(num) = \(i * num)")
 }
}
printTimesTable(for: 5) // "1 x 5 = 5", "2 x 5 = 10", "3 x 5 = 15"

Default Values for Parameters

const printNumbers = ({ from, to = 10 }) => {
 for (let i = from; i <= to; i++) console.log(i)
}
printNumbers({ from: 8 }) // 8, 9, 10

func printNumbers(from: Int, to: Int = 10) {
 for i in from...to {
 print(i)
 }
}
printNumbers(from: 8) // 8, 9, 10

Handle Errors in Functions

const PasswordError = Object.freeze({
 short: Symbol("short"),
 obvious: Symbol("obvious"),
})
const checkPassword = (password) => {
 const length = password.length
 if (length < 5) throw PasswordError.short
 if (password === "12345") throw PasswordError.obvious
 if (length < 8) return "Ok"
 if (length < 10) return "Good"
 return "Excellent"
}
try {
 const res = checkPassword("12345")
 console.log(res)
} catch (err) {
 if (err === PasswordError.short) {
 console.log("Short password")
 } else if (err === PasswordError.obvious) {
 console.log("Try a stronger password.") // "Try a stronger password."
 } else {
 console.log("An error occured.")
 }
}

enum PasswordError: Error {
 case short, obvious
}
func checkPassword(_ password: String) throws -> String {
 let count = password.count
 if count < 5 {
 throw PasswordError.short
 }
 if password == "12345" {
 throw PasswordError.obvious
 }
 if count < 8 {
 return "Ok"
 } 
 if count < 10 {
 return "Good"
 }
 return "Excellent"
}
do {
 let res = try checkPassword("12345")
 print(res)
} catch PasswordError.short {
 print("Short password")
} catch PasswordError.obvious {
 print("Try a stronger password.") // "Try a stronger password."
} catch {
 print("An error occured")
}

Closures

const sayHi = () => console.log("Hi!")
sayHi() // "Hi"
const greet = (name) => `Hi, ${name}!`
console.log(greet("Ali")) // "Hi, Ali!"
const sorted = [3, 1, 2].sort((a, b) => a - b)
console.log(sorted) // [1, 2, 3]

let sayHi = {
 print("Hi!")
}
sayHi() // "Hi!"
let greet = { (name: String) -> String in
 "Hi, \(name)"
}
print(greet("Ali")) // "Hi, Ali!"
let sorted = [3, 1, 2].sorted(by: { (a: Int, b: Int) -> Bool in
 a < b
})
print(sorted) // [1, 2, 3]

Trailing Closure

const sorted = [3, 1, 2].sort((a, b) => a - b)
console.log(sorted) // [1, 2, 3]
const reversed = [3, 1, 2].sort((a, b) => b - a)
console.log(reversed) // [3, 2, 1]

let sorted = [3, 1, 2].sorted { a, b in 
 a < b
}
print(sorted) // [1, 2, 3]
let reversed = [3, 1, 2].sorted { 0ドル > 1ドル }
print(reversed) // [3, 2, 1]

Functions as Parameters

const makeArray = ({ size, using: generator }) => {
 const numbers = []
 for (let i = 0; i < size; i++) {
 numbers.push(generator())
 }
 return numbers;
}

func makeArray(size: Int, using generator: () -> Int) -> [Int] {
 var numbers = [Int]()
 for _ in 0..<size {
 numbers.append(generator())
 }
 return numbers
}

Example 1

const arr = makeArray({ size: 3, using: () => Math.floor(Math.random() * 10) })
console.log(arr) // [4, 2, 8]

let arr = makeArray(size: 3) { Int.random(in: 1..<10) }
print(arr) // [8, 6, 2]

Example 2

const generateNumber = () => Math.floor(Math.random() * 10)
const arr = makeArray({ size: 3, using: generateNumber })
console.log(arr) // [5, 0, 4]

func generateNumber() -> Int { Int.random(in: 0..<10 )}
let arr = makeArray(size: 3, using: generateNumber)
print(arr) // [7, 9, 3]

Example 3

const printThreeSteps = ({ first, second, third }) => {
 console.log("1st:")
 first()
 console.log("2nd:")
 second()
 console.log("3rd:")
 third()
 console.log("Completed")
}
printThreeSteps({
 first: () => console.log("a"),
 second: () => console.log("b"),
 third: () => console.log("c"),
}) // "1st:", "a", "2nd:", "b", "3rd:", "c", "Completed"

func printThreeSteps(first: () -> Void, second: () -> Void, third: () -> Void) {
 print("1st:")
 first()
 print("2nd:")
 second()
 print("3rd:")
 third()
 print("Completed")
}
printThreeSteps {
 print("a")
} second: {
 print("b")
} third: {
 print("c")
} // "1st:", "a", "2nd:", "b", "3rd:", "c", "Completed"

How to Chain Functions

const arr = [4, 3, 2, 5, 1]
 .filter(x => x % 2 === 0)
 .map(x => x * x)
 .sort((x, y) => x - y)
console.log(arr) // [4, 16]

let arr = [4, 3, 2, 5, 1].filter { 
 0ドル % 2 == 0
}.map {
 0ドル * 0ドル
}.sorted {
 0ドル < 1ドル
}
print(arr) // [4, 16]