Free AI web copilot to create summaries, insights and extended knowledge, download it at here

10725

Abstract

ss="hljs-operator">= greet(name: "Bytefer", greeting: "Greetings") let defaultGreeting = greet(name: "Bytefer") print(customGreeting) print(defaultGreeting)

/** Output: Greetings, Bytefer! Hello, Bytefer! */</pre></div>TypeScript Code<div id="88e9"><pre>function greet(name: string, greeting?: string): string { if (greeting) { return ${greeting}, ${name}!; } else { return Hello, ${name}!; } }

const customGreeting: string = greet("Bytefer", "Greetings"); const defaultGreeting: string = greet("Bytefer"); console.log(customGreeting); console.log(defaultGreeting);

/** Output: "Greetings, Bytefer!" "Hello, Bytefer!" */</pre></div><h1 id="5a27">Define variadic parameters</h1>Variadics allow a function to accept a variable number of parameters. In Swift, variadic parameters are declared by adding an ellipsis <code>…</code>after the parameter type.Swift Code<div id="85e2"><pre>func calculateSum(_ numbers: Double...) -> Double { return numbers.reduce(0, +) }

let sum = calculateSum(4, 5, 6) print("Sum: (sum)")

// Output: Sum: 15.0</pre></div>The function calculateSum accepts a variadic parameter <code>numbers</code>, which means it can accept a variable number of Double parameters. The underscore <code></code> indicates that we can omit the external naming of this parameter when calling the function, making the call more concise.<div id="b9f8"><pre>let sum = calculateSum(4, 5, 6)</pre></div>In this call, we pass the number directly to calculateSum without specifying a parameter name. Without the underscore <code></code>, the call would look like this:<div id="3d6a"><pre>func calculateSum(numbers: Double...) -> Double { return numbers.reduce(0, +) }

let sum = calculateSum(numbers: 4, 5, 6)</pre></div>TypeScript Code<div id="e96d"><pre>function calculateSum(...numbers: number[]): number { return numbers.reduce((sum, num) => sum + num, 0); }

const sum = calculateSum(4, 5, 6); console.log(Sum: ${sum});

// Output: "Sum: 15"</pre></div><h1 id="c016">In-out Parameters</h1>In Swift, function parameters can be declared as in-out parameters, which means that they can be changed by the function and these changes will be retained after the function call ends. This feature is useful in situations where you need to change the value of a parameter within a function.<div id="c482"><pre>// Update the quantity of a certain item in the shopping cart func updateCart(_ cart: inout [String: Int], forProduct product: String, quantity: Int) { // If the product already exists, update the quantity; // otherwise, add a new product if let existingQuantity = cart[product] { cart[product] = existingQuantity + quantity } else { cart[product] = quantity } }

// Initialize shopping cart var shoppingCart = ["Apple": 3, "Banana": 2, "Orange": 1]

print("Before Update: (shoppingCart)")

// Call the function and pass in-out parameters updateCart(&shoppingCart, forProduct: "Banana", quantity: 3)

print("After Update: (shoppingCart)")

/** Output: Before Update: ["Apple": 3, "Banana": 2, "Orange": 1] After Update: ["Apple": 3, "Banana": 5, "Orange": 1] */</pre></div>If the <code>inout</code> keyword is removed from the <code>cart</code> parameter, the Swift compiler will prompt the following error message.<figure id="930c"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*D6_RGB9ujvtX6oeTkcwmvQ.png"><figcaption></figcaption></figure><h1 id="a8a8">Returns multiple values</h1>Functions in Swift can return multiple values, effectively returning a tuple containing multiple values.Swift Code<div id="3592"><pre>func getPersonInfo() -> (name: String, age: Int) { return ("Bytefer", 30) }

let personInfo = getPersonInfo() print("Name: (personInfo.name), Age: (personInfo.age)")

// Output: Name: Bytefer, Age: 30</pre></div>TypeScript Code<div id="8447"><pre>function getPersonInfo(): [string, number] { return ["Bytefer", 30]; }

const personInfo: [string, number] = getPersonInfo(); console.log(Name: ${personInfo[0]}, Age: ${personInfo[1]});

// Output: "Name: Bytefer, Age: 30"</pre></div><h1 id="1ce3">Function Types</h1><h2 id="ca53">1. Declare function type</h2>In Swift, when declaring a function type, you need to specify the parameter types and return type.Swift Code<div id="8923"><pre>func add(_ a: <span c

Options

lass="hljs-type">Int, _ b: Int) -> Int { return a + b }

// Declare a variable of function type var mathFunction: (Int, Int) -> Int

