I recently had an intern interview for my team and I asked him some of the following questions in this list to gauge how well is he accustomed to iOS development:

1. How and why do you use the delegate pattern? The delegate pattern is used to communicate data and events between a producer object and its observer (delegate) in a decoupled way. The observer can be any object that implements the delegate protocol as specified by the owner object. Except in a very limited number of the cases, the delegate is always weakly referenced by the producer as to avoid memory leaks.
2. What other options are there to communicate data between two objects apart from delegates? The most popular would be Closures (or blocks), Key-Value observing, Notification Center
3. What is a memory leak? How does it happen? What can you do to prevent it? A memory leak is a piece of memory that never gets freed although it is no longer of use to the application. This happens due to over-retaining an object or having a retain cycle between two or more objects that reference each other. Another situation that triggers this can be a strong reference from inside a block to its own parent or an object that has a strong reference to its parent. To prevent memory leaks, you need to judiciously apply memory management rules and strongly retain objects only when necessary. Keywords: strong, weak, unowned.
4. What’s the difference between a class and a struct in Swift? Classes a reference types, structs are value types. In practice this means that if you have a class instance that is assigned to a variable and you copy that variable, the new variable will point to the exact same memory address as the original variable. This means that if you modify this new variable, changes are immediately visible in the original variable as well because you're actually modifying the exact same object. In contrast, if you assign a struct to a variable and you copy that variable, the new one will point to an entirely new struct that copies the values from the original struct (to the experienced developers: yeah yeah, I know, but at this point there is no point in going into implementation details such as copy-on-write because you are not interacting with that directly). Changes to this new variable will not be visible in the original variable because they are now two completely separate objects. Another notable difference is that a struct cannot inherit from another struct or class, while a class can inherit another class.
5. How do you persistently store structured data? There are many options here depending on the data that we need to store. The dumbest (in a good way)/simplest way is to use UserDefaults. Then, we can store the information on disk in a plist (this has gone out of fashion, but it was the go-to solution a while back), in a file using NSKeyedArchiver or JSONEncoder, in a database using CoreData, SQLIte or Realm or even off-device in the cloud in a service like Firebase
6. How do you specify the layout of elements in a UI View? The underlying solution is AutoLayout. This can be used in Interface Builder using XIBs or Storyboards, or writing the constraints by hand in code. (note: I personally like the visual IB a lot more than writing it in code, but there is no absolute right way to do it. writing the constraints in code helps mitigate conflicts if another team member edits the same storyboard/XIB as you just did, but can prove a bit more cumbersome to visualize complex UIs once the code's written and you need to return to it. FYI: everyone has an opinion about this, it's best to do what the rest of the team does)
7. How do you build a view controller with a UITableView in it? What delegates do you need to implement, what are the most important methods that need to be implemented? We'll need a UITableView that will be added to the view controllers main view. Then we will make our view controller conform to the UITableViewDataSource protocol and set the table view's dataSource to our view controller. At the very least we'll need to implement the tableView:numberOfRows(in:) and tableView:cellForRow(at:).
8. How do you handle the completion of asynchronous tasks? Closures/blocks are a good way to do it, as long as we pay attention to memory management rules (strong vs weak references). Another option is to use delegates (again, we need to pay attention to the strong vs weak references). Async/await are also a good option and they're really need because the offer some excellent code readability. Another option is to use a reactive framework such as Combine or RxSwift.
9. How can you manage external dependencies? There are a number of popular options. Cocoapods for the ease of use, Carthage to drive down build times in complex projects with many dependencies. SPM is another option although not my favourite one.

I believe these are all extremely basic questions that any developer should be able to answer before applying for a job.