MVVM Design Pattern in Swift

Samith Wijesinghe — Sun, 11 Dec 2022 03:16:12 +0000

MVVM stands for Model-View-ViewModel. It is a design pattern used for building user interfaces, particularly for mobile applications. The idea behind MVVM is to separate the logic of an application from its user interface.

In the MVVM pattern, the ViewModel acts as a middleman between the View and the Model. The ViewModel exposes data and commands that are specific to the view, and it also translates data and commands from the view into actions that can be handled by the model. This helps to keep the view and the model separate, and it makes it easier to test and maintain the code.

Here is a brief overview of the roles of each component in the MVVM pattern:

Model: The model represents the data and business logic of the application. It is responsible for managing the data and providing access to it for the rest of the application.
View: The view is the user interface of the application. It is responsible for displaying the data and accepting user input.
ViewModel: The ViewModel acts as a middleman between the view and the model. It exposes data and commands that are specific to the view, and it translates data and commands from the view into actions that can be handled by the model.

In Swift, the MVVM pattern can be implemented by using object-oriented programming techniques, such as classes, structs, and protocols. There are many different ways to implement the MVVM pattern in Swift, and the specific details of how it is implemented can vary depending on the needs of the application.

Here is an example of how MVVM implemented in a simple Swift app that displays a list of users:

First, we would create a User model that holds the data for each user, such as their name and email address:

struct User {
let name: String
let email: String
}

Next, we would create a UserViewModel that converts the User data into a form that can be easily displayed in the View:

struct UserViewModel {
let user: User

var name: String {
return user.name
}

var email: String {
return user.email
}
}

In the View, we would use the UserViewModel to populate the user interface elements:

class UserListViewController: UIViewController {
var userViewModels: [UserViewModel] = []

// MARK: - View Lifecycle

override func viewDidLoad() {
super.viewDidLoad()
setupTableView()
}

// MARK: - User Interface

private func setupTableView() {
let tableView = UITableView()

// Set the data source and delegate for the table view
tableView.dataSource = self
tableView.delegate = self

// Register the custom cell class for the table view
tableView.register(UserCell.self, forCellReuseIdentifier: "UserCell")

// Add the table view to the view hierarchy
view.addSubview(tableView)
}
}

extension UserListViewController: UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return userViewModels.count
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
// Dequeue a reusable cell for the table view
let cell = tableView.dequeueReusableCell(withIdentifier: "UserCell", for: indexPath) as! UserCell
// Get the user view model for the current row
let userViewModel = userViewModels[indexPath.row]

// Configure the cell with the user view model data
cell.configure(with: userViewModel)

return cell
  }
}

In this example, the UserListViewController acts as the View, using the UserViewModel to populate the table view with data from the User model. This separation of concerns allows the presentation logic to be easily tested and maintained without affecting the data model.

Functions in Swift

Samith Wijesinghe — Sun, 24 Jul 2022 09:25:00 +0000

In this post we will have a in depth look into following points in functions.

Basics of functions
Function parameters
Advance parameter handling
Overloading
Functions as variables
island of no returns

functions are consider as a core part of many programming languages. if we have a simple explanation about what is function, it lets you define block of code that perform a some kind of task.when ever your app need to execute a task you can call the function and run it other than copy and paste the same code block over and over again.

In here we will see how the swift will use functions and how it make easier to use it.

Basics of functions

lets say you want to greet the user when he open your app.you can write a function to doing that.

func greetings(){
print("Wellcome to app")
}

above code is known as a function declaration. we define a function using a func keyword. after that comes name of the function.followed by the parentheses. all the inputs that going inside the function is come between these parentheses. after parentheses comes an opening braces followed by the code you want to run in the function, followed by a closing bracket.

you can call you functions as follows.

greetings()

this will print out the following.

Wellcome to the app

Function parameters

In the previous example we see function simply prints out a message. but sometime we need parameterize our function.that function perform differently according to the passing data via it's parameters.

let's consider the following example.

func printthewellcome(name: String){
print("Hello, \(name)")
}

printwellcome(name: "John")

In here you can see definition of one parameter inside the parentheses after function name. parameter named as "name" and value type is a string.
In any function, the parentheses contains what's known as a parameter list.
you need to add parentheses even the parameter list is empty to invoke the function.
in this example we pass the name "John" to the function. so you can say function with an argument "john". > Don't confuse the terms parameter and Argument. a function declare its parameters in its parameter list. when you call a function, you provide values as arguments for the functions parameters.

Also you can add multiple parameters feel the function like more general

func printAdditionOf(firstNo: Int, andSecondNo: Int){
print("\(firstNo) + \(secondNo) = \(firstNo + andSecondNo)")
}

printAdditionOf(firstNo: 4, andSecondNo: 5)

in swift you should try to make your functions calls and read like a sentence. in previous example you can read the last code line like this

print addition of firstNo 4 and secondNo 5

we can make this even better by giving a parameter a different external name. in here we can change the name of the andSecondNo parameter:

func printAdditionOf(firstNo: Int, and SecondNo: Int){
print("\(firstNo) + \(secondNo) = \(firstNo + andSecondNo)")
}

printAdditionOf(firstNo: 4, and: 5)

you can assign different external name by writing in front of the parameter name.

Advance parameter handling

functions parameters are constant by default. that means they can not be modified.

let's take below code snippet as an example.

func incerementAndPrint(_ value: Int){
    value += 1
    print(value)
    }

it's gives us the error saying Left side of mutating operator isn't mutable: 'value' is a 'let' constant

this explain the previous point. that the all the parameters are constant by default.

the important fact that we have to remember here is to swift follows the pass by value behavior.

pass by value means swift copies the value before passing it to the function. we need this type of behaviour in swift that functions doesn't alter it parameters. if it did then you can not be sure about the parameter values and you can make incorrect assumptions about your code.leading to the wrong idea.

sometimes we need to let functions to change their parameter directly. this can be done by using the behavior known as [[call by value result]]. let see this concept with an example.

    func incrementAndPrint(_ value: inout Int){
    value += 1 
    print(value)
    }

this inout keyword indicates that this parameter should be copied in,local copy used within the function and then copied back out when the function returns.

when you calling for the function that using this behavior you need to add ampersand(&) before the argument.

var value = 5
incrementAndPrint(&value)
print(value)

now the function can change the value however its want.

DEV Community: Samith Wijesinghe

MVVM Design Pattern in Swift

Functions in Swift

Basics of functions

Function parameters

Advance parameter handling