let price = 7; print(price)
//输出：7

var arr = [1, 2, 3]
for item in arr {
	print(item)  //结束符默认为换行符，所以每次输出会换行
}
//输出：
//1
//2
//3
for item in arr {
	print(item, terminator: " ") //结束符为一个空格
}
//输出：1 2 3

let minValue = UInt8.min // minValue 为 0，是 UInt8 类型
let maxValue = UInt8.max // maxValue 为 255，是 UInt8 类型

typealias EmployeeID = UInt16
var maxEmployeeIDNum = EmployeeID.min
// EmployeeID.min 本质上就是 UInt16.min
// maxEmployeeIDNum 现在是 0

let constant = 1  //常量
var variable = 42 //变量
let π = 3.14159
let 你好 = "你好世界"
let 🐶🐮 = "dogcow"

let price = 69.9  //这是Double
let discountPrice: Double = 70  //没有类型注解就是Int了

let label = "The Price is "
let price: Double = 70;
let priceTag = label + String(price);

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

let appleNum = 5
let applePrice = 3.0
//字符串插值
let quotation = """
I said "I have \(appleNum) apples."
And I said "I spent \(appleNum * Int(applePrice)) to buy them."
"""
//I said "I have 5 apples."
//And I said "I spent 15 to buy them."

let softWrappedQuotation = """
The White Rabbit put on his spectacles.
"Where shall I begin, \
please your Majesty?" he asked.
"""
//The White Rabbit put on his spectacles.
//"Where shall I begin, please your Majesty?" he asked.

let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)

for character in "Dog!🐶" {
    print(character, terminator: " ")
}
//输出：D o g ! 🐶

let myString = "Dog!🐶"
for index in myString.indices {
	print(myString[index], terminator: " ")
}
//输出：D o g ! 🐶

let greeting = "Guten Tag!"
greeting[greeting.startIndex]  // G
greeting[greeting.index(before: greeting.endIndex)]  // !
greeting[greeting.index(after: greeting.startIndex)] // u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index] // a

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome = "hello!"
welcome.insert(contentsOf:" there", at: welcome.index(before: welcome.endIndex))
// welcome = "hello there!"

welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome 现在等于 "hello there"
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome 现在等于 "hello"

let http404Error = (404, "Not Found")
// 这是一个(Int, String)的元组，值是 (404, "Not Found")

let (statusCode, statusMessage) = http404Error
//statusCode = 404
//statusMessage = "Not Found"

print("The status code is \(http404Error.0)")
// 输出：“The status code is 404”
print("The status message is \(http404Error.1)")
// 输出：“The status message is Not Found”

let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")
// 输出“The status code is 200”
print("The status message is \(http200Status.description)")
// 输出“The status message is OK”

var myString: String? = "Hello, World"
var myAge: Int? = 18

var convertValue: String? = "blackdn"
if convertValue != nil {
	print("convertValue has the value of \(convertValue).")
	print("convertValue has the value of \(convertValue!).")
}
//输出：
//convertValue has the value of Optional("blackdn").
//convertValue has the value of blackdn.

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // 不需要感叹号

var intArray: [Int] = []
print("intArray is of type [Int] with \(intArray.count) items.")
//intArray is of type [Int] with 0 items.
intArray.append(3)
var newIntArray = Array(repeating: 2, count: 3)
var combineArray = intArray + newIntArray
print(combineArray)
//[3, 2, 2, 2]

combineArray[1...3] = [5]   //combineArray = [3, 5]
combineArray.insert(9, at: 0)   //combineArray = [9, 3, 5]
let removedItem = combineArray.remove(at: 1)
//removedItem = 3, combineArray = [9, 5]

for (index, value) in combineArray.enumerated() {
	print("Item \(String(index + 1)): \(value)")
}
// Item 1: 9
// Item 2: 5

var intSet: Set = [2, 4]
intSet.insert(6)  //intSet = [2, 4, 6]
intSet.insert(2)  //intSet = [2, 4, 6]

