swift语法基础(一)

发表于 更新于 分类于
本文字数： 6.3k 阅读时长 ≈ 6 分钟

写在前面

寒假开始了1周了，终于也是咸鱼了一周，在今天开始学点东西，既然之后要做ios开发的话，就打算学点swift。整个周期大概20天，先整体看一遍swift的语法，然后去leetcode刷题。因为是windows系统，所以这其中可能会有一些问题。不过只要有开头的话，后面慢慢来就行了。

swift初见

简单值

1.使用let声明常量，使用var来声明变量，常量和变量定义和c语言中一样，常量只能赋值一次。变量可以多次赋值。可以不用明确的声明类型，这可以由编译器自动判断其类型。但是如果在申明时没有提供足够的信息表现出类型，需要如下表现：

//变量和常量
var myVariable = 42
myVariable = 50
let myConstant = 42
//类型
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

2.一个变量或者常量的值类型时保持不变的，如果需要类型转换，请显示进行。

let label = "The width is"
let width = 94
let widthLabel = label + String(width)
//widthLabel = "The width is 94"

上面例子中将 整形转化为String,还有一种更简单的值转化为字符串的方式： 把值写道括号中，在括号前加一个反斜杠。

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
//  "I have 3 apples"
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
//  "I have 8 pieces of fruit"

使用三分双引号来包含多行字符串内容，每行行首的缩进会被去除，知道和结尾双引号相互匹配。

let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
//一段三行的String

3.和c语言类似，使用[]创建数组和字典，使用下标或者key来访问元素，最后一个元素后面语序有个逗号。

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
//通过下表访问数组
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
//通过key访问数组
shoppingList.append("blue paint")
//使用append添加元素

下面是数组或者字典的创建

let emptyArray = [String]() //数组
let emptyDictionary = [String: Float]() //字典

如前所述，如果可以推断出是数组或者字典，也可以如下声明：

var shoppingList = []
var occupations = [:]

控制流

使用if和switch来进行条件操作，使用for-in，while，repeat-while来进行循环，包裹条件和循环变量的括号可以省略，但是条件或者循环体的大括号是必须的。

1.在if语句中，条件表达式必须为一个布尔式。可选值：可选值是一个具体的值或者说是nil表示值缺失。在类型后面加一个问号标记这个变量的值是可选的。

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}
//如果常量name！=nil，执行if条件

使用？？来提供一个默认值，如果可选值缺失，可以使用默认值来代替

let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
//nickname值缺失，使用fullname informalGreeeting="HI john appleseed"

2.运行switch语句时，在switch中匹配到case语句后会直接推出，所以不必加上break，但是default需要特别注意。

3.使用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 {
//kind 和number表示一个键值对
     for number in numbers {
//number指向numbers的每一个成员
        if number > largest {
            largest = number
        }
    }
}
print(largest)

while的使用和c语言中一致，但是作为条件的括号可以省略。

在循环中使用..<表示下标范围。

var total = 0
for i in 0..<4 {
total += i
}
print(total)

使用 ..< 创建的范围不包含上界，如果想包含的话需要使用 …。

函数和闭包

1.使用 func 来声明一个函数，使用名字和参数来调用函数。使用 -> 来指定函数返回值的类型。

//函数调用
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person:"Bob", day: "Tuesday")

2.使用元组来生成复合值，让一个函数返回多个值，改元组的元素可以用名称或者数字来获取。
//返回值为复合值
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])
//两种方式访问sum
print(statistics.sum)
print(statistics.2)

3.函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

func returnFifteen() -> Int {
var y = 10
func add() { //函数没有返回值
    y += 5
}
add()
return y
}
returnFifteen()

函数实际上是一种特殊的闭包，它是一段能之后被调用的代码，闭包中的代码能访问闭包作用于中的变量和函数。即使闭包是在一个不同的作用域被执行的，可以使用{}来创建一个匿名闭包，使用in将参数和返回值类型的声明与闭包函数体进行分离。

对象和类

1.使用class和类名创建一个类，类中属性和的声明和常量变量的声明一样。唯一的区别是他们的上下文是类。

//创建一个类
class Shape {
var numberOfSides = 0
func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
}
}

创建一个类的实例，在类名后面加上括号。使用如下方法访问实例的属性和方法。

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

2.在类中加入构造函数，使用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."
    }
}

注意self用来区别实例变量name和构造器参数name，当创建实例的时候，像传入参数一样给类传入构造器的参数，每个属性都需要赋值。

3.使用deinit来创建一个析构函数。

4.子类的定义方法是在其类名后面加上父类的名字，使用冒号分隔。子类如果要重写父类的方法的话，需要使用override标记，编译器会检测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
}

//重写父类方法
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()

枚举和结构体

使用enum来创建一个枚举，枚举可以包含方法。

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

上面例子中，使用rawValue属性来访问下一个枚举成员的值。

使用struct创建一个结构体。结构体和类由很多先攻的地方，包括方法和构造器，他们最大的区别是结构体是传值，类是传引用。

struct Card {
var rank: Rank
var suit: Suit
func simpleDescription() -> String {
    return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
}
}
//值传递
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

协议和扩展

使用protocol来声明一个协议

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

类，枚举和结构体都可以遵循协议。

   //类继承协议
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
    simpleDescription += "  Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
//结构继承协议
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
    simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

泛型

在尖括号中写一个名字来创建一个泛型函数或者类型

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
var result = [Item]()
for _ in 0..<numberOfTimes {
    result.append(item)
}
return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

也可以创建泛型函数，方法，类，枚举和结构体。

// 重新实现 Swift 标准库中的可选类型
enum OptionalValue<Wrapped> {
case none
case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)