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

The Challenge

自2014年推出Objective-C以来，Swift一直在努力超越它. 作为iOS应用宝座上Objective-C的继承者, 它拥有新一代编程语言应该具备的一切. 它直观、互动、安全、快捷、可靠、省时、免费. Swift是为ipad设计的, iPhones, 以及所有其他苹果设备，并与Cocoa和Cocoa Touch框架完全兼容.

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

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

尽管Swift的发展在两年前才出现, 目前已经有一个庞大的开发人员社区，他们被认为是这方面的专家. However, 开发者和优秀开发者的区别在于他们的适应能力, learn, 与世界其他地方保持同步. 因为斯威夫特面临着一个光明的未来, 而且每年肯定会有很多新的更新, 一个伟大的开发者必须始终站在进化曲线的顶端. 找到这样的人才并不是一件容易的事. So, 这篇文章提供了一些问题的样本，这些问题对于评估候选人对Swift掌握的广度和深度至关重要.

问题与答案

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

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

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

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

问:解释一下Swift编程中类和结构的主要区别.

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

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

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

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

• 类是引用类型——当它们被分配给不同的属性时，它们不会被复制, 当它们被传递给函数时也是如此.
• 结构更快. 类实例在堆上分配，而结构实例在堆栈上分配.
• 结构不支持继承.
• 结构体为所有没有默认值的属性提供默认初始化式:

struct Person {
    let name: String
}

让patrik = Person(name: " patrik ")

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

问:解释Swift中的泛型.

复杂的应用程序需要没有任何重复的干净代码. 这里，泛型会派上用场，因为它们可以帮助我们避免不必要的重复. In general, 泛型被认为是Swift最复杂的特性之一, 而且应该尽可能多地使用它们. 它们使我们能够编写类和方法而不指定它们使用的类型. 只要有可能，Swift就会在内部使用泛型.

让我们看一下最好的例子之一，数组，因为它们可以存储任何类型. 在我们的例子中，我们将实现一个简单的数据结构， 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 仅在第一次调用存储属性时才计算存储属性. 有些情况下 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 变量包含一个print语句来演示底层发生的事情. 打了两次电话之后 let _ = myControllers，控制台日志中只有一条消息. 那是因为第二次 lazy 变量已经初始化，不需要再初始化一次.

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

在开始讨论之前, 我们需要提到有两种类型的变量:引用类型和值类型. 这两种类型的区别在于，通过传递值类型, 该变量将创建其数据的副本, 而引用类型变量将只指向内存中的原始数据.

在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 参数声明前的关键字和变量前的&号. 让我们考虑一个类似的例子:

函数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 块将在执行离开当前作用域的情况下执行. 考虑下面的代码，并尝试回答输出将是什么.

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 语句在每次循环迭代后执行. 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可以显著地帮助程序员避免重复，但了解它是至关重要的 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]

然而，用更优雅的方式编写更少的代码不是更好吗?

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 键，或应用程序中使用的颜色的调色板. 小项目不需要任何精确的规则来正常工作. 我们可以简单地使用如下代码:

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 {
    静态让appColor = UIColor(红色:34/255，绿色:36/255，蓝色: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 对于两个不同的属性. 此外，这种方式为我们提供了拼写检查，如果我们正确地编写了密钥. Also, 如果我们决定去掉一些键或颜色, 删除一行将告诉我们哪些文件使用了弃用的密钥. 在一个地方使用所有的钥匙有很多好处.

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

extension UIColor {
    struct MyProject {
        静态让appColor = UIColor(红色:34/255，绿色:36/255，蓝色:38/255,alpha: 1)
        静态让greyColor = UIColor(红色:130/255，绿色:130/255，蓝色: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应用程序开发人员来说都是小菜一碟. 事实上，Swift语言本身并不难学习和使用. However, 请记住，当越来越多的新更新发布和新功能加入时，你的专职开发者是否优秀就会显露出来. Swift的精通在于能够在尽可能短的时间内正确理解和应用新的应用程序开发原则，以保持应用程序的功能领先.

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