// Assign function to variable mathFunction = add

// Calling a function using a function type variable let result = mathFunction(2, 3) print("Result: (result)")

// Output: Result: 5</pre></div>TypeScript Code<div id="303c"><pre>function add(a: number, b: number): number { return a + b; }

// Declare a variable of function type let mathFunction: (a: number, b: number) => number;

// Assign function to variable mathFunction = add;

// Calling a function using a function type variable const result: number = mathFunction(2, 3); console.log(Result: ${result});

// Output: "Result: 5"</pre></div><h2 id="6864">2. Function type as parameter type</h2>Swift Code<div id="fdbb"><pre>func add( a: Int,  b: Int) -> Int { return a + b }

// Define a function that executes a function func executeMathOperation( a: Int,  b: Int, _ operation: (Int, Int) -> Int) -> Int { return operation(a, b) }

// Call the function and pass the add function as parameter let result = executeMathOperation(2, 3, add)

print("Result: (result)")

// Output: Result: 5</pre></div>TypeScript Code<div id="0f3e"><pre>function add(a: number, b: number): number { return a + b; }

// Define a function that executes a function function executeMathOperation(a: number, b: number, operation: (a: number, b: number) => number): number { return operation(a, b); }

// Call the function and pass the add function as parameter const result = executeMathOperation(2, 3, add); console.log(Result: ${result});

// Output: "Result: 5"</pre></div><h2 id="aed3">Function type as the type of return value</h2>Swift Code<div id="10dd"><pre>func add( a: Int,  b: Int) -> Int { return a + b }

// Define a function that returns an addition function func getAdditionFunction() -> (Int, Int) -> Int { return add }

// Get the addition function and call let additionFunction = getAdditionFunction() let result = additionFunction(2, 3) print("Result: (result)")

// Output: Result: 5</pre></div>TypeScript Code<div id="1e0c"><pre>function add(a: number, b: number): number { return a + b; }

// Define a function that returns an addition function function getAdditionFunction(): (a: number, b: number) => number { return add; }

// Get the addition function and call const additionFunction: (a: number, b: number) => number = getAdditionFunction(); const result: number = additionFunction(2, 3); console.log(Result: ${result});

// Output: "Result: 5"</pre></div>In this article, we introduce how to define functions, optional parameters, variadic parameters, in-out parameters, and function types in Swift. By comparing it to TypeScript syntax, we hope to help you better understand the features of Swift. If you want to learn Swift, follow me on <a href="https://medium.com/@bytefer">Medium</a> or <a href="https://twitter.com/Tbytefer">Twitter</a> to read more about Swift and TS!<div id="1440" class="link-block"> <a href="https://medium.com/@bytefer/list/688ee7c12807"> <div> <div> <h2>Mastering TypeScript Series</h2> <div><h3>This series will introduce the core knowledge and techniques of TypeScript in the form of animations.</h3></div> <div>medium.com</div> </div> <div> <div style="background-image: url(https://miro.readmedium.com/v2/resize:fit:320/0*624748c44fc686389a9ed7259663c489edb2ceb7.jpeg)"></div> </div> </div> </a> </div><h1 id="fc03">Stackademic</h1>Thank you for reading until the end. Before you go:<ul><li>Please consider clapping and following the writer! 👏</li><li>Follow us on <a href="https://twitter.com/stackademichq">Twitter(X)</a>, <a href="https://www.linkedin.com/company/stackademic">LinkedIn</a>, and <a href="https://www.youtube.com/c/stackademic">YouTube</a>.</li><li>Visit <a href="http://stackademic.com/">Stackademic.com</a> to find out more about how we are democratizing free programming education around the world.</li></ul></article></body>

Swift Tutorials for Front-end Developers: Functions

Master Swift in 2024 and Start Developing Your Own iOS/macOS App

Welcome to the Mastering Swift tutorial series, in this article we will introduce optional parameters, variadic parameters, in-out parameters, and function types in Swift. If you still need to install Xcode and configure your Swift development environment, please read the following article first.

Swift Tutorials for Front-end Developers: Getting Started

Master Swift in 2024 and Start Developing Your Own iOS/macOS App

medium.com

Next, we launch Xcode and select “File” > “New” > “Playground”. Create a new Playground and name it “Functions”.

Define and call functions

In Swift, functions are defined using the func keyword, which allows you to specify parameters and return type. In TypeScript, functions are defined using the function keyword.

Swift Code

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

let greetingMessage = greet(name: "Bytefer")
print(greetingMessage)

// Output: Hello, Bytefer!

