swift学习二:基本的语法

声明本文转载自：http://www.cocoachina.com/applenews/devnews/2014/0603/8653.html

Swift是什么？

Swift是苹果于WWDC 2014公布的编程语言，这里引用The
Swift Programming Language的原话：

 Swift is a new programming language for iOS and OS X apps that builds on the best
of C and Objective-C, without the constraints of C compatibility.

Swift adopts safe programming patterns and adds modern features to make programming easier, more flexible and more fun.

Swift’s clean slate, backed by the mature and much-loved Cocoa and Cocoa Touch frameworks, is an opportunity to imagine how software development works.

Swift is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language.

简单的说：

Swift用来写iOS和OS X程序。（预计也不会支持其他屌丝系统）

Swift吸取了C和Objective-C的长处，且更加强大易用。

Swift能够使用现有的Cocoa和Cocoa Touch框架。

Swift兼具编译语言的高性能（Performance）和脚本语言的交互性（Interactive）。


Swift语言概览

基本概念

注：这一节的代码源自The
Swift Programming Language中的A Swift Tour。

Hello, world

类似于脚本语言，以下的代码即是一个完整的Swift程序。

    

  1. println("Hello, world")
    2.

变量与常量

Swift使用var声明变量，let声明常量。

    

  1. var myVariable = 42
    2. 

  2. myVariable = 50
    3. 

  3. let myConstant = 42
    4.

类型推导

Swift支持类型推导（Type Inference），所以上面的代码不需指定类型，假设须要指定类型：

    

  1. let explicitDouble : Double = 70
    2.

Swift不支持隐式类型转换（Implicitly casting），所以以下的代码须要显式类型转换（Explicitly casting）：

    

  1. let label = "The width is "
    2. 

  2. let width = 94
    3. 

  3. let width = label + String(width)
    4.

字符串格式化

Swift使用\(item)的形式进行字符串格式化：

    

  1. let apples = 3
    2. 

  2. let oranges = 5
    3. 

  3. let appleSummary = "I have \(apples) apples."
    4. 

  4. let appleSummary = "I have \(apples + oranges) pieces of fruit."
    5.

数组和字典

Swift使用[]操作符声明数组（array）和字典（dictionary）：

    

  1. var shoppingList = ["catfish", "water", "tulips", "blue paint"]
    2. 

  2. shoppingList[1] = "bottle of water"
    3. 

  3. var occupations = [
    4. 

  4. "Malcolm": "Captain",
    5. 

  5. "Kaylee": "Mechanic",
    6. 

  6. ]
    7. 

  7. occupations["Jayne"] = "Public Relations"
    8.

一般使用初始化器（initializer）语法创建空数组和空字典：

    

  1. let emptyArray = String[]()
    2. 

  2. let emptyDictionary = Dictionary<String, Float>()
    3.

假设类型信息已知，则能够使用[]声明空数组，使用[:]声明空字典。

控制流

概览

Swift的条件语句包括if和switch，循环语句包括for-in、for、while和do-while，循环/推断条件不须要括号，但循环/推断体（body）必需括号：

    

  1. let individualScores = [75, 43, 103, 87, 12]
    2. 

  2. var teamScore = 0
    3. 

  3. for score in individualScores {
    4. 

  4. if score > 50 {
    5. 

  5. teamScore += 3
    6. 

  6. } else {
    7. 

  7. teamScore += 1
    8. 

  8. }
    9. 

  9. }
    10.

可空类型

结合if和let，能够方便的处理可空变量（nullable variable）。对于空值，须要在类型声明后加入?显式标明该类型可空。

    

  1. var optionalString: String? = "Hello"
    2. 

  2. optionalString == nil
    3. 

  3. var optionalName: String? = "John Appleseed"
    4. 

  4. var gretting = "Hello!"
    5. 

  5. if let name = optionalName {
    6. 

  6. gretting = "Hello, \(name)"
    7. 

  7. }
    8.

灵活的switch

