Swift基础加强_跟我打500行

今天上午、 继续练习了一下swift

然后 首先打开Xcode6

紧接着 我们创建一个playGround。  playGround不知道的孩子、 去百度给自己科普一下 

然后 我们看一下代码 、 跟着打 别赋值粘贴

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

import UIKit

// HelloWorld
var str = "Hello, playground"

// 常量可以改变值
var myVariable = 42
myVariable = 50
let myConstant = 42

// 指定数据类型
let floatNumber:Float = 4

// 使用强制转换
let lable = "the lable is "
let width = 94
let labelwidth = lable + String(width)

// 使用双引号中的来转换
let apples = 3
let oranges = 5
let appleSummary = "i have (apples) apples"
let orangeSummary = "i have (oranges) oranges"

// 自动识别数据类型加斜杠转换
let somebody = "Alice"
let age = 23.5
let hellosomebody = "(somebody) is (age)"

// 数组的初始化以及赋值
var shoppingList = ["Alice", "Dylan"]
shoppingList[1] = "Petit Alice"

// 字典的初始化以及赋值
var occupations = [

    "male" : "Alice",
    "female" : "Dylan"
]
occupations["male"] = "Alice.Petit"

// 初始化一个空的数组或者字典
let emptyArray = [String]()
let emptyDictionary = [String:Float]()

// 初始化一个自动识别类型的字典或者数组
let emptyArray_auto = []
let emptyDictionary_auto = [:]

// 控制流 不能省略大括号
let individualScores = [75, 42, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
teamScore

// 写到这里 突然发现 变量名称直接打出去 就能打印了
let emptyA = ["key": "value"]
emptyA

// 在if条件中 条件必须是bool表达式 输如一个直接score会出错的 看好了  是必须是表达式

// 使用let来标记
var optionalString: String? = "Hello"
optionalString == nil

var optionalName: String? = "John Appleseed"
var getting = "Hello"
optionalName = nil

if let name = optionalName {
    getting = "hello, (name)"
} else {
    getting = "hello, Alice"
}

// switch
let vegetable = "red pepper"
switch vegetable {
    case "celery":
        let vegetableComment = "add some"
    case "cummber", "watercress":
        let vegetableComment = "this would make a good tea"
case let x where x.hasSuffix("pepper"):
    let vegetableComment = "is it a spicy (x)"
default:
    let vegetableComment = "everything tastes good in soup"
}

// 碰到匹配的句子后 switch不会在继续往前走
let interstingNumbers = [
    "prime" : [2, 3, 4, 6],
    "Fibonacci" : [1, 1, 2, 3],
    "Square" : [1, 4, 5]
]

var largest = 0
var maxtype = ""
for (kind, numbers) in interstingNumbers {
    
    for number in numbers {
        if number > largest {
            largest = number
            maxtype = kind
        }
    }
    
}
largest
maxtype

// while
var n = 2
while n < 100 {
    n = n*2
}
n

var m  = 2
do {
m = m*2
} while m < 100

m

//  注意到了把  while do 不会多循环一次的  他们是等价的

// ..<
var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
firstForLoop

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

var thirdForLoop = 0
for i in 0...4 {
    thirdForLoop += i
}
thirdForLoop

// func
func greet(name:String, day:String) ->String {
    
    return "Hello. (name), today is (day)"
}
greet("Alice", "Tuesday")

func whateating(name:String) ->String {
    return "(name) eat what?"
}
whateating("Alice")

// 使用元组让一个函数返回多个值
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
        }
        
        if score < min {
            min = score
        }
        
        sum += score
    }
    
    return (min, max, sum)
}
let staticArray = [1, 2, 3, 4, 5]
calculateStatistics(staticArray)
//  返回值可以用点语法单独的取到 也可以用位置
calculateStatistics(staticArray).sum
calculateStatistics(staticArray).0

// 函数可以带有可变个数的参数
func sumOf(numbers: Int...) ->Int {
    
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf(1, 2)
sumOf()
sumOf(1,2 ,3 ,4,5)

// 计算参数平均值的联系
func acr(number:Int...) ->Float {
    
    var sum = 0
    for num in number {
        sum += num
    }
    return Float(sum)/Float(number.count)
}
acr(1, 2, 3)
acr(3, 4)

// 函数可以嵌套 被嵌套的函数可以访问外侧函数的变量 可以嵌套函数来重构一个太长或者太复杂的函数
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, 2, 12]
hasAnymatches(numbers, lessThanTen)

// 函数实际上是一特殊的闭包 使用{} 来创建一个匿名的闭包 使用int将参数和饭追只类型声明与闭包函数体进行分离
numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})

numbers.map({
    (number: Int) -> Int in
    if number % 2 != 0 {
        return 0
    }
    return 1
})

let mappedNumbers = numbers.map({
    number in 3 * number
})
mappedNumbers

let sortedNumbers = sorted(numbers) {
    $0 > $1
}
sortedNumbers

// 对象和类
class Shape {
    var numberOdSides = 0
    let testGetNumber = 0
    
    func setNumber(number: Int) {
        numberOdSides = number
    }
    
