Swift 基本语法(一)

1、语法知识点 使用playfround 进行的结果验证。工程创建方式 xcode->new->playground

import UIKit

var str = "Hello, playground"

// 1.never,guard 使用
func myFatalError() -> Never {
    print("!!!")
    fatalError() // 进行强制终止的错误
}

func mod(_ a: Int,_ b: Int) -> Int {
    guard b != 0 else {
        myFatalError()
    }
    return a%b
}

//mod(a: 2, b: 0)
mod(2, 3)

// 2.隐式可选型，变量可以承载nil，但是正常情况不应该承载nil
let a: Int! = 5
let b = a // b is Int?
let c: Int = a
let d = a + 0 // d is Int

// 3. #keyPath,forKeyPath 使用方式
let superviewColor = #keyPath(UIView.superview.backgroundColor)
let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
let label = UILabel(frame: CGRect(x: 0, y: 0, width: 100, height: 20))
view.backgroundColor = UIColor.blue
view.addSubview(label)
// 如下两种方式都可以取值
label.value(forKeyPath: superviewColor)
label.superview?.backgroundColor

// 4.index获取，key取值
let arr = [10,20,30,40,50]
let i = arr.startIndex
let next = arr.index(after: i)
let before = arr.index(before: next)

let j = str.startIndex
let k = str.index(j, offsetBy: 5) // k = 5
str[k]
str[j..<k]

// 5.定义泛型类型，子类或协议 .pi 使用
func square<T: FloatingPoint>(_ a: T) -> T { // T指定的泛型类型
    return (a).squareRoot()
}
let a: CGFloat = 4.0
let b: Float = 4.0
let d: Double = 4.0
square(a)
square(b)
square(d)
a * .pi
b * .pi
d * .pi

// 6.infinity 正无穷大
func findMin<T: FloatingPoint>(_ a: [T]) -> T? {
    var res = T.infinity

    for i in a {
        res = i < res ? i : res
    }
    return res
}
findMin([3,4,5,-1,-4])

// 7.nan(not a number)
let myNan = Double.nan;
myNan > 0
myNan <= 0
if myNan.isZero {
    print("nan")
}
myNan.isNaN

// 8.尾随闭包,map, ?? 空合运算符
let arr = ["12","16","15","no data","19","no data","18"]
let temp = arr.map { Double($0) ?? .nan }
let temp1 = temp.filter { !$0.isNaN }
temp1

// 9.自定义中缀运算符???,泛型，@atuoclosure 自动闭包
infix operator ???
//func ???<T>(option: T?, defaultValue:() -> T) -> T {
func ???<T>(option: T?, defaultValue:@autoclosure () -> T) -> T {
    if let value = option {
        return value;
    }
    return defaultValue();
}

func login() -> String? {
    print("login...")
    return nil;
}
// 参数默认值，强制解包(a!)
func loginGuest(_ a: String? = "bbb") -> String{
    print("guest...\(a!)")
    return "aaa"
}
//let flag = login() ??? "guest"
//let flag = login() ??? {"guest" }
let flag = login() ??? loginGuest()

// 10. where 3.0后去除，guard规范写法
let vector = (4,0)
if case (let x, 0) = vector , x > 2 && x < 5 {
    print("success")
}
func doMath(a: Int?, b: Int?,c: Int?) -> Int? {
    guard let a = a, let b = b, let c = c,
          a>0,b<0,c==0 else {
        return nil
    }
    return 0
}

//// 11. < 自定义的数组比较函数
func <(t1:(Int,Int),t2:(Int,Int)) -> Bool {
    print("score1 < score2")
    return true;
}

let score1 = (23,10)
let score2 = (23,11)

score1 < score2

// 12. forin,[starIndex...],where,switch， 值绑定，fallthrough,continue,break,标签跳转
let numbers = [100,1,2,3,5,-10,-2]
var sum = 0
outer: for num in numbers[1...] where num > 0 {
    switch num {
    case let x where x == 1:
        sum +=  num
        continue // 继续for循环
    case let x where x == 2:
        fallthrough // 继续执行next case。若是没有该语句，直接跳出switch
    case let x where x == 3:
        continue;
    default:
        break outer; // 跳出 outer
    }
    sum += num;
}
print("\(sum)")
// 13. inout 使用 地址传递
var number = 10
func add(_ num: inout Int) {
    num = 11
}
add(&number)

// 14. 函数重载->参数名称有关。和返回参数无关.print
func sum(_ :Int ,_ : Int) {

}
func sum(a:Int ,b: Int) {

}
func sum(a:Int , b: Int, _: Int) {

}
func sum(c: String...) {
//    for item in c {
//        print(item, separator: " ", terminator: "\t")
//    }
    print(1.0, 2.0, 3.0, 4.0, 5.0, separator: "...", terminator: "\n")
}
sum(1, 3)
sum(a: 1, b: 3)
sum(a: 1, b: 3, 4)
sum(c: "12","34","56")

// 15. 嵌套函数
func forward(_ forward: Bool) -> (Int) -> Int {
    func next(_ input: Int) -> Int {
        return input + 1
    }
    func previous(_ input: Int) -> Int {
        return input - 1
    }
    return forward ? next : previous;
}

forward(true)(5)
forward(false)(5)

 // 16. enum 基本用法,关联值,原始值
enum Direction {
    case north
    case south
    case east
    case west
}
//enum Direction {
//    case north, south, east, west
//}

var dir = Direction.north
dir = Direction.west
dir = .east
print(dir)

enum Score {
    case points(Int)
    case grade(Character)
}
var score = Score.points(12)
//score = .grade("A")
let i = 0
switch score {
case let .points(i):
    print(i,"points")
case let .grade(i):
    print("grade",i)
}
// 关联值
enum Date {
    case digit(year: Int, month: Int, day: Int)
    case string(String)
}
var date = Date.digit(year: 2020, month: 10, day: 26)
//date = .string("2020-10-26")
switch date {
case .digit(let year, let month, let day):
    print(year,month,day,separator:"/")
case let .string(value):
    print(value)
}

// 原始值
enum Direction : String {
    case north = "north1"
    case south = "south1"
    case east = "east1"
    case west = "west1"
}
print(Direction.north.rawValue)
print(Direction.south.rawValue)

enum Direction1 : Int {
    case north = 1
    case south
    case east = 5
    case west
}
print(Direction1.north.rawValue)
print(Direction1.east.rawValue)
print(Direction1.west.rawValue)

// 递归枚ji
indirect enum ArithExpr {
    case number(Int)
    case sum(ArithExpr,ArithExpr)
    case diff(ArithExpr,ArithExpr)
}
enum ArithExpr {
    case number(Int)
    indirect case sum(ArithExpr,ArithExpr)
    indirect case diff(ArithExpr,ArithExpr)
}
func calculate(_ expr: ArithExpr) -> Int {
    switch expr {
    case let .number(value):
        return value
    case let .sum(left , right):
        return calculate(left) + calculate(right)
    case let .diff(left, right):
        return calculate(left) - calculate(right)
    }
}
let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let diff = ArithExpr.diff(five, two)
calculate(sum)
calculate(diff)