Swift中的switch支持各种各样的比較操作：

    

  1. let vegetable = "red pepper"
    2. 

  2. switch vegetable {
    3. 

  3. case "celery":
    4. 

  4. let vegetableComment = "Add some raisins and make ants on a log."
    5. 

  5. case "cucumber", "watercress":
    6. 

  6. let vegetableComment = "That would make a good tea sandwich."
    7. 

  7. case let x where x.hasSuffix("pepper"):
    8. 

  8. let vegetableComment = "Is it a spicy \(x)?"
    9. 

  9. default:
    10. 

  10. let vegetableComment = "Everything tastes good in soup."
    11. 

  11. }
    12.

其他循环

for-in除了遍历数组也能够用来遍历字典：

    

  1. let interestingNumbers = [
    2. 

  2. "Prime": [2, 3, 5, 7, 11, 13],
    3. 

  3. "Fibonacci": [1, 1, 2, 3, 5, 8],
    4. 

  4. "Square": [1, 4, 9, 16, 25],
    5. 

  5. ]
    6. 

  6. var largest = 0
    7. 

  7. for (kind, numbers) in interestingNumbers {
    8. 

  8. for number in numbers {
    9. 

  9. if number > largest {
    10. 

  10. largest = number
    11. 

  11. }
    12. 

  12. }
    13. 

  13. }
    14. 

  14. largest
    15.

while循环和do-while循环：

    

  1. var n = 2
    2. 

  2. while n < 100 {
    3. 

  3. n = n * 2
    4. 

  4. }
    5. 

  5. n
    6. 

  6. var m = 2
    7. 

  7. do {
    8. 

  8. m = m * 2
    9. 

  9. } while m < 100
    10. 

  10. m
    11.

Swift支持传统的for循环，此外也能够通过结合..（生成一个区间）和for-in实现相同的逻辑。

    

  1. var firstForLoop = 0
    2. 

  2. for i in 0..3 {
    3. 

  3. firstForLoop += i
    4. 

  4. }
    5. 

  5. firstForLoop
    6. 

  6. var secondForLoop = 0
    7. 

  7. for var i = 0; i < 3; ++i {
    8. 

  8. secondForLoop += 1
    9. 

  9. }
    10. 

  10. secondForLoop
    11.

注意：Swift除了..还有...：..生成前闭后开的区间，而...生成前闭后闭的区间。

函数和闭包

函数

Swift使用funckeyword声明函数：

    

  1. func greet(name: String, day: String) -> String {
    2. 

  2. return "Hello \(name), today is \(day)."
    3. 

  3. }
    4. 

  4. greet("Bob", "Tuesday")
    5.

通过元组（Tuple）返回多个值：

    

  1. func getGasPrices() -> (Double, Double, Double) {
    2. 

  2. return (3.59, 3.69, 3.79)
    3. 

  3. }
    4. 

  4. getGasPrices()
    5.

支持带有变长參数的函数：

    

  1. func sumOf(numbers: Int...) -> Int {
    2. 

  2. var sum = 0
    3. 

  3. for number in numbers {
    4. 

  4. sum += number
    5. 

  5. }
    6. 

  6. return sum
    7. 

  7. }
    8. 

  8. sumOf()
    9. 

  9. sumOf(42, 597, 12)
    10.

函数也能够嵌套函数：

    

  1. func returnFifteen() -> Int {
    2. 

  2. var y = 10
    3. 

  3. func add() {
    4. 

  4. y += 5
    5. 

  5. }
    6. 

  6. add()
    7. 

  7. return y
    8. 

  8. }
    9. 

  9. returnFifteen()
    10.

作为头等对象，函数既能够作为返回值，也能够作为參数传递：

    

  1. func makeIncrementer() -> (Int -> Int) {
    2. 

  2. func addOne(number: Int) -> Int {
    3. 

  3. return 1 + number
    4. 

  4. }
    5. 

  5. return addOne
    6. 

  6. }
    7. 

  7. var increment = makeIncrementer()
    8. 

  8. increment(7)
    9. 



    

  1. func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    2. 

  2. for item in list {
    3. 

  3. if condition(item) {
    4. 

  4. return true
    5. 

  5. }
    6. 

  6. }
    7. 

  7. return false
    8. 

  8. }
    9. 

  9. func lessThanTen(number: Int) -> Bool {
    10. 

  10. return number < 10
    11. 

  11. }
    12. 

  12. var numbers = [20, 19, 7, 12]
    13. 

  13. hasAnyMatches(numbers, lessThanTen)
    14.