In Swift, string interpolation is accomplished by including variables or expressions in a string and using the \() syntax. In TypeScript, we use backquotes (``) to create template strings and the ${} syntax to insert variables or expressions.

TypeScript Code

function greet(name: string): string {
    return `Hello, ${name}!`;
}

const greetingMessage: string = greet("Bytefer");
console.log(greetingMessage);

// Output: "Hello, Bytefer!"

Define a function with multiple parameters

When defining a function, you can add multiple arguments to the function.

Swift Code

func calculateRectangleArea(length: Double, width: Double) -> Double {
    return length * width
}

let area = calculateRectangleArea(length: 5.0, width: 3.0)
print("The area of the rectangle is \(area)")

// Output: The area of the rectangle is 15.0

TypeScript Code

function calculateRectangleArea(length: number, width: number): number {
    return length * width;
}

const area: number = calculateRectangleArea(5.0, 3.0);
console.log(`The area of the rectangle is ${area}`);

// Output: "The area of the rectangle is 15"

Set default values for function parameters

In Swift, you can set default values for function parameters. When the user calls a function, if no parameter value is passed, the parameter’s default value is used.

Swift Code

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

let customGreeting = greet(name: "Bytefer", greeting: "Greetings")
let defaultGreeting = greet(name: "Bytefer")
print(customGreeting)
print(defaultGreeting)

/**
Output:
Greetings, Bytefer!
Hello, Bytefer!
*/

TypeScript Code

function greet(name: string, greeting: string = "Hello"): string {
    return `${greeting}, ${name}!`;
}

const customGreeting: string = greet("Bytefer", "Greetings");
const defaultGreeting: string = greet("Bytefer");

console.log(customGreeting);
console.log(defaultGreeting);

/**
Output:
"Greetings, Bytefer!"
"Hello, Bytefer!"
*/

Define optional parameters

In Swift, optional parameters are declared by adding ? after the parameter type. to declare optional parameters. Optional parameters can be omitted and do not have to be passed a value when the function is called.

Swift Code

func greet(name: String, greeting: String? = nil) -> String {
    if let customGreeting = greeting {
        return "\(customGreeting), \(name)!"
    } else {
        return "Hello, \(name)!"
    }
}

let customGreeting = greet(name: "Bytefer", greeting: "Greetings")
let defaultGreeting = greet(name: "Bytefer")
print(customGreeting)
print(defaultGreeting)

/**
Output:
Greetings, Bytefer!
Hello, Bytefer!
*/

TypeScript Code

function greet(name: string, greeting?: string): string {
    if (greeting) {
        return `${greeting}, ${name}!`;
    } else {
        return `Hello, ${name}!`;
    }
}

const customGreeting: string = greet("Bytefer", "Greetings");
const defaultGreeting: string = greet("Bytefer");
console.log(customGreeting);
console.log(defaultGreeting);

/**
Output:
"Greetings, Bytefer!"
"Hello, Bytefer!"
*/

Define variadic parameters

Variadics allow a function to accept a variable number of parameters. In Swift, variadic parameters are declared by adding an ellipsis …after the parameter type.

Swift Code

func calculateSum(_ numbers: Double...) -> Double {
    return numbers.reduce(0, +)
}

let sum = calculateSum(4, 5, 6)
print("Sum: \(sum)")

// Output: Sum: 15.0

The function calculateSum accepts a variadic parameter numbers, which means it can accept a variable number of Double parameters. The underscore _ indicates that we can omit the external naming of this parameter when calling the function, making the call more concise.

let sum = calculateSum(4, 5, 6)

In this call, we pass the number directly to calculateSum without specifying a parameter name. Without the underscore _, the call would look like this:

func calculateSum(numbers: Double...) -> Double {
    return numbers.reduce(0, +)
}

let sum = calculateSum(numbers: 4, 5, 6)

TypeScript Code

function calculateSum(...numbers: number[]): number {
    return numbers.reduce((sum, num) => sum + num, 0);
}

const sum = calculateSum(4, 5, 6);
console.log(`Sum: ${sum}`);

// Output: "Sum: 15"

In-out Parameters

In Swift, function parameters can be declared as in-out parameters, which means that they can be changed by the function and these changes will be retained after the function call ends. This feature is useful in situations where you need to change the value of a parameter within a function.

// Update the quantity of a certain item in the shopping cart
func updateCart(_ cart: inout [String: Int], forProduct product: String, quantity: Int) {
    // If the product already exists, update the quantity;
    // otherwise, add a new product
    if let existingQuantity = cart[product] {
        cart[product] = existingQuantity + quantity
    } else {
        cart[product] = quantity
    }
}

