Hire the Top 3% of 自由Swift开发者

The Challenge

自2014年推出Objective-C以来，Swift一直在努力超越它. 作为iOS应用宝座上Objective-C的继承者, 它拥有新一代编程语言应该具备的一切. It’s intuitive, interactive, safer, faster, more reliable, time saving, and free. Swift是为ipad设计的, iPhones, 以及所有其他苹果设备，并与Cocoa和Cocoa Touch框架完全兼容.

最初的策略是通过展示新语言的所有优点，让开发人员自己迁移到新语言. 然而，Swift的第一个版本相当不稳定，漏洞百出，并且不能与Xcode完全兼容.

转折点出现在2015年12月，当时苹果对其新生儿的强烈偏好通过将其开源来证明, 发布带有补丁和更新的新大版本. Swift 2已经足够稳定，可以在应用程序中安全使用, 从而确保了它作为watchOS首选语言的地位, tvOS, and iOS development.

尽管Swift的发展在两年前才出现, 目前已经有一个庞大的开发人员社区，他们被认为是这方面的专家. However, the difference between a developer and a great developer is their ability to adapt, learn, 与世界其他地方保持同步. 因为斯威夫特面临着一个光明的未来, 而且每年肯定会有很多新的更新, a great developer has to be on top of the evolutionary curve all the time. 找到这样的人才并不是一件容易的事. So, 这篇文章提供了一些问题的样本，这些问题对于评估候选人对Swift掌握的广度和深度至关重要.

Questions and Answers

Q: Describe Swift. 这是一种什么样的语言啊? 它的主要福利是什么?

Swift is a compiling language whose source code is translated to machine code. 它与它的前身Objective-C和苹果的Cocoa框架完全兼容. 通过开源语言, 苹果明确表示，Swift不仅仅是一种用于移动应用程序的语言. New frameworks, like Perfect这些都是Swift成为服务器端语言的第一次尝试. 这样一来，Swift开发人员和全栈开发人员将能够使用同一种语言创建客户端和服务器端应用程序.

以下是Swift的一些主要优势:

• 可选类型，使应用程序抗崩溃
• 内置错误处理
• Closures
• 比其他语言快得多
• Type-safe language
• 支持模式匹配

Q: Explain the main differences between classes and structures in Swift programming.

类和结构是大多数编程语言的基本构建块. 然而，它们之间有区别. 为了在Swift中充分利用它们，我们需要了解它们提供的所有可能性. 有一些原则是每个开发者都应该知道并遵守的.

让我们从类和结构体共有的属性开始:

• 两者都符合协议，将功能标准化，以达到特定的目的，即接口.
• 两者都可以扩展其功能以添加额外的方法，而无需修改原始类或结构.

然而，比了解它们的共同点更重要的是了解它们的不同之处:

• 类是引用类型——当它们被分配给不同的属性时，它们不会被复制, 当它们被传递给函数时也是如此.
• 结构更快. Class instances are allocated on the heap, while structure instances are on the stack.
• 结构不支持继承.
• 结构体为所有没有默认值的属性提供默认初始化式:

struct Person {
    let name: String
}

让patrik = Person(name: " patrik ")

let patrik2 = Person() //不编译，name属性需要一个值

问:解释Swift中的泛型.

复杂的应用程序需要没有任何重复的干净代码. Here, generics come in handy as they can help us to avoid unnecessary duplication. In general, generics are considered as one of the most sophisticated features of Swift, 而且应该尽可能多地使用它们. They enable us to write classes and methods without specifying the types they use. 只要有可能，Swift就会在内部使用泛型.

Let’s have a look on one of the best example, arrays, as they can store any types. 在我们的例子中，我们将实现一个简单的数据结构， Queue，以演示泛型的强大和有用:

class Queue {
    
    private var data = [T]()
    
    函数enqueue(item: T) {
        data.append(item)
    }
    
    func dequeue() -> T? {
        return data.count == 0 ? nil : data.removeFirst()
    }
}

let q = Queue()

在这里，我们去掉了创建的需要 Queue 对于稍后将在应用程序中使用的其他类型. Our Queue 可以包含任何类型，我们可以在一个地方定义它吗. 它为我们节省了很多时间，否则我们会花在设置 Queue each time later.

Q: Explain the lazy keyword.

的初始值 lazy stored properties is calculated only when the property is called for the first time. 有些情况下 lazy 房地产对开发商来说非常方便. 假设该属性需要相当长的初始化时间, 就像在实例化storyboard的控制器数组时 UIPageViewControllers.