闭包

本质来说，函数是特殊的闭包，Swift中能够利用{}声明匿名闭包：

    

  1. numbers.map({
    2. 

  2. (number: Int) -> Int in
    3. 

  3. let result = 3 * number
    4. 

  4. return result
    5. 

  5. })
    6.

当闭包的类型已知时，能够使用以下的简化写法：

    

  1. numbers.map({ number in 3 * number })
    2.

此外还能够通过參数的位置来使用參数，当函数最后一个參数是闭包时，能够使用以下的语法：

    

  1. sort([1, 5, 3, 12, 2]) { $0 > $1 }
    2.

类和对象

创建和使用类

Swift使用class创建一个类，类能够包括字段和方法：

    

  1. class Shape {
    2. 

  2. var numberOfSides = 0
    3. 

  3. func simpleDescription() -> String {
    4. 

  4. return "A shape with \(numberOfSides) sides."
    5. 

  5. }
    6. 

  6. }
    7.

创建Shape类的实例，并调用其字段和方法。

    

  1. var shape = Shape()
    2. 

  2. shape.numberOfSides = 7
    3. 

  3. var shapeDescription = shape.simpleDescription()
    4.

通过init构建对象，既能够使用self显式引用成员字段（name），也能够隐式引用（numberOfSides）。

    

  1. class NamedShape {
    2. 

  2. var numberOfSides: Int = 0
    3. 

  3. var name: String
    4. 

  4. init(name: String) {
    5. 

  5. self.name = name
    6. 

  6. }
    7. 

  7. func simpleDescription() -> String {
    8. 

  8. return "A shape with \(numberOfSides) sides."
    9. 

  9. }
    10. 

  10. }
    11.

使用deinit进行清理工作。

继承和多态

Swift支持继承和多态（override父类方法）：

    

  1. class Square: NamedShape {
    2. 

  2. var sideLength: Double
    3. 

  3. init(sideLength: Double, name: String) {
    4. 

  4. self.sideLength = sideLength
    5. 

  5. super.init(name: name)
    6. 

  6. numberOfSides = 4
    7. 

  7. }
    8. 

  8. func area() -> Double {
    9. 

  9. return sideLength * sideLength
    10. 

  10. }
    11. 

  11. override func simpleDescription() -> String {
    12. 

  12. return "A square with sides of length \(sideLength)."
    13. 

  13. }
    14. 

  14. }
    15. 

  15. let test = Square(sideLength: 5.2, name: "my test square")
    16. 

  16. test.area()
    17. 

  17. test.simpleDescription()
    18.

注意：假设这里的simpleDescription方法没有被标识为override，则会引发编译错误。

属性

为了简化代码，Swift引入了属性（property），见以下的perimeter字段：

    

  1. class EquilateralTriangle: NamedShape {
    2. 

  2. var sideLength: Double = 0.0
    3. 

  3. init(sideLength: Double, name: String) {
    4. 

  4. self.sideLength = sideLength
    5. 

  5. super.init(name: name)
    6. 

  6. numberOfSides = 3
    7. 

  7. }
    8. 

  8. var perimeter: Double {
    9. 

  9. get {
    10. 

  10. return 3.0 * sideLength
    11. 

  11. }
    12. 

  12. set {
    13. 

  13. sideLength = newValue / 3.0
    14. 

  14. }
    15. 

  15. }
    16. 

  16. override func simpleDescription() -> String {
    17. 

  17. return "An equilateral triagle with sides of length \(sideLength)."
    18. 

  18. }
    19. 

  19. }
    20. 

  20. var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
    21. 

  21. triangle.perimeter
    22. 

  22. triangle.perimeter = 9.9
    23. 

  23. triangle.sideLength
    24.

