Functions are reusable blocks of code in a program. It performs a specific task like addition or printing or even some other complex task. It might take parameters, and it might also return values. It makes our code more modular. In this article, we\u2019ll learn about the basics of functions, functions with or without parameters and return values, their different types and their usage in programming in Swift.<\/p>\n
There are two main kinds of functions. They can be standard library functions, or they can be user-defined functions.<\/p>\n
Swift offers inbuilt functions for our use. These are known as standard library functions.<\/p>\n
Some of the common library functions are print(), pow(), etc.<\/p>\n
These can directly be used in our programs. These library functions are included in frameworks, so we need to import the framework corresponding to it.<\/p>\n
For example, pow() is defined in the Foundation Framework of Swift.<\/p>\n
Users define their own functions. These are known as user-defined functions. These kinds of functions are discussed in detail below<\/strong>.<\/p>\n We use the func keyword followed by the name of the function to define a function. We mention the parameters of the function within parentheses (). We can optionally specify the return type after parentheses. The body of the function is written within braces {}. We write the return statement at the end of the body of the function.<\/p>\n The syntax of a function.<\/strong><\/p>\n For example, we have to define a function that multiplies 2 numbers.<\/strong><\/p>\n We call a function by writing the function name followed by writing the parameters (if they are defined).<\/p>\n Output:<\/strong><\/p>\n Product:<\/strong> 20<\/p>\n A function might take a parameter. It might have a return value. It can also have an optional return value. It can also have an implicit return value. Based on a specific scenario and use case, we might have a parameter or return value. Below, we have discussed each of these with examples.<\/p>\n Functions with parameters are functions that contain one or more parameters in their argument.<\/p>\n For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n Functions can also be defined without parameters. For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n Functions with return values usually return one or more values after completion of the task. We need to specify the return type of the function. We write an arrow symbol -> after the parentheses followed by the return type. We can refer to the following syntax to understand it better.<\/p>\n Example for the same.<\/strong><\/p>\n Output:<\/strong><\/p>\n Sum is 43<\/p>\n A function can also be written without return values. These functions return a special type known as void type. For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n When we are not sure whether we will get a result or not, we can use optional return values. We can define these by adding a question mark \u2018?\u2019 after the return type of the function. If there is no value to return, nil is returned.<\/p>\n Output:<\/strong><\/p>\n DataFlair found.<\/p>\n In some functions, we don\u2019t need to explicitly write the return statement in the function declaration. The whole body of the function can be returned in a single expression. For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n Swift offers several uses of parameters. They can be used in several ways. We can use this based on our use case and convenience. Some of these are argument labels, local and external parameter names, variadic parameters and InOut parameters.<\/p>\n We use local parameter names inside the function body locally. It is also known as internal parameter names.<\/p>\n We use external parameter names while calling the function externally. It is also known as argument labels.<\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n Argument Labels are explained in detail in the next subtopic.<\/p>\n Argument Labels are descriptive names of function parameters. We write them in the function signature when we call them externally.<\/p>\n An example of argument labels is as follows<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n We can also omit these argument labels while calling the function. We can do it by writing an underscore \u2018_\u2019 instead of a label while defining the function. For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair!<\/p>\n We can define a function with multiple parameters with the help of variadic parameters. We do it by adding an ellipsis (…) after the parameter name. For example,<\/strong><\/p>\n Output:<\/strong><\/p>\n 33<\/p>\n Inout parameters change the value of the variable passed through a function. To declare an inout parameter, we write the inout keyword before the data type. The variable needs to be mutable.<\/p>\n We call a function with inout parameters by prefixing the variables with an ampersand \u2018&\u2019. This means that we want to pass them by reference. This allows the function to modify its value.<\/p>\n Output:<\/strong><\/p>\n Before Swapping 6, 10 We can convert functions into data types. We can treat them as regular data types. We can assign them to variables. We can pass them as arguments in other functions. We can also return them from other functions.<\/p>\n Output:<\/strong><\/p>\n Hello from DataFlair<\/p>\n Functions defined inside another function are known as nested functions. The syntax of nested functions is as follows.<\/strong><\/p>\n The example below defines the inner and outer functions.<\/strong><\/p>\n Output:<\/strong><\/p>\n Outer Function We cannot call the inner function outside of the outer function. It throws errors if we can an inner function from outside of the outer function.<\/p>\n Functions help us in reusing our code. They make our code modular. In this article, we have discussed about kinds of Swift functions and how we use them. We have seen how to declare and use these functions based on our requirements. We\u2019ve learnt about different combinations of functions with and without parameters and return values. We have also gone through different kinds of parameters defined in Swift.<\/p>\n","protected":false},"excerpt":{"rendered":" Functions are reusable blocks of code in a program. It performs a specific task like addition or printing or even some other complex task. It might take parameters, and it might also return values....<\/p>\n","protected":false},"author":581,"featured_media":120679,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[27789],"tags":[28455,28456,21771,28454,28287],"class_list":["post-120677","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-swift-tutorials","tag-functions-in-swift","tag-kinds-of-function","tag-swift","tag-swift-functions","tag-swift-tutorials"],"yoast_head":"\nFunction Declaration in Swift<\/h3>\n
func functionName(parameter1, parameter2, ..., parameterN) -> returnType{\r\n \/\/Function Body\r\n Return statement\r\n}<\/pre>\n\n\n
\n Parts of the function<\/b><\/td>\n Name of the component in the function<\/b><\/td>\n<\/tr>\n \n Name of the function<\/span><\/td>\n multiply<\/span><\/td>\n<\/tr>\n \n Parameters<\/span><\/td>\n num1, num2<\/span><\/td>\n<\/tr>\n \n Return Type<\/span><\/td>\n Int<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n func multiply(num1: Int, num2: Int) -> Int{\r\n let temp = num1 * num2\r\n return temp\r\n}<\/pre>\nCalling a function<\/h3>\n
func multiply(num1: Int, num2: Int) -> Int{\r\n let temp = num1 * num2\r\n return temp\r\n}\r\n\r\nvar product = multiply(num1: 4, num2: 5)\r\nprint(\"Product: \\(product)\")<\/pre>\nFunction, Parameters and Return Values<\/h3>\n
Function with Parameters<\/h4>\n
func greetName(name:String){\r\n print(\"Hello from \\(name)!\")\r\n}\r\n\r\ngreetName(name: \"DataFlair\")<\/pre>\nFunction without Parameters<\/h4>\n
func greet(){\r\n print(\"Hello from DataFlair!\")\r\n}\r\n\r\ngreet()<\/pre>\nFunction with Return Values<\/h4>\n
func functionName() -> ReturnType{\r\n \/\/body\r\n Return value\r\n}<\/pre>\nfunc addNums(num1: Int, num2: Int) -> Int{\r\n return num1 + num2\r\n}\r\n\r\nlet sum = addNums(num1: 20, num2: 23)\r\nprint(\"Sum is \\(sum)\")<\/pre>\nFunction without Return Values<\/h4>\n
func greet(){\r\n print(\"Hello from DataFlair!\")\r\n}\r\n\r\ngreet()<\/pre>\nFunction with Optional Return Values<\/h4>\n
func findDataFlair(sentence: String) -> String?{\r\n if sentence.contains(\"DataFlair\"){\r\n return \"DataFlair\"\r\n }else{\r\n return nil\r\n }\r\n}\r\nlet exampleSentence = \"Hello from DataFlair\"\r\n\r\nif let example = findDataFlair(sentence: exampleSentence){\r\n print(\"\\(example) found.\")\r\n}else{\r\n print(\"Not found.\")\r\n}<\/pre>\nFunction with Implicit Return Values<\/h4>\n
func greet() -> String{\r\n \"Hello from DataFlair!\"\r\n}\r\n\r\nlet example: String = greet()\r\nprint(example)<\/pre>\nMore on Swift Function Parameters<\/h3>\n
Local Parameter Names and External Parameter Names<\/h4>\n
func greet(name: String){\r\n \/\/name is an internal parameter\r\n print(\"Hello from \\(name)!\")\r\n}<\/pre>\nfunc greet(name: String){\r\n \/\/name is an internal parameter\r\n print(\"Hello from \\(name)!\")\r\n}\r\n\r\n\/\/name is an external parameter here\r\ngreet(name: \"DataFlair\")<\/pre>\nArgument Labels<\/h4>\n
func greet(fromPerson name: String){\r\n print(\"Hello from \\(name)!\")\r\n}\r\n\r\ngreet(fromPerson: \"DataFlair\")<\/pre>\nfunc greet(_ name: String){\r\n print(\"Hello from \\(name)!\")\r\n}\r\n\r\ngreet(\"DataFlair\")<\/pre>\nVariadic Parameters<\/h4>\n
func sum(numbers: Int...)->Int{\r\n var total = 0\r\n for number in numbers{\r\n total += number\r\n }\r\n return total\r\n}\r\n\r\nprint(sum(numbers: 2, 5, 7, 9, 10))<\/pre>\nInOut Parameters<\/h4>\n
func swapValues(_ num1: inout Int, _ num2: inout Int){\r\n let temp = num1\r\n num1 = num2\r\n num2 = temp\r\n}\r\n\r\nvar num1 = 6\r\nvar num2 = 10\r\n\r\nprint(\"Before Swapping \\(num1), \\(num2)\")\r\nswapValues(&num1, &num2)\r\nprint(\"After Swapping \\(num1), \\(num2)\")<\/pre>\n
\nAfter Swapping 10, 6<\/p>\nFunction Types<\/h3>\n
func greet(name: String){\r\n print(\"Hello from \\(name)\")\r\n}\r\nlet printGreetings: (String) -> Void = greet\r\n\r\nprintGreetings(\"DataFlair\")<\/pre>\nNested Functions<\/h3>\n
func functionName1(){\r\n \/\/func body\r\n func functionName2(){\r\n \/\/func body\r\n }\r\n}<\/pre>\nfunc function1(){\r\n print(\"Outer Function\")\r\n func function2(){\r\n print(\"Inner Function\")\r\n }\r\n \r\n function2()\r\n}\r\nfunction1()<\/pre>\n
\nInner Function<\/p>\nConclusion<\/h3>\n