Swift 學習- 01 -- 基礎部分

標籤：gre   ack   list   fan   oda   完全   函數返回   orange   rem   

print("世界,你好")

 

var myVariable = 42

myVariable = 50

let myConstant = 42

 

let implicitinteger = 70

let  fffffff = 70.0

let exnfjenb: Double = 80

 

let changliang: Float = 4

var frewf: Double = 5

print(changliang)

 

 

let  label = "你哦好的"

let width = 94

let widthlabel = label + String(width)

 

let label2 = "1234565"

let heught: Int = 88

let all = String(heught) + label2

 

let apples = 3

let oranges = 5

 

let appleCount = "I have \(apples) apples"

 

let  fruitCount = "i have \(oranges) oranges"

print(fruitCount)

 

let fudina: Double = 402.0840000

let helloStr = "nihao de \(fudina) nihao"

print(helloStr)

 

 

var shoplist = ["apple","oranges","banage","blueanj"]

shoplist[1] = "bbbbbb"

shoplist .removeAll()

if shoplist.count > 2 {

    print(shoplist[1])

}else{

    print("數組為空白")

}

 

var dictionary = ["aaa":"AAA","bbb":"BBB"]

var emptyArray = [String]()

 

let individualScores = [12,23,34,45,56]

 

var teamScores = 0

for score in individualScores {

    if score > 20 {

        teamScores += 3

    }else{

        teamScores += 1

    }

}

 

print(teamScores)

 

// 在 if 語句中  條件必須是一個bool值,這意味著 判斷不會隱形的與 0 做對比

// 你可以一起使用 if 與 let 來處理值確實的情況,這些值將由可選值來代表

// 一個可選值是一個具體的值或者是 nil 以表示值缺失,在類型後面加一個問號來標記這個變數的值是可選的

 

 

var optionalName: String? = "John Appleseed"

optionalName = nil

var greeting = "Hello!"

if let name = optionalName {

    greeting = "Hello, \(name)"

}else{

    greeting = "Hello!,(杜露茜)"

}

 

print(greeting)

 

 

// 如果變數的可選值是nil,條件會判斷為false , 大括弧中的代碼會被跳過,如果不是nil ,會將值解包並賦給 let 後面的常量,這樣代碼中就可以使用這個值了

 

 

// 還有一種處理可選值的方法就是通過使用 ?? 操作符來提供一個預設值,如果可選值缺失的話,可以使用預設值來代替

 

let nickName: String? = "dingzhiije"

let fullName: String = "DingZhijie"

let myName = "my name is \(nickName ?? fullName)"

print(myName)

 

 

// switch 支援任意類型的資料以及各種比較操作--不僅僅是整數以及測試相等

 

let vegetrabel = "red pepper"

switch vegetrabel {

case "red pepper":

    print("red")

case "black":

    print("black")

default:

    print("no")

}

 

// swift 中 運行 switch 的時候 運行完匹配完的子句之後,程式會退出 switch 語句,並不會向下運行,所以不需要再每個子句之後寫 break;

 

 

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

var largestKey: String = ""

 

for (kind,numbers) in interestingNumbers {

    for number in numbers {

        if number > largest {

            largest = number;

            largestKey = kind

        }

    }

}

 

print(largest)

print(largestKey)

 

 

var num = 0

var addNum = 0

 

while num < 101 {

    addNum = addNum + num

    num += 1

}

print(addNum)

 

 

// 迴圈條件也可以在結尾迴圈一次,至少會迴圈一次

// repeat 迴圈語句

var m = 2

repeat { // 重複

    m = m * 2

} while m < 100

    print(m)

 

// 可以再迴圈中使用 ..< 來表示範圍

 

var total = 0

for i in 0 ..< 4 {

    total += 1

    print(i)

}

 

 

// a ..< b 的範圍是  大於等於 a , 但是小於 b

// a ... b 的範圍是  大於等於 a , 而且小於等於 b

// 這是因為 ..< 建立的範圍不包含上界, 但是 ... 建立的範圍包含上界

 

// 使用 func 來聲明一個函數,使用名字和參數來調用函數, 使用 -> 來指定函數的傳回值的類型

 

func green(person: String, day: String) -> String {

    return "hello \(person), today is \(day)"

}

 

print(green(person: "houdecheng", day: "2017-5-5"))

 

 

func eat(person: String, eatWhat: String) -> String {

    return "hello, \(person), my today wat\(eatWhat)"

}

 

print(eat(person: "houdehcneg", eatWhat: "danchaofan"))

 

 

// 預設情況下,函數使用它們的參數名稱作為它們參數的標籤, 在參數名稱前面可以自訂參數標籤, 或者使用 _ 表示不使用參數標籤

 

func ceshi( _ person: String,on day: String) -> String{

    return "hello, \(person), today is \(day)"

}

 

print(ceshi("houdehceg", on: "2017-5-5"))

 

 

// 使用元組讓函數返回多個值,元組的元素可以用名稱或者數字來表示

 

func yuanzuceshi(scores: [Int]) -> (min: Int,max: Int, sum: String){

    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;

    }

    let sumStr: String = String(sum)

    

    

    return (min,max,sumStr)

}

 

print(yuanzuceshi(scores: [15,54,45,54,78,15,6,98]))

 

// 函數可以帶有可變個數的參數,這些參數在函數內表現為數組的形式

 