注意：赋值器（setter）中，接收的值被自己主动命名为newValue。

willSet和didSet

EquilateralTriangle的构造器进行了例如以下操作：

1.为子类型的属性赋值。

2.调用父类型的构造器。

3.改动父类型的属性。

假设不须要计算属性的值，但须要在赋值前后进行一些操作的话，使用willSet和didSet：

    

  1. class TriangleAndSquare {
    2. 

  2. var triangle: EquilateralTriangle {
    3. 

  3. willSet {
    4. 

  4. square.sideLength = newValue.sideLength
    5. 

  5. }
    6. 

  6. }
    7. 

  7. var square: Square {
    8. 

  8. willSet {
    9. 

  9. triangle.sideLength = newValue.sideLength
    10. 

  10. }
    11. 

  11. }
    12. 

  12. init(size: Double, name: String) {
    13. 

  13. square = Square(sideLength: size, name: name)
    14. 

  14. triangle = EquilateralTriangle(sideLength: size, name: name)
    15. 

  15. }
    16. 

  16. }
    17. 

  17. var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
    18. 

  18. triangleAndSquare.square.sideLength
    19. 

  19. triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
    20. 

  20. triangleAndSquare.triangle.sideLength
    21.

从而保证triangle和square拥有相等的sideLength。

调用方法

Swift中，函数的參数名称仅仅能在函数内部使用，但方法的參数名称除了在内部使用外还能够在外部使用（第一个參数除外），比如：

    

  1. class Counter {
    2. 

  2. var count: Int = 0
    3. 

  3. func incrementBy(amount: Int, numberOfTimes times: Int) {
    4. 

  4. count += amount * times
    5. 

  5. }
    6. 

  6. }
    7. 

  7. var counter = Counter()
    8. 

  8. counter.incrementBy(2, numberOfTimes: 7)
    9.

注意Swift支持为方法參数取别名：在上面的代码里，numberOfTimes面向外部，times面向内部。

?的还有一种用途

使用可空值时，?能够出如今方法、属性或下标前面。假设?前的值为nil，那么?后面的表达式会被忽略，而原表达式直接返回nil，比如：

    

  1. 1
    2. 

  2. 2
    3. 

  3. 3
    4. 

  4. let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional
    5. 

  5. square")
    6. 

  6. let sideLength = optionalSquare?.sideLength
    7.

当optionalSquare为nil时，sideLength属性调用会被忽略。

枚举和结构

枚举

使用enum创建枚举——注意Swift的枚举能够关联方法：

    

  1. enum Rank: Int {
    2. 

  2. case Ace = 1
    3. 

  3. case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    4. 

  4. case Jack, Queen, King
    5. 

  5. func simpleDescription() -> String {
    6. 

  6. switch self {
    7. 

  7. case .Ace:
    8. 

  8. return "ace"
    9. 

  9. case .Jack:
    10. 

  10. return "jack"
    11. 

  11. case .Queen:
    12. 

  12. return "queen"
    13. 

  13. case .King:
    14. 

  14. return "king"
    15. 

  15. default:
    16. 

  16. return String(self.toRaw())
    17. 

  17. }
    18. 

  18. }
    19. 

  19. }
    20. 

  20. let ace = Rank.Ace
    21. 

  21. let aceRawValue = ace.toRaw()
    22.

使用toRaw和fromRaw在原始（raw）数值和枚举值之间进行转换：

    

  1. if let convertedRank = Rank.fromRaw(3) {
    2. 

  2. let threeDescription = convertedRank.simpleDescription()
    3. 

  3. }
    4.

注意：枚举中的成员值（member value）是实际的值（actual value），和原始值（raw value）没有必定关联。