    func simpleDescription() ->String {
        
        return "A shape with (numberOdSides) sides"
    }
}

var shape = Shape()
shape .setNumber(10)
shape .simpleDescription()

// init
class NamedShape {
    var numberOfSides: Int = 0
    var name:String
    
    init(name: String, number:Int) {
        self.name = name
        self.numberOfSides = number
    }
    
    func simepleDescription() ->String {
        return "A (name) with (numberOfSides) sides"
    }
}
var nameShape = NamedShape(name: "Alice", number: 20)
nameShape .simepleDescription()

// 继承
class Square: NamedShape {
    var sidelength: Double
    
    init(sidelength: Double, name:String, number: Int) {
        
        self.sidelength = sidelength
        super.init(name: name, number: number)
    }
    
    func area() ->Double {
        
        return sidelength * sidelength
    }
    
    override func simepleDescription() -> String {
        return "a Square with Sides of Length (sidelength)"
    }
}

// getter setter
class EquilaterTrabgle: NamedShape {
    
    var sideLengths: Double = 0.0
    
    init(side: Double, name: String, number: Int) {
        self.sideLengths = side
        super.init(name: name, number: number)
    }
    
    var perimeter: Double {
        
        get {
            return 3 * sideLengths
        }
        
        set {
            sideLengths = newValue / 3.0
        }
    }
    
    override func simepleDescription() -> String {
        return "an square triagle with (sideLengths)"
    }
}

var triangle = EquilaterTrabgle(side: 3.1, name: "Alice", number: 3)
triangle.perimeter
triangle.perimeter = 9.9
triangle.sideLengths
triangle.simepleDescription()

// 默认的情况相爱 方法的参数名和他们在方法内部的名字一样
class counter {
    var count: Int = 0
    func incrementBy(amount: Int, numberOfTimes times: Int) {
        count += amount * times
    }
}
var count = counter();
count.incrementBy(2, numberOfTimes: 7)

// 处理变量的可选值的时候。 你可以在操作之前加？之前的值是nil的话那么后边的东西讲不会被执行 否则 ？后边的东西被运行 这种情况下 整个表达式只有一个可选值
let optionalSquare: Square = Square(sidelength: 2, name: "Alice", number: 3)
let sidelength = optionalSquare.sidelength

// 枚举和结构体
enum Rank: Int {
    
    case Ace = 1
    case Two, Three, Four, Five
    case Jack, Queen
    
    func simpleDescription() ->String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        default:
            return String(self.toRaw())
        }
    }
}
let ace = Rank.Ace
let aceRowValue = ace.toRaw()
ace.simpleDescription()

// 写一个函数  来比较两个Rank值
enum Ranks: Int {
    case one = 1
    case two = 2
    case three = 3
    
    func sub(number1: Int, number2: Int) ->Int {
        
        return number1 > number2 ? number1 : number2
    }
}
let one = Ranks.one
one.sub(10, number2: 2)

//  使用toRow 和fromRow函数在原始值和枚举值之前轻松的切换
if let convertedRank = Rank.fromRaw(3) {
    let threeDescription = convertedRank.simpleDescription()
    threeDescription
}

// 枚举的成员是实际值并不是原始值的另一种表达方法 实际上 如果原始值没有意义 你不需要设置
enum Suit {
    
    case Spades, Hearts, Diamonds, Clubs
    
    func simleDescription() -> String {
        switch self {
        case .Spades:
            return "spa"
        case .hearts:
            return "heart"
        case .Diamonds:
            return "dia"
        case .Clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simleDescription()

// 定义一个结构体 接受上边传来的东西
struct Card {
    var rank: Rank
    var suit: Suit
    
    func sipleDescription() ->String {
        return "(rank), (suit)"
    }
}
let thspeed = Card(rank: .Three, suit: .Spades)
let thspeeds = thspeed.sipleDescription()
thspeeds
thspeed

// 通过枚举 区别正确或者错误信息
enum ServerResponse {
    case Result(String, String)
    case Error(String)
}

let success = ServerResponse.Result("Alice", "Dylan")
let failure = ServerResponse.Error("Error")

switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "(sunrise), (sunset)"
case let .Error(error):
    let serverResponse = "Failure .. (error)"
}

// 协议和扩展

// 首先  使用protocal来申明一个协议 
protocol ExamplepRrotocol {
    var simpleDescription: String {
        get
    }
    mutating func adjust()
}

// 类 枚举 结构体都可以实现协议
class SimoleClass: ExamplepRrotocol  {
    var simpleDescription: String = "A very petit girl"
    var anotherpRroperty: Int = 69105
    func adjust() {
        simpleDescription += "Alice"
    }
}

var a = SimoleClass()
a.adjust()

let aDescription = a.simpleDescription

struct SimpleStructure : ExamplepRrotocol{
    var simpleDescription: String = "Alice"
    mutating func adjust() {
        simpleDescription += ".Dylan"
    }
}

var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

// extension 为现有的类型添加功能
//extension Int: ExamplepRrotocol {
//    var simpleDescription: String {
//        return "the number (self)"
//    }
//}

ok 大家又会有个提升。  加油喽