swift快速入门

最新推荐文章于 2023-07-25 17:39:21 发布
最新推荐文章于 2023-07-25 17:39:21 发布
阅读量515 收藏 1
点赞数
分类专栏： iOS Swift
iOS 同时被 2 个专栏收录
59 篇文章 0 订阅
订阅专栏
Swift
5 篇文章 0 订阅
订阅专栏
  1. swift中的代码是在全局作用域下，这些代码直接作为整个项目的入口，所以这里并不需要main函数。（Swift没有main函数，从top level code的上方开始往下执行（就是第一个非声明语句开始执行[表达式或者控制结构，类、结构体、枚举和方法等属于声明语句]），不能存在多个top level code文件(否则编译器无法确定执行入口，事实上swift隐含一个main函数，这个main函数会设置并调用全局 “C_ARGC C_ARGV”并调用由top level code构成的top_level_code()函数)；）
  2. Swift通过import引入其他类库（和Java比较像）；
  3. Swift语句不需要双引号结尾（尽管加上也不报错），除非一行包含多条语句（和Python有点类似）；
print("Hello, world!")
 
 
  • 1

 
 
  • 1

常量与变量

  1. 使用let声明一个常量，使用var声明一个变量。常量的值在编译阶段并不需要被编译器所知道，但常量在最初定义时必须赋值。
var myVariable = 42
myVariable = 50
let myConstant = 42
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3
  1. 你可以为变量或常量指定你所所想的类型。然而你不不需要每次都这么做。当你定义了一个变量或常量时，编译器可以推测这个变量或常量的类型。
let implicitInteger = 70
let implicitDouble = 70.0
 
 
  • 1
  • 2

 
 
  • 1
  • 2
  1. 例如上面两行，编译器会将implicitInteger的类型视为整型，因为这个常量最初的值为一个整数。
  2. 当然也可以显示说明变量或常量的类型。形式如下：
let explicitDouble: Double = 70
 
 
  • 1

 
 
  • 1

练习：

let explicitDouble: Double = 70
let explicitFloat:Float=4
let implicitInteger = 70
print("explicitDouble=",explicitDouble);
print("explicitFloat=",explicitFloat);
print("implicitInteger=",implicitInteger);
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

运行结果： 
这里写图片描述

  1. 一个值不会随意改变类型，如果你需要改变一个值得类型，需要强制类型转换。举例说明：
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3
  1. 有一种更加简单的方法将其它类型转换成字符串类型。那就是使用\()。
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4
  1. 通过[ ]符号创建数组。在swift中，既可以通过数组下标访问数组元素，也可以通过关键字访问数组元素。
  2. 例子：
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

for item1 in shoppingList{
    print(item1)
}
for item2 in occupations{
    print(item2)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

这里写图片描述

  1. 创建一个空数组：
let emptyArray = [String]()
 
 
  • 1

 
 
  • 1
  1. 创建一个空的字典：
let emptyDictionary = [String: Float]()
 
 
  • 1

 
 
  • 1
  1. 如果数组或者字典的类型可以被推测，可以用如下表达式：
shoppingList = []
occupations = [:]
 
 
  • 1
  • 2

 
 
  • 1
  • 2

控制流

  1. if 和 switch都可以用来做条件判断，for-in，for，while，repeat-while都可以用来做循环。swift中条件语句的判断语句的括号和循环语句的括号是可以省略的，而它们之后的{ }是不能省略的。
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  1. if和let一起用可能导致值丢失，所以必须把这些量定义为可选值（optional）。
  2. 通过在类型后面加一个 ? 来将变量声明为 Optional 的。如果不是 Optional 
    的变量，那么它就必须有值。如果可能没有值的话，我们使用 Optional 并且将它设置为 nil 来表示没有值。 
  3. 如果可选值为nil，则条件判断为false，花括号中的代码会被跳过。反之，可选值去包装并且赋给let后面的常量，使得去包装的值可以在代码块内部访问。
var optionalString: String? = "Hello"
var notoptionalString: String? 
print(optionalString == nil)
print(notoptionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}
print(greeting)

var optionalname: String?
var smiling = "Hey!"
if let name = optionalname {
    smiling = "Hello, \(name)"
}
print(smiling)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

这里写图片描述 
参考：Swift 可选值(Optional Values)介绍

  1. 也可以使用??操作符来处理可选值。
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
print(informalGreeting)
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

这里写图片描述

  1. 在swift中，switch支持任意类型的数据和多种比较，不再局限于整数或者只是比较像等。

参考：Swift Switch介绍

  1. 在 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)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  1. while和do while的用法：