一些情况下枚举不存在有意义的原始值，这时能够直接忽略原始值：

    

  1. enum Suit {
    2. 

  2. case Spades, Hearts, Diamonds, Clubs
    3. 

  3. func simpleDescription() -> String {
    4. 

  4. switch self {
    5. 

  5. case .Spades:
    6. 

  6. return "spades"
    7. 

  7. case .Hearts:
    8. 

  8. return "hearts"
    9. 

  9. case .Diamonds:
    10. 

  10. return "diamonds"
    11. 

  11. case .Clubs:
    12. 

  12. return "clubs"
    13. 

  13. }
    14. 

  14. }
    15. 

  15. }
    16. 

  16. let hearts = Suit.Hearts
    17. 

  17. let heartsDescription = hearts.simpleDescription()
    18.

除了能够关联方法，枚举还支持在其成员上关联值，同一枚举的不同成员能够有不同的关联的值：

    

  1. enum ServerResponse {
    2. 

  2. case Result(String, String)
    3. 

  3. case Error(String)
    4. 

  4. }
    5. 

  5. let success = ServerResponse.Result("6:00 am", "8:09 pm")
    6. 

  6. let failure = ServerResponse.Error("Out of cheese.")
    7. 

  7. switch success {
    8. 

  8. case let .Result(sunrise, sunset):
    9. 

  9. let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
    10. 

  10. case let .Error(error):
    11. 

  11. let serverResponse = "Failure... \(error)"
    12. 

  12. }
    13.

结构

Swift使用structkeyword创建结构。结构支持构造器和方法这些类的特性。结构和类的最大差别在于：结构的实例按值传递（passed by value），而类的实例按引用传递（passed by reference）。

    

  1. struct Card {
    2. 

  2. var rank: Rank
    3. 

  3. var suit: Suit
    4. 

  4. func simpleDescription() -> String {
    5. 

  5. return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    6. 

  6. }
    7. 

  7. }
    8. 

  8. let threeOfSpades = Card(rank: .Three, suit: .Spades)
    9. 

  9. let threeOfSpadesDescription = threeOfSpades.simpleDescription()
    10.

协议（protocol）和扩展（extension）

协议

Swift使用protocol定义协议：

    

  1. protocol ExampleProtocol {
    2. 

  2. var simpleDescription: String { get }
    3. 

  3. mutating func adjust()
    4. 

  4. }
    5.

类型、枚举和结构都能够实现（adopt）协议：

    

  1. class SimpleClass: ExampleProtocol {
    2. 

  2. var simpleDescription: String = "A very simple class."
    3. 

  3. var anotherProperty: Int = 69105
    4. 

  4. func adjust() {
    5. 

  5. simpleDescription += " Now 100% adjusted."
    6. 

  6. }
    7. 

  7. }
    8. 

  8. var a = SimpleClass()
    9. 

  9. a.adjust()
    10. 

  10. let aDescription = a.simpleDescription
    11. 

  11. struct SimpleStructure: ExampleProtocol {
    12. 

  12. var simpleDescription: String = "A simple structure"
    13. 

  13. mutating func adjust() {
    14. 

  14. simpleDescription += " (adjusted)"
    15. 

  15. }
    16. 

  16. }
    17. 

  17. var b = SimpleStructure()
    18. 

  18. b.adjust()
    19. 

  19. let bDescription = b.simpleDescription
    20.

扩展

扩展用于在已有的类型上添加新的功能（比方新的方法或属性），Swift使用extension声明扩展：

    

  1. extension Int: ExampleProtocol {
    2. 

  2. var simpleDescription: String {
    3. 

  3. return "The number \(self)"
    4. 

  4. }
    5. 

  5. mutating func adjust() {
    6. 

  6. self += 42
    7. 

  7. }
    8. 

  8. }
    9. 

  9. 7.simpleDescription
    10.

泛型（generics）

Swift使用<>来声明泛型函数或泛型类型：

    

  1. func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    2. 

  2. var result = ItemType[]()
    3. 

  3. for i in 0..times {
    4. 

  4. result += item
    5. 

  5. }
    6. 

  6. return result
    7. 

  7. }
    8. 

  8. repeat("knock", 4)
    9.