// Initialize shopping cart
var shoppingCart = ["Apple": 3, "Banana": 2, "Orange": 1]

print("Before Update: \(shoppingCart)")

// Call the function and pass in-out parameters
updateCart(&shoppingCart, forProduct: "Banana", quantity: 3)

print("After Update: \(shoppingCart)")

/**
Output: 
Before Update: ["Apple": 3, "Banana": 2, "Orange": 1]
After Update: ["Apple": 3, "Banana": 5, "Orange": 1]
*/

If the inout keyword is removed from the cart parameter, the Swift compiler will prompt the following error message.

Returns multiple values

Functions in Swift can return multiple values, effectively returning a tuple containing multiple values.

Swift Code

func getPersonInfo() -> (name: String, age: Int) {
    return ("Bytefer", 30)
}

let personInfo = getPersonInfo()
print("Name: \(personInfo.name), Age: \(personInfo.age)")

// Output: Name: Bytefer, Age: 30

TypeScript Code

function getPersonInfo(): [string, number] {
    return ["Bytefer", 30];
}

const personInfo: [string, number] = getPersonInfo();
console.log(`Name: ${personInfo[0]}, Age: ${personInfo[1]}`);

// Output: "Name: Bytefer, Age: 30"

Function Types

1. Declare function type

In Swift, when declaring a function type, you need to specify the parameter types and return type.

Swift Code

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

// Declare a variable of function type
var mathFunction: (Int, Int) -> Int

// Assign function to variable
mathFunction = add

// Calling a function using a function type variable
let result = mathFunction(2, 3)
print("Result: \(result)")

// Output: Result: 5

TypeScript Code

function add(a: number, b: number): number {
    return a + b;
}

// Declare a variable of function type
let mathFunction: (a: number, b: number) => number;

// Assign function to variable
mathFunction = add;

// Calling a function using a function type variable
const result: number = mathFunction(2, 3);
console.log(`Result: ${result}`);

// Output: "Result: 5"

2. Function type as parameter type

Swift Code

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

// Define a function that executes a function
func executeMathOperation(_ a: Int, _ b: Int, _ operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)
}

// Call the function and pass the add function as parameter
let result = executeMathOperation(2, 3, add)

print("Result: \(result)")

// Output: Result: 5

TypeScript Code

function add(a: number, b: number): number {
    return a + b;
}

// Define a function that executes a function
function executeMathOperation(a: number, b: number, operation: (a: number, b: number) => number): number {
    return operation(a, b);
}

// Call the function and pass the add function as parameter
const result = executeMathOperation(2, 3, add);
console.log(`Result: ${result}`);

// Output: "Result: 5"

Function type as the type of return value

Swift Code

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

// Define a function that returns an addition function
func getAdditionFunction() -> (Int, Int) -> Int {
    return add
}

// Get the addition function and call
let additionFunction = getAdditionFunction()
let result = additionFunction(2, 3)
print("Result: \(result)")

// Output: Result: 5

TypeScript Code

function add(a: number, b: number): number {
    return a + b;
}

// Define a function that returns an addition function
function getAdditionFunction(): (a: number, b: number) => number {
    return add;
}

// Get the addition function and call
const additionFunction: (a: number, b: number) => number = getAdditionFunction();
const result: number = additionFunction(2, 3);
console.log(`Result: ${result}`);

// Output: "Result: 5"

In this article, we introduce how to define functions, optional parameters, variadic parameters, in-out parameters, and function types in Swift. By comparing it to TypeScript syntax, we hope to help you better understand the features of Swift. If you want to learn Swift, follow me on Medium or Twitter to read more about Swift and TS!

Mastering TypeScript Series

This series will introduce the core knowledge and techniques of TypeScript in the form of animations.

medium.com

Stackademic

Thank you for reading until the end. Before you go:

Please consider clapping and following the writer! 👏
Follow us on Twitter(X), LinkedIn, and YouTube.
Visit Stackademic.com to find out more about how we are democratizing free programming education around the world.

Swift Tutorials for Front-end Developers: Functions

Master Swift in 2024 and Start Developing Your Own iOS/macOS App

Swift Tutorials for Front-end Developers: Getting Started

Master Swift in 2024 and Start Developing Your Own iOS/macOS App

Define and call functions

Define a function with multiple parameters

Set default values ​​for function parameters

Define optional parameters

Define variadic parameters

In-out Parameters

Returns multiple values

Function Types

1. Declare function type

2. Function type as parameter type

Function type as the type of return value

Mastering TypeScript Series

This series will introduce the core knowledge and techniques of TypeScript in the form of animations.

Stackademic

Set default values for function parameters