var n = 2
while n < 100 {
    n = n * 2
}
print(n)

var m = 2
repeat {
    m = m * 2
} while m < 100
print(m)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  1. 可以通过使用..<来控制循环变量的值，间接限制循环的次数，不是直接限制循环的次数。
var total = 0
for i in 0..<4 {
    total += i
}
print(total)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

运行结果为6。

函数和闭包

  1. 使用func 声明一个函数。通过函数名称和参数调用一个函数。使用->区分参数名和函数返回的类型。

  2. 在Swift的历史版本中出现过在调用函数时不需要指定任何函数参数（或者从第二个参数开始指定参数名），在调用方法时则必须从第二个参数开始必须指定参数名等多种情况，而在Swift3.0中不管是函数还是方法都必须从第一个参数开始必须指定参数名（当然可以使用“_”明确指出调用时省略参数）。

    swift3.0的表示法：

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4

由于用的在线编译器不支持swift3.0，所以我用以前的语法跑了一遍。

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
print(greet("Bob", day: "Tuesday"))
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4
  1. 使用元组可以返回多个值，元组中的元素既可以通过下标访问，也可以通过名字访问。
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)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  1. 函数也可以有可变数量的参数，将这个参数看成是一个数组。
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  1. 函数可以嵌套。嵌套的函数可以访问在外层函数定义的变量。使用嵌套函数可以组织更长更复杂的函数。
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  1. 函数是一个引用类型，就是说一个函数可以返回另一个函数作为返回值。类似于C语言中的指针函数。
func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

注意：上面的例子(Int) -> Int 表示返回函数的参数类型和返回类型。

  1. 一个函数可以使用一个函数作为它的的返回值。
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)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  1. Swift中的闭包其实就是一个函数代码块，它和ObjC中的Block及C#、Java中的lambda是类似的。闭包的特点就是可以捕获和存储上下文中的常量或者变量的引用，即使这些常量或者变量在原作用域已经被销毁了在代码块中仍然可以使用。事实上前面的全局函数和嵌套函数也是一种闭包，对于全局函数它不会捕获任何常量或者变量，而对于嵌套函数则可以捕获其所在函数的常量或者变量。通常我们说的闭包更多的指的是闭包表达式，也就是没有函数名称的代码块，因此也称为匿名闭包。
  2. 函数实际上是一种特殊的闭包。在闭包体内使用in去分离参数和返回值。
numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  1. 你已经有几种方式可以更自如的写闭包。当一个闭包类型已经知道，比如是一个代理的回调，你可以去除参数类型、返回类型或者两个都去除。单个语句闭包会把它语句的值当做结果返回。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
 
 
  • 1
  • 2

 
 
  • 1
  • 2
  1. 你可以通过参数位置访问－这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
 
 
  • 1
  • 2

 
 
  • 1
  • 2

对象和类

  1. 用class关键字，后面加上一个类名来创建一个类。类中属性的定义和普通常量或者变量的定义相同，但属性是属于这个类的。类中方法和函数的定义和普通方法与函数的定义相同。