if intSet.contains(2) {
	var removedItem = intSet.remove(2)
}
//removedItem = 2, intSet = [4, 6]

for item in intSet.sorted() {
	print(item, terminator: " ")
}
//output: 2 4 6

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let primeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(primeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(primeNumbers).sorted()
// [1, 2, 9]

let number: Set = [-2, -1, 0, 1, 2]
let minusNumber: Set = [-1, -2]
let naturalNumber: Set = [0, 1, 2, 3, 4]

minusNumber.isSubset(of: number)    //true
number.isSuperset(of: minusNumber)    //true
minusNumber.isDisjoint(with: naturalNumber)    //true

var namesOfIntegers: [Int: String] = [:]
namesOfIntegers = [2: "two", 4: "four", 10: "ten"]
print(namesOfIntegers.count)    //3
print(namesOfIntegers[4])   //Optional("four")
print(namesOfIntegers[4]!)  //four
print(namesOfIntegers[3])  //nil

namesOfIntegers[4] = nil
namesOfIntegers.removeValue(forKey: 10)
namesOfIntegers  //[2: "two"]

var oldPair = namesOfIntegers.updateValue("twooo", forKey: 2)
//oldPair = Optional("two"), namesOfIntegers = [2: "twooo"]

namesOfIntegers[3] = "three"
namesOfIntegers[5] = "five"
//[5: "five", 3: "three", 2: "twooo"]

for (number, name) in namesOfIntegers {
	print("\(name) means \(number)")
}
//five means 5
//...

for number in namesOfIntegers.keys {
	print("we get \(number) as key")
}
//we get 5 as key
//...
for name in namesOfIntegers.values {
	print("we get \(name) as value")
}
//we get five as value
//...

//to calculate base^power
let base = 2
let power = 10
var answer = 1
for _ in 1...power {
	answer *= base
}
//answer = 1024

let seconds = 60
for tickMark in 0..<seconds {
	print(tickMark, terminator: " ")  //0 1 2...
}

let totalSecond = 10
let twoSecInterval = 2
for tickMark in stride(from: 0, to: totalSecond, by: twoSecInterval) {
	print(tickMark, terminator: " ")    //0 2 4 6 8
}

for tickMark in stride(from: 0, through: totalSecond, by: twoSecInterval) {
	print(tickMark, terminator: " ")    //0 2 4 6 8 10
}

//normal while
while condition {
	statements
}
//repeat-while
repeat {
	statements
} while condition

var convertValue = "123"
if let result = Int(convertValue) {
	print("convert success \(result)")
} else {
	print("convet failed.")
}

switch value {
case value1:
	//respond to value 1
	break;
case value 2,
	value 3:
	//respond to value 2 or 3
	break;
default:
	//otherwise, do something else
}

let inputCharacter: Character = "a"
//错误情况，会报错
switch inputCharacter {
case "a":
case "A":
	print("input the letter A")
default:
	print("Not A")
}
//正确情况
switch inputCharacter {
case "a", "A":
    print("The letter A")
default:
	print("Not A")
}

//会报错：
switch inputCharacter {
case "a", "A":
    print("The letter A")
}

let score = 5
switch score {
case 0:
	print("zero")
case -4..<0:
	print("negative score")
case 1..<5:
	print("positive score")
default:
    print(" out of scope")
}

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) is at the origin")
case (_, 0):
    print("\(somePoint) is on the x-axis")
case (0, _):
    print("\(somePoint) is on the y-axis")
case (-2...2, -2...2):
    print("\(somePoint) is inside the box")
default:
    print("\(somePoint) is outside of the box")
}

let somePoint = (1, 0)
switch somePoint {
case (let x, 0):
	print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with a y value of \(y)")
case let (x, y):
    print("somewhere else at (\(x), \(y))")
}
//on the x-axis with an x value of 1

