swift学习1-入门＋基本语法

swift是一门由apple开发的开源软件，它不仅可以支持iOS开发，传说还可以支持android开发，有消息称Google因为和甲骨文因为使用了sun公司的几行代码，打了好久的官司，所有有意愿使用swift作为新的底层。swift的好处自然不用说了，有apple在后面，至少可以放心一点了。

我也是一个new guy对于swift，但是对于新技术好技术必须要有足够的重视，因为他们一不小心就可能引领潮流了。可以使自己不落后吧，希望。

下面是我学习到的关于swift的基本语法，和java语法类似，但是也有一些看得别扭的地方，一些看得一点点懂的，觉得和java一对比起来，是先进了不少。

一些可能看不是很懂的地方，我做了一些解释，方便以后自己会来查看。

//: Playground - noun: a place where people can play

import UIKit
import MapKit

//你不用明确地声明类型，声明的同时赋值的话，编译器会自动推断类型。
//variabl 变量
var str = "Hello, playground"
var num = "123"
let name = "jack"//定义一个不可变的常量

//如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。
let explicitDouble: Double = 70

//值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。
let label = "The width is"
let width = 94
let widthLabel = label + String(width)
//有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

//使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素。
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
shoppingList[0];

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

//要创建一个空数组或者字典，使用初始化语法。
var emptyArray = [String]()
var emptyDictionary = [String: Float]()//如何赋值
var abc = 11;
//emptyArray[0] = "index"//数组越界了

//使用if和switch来进行条件操作，使用for-in、for、while和repeat-while来进行循环。包裹条件和循环变量括号可以省
//略，但是语句体的大括号是必须的。
var individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
func getScore(score: Int) -> Int{
    for score in individualScores {
        if score > 50 {//在if语句中，条件必须是一个布尔表达式——这意味着像if score { ... }这样的代码将报错，
            //而不会隐形地与 0 做对比。
            teamScore += 3
        } else {
            teamScore += 1
        }
    }
    return score;
}
getScore(10)
print(getScore(10))


var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "jack"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}else{
    greeting = "googby"
}

let vegetable = "red pepper"
switch vegetable {
case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
case let a where a.hasSuffix("pepper")://where关键字指定额外的要求，并只可在 switch 语句。
    //因为所有这一切都泛， vegetable 变量分配给 x ( let x )。
    print(a)
    let vegetableComment = "Is it a spicy \(a)?"
default:
    let vegetableComment = "Everything tastes good in soup."
}

//使用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)

//使用while来重复运行一段代码直到不满足条件。循环条件也可以在结尾，保证能至少循环一次。

var n = 2
while n < 100 {
    n = n * 2
}
print(n)

var m = 2
repeat {
    m = m * 2
} while m < 100
print(m)

//你可以在循环中使用..<来表示范围，也可以使用传统的写法，两者是等价的：
var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

var secondForLoop = 0
for var i = 0; i < 4; ++i {
    secondForLoop += i
}
print(secondForLoop)

//函数和闭包
//使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型。
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob",day: "Tuesday")

//
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([5, 3, 100, 30, 9])
print(statistics.max)
print(statistics.0)

//函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式：
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

//函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

//函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()//返回一个函数
increment(7)

//函数也可以当做参数传入另一个函数。
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(numbers, condition: lessThanTen)

numbers.map({(number: Int) -> Int in
    let result = 3 * number
    return result
})

//使用class和类名来创建一个类
class Shape {
    var numberOfSides = 1
    init(name: Int) {//构造函数
        self.numberOfSides = name
    }
    deinit{//栖构函数
        numberOfSides = 0
    }
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
var shape1 = Shape(name: 5);
var shape = Shape.init(name: 3);
shape.simpleDescription();
shape1.numberOfSides

//继承类
class Square: Shape {
    var sideLength: Double
    
    init(sideLength: Double, name: Int) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    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: 32)
test.area()
test.simpleDescription()

以上是swift入门的基础，以后还会持续学习。