Key features of the Swift programming language?

In this tutorial, you are about to learn about what is Swift, and what are the key features of the Swift programming language.

What is the Swift language?

Swift is a clean and concise programming language that is growing fast and becoming increasingly popular. Swift was initially used for iOS development but has become very popular for many other things like macOS, watchOS, and server-side development.

Basically, Apple introduced the Swift language as an open-source programming language as a replacement for Objective-C, C, and C++. The Swift language was created in 2014 and released publicly in 2015 by Apple Inc.

We can say Swift is a modern programming language like JavaScript, Kotlin, and Python. Its short syntax and easy readability make it a popular language, especially for Apple development. We can build apps for iOS 7+ and macOS 10.9+ versions.

What does Swift mean?

• A safe and easy-to-use language.

• Fast compared to other programming languages.

• A clean and concise programming language.

• Singular language for all platforms, not just iOS, but also macOS, watchOS, and tvOS.

• Compatible with Linux and Windows servers

What are the key features of the Swift language?

Swift language has many features which make swift an easy, safe, and strong programming language compare to other languages. Let’s understand some of the key features of Swift language −

Automatic Reference Counter (ARC)

In Swift, ARC determines which class instances are no longer in use and gets rid of them automatically. They are useful for reducing the memory footprint. Before ARC, developers had to manage memory manually and track reference counts for every class. ARC eliminates the need for developers to perform these tasks manually, which allows increased performance without lagging your memory.

Generics

In Swift, generics allow you to write flexible and reusable code that can work with any type. Using generics, we can write functions and types that are reusable and can work with any type.

Example

class GenericExample<T> {
   // property of T type
   var data: T
   init (data: T) {
      self.data = data
   }
   
   // method that return T type variable
   func getData() -> T {
   return self.data
   }
}

// initialize a generic class object with Int type
var intObj = GenericExample<Int>(data: 1620)
print("Generic Class returning: ", intObj.getData())

// initialize a generic class object with String type
var strObj = GenericExample<String>(data: "Tutorials Points")
print("Generic Class returning: ", strObj.getData())

Output

Generic Class returning:  1620
Generic Class returning:  Tutorials Points

Tuples and Multiple Values Return

In Swift, tuples allow us to create and share value in groups. You can return more than one value from functions using a tuple. In other languages like the C language, you can return multiple values using pointers or structures but in Swift, you can return multiple values as a single entity. Remember that tuples are a fixed set of elements arranged in an ordered sequence.

Example

// returning multiple values into a single entity called a tuple.
func tupleExample() -> (name: String, age: Int, score: Double) {
   return (name: "Sneha Sharma", age: 25, score: 9.2)
}
let studentDetails = tupleExample()
print("Student name: \(studentDetails.name), age: \(studentDetails.age), score: \(studentDetails.score)")

Output

Student name: Sneha Sharma, age: 25, score: 9.2

Advance Control Flow

Swift provides some advanced features to control flow in addition to control transfer statements. These are such as a do statement to introduce scope, a guard statement to handle conditions and errors, a defer statement to run clean-up actions, and a repeat statement to allow us to do a task in repeat mode with a dependent condition.

Example of guard statement

func guardExample() {
   let name: String? = "Amit Saxena"
   guard let nameString = name else {
      print("name is not found")
      return
   }
   print("Name found: \(nameString)")
}
guardExample()

Output

Name found: Amit Saxena

Closures unified with function pointers

Function pointers contain the address of a specific function and point to code vs. data. When using a function pointer, you signify a particular behavior by calling the function instead of writing code. Closures contain these function pointers. Swift’s nested functions mean that closures are unified with function pointers and can therefore take values from the functions enclosed within the closure.

Example

let names = ["Amit", "Sachin", "Sonali", "Rahul"]
let reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
   return s1 < s2
})
print("Reversed Names: \(reversedNames)")

Output

Reversed Names: ["Amit", "Rahul", "Sachin", "Sonali"]

Powerful Structures

In Swift, structs are more powerful with additional features like protocols, extensions, and methods. These features are very significant and make structs more useful when making apps.

An example of the structure with protocol

protocol StudentCafeteriaAccess {
   func hasCafeteriaAccess() -> Bool
   func requestForCafeteriaAccess()
}
struct Student: StudentCafeteriaAccess  {
   var name: String
   var grade: Int
   
   // MARK: - StudentCafeteriaAccess Methods
   func hasCafeteriaAccess() -> Bool {
      grade > 2 ? true : false
   }
   func requestForCafeteriaAccess() {
      // write code for requesting Cafeteria Access
   }
}
let student1 = Student(name: "Student 1", grade: 8)
print("Name: \(student1.name) and grade: \(student1.grade)")

Output

Name: Student 1 and grade: 8

Native Error Handling

In Swift, errors are thrown, caught, propagated, and handled at runtime.

Package Manager

In Swift 3.0+, Apple provides a tool called Swift Package Manager (SPM) that automates the process of installing, upgrading, configuring, and removing packages from apps. Using SPM, we can easily manage third-party library dependencies. If any library has a dependency on another one, SPM will handle it for you easily.

Fantastic Enumeration

Swift's enums offer a wide variety of features that can be used in different situations. It helps us write type-safe code that is error-free and easy to use. Swift's enums offer associated values, custom raw values, iterating over cases, cases as functions, etc.

Example

// An enum example with associated values.
enum NetworkEndpoint {
   case login(email: String, password: String)
   case register(params: [String: Any])
   case categoryList
   case logout(userId: String)
}
let loginEndpoint = NetworkEndpoint.login(email: "test@gmail.com", password: "test@123")
print(loginEndpoint)

Output

login(email: "test@gmail.com", password: "test@123")

Type Safety

When we create a variable and assign any kind of value to that variable. You cannot assign a new value of another type. Here, Swift will ensure type safety while writing code on a daily basis.

Example

var names = ["Amit", "Sachin", "Sonali", "Rahul"]
names.append(136)

Output

error: cannot convert value of type 'Int' to expected argument type 'String' names.append(136)

Playgrounds

Swift playground is a development environment released within Xcode. The Swift playground allows developers, students, and others to learn the Swift programming language without creating any projects. This app is available on iPad as well, so you can learn the Swift language more quickly. Basically, the playground app provides a run-time environment to run Swift code.

Conclusion

You learned about the key features of the Swift programming language. But apart of the above, there are so many features available in Swift language. So keep learning other things and do more practice on them.