As developers, one of the most exciting milestones in our learning journey is venturing beyond our first programming language. After mastering the fundamentals of JavaScript, I decided to explore Swift, Apple's modern language for building iOS, macOS, watchOS, and tvOS applications. In this blog, I’ll compare JavaScript and Swift, highlighting key differences, commonalities, and tips for transitioning as a JavaScript developer.

Why Learn Swift?

Performance: Swift is designed to be fast. Unlike JavaScript, which relies on an interpreter in the browser or Node.js, Swift compiles directly into machine code. This makes Swift applications noticeably quicker and more efficient, especially for resource-intensive tasks.
Popularity and Ecosystem: Swift has gained immense popularity since its release in 2014. Supported by a robust Apple ecosystem, it continues to grow with frameworks like SwiftUI and Vapor. While it’s not as universal as JavaScript, its niche is highly valuable.
Career Opportunities: With the demand for mobile apps, iOS development provides rewarding career opportunities. Swift, as Apple's primary language for iOS, is essential for anyone looking to develop apps for iPhones, iPads, Macs, and even Apple Watches.

Key Differences Between Swift and JavaScript

Type System: Swift is statically typed, while JavaScript is dynamically typed. Swift's static typing ensures safer and faster code, catching errors at compile time, whereas JavaScript's dynamic typing gives more flexibility but can lead to runtime errors.

Runtime Behavior: Swift code compiles to machine code, enabling high-performance execution directly on Apple devices. JavaScript code, by contrast, runs within an engine (like V8 or JavaScriptCore), relying on interpretation or JIT compilation, making it more flexible but typically slower.

Essential Syntax: Data Types in Swift

Swift provides several basic data types to improve code reliability and type safety. Understanding how to declare and use these data types is critical for writing effective Swift code.

Swift is a statically typed language, meaning every variable and constant has a specific type determined at compile time. You must declare the type explicitly when creating a variable (e.g., var age: Int = 19) unless the compiler can infer it from the assigned value (e.g., var name = "Alice"). This ensures safer, more predictable code and allows for compile-time type checking and optimization.

var message: String
var isValid: Bool
var total: Int
// Statically typed
var name: String = "Alice" // A variable holding a string 
let age: Int = 19 // A constant holding an integer

In the example above:
name is declared as a string.
age is declared as an integer.

You can also use type inference, where Swift can figure out the type based on the assigned value:

var message = "Hello, Swift!"  // Type inferred as String
var isValid = true  // Type inferred as Bool
var total = 42  // Type inferred as Int

Assigning Values to Variables
Once you declare a variable with a type annotation, you must assign a value that matches that type. Swift will generate a compile-time error if the types do not match.

var total: Int = 42
total = "forty-two"  // Error: Cannot assign value of type 'String' to type 'Int'

Here, attempting to assign a string to the variable total, which is supposed to be an integer (Int), will result in an error.

Handling Incorrect Data Type Assignments
Since Swift is statically typed, it provides strong type checking at compile time, ensuring errors are caught early. For example, if you try to assign a value to a variable or pass an argument to a function with the wrong type, Swift will generate a compile-time error.

var total: Int = 42
total = "forty-two"  // Error: Cannot assign value of type 'String' to type 'Int'

Example: Swifts Type Safety in Action

Swift’s type safety ensures that the function will only accept values of the correct type. If you try to pass an argument of the wrong type, you will get a compile-time error.

func add(a: Int, b: Int) -> Int {
  return a + b
}

let result = add(a: 5, b: 10)  // Output: 15

let errorResult = add(a: 5, b: "Hello")  // Error: Cannot convert value of type 'String' to expected argument type 'Int'

Here, the function add only accepts integers. If you try to pass a string instead, Swift will generate an error, preventing the bug from occurring.

Functions
In Swift, functions require explicit type declarations for parameters and return values, ensuring type safety at compile time. For example, in func greet(name: String) -> String, the parameter and return type are clearly defined, preventing runtime errors from incorrect types. Unlike JavaScript, which allows any type without checks, Swift’s static typing catches errors early, improves code clarity, and enhances debugging and tooling support, making code more reliable and easier to read.

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

Arrays and Objects
JavaScript arrays and objects are more flexible, but Swift offers type safety.

In JavaScript:
let fruits = ["Apple", "Banana", "Cherry"];  
let person = { name: "Alice", age: 25 };  

Swift allows you to specify the types of collections like arrays and dictionaries to ensure consistent data types.

var fruits: [String] = ["Apple", "Banana", "Cherry"] // Array of strings
var person: [String: Any] = ["name": "Alice", "age": 25] // 

Dictionary with string keys and any type values

Commonalities with JavaScript

Object-Oriented Programming (OOP): Both languages support OOP concepts like classes, inheritance, and polymorphism.
Javascript:

// JavaScript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    return `Hello, I'm ${this.name}.`;
  }
}

const alice = new Person("Alice", 25);
console.log(alice.greet());  // Output: Hello, I'm Alice.

In Swift:

// Swift
class Person {
  var name: String
  var age: Int

  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }

  func greet() -> String {
    return "Hello, I'm \(name)."
  }
}

let alice = Person(name: "Alice", age: 25)
print(alice.greet())  // Output: Hello, I'm Alice.

Functions as First-Class Citizens: Both languages treat functions as first-class objects, meaning they can be passed around as arguments, returned from other functions, and assigned to variables.
JavaScript:

// JavaScript
function greet(name) {
  return `Hello, ${name}!`;
}

const greetUser = greet;
console.log(greetUser("Alice"));  // Output: Hello, Alice!

Swift:

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

let greetUser = greet
print(greetUser("Alice"))  // Output: Hello, Alice!

Tips for Learning Swift as a JavaScript Developer

Practice Regularly: Practice on a regular basis by participating in coding challenges and projects that require Swift. Websites like Leetcode, or even sample projects found on YouTube, can be extremely useful!

Use Swift Playgrounds: A great tool for experimenting with Swift code interactively. It's perfect for practicing Swift syntax and concepts before diving into full-scale app development.

Explore Documentation and Tutorials:

Apple dev documentations for swift
Full CodeCademy course

Conclusion

While JavaScript and Swift serve distinct purposes and ecosystems, they share many fundamental concepts, making the transition easier for developers who are familiar with JavaScript. Swift's speed, type safety, and deep integration with the Apple ecosystem make it an exciting language to learn for anyone interested in mobile or macOS development. Understanding the key differences and commonalities will help you master Swift!

Happy coding and have fun!