func kebiancanshu(numbers: Int...) -> Double {

    var sum = 0

    for i in numbers {

        sum += i

    }

    

    let pingjunzhi: Double = Double(sum)/Double(numbers.count)

    

    

    

    return pingjunzhi

}

 

print(kebiancanshu(numbers: 4,3,5,6))

 

// 函數可以嵌套 , 被嵌套的函數可以訪問外側函數的的變數 你可以使用嵌套函數來重構一個太長或者太複雜的函數

 

func returnFifteen() -> Int{

    var y = 10

    func add(){

        y += 5

    }

    

    add()

    return y

}

 

print(returnFifteen())

 

// 函數是第一等類型  這意味著函數可以作為另一個函數的傳回值

 

func addOne(number: Int,str: String) -> Int{

    return Int(str)! + number

}

 

func makeIncrmenter() -> ((Int,String) -> Int) {

    return addOne(number:str:)

}

 

var increment = makeIncrmenter()

print(increment(88,"44"))

 

 

// 函數也可以當做參數傳入另一個函數

 

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

}

 

let numbers = [20,19,7,12]

let dictionary2: Dictionary = ["1":45,"2":43]

 

 

print(hasAnyMatches(list: numbers, condition: lessThanTen(number:)))

 

 

// 函數實際上是一種特殊的閉包, 他是一段之後能調用的代碼.閉包中的代碼能訪問閉包所建立範圍中能得到的變數和函數,即使閉包是在一個不同的範圍被執行的 - 可以使用 {} 來建立一個匿名閉包, 使用 in 將參數和傳回值類型與閉包函數體進行分離

 

print(numbers.map { (number: Int) -> Int in

    let result = 3 * number

    return result

})

 

// 有很多種建立更簡潔的閉包的方法,如果一個閉包的類型已知,比如作為一個回呼函數,你可以忽略參數的類型和傳回值,單個語句閉包會把它語句的值當做傳回值返回

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

//print(mappedNumbers)

 

let mappendNumbers = numbers.map { (number: Int) -> Int in

    let result = 3 * number

    return result

}

print(mappendNumbers)

 

// 可以通過參數的位置而不是參數的名稱來引用參數 -- 這個方法在非常短的閉包中非常有用,當一個閉包作為最後一個參數傳給函數的時候,他可以直接在括弧後面,當一個閉包是傳給函數的唯一參數,你可以完全忽略括弧

 

let sortedNumbers = numbers.sorted { (a, b) -> Bool in

    a > b

}

 

print(sortedNumbers)

 

 

// 字典的排序

let dicSorted = dictionary2.sorted { (a, b) -> Bool in

    a.value > b.value

}

 

print(dicSorted)

 

 

// 對象和類

// 使用 class 和類名建立一個類. 類中屬性的聲明和變數,變數聲明一樣,唯一的區別就是他們的上下文是類,同樣,方法核函式宣告也一樣

 

class Shape {

    var numberOfSides = 0

    func simpleDescription() -> String {

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

    }

}

 

// 要建立一個類的執行個體,在類名後面加上括弧,使用點文法來訪問執行個體的屬性和方法

var shape = Shape()

shape.numberOfSides = 7

print(shape.simpleDescription())

 

 

 

class MyDay{

    let day = "2017年 5月 5號"

    func prienDay(day: String) -> String {

        return "今天是 \(day)"

    }

}

 

 

var mydays = MyDay.init()

print(mydays.prienDay(day: mydays.day))

 

// 這個版本的 Shape 缺少了一些重要的東西,一個建構函式來初始化執行個體,使用 init 來建立一個構造器

class NamedShape{

    var numberOfSides: Int = 0

    var name: String

    init(name: String) {

        self.name = name

    }

    

    func simpleDecription() -> String {

        return "A shape with \(numberOfSides) \(name) sides"

    }

}

 

var nameShpe = NamedShape.init(name: "houdehcneg")

print(nameShpe.simpleDecription())

 

 

// 注意 self 被用來區別執行個體變數,當你建立的時候,像傳入函數參數一樣給類擦混入構造器的參數,每個屬性都需要賦值 -- 無論是通過聲明 (例如 numberOfSides) 還是通過構造器 (例如 name)

 

// 如果你需要在刪除對象之前進行一些清理工作, 使用 deinit 建立一個拆構函數

 

// 子類的定義方法是在他們的類名後面加上父類的名字,用冒號分割,建立類的時候並不需要一個標準的跟類,所以你可以忽略父類

 

// 子類如果需要重寫父類的方法,需要用 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 simpleDecription() -> String {

        return "A squre with side of length \(sideLength) \(numberOfSides)"

    }

    

}

 

let test = Square.init(sideLength: 5.2, name: "my test squre")

print(test.area())

print(test.simpleDecription())

 

class Circle: NamedShape{

    var banjing:Double

    

    init(banjing: Double,name: String) {

        self.banjing = banjing

        super.init(name: name)

        

    }

    

    func area() -> Double {

        return self.banjing

    }

    

    override func simpleDecription() -> String {

        return "\(banjing),\(numberOfSides),\(name)"

    }

}

 

var circle = Circle.init(banjing: 2.0, name: "dinngzhijie")

 

print(circle.area())

print(circle.simpleDecription())

Swift 學習- 01 -- 基礎部分