前言：
从2014年Swift1.0时候开始关注学习，到Swift2.3的时候用Swift帮朋友做过一个项目，后来由于Swift的版本在不断的更新迭代，没有稳定，考虑兼容性问题，公司用的是OC，有一段时间没有碰了，说来惭愧，现在它更新到4.0了。。。下面记录下《A Swift Tour》(Swift4.0初见)
1. 打印
print("hello!")
2.1 常量和变量，用let 表示常量，var表示变量; 编译器可以根据给变量或者常量所赋的值，推断它的数据类型;如果没有给一个变量或者常量赋值，可以指定它的数据类型，用冒号隔开。
let Num = 10
var name = "xiaoming"
name = "lihao"
let explicitFloat:Float
explicitFloat = 70
let explicitDouble: Double = 80
2.2 值不隐式转换，需要显式转换成其他数据类型
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
2.3 字符串里嵌入其他变量，用反斜杠"\"
let apples = 3
let oranges = 5
let myStr = "my"
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) \(myStr)pieces of fruit."
2.4 使用两对3引号表示多行字符串，而且3引号所在行不能有字符串元素。
正确：
let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
错误：
let quotation = """I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
错误：
let quotation = """I said "I have \(apples) apples."
And then I said "I have \(apples + oranges)
pieces of fruit." """
2.5 使用[ ]创建数组和字典
1. var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
2. 创建空数组和字典
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
如果可以推断知道类型信息，可以如下：
shoppingList = [ ]
emptyDictionary = [:]
3 控制语句
3.1 if 语句
let score = 100
if score > 0 {
print("my name is Redin")
}else
{
print("好")
}
输出： my name is Redin
3.2 问号 ？ 表示可选变量，即一个变量可能存在也可能为空(nil)，可选值可以结合if和let使用，如果可选变量为空（nil),条件判断为false,相反为true。
var optionalString: String? = "Hello"
print(optionalString == nil)
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
print(greeting)
输出：false 和Hello,John Appleseed
3.3 ?? 处理可选变量，如果可选变量为空（nil），则使用它的默认值
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
注： nickName为可选变量，并且它的值为nil,fullName为默认值，于是informalGreeting的值为"John Appleseed"
3.4 switch, 它不局限于整型，它可以同时用于各种数据类型和各种比较，并且不需要使用break
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}
输出：Is it a spicy red pepper?
3.5 for-in 遍历数组和字典
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
输出： 25
3.6 while
var n = 2
while n < 100 {
n *= 2
}
print("n:\(n)")
var m = 2
repeat {
m *= 2
} while m < 10
print("m:\(m)")
输出： n:12 m:16
3.7 使用索引遍历：..<(不包含最右边索引值)，...(两边索引都包含)
var total1 = 0
for i in 0..<4 {
total1 += i
}
print("total1=\(total1)")
var total2 = 0
for i in 0...4 {
total2 += i
// print("test\(i)")
}
print("total2=\(total2)")
输出：total1=6 total2=10
4 函数和闭包
4.1 使用 func声明一个函数
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
注： 函数名： greet ， 参数person和day 是字符串类型， 返回一个字符串
4.1 函数标签， 一般的，函数使用函数参数名作为参数的标签，我们可以自定义一个参数标签放在参数名的前面,或者使用下划线“_”,没有参数标签
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
4.2 元组（tuple）， 它可以包含多个参数，表示一个符合值；可以通过元组参数名或索引引用元组的参数。
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum) //参数名引用
print(statistics.2) //索引引用
4.3 函数嵌套,内部函数可以使用外部函数的参数。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
4.4 函数作为参数使用
1.作为返回参数
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
2.作为函数的参数
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)
4.5 闭包，函数其实是一种特殊的闭包，他是一种可以被延迟调用的代码块。通常的，闭包是一个没有名字的代码块。（其内容较多，这里只做简单介绍，以后会专门写一篇讲闭包）
numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
5 类和对象，有面向对象编程经验的同学知道，类是对具有相同特点对象的抽象，而对象是对类的具体化。
1. 创建类
class Shape { //shape为对象名
var numberOfSides = 0 //属性变量
func simpleDescription() -> String { //方法
return "A shape with \(numberOfSides) sides."
}
}
//带有init方法
class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
2.创建对象
var shape = Shape() //创建
shape.numberOfSides = 7 //属性赋值
var shapeDescription = shape.simpleDescription() //方法调用
var nameShape = NamedShape.init(name: "Redin")
3.继承父类，用override重写父类方法
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
//重写父类NamedShape方法
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()
4.setter和getter方法
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
//setter和getter
var perimeter: Double {
get {
return 3.0 * sideLength
}
set(newValue) {
sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triangle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print("value:\(triangle.perimeter)")
triangle.perimeter = 9.9
print("sideLength：\(triangle.sideLength)")
输出：value:9.3 sideLength：3.3
6 枚举和结构体
6.1 枚举,在它的内部定义方法
enum Rank: Int {
case ace = 1
case two, three, four, five, six, seven, eight, nine, ten
case jack, queen, king
//方法
func simpleDescription() -> String {
switch self {
case .ace:
return "ace"
case .jack:
return "jack"
case .queen:
return "queen"
case .king:
return "king"
default:
return String(self.rawValue)
}
}
}
let ace = Rank.ace
let aceRawValue = ace.rawValue
print("ace=\(ace)")
print("aceRawValue=\(aceRawValue)")
print("simpleDescription= \(ace.simpleDescription())")
输出： ace=ace
aceRawValue =1
simpleDescription = ace
6.2 使用init?(rawValue:)初始化一个枚举 可选变量