Syntax: Similarities between Kotlin and Swift

Kotlin and Swift serve as bridges in mobile development between Android and iOS. Thanks to their remarkable similarities, diving into the Android realm becomes easier if you're already versed in iOS.

In this article, you'll discover how these common elements simplify the transition and open up new possibilities in app development.

Declarative Syntax

Both Kotlin and Swift support a clear and concise syntax. Variable declarations in both languages are straightforward, with the type of a variable often inferred by the compiler.

Swift:

var name = "John"
let age = 30

Kotlin:

var name = "John"
val age = 30

String Interpolation

Both languages offer modern string interpolation, facilitating the embedding of variables within strings.

Swift:

let greeting = "Hello, \(name)"

Kotlin:

val greeting = "Hello, $name"

Function Definitions

Function definition in both languages is similar, with a clear focus on readability.

Swift:

func greet(name: String) -> String {
    return "Hello, \(name)"
}

Kotlin:

fun greet(name: String): String {
    return "Hello, $name"
}

Lambdas and Higher-Order Functions

Both languages support lambdas and higher-order functions, allowing for code blocks to be passed as arguments or returned by functions. This promotes a compact and flexible coding style.

Swift:

let names = ["Anna", "Bob", "Charlie"]
let lowercaseNames = names.map { $0.lowercased() }

Kotlin:

val names = listOf("Anna", "Bob", "Charlie")
val lowercaseNames = names.map { it.lowercase() }

Control Structures (if-else)

The use of `if-else` statements is similar in Kotlin and Swift, with both languages allowing `if-else` blocks to be used as expressions that return values.

Swift:

let score = 85
let grade = score >= 90 ? "A" : score >= 80 ? "B" : "C"

Kotlin:

val score = 85
val grade = if (score >= 90) "A" else if (score >= 80) "B" else "C"

Control Structures (when/switch)

Both Kotlin and Swift offer a powerful `switch` or `when` statement, enabling a variable to be checked against a series of conditions.

Swift:

let number = 2
switch number {
case 1:
    print("One")
case 2:
    print("Two")
default:
    print("Other")
}

Kotlin:

val number = 2
when (number) {
    1 -> print("One")
    2 -> print("Two")
    else -> print("Other")
}

Optional Types and Null Safety

Both languages emphasize safety in handling null values. Swift uses optional types, while Kotlin has a similar concept with nullable and non-nullable types to prevent runtime crashes due to null pointer exceptions.

Swift:

var optionalString: String? = "Hello"
print(optionalString) // Optional("Hello")
optionalString = nil

Kotlin:

var optionalString: String? = "Hello"
print(optionalString) // Prints "Hello"
optionalString = null

Extension Functions

Both Kotlin and Swift allow developers to extend existing classes with new functionalities without using inheritance or modifying the original class.

Swift:

extension String {
    func greet() -> String {
        return "Hello, \(self)"
    }
}
print("John".greet()) // "Hello, John"

Kotlin:

fun String.greet(): String {
    return "Hello, $this"


}
println("John".greet()) // Prints "Hello, John"

Classes and Data Structures

Both languages offer advanced capabilities for defining classes and data structures, including support for data classes (in Kotlin) or structures with similar capabilities (in Swift), simplifying the creation of models for data storage.

Swift:

struct Person {
    var name: String
    var age: Int
}
let person = Person(name: "John", age: 30)

Kotlin:

data class Person(val name: String, val age: Int)
val person = Person(name = "John", age = 30)

Pattern Matching

Both languages support advanced pattern matching techniques, simplifying work with complex data structures and making code more readable.

Swift:

let someValue: Any = "Hello"
switch someValue {
case let stringValue as String:
    print("It's a String: \(stringValue)")
default:
    print("It's something else")
}

Kotlin:

val someValue: Any = "Hello"
when (someValue) {
    is String -> print("It's a String: $someValue")
    else -> print("It's something else")
}

Practical Examples: Kotlin and Swift in Action

Having familiarized ourselves with the syntactic similarities between Kotlin and Swift, it's time to see these concepts in real programming situations. The following examples illustrate how you can apply the discussed concepts in your projects to create more efficient and clearer code structures.

Declarative Syntax: JSON Parsing

Swift:

struct User: Codable {
    var name: String
    var age: Int
}

let jsonData = """
{
    "name": "John",
    "age": 30
}
""".data(using: .utf8)!

let user = try? JSONDecoder().decode(User.self, from: jsonData)
print(user?.name ?? "Unknown") // "John"

Kotlin:

import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class User(val name: String, val age: Int)

val jsonData = """
{
    "name": "John",
    "age": 30
}
"""
val user = Json.decodeFromString<User>(jsonData)
println(user.name) // "John"

Lambdas and Higher-Order Functions: UI Events

Swift:

let button = UIButton()
button.addTarget(self, action: #selector(buttonClicked), for: .touchUpInside)

@objc func buttonClicked() {
    print("Button clicked!")
}

Kotlin:

val button = Button(this)
button.setOnClickListener { 
    println("Button clicked!") 
}

Optional Types and Null Safety: Data Access

Swift:

var users: [String]? = ["Anna", "Bob", "Charlie"]

if let users = users {
    print("Number of users: \(users.count)")
} else {
    print("No users available.")
}

Kotlin:

var users: List<String>? = listOf("Anna", "Bob", "Charlie")

println("Number of users: ${users?.size ?: "No users available."}")

These examples show how you can leverage the similarities between Kotlin and Swift to efficiently tackle similar tasks in both languages. By applying these patterns and techniques in your own projects, you can accelerate the development process and enhance the quality of your code.