class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  1. 通过在类名后面加括号来创建类的一个实例。一个实例通过一个小圆点来访问这个类的属性和方法。
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
 
 
  • 1
  • 2
  • 3

 
 
  • 1
  • 2
  • 3
  1. 上面版本的shape类少了一些重要的东西：在一个实例被创建时缺少初始化程序来初始化这个类。可以使用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."
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

  1. 注意怎样用self来区分属性和初始化程序的参数。当你创建一个类的实例时，初始化程序的参数就像函数调用那样传递。每一个属性都需要给它分配一个值，要么是在属性定义的时候，那么是在初始化程序时。

  2. 在一个对象（实例）被销毁或者重新分配之前。使用deinit做一些清理工作。

  3. 子类要继承父类是通过在子类名后面加上冒号，然后跟上父类名。没有要求一个类必须继承一个标准的根类，所以你可以根据需要继承一个父类。

  4. 子类可以重写父类声明的方法，即在方法前加上 override，如果没有加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()
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  1. 除了存储属性，属性可以有getter和setter，称为计算属性。 
    参考：getter 和 setter
class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }

    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            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(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

  1. 在perimeter的setter中，参数被隐含地命名为newValue。你也可以将参数名字在set后面用括号括起来。

  2. 注意EquilateralTriangle类的构造器有三个不同的步骤： 
    给子类的属性赋值。 
    调用父类的构造器。 
    改变定义在父类中的属性的值。任何其它的使用方法，getter，setter的步骤可以在这一步完成。

  3. 如果你不需要一个计算属性但是仍然想在代码运行前后设定新值的话，可以使用willSet和DidSet。

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  1. 当处理可选类型，你可以在方法属性和subscripting 
    前面加上问号？。如果？号前面的值是nil，那么问号后面的所有值都是nil.否则，？之后的所有代码都会运行。在这两种情况下，整个表达式的值是可选类型的。

swift3.0-将元组加到数组中

//创建元组  键：值
var student1 = (number:"2014110323",name:"allen",age:20,sex:"f"); //方式一
var student2 = ("2014110324","iverson",21,"m");   //方式二



//访问元组
print("\(student1.number)   \(student1.name)   \(student1.age)   \(student1.sex)") //方式一
print("\(student2.0)   \(student2.1)   \(student2.2)   \(student2.3)");  //方式二



//将方式二的访问方式转换成方式一
var (number,name,age,sex) = student2;
print("\(number)")



//忽略元组中某些值
var student3 = student2;
let (number1,_,age1,sex1) = student3  
print("\(student3.0)   \(student3.1)   \(student3.2)   \(student3.3)");//仍可以通过标号访问
print("\(number1)   \(age1)   \(sex1)")   //不能通过”键“访问



//可变元组与不可变元组
//用var声明的是可变元组，可改变元组中的值
//用let声明的是不可变元组


//改变元组中的值
//改变student1的学号
student1.number = "001"

//改变student2的学号
//student2.number = "002"   //错误做法
/*type '(String, String, Int, String)' has no member 'number'
student2.number = "002" */

student2.0 = "002"    //正确做法
student3.0 = "003"

//将元组加到数组当中

var Student:[(String,String,Int,String)] = []
Student.append(student1);
Student.append(student2);
Student.append(student3);

for var student in Student{
    print(student)
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

这里写图片描述

swift-数组，元组，字典优缺点

字典 
优点： 
通过key值进行索引，查找效率高 
通过key值进行数据标注，可读性高，易于区分多种数据 
key值唯一，增删改可以保证数据唯一性

缺点： 
一个value必须对应一个key，尽管有时不需要key 
key值顺序不定，字典对key值表进行了hash，所以不方便存储对顺序敏感的数据

数组 
优点： 
数据存储顺序固定，增删改也通过index来进行 
集成了遍历方法，适合对大量同类数据的处理 
不需要定义key，写法相对简单

缺点： 
访问特定数据时，查找效率不高 
处理特定数据时，需要牢记数据的index，可读性不好，容易产生错位处理

元组

优点： 
元组可以同时存储多种类型元素，且元素类型固定，以保证数据安全，除非你定义数据类型为Any。编译器会对赋值参数类型进行检查 
元组的元素个数固定，不允许增加、删除，编译器会严格校验赋值参数个数 
无需定义key，但是必要时可以为数据命名，方便数据访问 
适合同时遍历多元数据，例如官方文档的例子 
for (index, value) in shoppingList.enumerate()

缺点： 
不适合存储大量数据，因为元组不支持append、remove等方法 
考虑到工程实际情况，后端使用的语言可能不支持元组，需要转换为其他格式

转自swift3.0快速入门

H个MJ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
swift语言快速入门教程
11-02
swift语言 写的很简洁很棒的 还需要资源加我微信macforyou1 ，免费给大家
Swift3.0语言快速入门
08-05
Swift3.0语言快速入门
Swift快速入门（一）之基础语法
weixin_34291004的博客
05-28 311
Swift快速入门（一）之 Swift基础语法 近期重新学习了一遍Swift语言，主要以《Swift编程权威指南（第2版）》为教程，学习过程中结合比对Java语言特性将学习心得作为三篇笔记：Swift基础语法，Swift面向对象编程，Swift高级编程。 本文为第一篇《Swift基础语法》主要涵盖以下内容 类型、常量和变量 if-else条件语句 switch语句 数 整数和浮点数 循环 f...
Swift工程main函数去哪里了？
竹毛言己
05-11 646
有些东西很简单，但是我还是把它记录了下来。 main()函数是所有应用程序的入口，C、C++、Python等所有的应用程序都有且仅有一个main函数作为程序的入口。Swift创建一个新的工程，项目文件中怎么没有main()函数？ 用OC创建一个新项目后，会生成一个main.m的文件，里面是main函数： #import <UIKit/UIKit.h> #import "AppDelegate.h" int main(int argc, char * argv[]) { NSStri.
swift 添加main入口文件 略谈
allanGold
04-27 2062
现在通过  xcode8 创建的swift工程是没有main文件的  因为 在AppDelegate的文件中  @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { 这样进行了注解 那么问题来了，如果想要实现自己的main文件该怎么办呢？ i
Swift - @main 与 @UIApplicationMain
HumorousGhost
03-24 3251
因为Cocoa 开发环境已经在新建一个项目时帮助我们进行了很多配置，这导致了不少刚接触iOS 的开发者都存在基础比较薄弱的问题，其中一个最显著的现象就是很多人无法说清一个App 启动的流程。程序到底是怎么开始的，AppDelegate 到底是什么，xib 或者storyboard 是怎么被加载到屏幕上的？ 这一系列的问题，我们在开发中虽然不会每次都会去关心和配置，但是如果能进行一些了解的话，对于程序各个部分的职责的明确会很有帮助。 在C 语言中，程序的入口都是main 函数。对于一个Objective-C
Swift 语言快速入门
萌宅鹿的技术小屋
11-09 1261
Swift 语言快速入门简单值控制流函数闭包对象和类枚举和结构体协议和拓展错误处理泛型 由于项目原因，需要做一款 iOS 应用。。。然后这个任务就落到了我身上…emm 经过我的全方面了解，目前打算采用 SwiftUI 进行开发，对于 Swift 语言本身需要在实战中慢慢积累。。 这里是一篇快速入门，教程来源于：http://www.swift51.com 简单值 let 声明常量，var 声明变量 值不会被隐式转换为其他类型，如果需要进行不同类型的运算，需要显示的转换： let label = "The w
swift编程入门（非常详细）从零基础入门到精通，看完这一篇就够了
leah126的博客
07-25 5152
阅读完《the swift programming language 中文版》，对swift语言有了初步的认识。在特点是：swift既是项目开发的编程语言，又有脚本语言的特点；在学习上：swift可以在xcode的playground进行编写，所见即所得，非常适合语法学习。对于swift语言，个人认为就是"站在巨人的肩膀上"的一门语言，及众家之所长。只要熟悉一门主流的编程语言，学习swift的语法都不会太困难。swift和Java语言在某些语法和关键字上面甚是相似，因此在学习时困难不大。
Swift快速入门
阿福的专栏
09-07 2400
一、常量&变量 在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量 1、使用 let 定义常量,定义之后不可以修改 let number = 10 // 常量不可以修改 number = 20 ❌ 2、使用 var 定义变量,定义之后可以修改 var number = 10 number = 20 ⚠️编译器会根据给变量或常量所赋的值，推断它的数据类型。所以这里系统会认为number是Int类型的 ⚠️ swift中输出语句：print函数 pri
Swift项目的main函数为何消失了？如何把它找出来？
sun_ljz的博客
06-25 6727
创建过Swift项目的童鞋应该会发现，项目中没有一个名为main.swift的文件，为何没有了main函数，如果我想要创建UIApplication子类的时候要怎么办...
Swift4.0语言快速入门
09-21
Swift4.0语言快速入门Swift4.0语言快速入门Swift4.0语言快速入门Swift4.0语言快速入门Swift4.0语言快速入门Swift4.0语言快速入门
Swift hello world！Swift快速入门教程
09-04
主要介绍了Swift hello world！Swift快速入门教程,本文在快速了解Swift编程语言,需要的朋友可以参考下
零基础上手Swift快速入门教程概览
09-03
主要介绍了零基础上手Swift快速入门教程概览,Swift是由苹果开发的新编程语言并且即将开源,需要的朋友可以参考下
ios开发-swift快速入门.zip
10-04
这是swift的源码和资料，推荐对着视频敲一遍代码（如果没有足够的时间可以先看一遍视频，不敲代码，这样对课程讲的内容有一个大概了解，后面工作中遇到了问题才知道去哪一节找），后面遇到问题了可以直接先看电子书...
基于java的-28-“智慧食堂”设计与实现--LW-源码.zip
04-25
提供的源码资源涵盖了Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 适合毕业设计、课程设计作业。这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。 所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！
C#，回文分割问题（Palindrome Partitioning Problem）算法与源代码
04-25
C#，回文分割问题（Palindrome Partitioning Problem）算法与源代码 1 回文串 “回文串”是一个正读和反读都一样的字符串，初始化标志flag=true，比如“level”或者“noon”等等就是回文串。 2 回文分割问题 给定一个字符串，如果该字符串的每个子字符串都是回文的，那么该字符串的分区就是回文分区。 例如，“aba | b | bbabb | a | b | aba”是“abababababa”的回文分区。 确定给定字符串的回文分区所需的最少切割。 例如，“ababababababa”至少需要3次切割。 这三个分段是“a | babbab | b | ababa”。 如果字符串是回文，则至少需要0个分段。 如果一个长度为n的字符串包含所有不同的字符，则至少需要n-1个分段。
node-v9.2.1.tar.xz
最新发布
04-25
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
贪心算法解决活动选择问题，Java版源码
04-25
贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。贪心算法在有最优子结构的问题中尤为有效。最优子结构的意思是局部最优解可以决定全局最优解。 附件中一个使用贪心算法解决活动选择问题（也称为会议时间安排问题）的 Java 示例代码。这个问题的目标是选择最大的活动数量，使得活动之间互不重叠。 在示例中，我们定义了一个 Activity 类来表示每个活动的开始和结束时间。然后，我们创建了一个活动数组，并使用 Arrays.sort() 方法按照活动的结束时间对它们进行排序。 接下来，我们遍历排序后的数组，使用贪心算法的策略选择活动。选择的标准是当前活动的开始时间是否晚于或等于之前选择的最后一个活动的结束时间。如果是，我们就选择这个活动，并更新 lastActivityEnd 为当前活动的结束时间。最后，我们打印出可以执行的最大活动数量。
swift demo项目
08-30
Swift Demo项目可以帮助开发者快速入门Swift语言，并且通过阅读和运行示例代码，可以更直观地了解代码的执行过程和结果。开发者可以通过修改示例代码来实践和尝试不同的编程思路和方法。 Swift Demo项目还可以作为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值