let somePoint = (1, 1)
switch somePoint {
case (let x, 0) where x < 0:
	print("\(somePoint) is on the (-x)-axis")
case (let x, 0) where x > 0:
	print("\(somePoint) is on the (+x)-axis")
case (let x, 0):
	print("\(somePoint) is on the origin")
default:
	print("\(somePoint) is not on the x-axis")
}
//(1, 0) is on the (+x)-axis

let inputCharacter: Character = "A"
switch inputCharacter {
case "a":
	print("input the letter a")
case "A":
	print("input the letter A")
	fallthrough
default:
	print("input the upper case letter")
}
//input the letter A
//input the upper case letter

guard condition else { }

func greet(name: String) {
	guard name.count >= 2 else {
		print("your name is too short!")
		return
	}
	print("hello, \(name)")
}
greet(name: "blackdn")  //hello, blackdn
greet(name: "a")  //your name is too short!

func showPrice(product: String, price: Double) -> String {
	return "The price of \(product) is \(price)."
}
print(showPrice(product:"apple", price: 3.5))
//Output: The price of apple is 3.5.

func showPrice(_ product: String, howMuch price: Double) -> String {
	return "The price of \(product) is \(price)."
}
print(showPrice("apple", howMuch: 3.5))
//Output: The price of apple is 3.5.

//get min & max number in array
func getMinAndMax(array: [Int]) -> (min: Int, max: Int) {
	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)
}
print(getMinAndMax(array: [1, 2, 3, 4, 5]))  //(min: 1, max: 5)

func greeting(name: String) -> String {
	"Hello, \(name)"
}
print(greeting(name: "blackdn"))    //Hello, blackdn

func sum(_ numbers: Int...) -> Int {
	var total = 0
	for number in numbers {
		total += number
	}
	return total
}
print(sum(1, 2, 3)) //6

func greeting(name: inout String) -> String {
	name = "white"
	return "Hello, \(name)"
}
var myName = "blackdn"
print(greeting(name: &myName))    //Hello, white
print(myName)   //white

func sumInt(first: Int, second: Int) -> Int {
	return first + second
}
func timesInt(first: Int, second: Int) -> Int {
	return first * second
}
func greet() {
	return "hello, world"
}

fun。 arriveZero(shouldPlus: Bool) -> (Int) -> Int {
	func plusOne(input: Int) -> Int {
		return input + 1
	}
	func minusOne(input: Int) -> Int {
		return input - 1
	}
	return shouldPlus ? plusOne : minusOne
}

var current = -3
let moveOneStep = arriveZero(shouldPlus: current < 0)
while current != 0 {
	print(current)
	current = moveOneStep(current)
}
//-3
//-2
//-1

{ (parameters) -> returnType in
    statements
}

let strArr = ["a", "abcd", "abc", "ab"]
func sortByLength(_ s1: String, _ s2: String) -> Bool {
	return s1.count < s2.count
}
let sortedArr = strArr.sorted(by: sortByLength)
//等价于：
let newSortedArr = strArr.sorted(by: {(s1: String, s2: String) -> Bool in
	return s1.count < s2.count
})
//sortedArr = ["a", "ab", "abc", "abcd"]

let newSortedArr = strArr.sorted(by: {(s1, s2) in
	return s1.count < s2.count
})

let newSortedArr = strArr.sorted(by: {(s1, s2) in
	s1.count < s2.count
})

let newSortedArr = strArr.sorted(by: {$0.count < $1.count})

//尾随闭包：
let sortedArr = strArr.sorted() {(s1: String, s2: String) -> Bool in
	return s1.count < s2.count
}
//省略括号：
let sortedArr = strArr.sorted {(s1: String, s2: String) -> Bool in
	return s1.count < s2.count
}
//最简形式：
let sortedArr = strArr.sorted { $0 > $1 }

var closureList: [() -> Void] = []
func functionWithEscapingClosure(escapeClosure: @escaping () -> Void) {
	closureList.append(escapeClosure)
}
func functionWithNoEscapingClosure(noEscapeClosure: () -> Void) {
	noEscapeClosure()
}