类MyController: UIPageViewController {
    
    lazy var myControllers: [UIViewController] = {
        print(“初始化”)
        让storyboard = self.Storyboard else {return []}
        让controller1 = storyboard.instantiateViewControllerWithIdentifier(“管理员一”)
        让controller2 = storyboard.instantiateViewControllerWithIdentifier(“Controller2”)
        让controller3 = storyboard.instantiateViewControllerWithIdentifier(“Controller3”)
        返回[controller1, controller1, controller1]
    }()
    
    重载函数viewDidLoad() {
        super.viewDidLoad()
        
        let _ = myControllers
        let _ = myControllers
    }
}

在我们的例子中，我们调用 myControllers two times in viewDidLoad (这只是为了测试目的，看看初始化是如何工作的). Our lazy variable contains a print statement to demonstrate what’s happening under the hood. 打了两次电话之后 let _ = myControllers，控制台日志中只有一条消息. 那是因为第二次 lazy variable is already initialized, and there is no need to do it once again.

问:讨论如何传递一个变量作为引用.

在开始讨论之前, we need to mention that there are two types of variables: reference and value types. 这两种类型的区别在于，通过传递值类型, 该变量将创建其数据的副本, and the reference type variable will just point to the original data in the memory.

在Swift中，所有的类实例都是引用类型. 带有类对象的变量只是指向内存的指针. 这同样适用于作为参数的函数. Consider the example:

类A: CustomStringConvertible {
    var name = "Patrik"
    var description:字符串{
        return name
    }
}

函数changeName(对象:A) {
    object.name = "Thomas"
}

let myObject = A()
changeName(myObject)
print(myObject) //

Here, an instance myObject is passed to the changeName 函数，并且不需要将参数标记为引用类型. Instead, 我们只需要知道它们在与不同参数类型一起使用时的一些行为规则. In this case, the print(myObject) will write “Thomas”.

结构、数组、字符串和字典都是值类型. 为了达到类似的效果，将变量作为引用类型传递给函数，我们需要添加 inout keyword before the parameter’s declaration and ampersand before the variable. 让我们考虑一个类似的例子:

函数changeFirstElement(输入输入:[Int]) {
    input[0] = 9
}

var array = [1, 2, 3]
changeFirstElement(&array)
Print (array) // [9,2,3]

Q: Explain what defer 是，什么时候应该使用它.

斯威夫特2介绍了新的 defer 关键字，该关键字提供了当外部块即将完成时将执行的代码块. We could say that defer block will be executed in the case when execution is leaving the current scope. 考虑下面的代码，并尝试回答输出将是什么.

func write() {
    延迟{print("end")}
    Print ("start for loop")
    for i in 0...5 {
        print(i)
    }
}

如前所述， defer 块将在函数的末尾执行，即使它是在 write() function.

输出结果将是:

start loop
0
1
2
end

现在来看一个更复杂的例子:

func write() {
    延迟{print("end")}
    print("start loop")
    for i in 0...2 {
        print(i)
        Defer {print(" Defer "， i)}
    }
}

The output is:

start loop
0
defer  0
1
defer  1
2
defer  2
end

值得注意的是 defer statement in the “for loop scope” is executed after each iteration of the loop. That’s because defer的父作用域是循环作用域.

Nesting defer block in if 语句也会做同样的事情 for loop.

函数write3(输入:Int) {
    if input > 0 {
        打印("数字大于零")
        Defer {print(" Defer positive")}
    }
    打印(“输入是”，输入)
}
write3(10)

The output is:

这个数大于零
defer positive
input is  10
这个数大于零
defer positive
input is  10

Using defers can significantly help programmers to avoid duplication, but it is crucial to know defer它的行为和执行时间. Simple print 函数可以验证开发人员是否理解问题.

问:为什么使用高阶函数更好? Explain with examples.

以另一个函数作为参数的函数, or return a function, as a result, 被称为高阶函数吗. Swift将这些函数定义为 CollectionType. 最基本的高阶函数是a filter. 它是数组上的一个函数，它接受另一个函数，该函数将用于返回数组的新过滤版本. 高级函数的主要目的是帮助我们在更短的时间内编写bug更少的代码. At first glance, 这些函数可能有点吓人, 但优秀的开发人员应该尽可能多地使用它们.

事实上，我们可以把一个函数放到另一个函数中，这样我们就可以把很多小函数组合成更大的函数. 如果我们意识到这一点，代码的可读性就会高得多.

假设我们有一个数字数组. 我们怎样才能只选择那些大于0的呢? 一个非常简单的方法是:

Let numbers = [- 10,4， - 3,5]
var positive = [Int]()
for n in numbers {
    if n > 0 {
        positive.append(n)
    }
}
Print (positive) // [4,5]