Swift也支持在类、枚举和结构中使用泛型：

    

  1. // Reimplement the Swift standard library‘s optional type
    2. 

  2. enum OptionalValue<T> {
    3. 

  3. case None
    4. 

  4. case Some(T)
    5. 

  5. }
    6. 

  6. var possibleInteger: OptionalValue<Int> = .None
    7. 

  7. possibleInteger = .Some(100)
    8.

有时须要对泛型做一些需求（requirements），比方需求某个泛型类型实现某个接口或继承自某个特定类型、两个泛型类型属于同一个类型等等，Swift通过where描写叙述这些需求：

    

  1. func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    2. 

  2. for lhsItem in lhs {
    3. 

  3. for rhsItem in rhs {
    4. 

  4. if lhsItem == rhsItem {
    5. 

  5. return true
    6. 

  6. }
    7. 

  7. }
    8. 

  8. }
    9. 

  9. return false
    10. 

  10. }
    11. 

  11. anyCommonElements([1, 2, 3], [3])
    12.

Swift语言概览就到这里，有兴趣的朋友请进一步阅读The Swift Programming Language。

接下来聊聊个人对Swift的一些感受。


个人感受

注意：以下的感受纯属个人意见，仅供參考。

大杂烩

虽然我接触Swift不足两小时，但非常easy看出Swift吸收了大量其他编程语言中的元素，这些元素包含但不限于：

1.属性（Property）、可空值（Nullable type）语法和泛型（Generic Type）语法源自C#。

2.格式风格与Go相仿（没有句末的分号，推断条件不须要括号）。

3.Python风格的当前实例引用语法（使用self）和列表字典声明语法。

4.Haskell风格的区间声明语法（比方1..3，1...3）。

5.协议和扩展源自Objective-C（自家产品随便用）。

6.枚举类型非常像Java（能够拥有成员或方法）。

7.class和struct的概念和C#极其相似。

注意这里不是说Swift是抄袭——实际上编程语言能玩的花样基本就这些，况且Swift选的都是在我看来相当不错的特性。

并且，这个大杂烩有一个优点——就是不论什么其他编程语言的开发人员都不会认为Swift非常陌生——这一点非常重要。

拒绝隐式（Refuse implicity）

Swift去除了一些隐式操作，比方隐式类型转换和隐式方法重载这两个坑，干的美丽。

Swift的应用方向

我觉得Swift主要有以下这两个应用方向：

教育

我指的是编程教育。现有编程语言最大的问题就是交互性奇差，从而导致学习曲线陡峭。相信Swift及其交互性极强的编程环境可以打破这个局面，让很多其它的人——尤其是青少年，学会编程。

这里有必要再次提到Brec Victor的Inventing on Principle，看了这个视频你就会明确一个交互性强的编程环境可以带来什么。

应用开发

现有的iOS和OS X应用开发均使用Objective-C，而Objective-C是一门及其繁琐（verbose）且学习曲线比較陡峭的语言，假设Swift可以提供一个同现有Obj-C框架的简易互操作接口，我相信会有大量的程序猿转投Swift；与此同一时候，Swift简易的语法也会带来相当数量的其他平台开发人员。

总之，上一次某家大公司大张旗鼓的推出一门编程语言及其编程平台还是在2000年（微软推出C#），将近15年之后，苹果推出Swift——作为开发人员，我非常高兴可以见证一门编程语言的诞生。

时间： 2024-10-19 18:13:09

swift学习二:基本的语法的相关文章

MVC学习二：基础语法

目录 一:重载方法的调用 二:数据的传递 三:生成控件 四:显示加载视图 五:强类型视图 六:@Response.Write() 和 @Html.Raw()区别 七:视图中字符串的输入 八:模板页 一:重载方法的调用 同一个控制器内的同名方法调用,可以用HttpGet 和HttpPost区分. [HttpGet] public void request(int id = 0) { Response.Write("get 请求成功~"); } [HttpPost] public void

Swift学习二