class MyClass {
	var x = 0
	func runBothEscapeAndNoEscape() {
		functionWithNoEscapingClosure { x = 10 }
		functionWithEscapingClosure { self.x = 20 }
	}
}

let myClassObj = MyClass()
print(myClassObj.x) //0

myClassObj.runBothEscapeAndNoEscape()
print(myClassObj.x) //10

if let escapeFunc = closureList.first { escapeFunc() }
print(myClassObj.x) //20

var intArr = [1, 2, 3, 4, 5]
let removeFirstNum = {intArr.removeFirst()} //这里不执行
print(intArr)   //[1, 2, 3, 4, 5]
removeFirstNum()    //这里执行
print(intArr)   //[2, 3, 4, 5]

enum PositionPoint {
    case north
    case south
    case east
    case west
}
//或者
enum CompassPoint {
    case north, south, east, west
}

var direction = PositionPoint.east
direction = .north

direction = .south
switch directionToHead {
case .north:
    print("Watch out for polar bears")
case .south:
    print("Watch out for penguins")
case .east:
    print("Where the sun rises")
case .west:
    print("Where the sun sets")
}
// 打印“Watch out for penguins”

enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

enum Planet: Int {
    case mercury , venus, earth, mars, jupiter, saturn, uranus, neptune
}
//mercury = 0， venus = 1, earth = 2...

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}
//mercury = 1, venus = 2, earth = 3...

enum PositionPoint: String {
    case north, south, east, west
}
//north = "north", south = "south"...

enum PositionPoint: String {
	case north, south, east, west
}
if let myPositionPoint = PositionPoint(rawValue: "southEast") {
	switch myPositionPoint {
	case .south:
		print("you are in south")
	default:
		print("you are not in south")
	}
} else {
	print("cannot find your postion")
}
//cannot find your postion

enum ProductMark {
	case stringMark(String)
	case codeMark(Int, Int, Int)
}

enum ProductMark {
	case stringMark(String)
	case codeMark(Int, Int, Int)
}
let firstProductMark = ProductMark.stringMark("Pen")
let secondProductMark = ProductMark.codeMark(9, 5, 7)

switch firstProductMark {
case .stringMark(let productStr):
	print("Product mark is \(productStr)")
case .codeMark(let codeHead, let codeMiddle, let codeTail):
	print("Product code is \(codeHead)-\(codeMiddle)-\(codeTail)")
}
//Product mark is Pen

switch secondProductMark {
case .stringMark(let productStr):
	print("Product mark is \(productStr)")
case .codeMark(let codeHead, let codeMiddle, let codeTail):
	print("Product code is \(codeHead)-\(codeMiddle)-\(codeTail)")
}
//Product code is 9-5-7

switch firstProductMark {
case let .stringMark(productStr):
	print("Product mark is \(productStr)")
case let .codeMark(codeHead, codeMiddle, codeTail):
	print("Product code is \(codeHead)-\(codeMiddle)-\(codeTail)")
}

enum mathExpression {
	case number(Int)
	indirect case addition(mathExpression, mathExpression)
	indirect case multiplication(mathExpression, mathExpression)
}
//等价于
indirect enum MathExpression {
	case number(Int)
	case addition(MathExpression, MathExpression)
	case multiplication(MathExpression, MathExpression)
}

let nine = MathExpression.number(9)
let five = MathExpression.number(5)
let seven = MathExpression.number(7)
let addNineAndFive = MathExpression.addition(nine, five)
let finalExpression = MathExpression.multiplication(addNineAndFive, seven)

func evalExpression(_ expression: MathExpression) -> Int {
	switch expression {
	case let .number(value):
		return value
	case let .addition(firstExpression, secondExpression):
		return evalExpression(firstExpression) + evalExpression(secondExpression)
	case let .multiplication(firstExpression, secondExpression):
		return evalExpression(firstExpression) * evalExpression(secondExpression)
	}
}

print(evalExpression(finalExpression))
//98