However, wouldn’t it be better to write less code and in a more elegant way?

Let numbers = [- 10,4， - 3,5]
令正=数.filter { (value: Int) -> Bool in
    return value > 0
}
Print (positive) // [4,5]

在上面的代码示例中， filter 函数将遍历每个值, and for each value, 它将把它作为当前值传递给回调函数. 然后，回调函数将返回一个布尔值，以确定该值是否应该在输出数组中.

Swift通过推断其参数的类型和返回值的类型，使我们能够使用更短版本的闭包. As a result, 当函数作为参数直接传递时，不需要编写完整的声明.

Let numbers = [- 10,4， - 3,5]
令正=数.filter { $0 > 0 }
Print (positive) // [4,5]

Swift还提供 map 函数，它返回一个包含所有新映射值的新数组，并且只有一行代码.

Let numbers = [- 10,4， - 3,5]
let strings = numbers.map { String($0) }
Print (strings) // ["-10"， "4"， "-3"， "5"]

要对数组中的所有值求和，有一个 reduce 高阶函数来帮助我们实现.

Let numbers = [- 10,4， - 3,5]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum) // -4

问:对应用程序设置进行分组以使项目尽可能干净的最佳实践是什么?

每个项目都包含一些自定义设置，如API密钥，名称 NSUserDefault 键，或应用程序中使用的颜色的调色板. Small projects do not require any precise rules for this to work properly. 我们可以简单地使用如下代码:

label.textColor = UIColor(红色:34/255，绿色:36.0/255，蓝色:38/255,alpha: 1)
NSUserDefaults.standardUserDefaults ().setBool(true, forKey: " istutorialshow ")

However, projects tend to grow, 应用程序的设计将会改变, 我们需要一个更好的系统来将“共享”数据集中在一个地方. 我们需要一种只改变一行代码的方法, 比如应用程序的颜色, 并在整个项目中恰当地传播.

有多种方法可以解决这个问题. 让我们来看看一个可能的解决方案:

struct Color {
    static let appColor = UIColor(red: 34/255, green: 36/255, blue: 38/255, alpha: 1)
    静态让greyColor = UIColor(红色:131.8/255, green: 131.8/255, blue: 131.8/255, alpha: 1.0)
}

struct Settings {
    struct NSUserDefaults {
        让istutorialconfigured = " istutorialconfigured "
    }
    struct APIKey {
        静态let织物= "xxx"
    }
}

通过将相似的属性包装在一起, 我们可以显著减少bug, 比如使用相同的钥匙 NSUserDefaults 对于两个不同的属性. Additionally, this way provides us a spell check if we wrote the key correctly. Also, 如果我们决定去掉一些键或颜色, 删除一行将告诉我们哪些文件使用了弃用的密钥. 在一个地方使用所有的钥匙有很多好处.

然而，我们知道创造 Color or Settings 结构在全局作用域级别并不是最好的方法, 因为它就像一个全局变量, 哪种做法不好. 我们应该将这些设置放入包装器中，然后将其与项目类型直接连接.

extension UIColor {
    struct MyProject {
        static let appColor = UIColor(red: 34/255, green: 36/255, blue: 38/255, alpha: 1)
        static let greyColor = UIColor(red: 130/255, green: 130/255, blue: 130/255, alpha: 1)
    }
}

扩展NSUserDefaults {
    struct MyProject {
        让istutorialconfigured = " istutorialconfigured "
    }
}

使用这些键的结果将是:

NSUserDefaults.standardUserDefaults ().setBool(true, forKey: NSUserDefaults.MyProject.isTutorialShown)
label.textColor = UIColor.MyProject.appColor

利用Swift扩展可以为我们提供一种复杂的方式来分组所有必要的设置，并使设计更简洁. 为所有扩展名创建一个单独的文件也是一个好主意, 然后，我们将得到设计更改比通过每个文件和手动更改颜色快得多.

Wrap Up

回答我们在本文中提到的问题对于任何顶级Swift应用程序开发人员来说都是小菜一碟. The truth is, the Swift language itself is not difficult to learn and use. However, 请记住，当越来越多的新更新发布和新功能加入时，你的专职开发者是否优秀就会显露出来. Swift的精通在于能够在尽可能短的时间内正确理解和应用新的应用程序开发原则，以保持应用程序的功能领先.

我们希望你发现这篇文章中提出的问题是你寻求顶级Swift应用程序开发专家的坚实基础. 在美国和国外找到这样高质量的兼职或全职职位的候选人是非常值得的, 因为它们无疑会对团队的生产力和结果产生重大的积极影响.