参考博客:http://blog.csdn.net/jaywon //swift不会自动为变量赋初始值,必须手动添加初始值 //数组 Arraylet array:Array = []; 声明一个空数组var array1 = String[]() 声明一个字符串数组往数组末尾添加新元素array.append("新元素")array += "新元素"array += ["新元素1","新元素2",...]往数组里的指定位置添

Swift学习笔记(1)--基本语法

1.分号; 1>Swift不要求每个语句后面跟一个分号作为语句结束的标识,如果加上也可以,看个人喜好 2>在一行中写了两句执行语句,需要用分号隔开,比如 let x = 0; println("hehe") 2.常量与变量的定义 1>常量名与变量名没有大小写的限制 2>常量关键字let 变量关键字var 3>例: ? 1 2 3 4 5 6 7 8 9 let pi = 3.1415  //常量必须初始化,且只能被赋值一次 var v1: String 

Swift学习笔记十二：下标脚本（subscript）

下标脚本就是对一个东西通过索引,快速取值的一种语法,例如数组的a[0].这就是一个下标脚本.通过索引0来快速取值.在Swift中,我们可以对类(Class).结构体(structure)和枚举(enumeration)中自己定义下标脚本的语法 一.常规定义 class Student{ var scores:Int[] = Array(count:5,repeatedValue:0) subscript(index:Int) -> Int{ get{ return scores[index];

Swift学习——格式控制符和元组流程控制(二)

Swift中的格式控制符和元祖 (1)首先介绍一下元祖,元祖是关系型数据库中  例如学生表中的姓名,年龄,电话等 定义如下 var studentinfo = ("jhon",29,"123456") println(studentinfo.0) 访问的时候是通过下标来访问的. //元组本身是以一个整体存在的,如果用下标获取元祖的某一项的数据时 //可以通过点语法加下标的形式得到,这叫元祖的拆包 println("name:\(studentinfo.0)

Swift开发学习(二)：Playground

Swift开发学习:Playground 关于 对于软件用户.游戏玩家,大家一直都在提倡用户体验.其实软件开发者自己也是用户,是各种开发工具的使用者,也会喜欢用户体验做得好的工具软件.这次苹果想开发者所想,提供了一个可以玩转swift的游乐场--Playground,它为开发着提供了方便.提供了乐趣. 原文作者:Power 转载请保留此链接. Playground可以干什么 快速练习swift 不需要编译.不需要点击执行,编写代码后直接看效果 是不是比脚本语言还方便? 开发者可以通过Playgr

swift学习笔记之二——集合

//=========================== //2014/7/21 17:27 swift集合 //=========================== swift提供了两种集合类型,arrays和dictionaryies,两种集合都是可变的,可以在集合声明后对其进行新增.删除和修改操作. 1.array 数组的定义与java数组相同,但swift的数组提供了更灵活的创建方式和操作方式. 数组创建和初始化方式: var array1: Array<T> = [val1,va

Swift学习笔记(二)参数类型

关于参数类型,在以前的编程过程中,很多时间都忽视了形参与实参的区别.通过这两天的学习,算是捡回了漏掉的知识. 在swift中,参数有形参和实参之分,形参即只能在函数内部调用的参数,默认是不能修改的,如果想要修改就需要在参数前添加var声明. 但这样的声明过后,仍旧不会改变实参的值,这样就要用到inout了,传递给inout的参数类型必须是var类型的,不能是let类型或者字面类型,(字面类型是在swift中常提的一个术语,个人认为就是赋值语句,也不能修改)而且在传递过程中,要用传值符号"&

Swift学习——Swift基础详解（二）

上节说了没有营养的变量和常量,这玩意,都差不多,自己稍微看下就好了 Integers    整型 整数就是整数了,没有小数,整数有符号(+,-,0)或者无符号(0,+) Swift提供了8,16,32,64位的有符号和无符号的整数,命名使用C的方式,比如,8位无符号的整型UInt8,32位有符号的整型就是Int32 Integer Bounds    整型范围 可以使用min 和 max获取整数类型的最大值和最小值 let minValue = UInt8.min // minValue is