编辑代码

import Foundation

/*:
# 1. OC中常见的for循环遍历 for(int i = 0; i < xx; i++)，Swift中如何写？
 */

var xx = 8

print("for版本1")
for i in 0..<xx {
    print(i)
}

print("for版本2")
for i in stride(from: 0, to: xx, by: 1) {
    print(i)
}

print("while版本1")
var i = 0
while i < xx {
    print(i)
    i += 1
}
print("while版本2")
i = 0
repeat {
    print(i)
    i += 1
} while i < xx

/*:
# 2. 下面哪种写法更符合Swift规范，为什么？
 ```
 1.
 let someCharacter = "z"
 switch someCharacter {
 case "a", "c":
     doSomething(someCharacter)
 default:
     print("Some other character")
 }
 
 2.
 let someCharacter = "z"
 switch someCharacter {
 case "c":
     fallthrough
 case "a":
     doSomething(someCharacter)
     break
 default:
     print("Some other character")
 }
```
 */

 print("第一种")
 /*
    此语句想表达的语境是，switch中a和c都调用doSomething处理
    而 fallthrough 关键字不会考虑下一个case的条件是否成立
    在第二种情况下，case "c" 和 case "a"的上下顺序必须紧挨
    而swift中switch无需添加break，且支持复合匹配
 */



/*:
# 3. 下面的if语句如何用switch语句重写？
```
 func findPoint(_ point: CGPoint) {
     if point.x <= 0 && point.y <= 0 {
         print("point at bottom left")
     } else if point.x <= 0 && point.y >= 0 {
         print("point at top left")
     } else if point.x >= 0 && point.y >= 0 {
         print("point at top right")
     } else if point.x >= 0 && point.y <= 0 {
         print("point at bottom right")
     } else {
         print("unknow")
     }
 }
```
 */
print("第一种方法")
var p = CGPoint(x: 2, y: 2)
switch p {
    case let point where point.x <= 0 && point.y <= 0:
        print("point at bottom left")
    case let point where point.x <= 0 && point.y >= 0:
        print("point at top left")
    case let point where point.x >= 0 && point.y >= 0:
        print("point at top right")
    case let point where point.x >= 0 && point.y <= 0:
        print("point at bottom right")
    default:
        print("unknow")
}

print("第二种方法")
let pp = (p.x, p.y)
switch pp {
    case (...0, ...0):
        print("point at bottom left")
    case (...0, 0...):
        print("point at top left")
    case (0..., 0...):
        print("point at top right")
    case (0..., ...0):
        print("point at bottom right")
    default:
        print("unknow")
}

/*:
# 4. 下面哪种写法更符合Swift代码风格，为什么？
 ```
 1.
 func test(_ someValue: Int?) -> Void {

     if someValue == nil {
         return
     }
     
     let notNilValue = someValue!
     print(notNilValue)
 }

 2.
 func test(_ someValue: Int?) {
     guard let someValue = someValue else { return }
     print(someValue)
 }
```
 */

 print("第二种")
 /*
    第一种可以用if let可选绑定去简洁一下，这个写法还是不够现代语言
    第二种利用了guard语句保证后续处理值不违规，切对违规情况显示处理
 */



/*:
# 5. 请问在OC中这样的方法声明，在Swift中会解析成什么样？（涉及一些混编知识，选做。）
 ```
 + (void)doSomethingWithIntValue:(NSInteger)intValue
                    doubleValue:(double)doubleValue
                        block:(void(^)(CGFloat value))block;
 ```
 */

/*  我根据swift中使用OC枚举的转换，猜的
    class func doSomething(intValue: NSInteger, doubleValue: double, block: (CGFloat) -> void);
*/



/*:
# 6. 请问以下代码有什么问题，如何改正？
 ```
 func somethingDeley(_ handle: () -> ()) {
    //相当于OC中的GCD的 dispatch_after
     DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
         handle()
     }
 }
 ```
 */

/*
    这里这个闭包应该声明为逃逸闭包，即加上@escaping关键字如：
    func somethingDeley(_ handle: @escaping () -> ())
    这里这个闭包被传入了延迟队列，将在该函数返回后被调用
*/


/*:
# 7. 请问以下代码会输出什么，为什么？
 
 var str = "123"

 let closure = {
     str += "456"
 }

 print(str)
 closure()
 print(str)
 
 */

 /* 输出：123456 
    因为这里闭包进行了值捕获
 */

/*:
# 8. 用Swift实现一个栈 FTSomeStack
 要求：包含入栈 stackPush 和 出栈 stackPop 的方法即可
 */

class FTSomeStack {
    var stack: [Int];
    func stackPush(_ newInt: Int) -> Bool {
        stack.append(newInt)
        return true
    }
    func stackPop(_ temp: inout Int) -> Bool {
        guard let myTemp = stack[stack.count - 1] else {
            return false
        }
        temp = myTemp
        stack.remove(at: stack.count - 1)
        return true
    }
    func showStack(){
        for item in stack {
            print(item)
        }
    }
    init() {
    // 在此处执行构造过程
    }
}

var myStack = FTSomeStack()

if myStack.stackPush(2) {
    myStack.showStack
}
if myStack.stackPush(4) {
    myStack.showStack
}
if myStack.stackPush(6) {
    myStack.showStack
}
var i = 0;
if myStack.stackPop(i) {
    myStack.showStack
    print(i)
}


/*:
# 9. 理解自动闭包的使用。
 - 闭包作为函数参数时，它的类型是什么
 - 自动闭包函数作为参数时，它的类型是什么
 -
 */

/*
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

//闭包作为参数
func serve(customer customerProvider: <#你的代码#>) {
    print("Now Serving \(customerProvider())!")
}
 
serve(customer: { customersInLine.remove(at: 0) } )  // 正常 此处的参数是啥
serve(customer:  customersInLine.remove(at: 0)  ) // 编译报错 为什么，如何才能这样调用

//自动闭包作为参数
func serveClosure(customer customerProvider: <#你的代码#>) {
    print("Now Serving \(customerProvider())!")
}

serveClosure(customer:  customersInLine.remove(at: 0)  )
*/