Swift - Funções
Uma função é um conjunto de instruções organizadas em conjunto para realizar uma tarefa específica. Uma função do Swift 4 pode ser tão simples quanto uma função C simples ou tão complexa quanto uma função da linguagem C Objective. Ele nos permite passar valores de parâmetros locais e globais dentro das chamadas de função.
Function Declaration - informa ao compilador sobre o nome de uma função, tipo de retorno e parâmetros.
Function Definition - Fornece o corpo real da função.
As funções do Swift 4 contêm o tipo de parâmetro e seus tipos de retorno.
Definição de Função
No Swift 4, uma função é definida pela palavra-chave "func". Quando uma função é recém-definida, ela pode receber um ou vários valores como 'parâmetros' de entrada para a função e irá processar as funções no corpo principal e devolver os valores para as funções como 'tipos de retorno' de saída.
Cada função tem um nome de função, que descreve a tarefa que a função executa. Para usar uma função, você "chama" essa função com seu nome e passa valores de entrada (conhecidos como argumentos) que correspondem aos tipos de parâmetros da função. Os parâmetros da função também são chamados de 'tuplas'.
Os argumentos de uma função sempre devem ser fornecidos na mesma ordem que a lista de parâmetros da função e os valores de retorno são seguidos por →.
Sintaxe
func funcname(Parameters) -> returntype {
Statement1
Statement2
---
Statement N
return parameters
}
Dê uma olhada no código a seguir. O nome do aluno é declarado como tipo de dados string declarado dentro da função 'aluno' e quando a função é chamada, ela retornará o nome do aluno.
func student(name: String) -> String {
return name
}
print(student(name: "First Program"))
print(student(name: "About Functions"))
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
First Program
About Functions
Chamando uma função
Vamos supor que definimos uma função chamada 'display' para considerar, por exemplo, para exibir os números, uma função com o nome da função 'display' é inicializada primeiro com o argumento 'no1' que contém o tipo de dados inteiro. Então, o argumento 'no1' é atribuído ao argumento 'a' que, a partir de agora, apontará para o mesmo tipo de dados inteiro. Agora, o argumento 'a' é retornado à função. Aqui, a função display () manterá o valor inteiro e retornará os valores inteiros sempre que a função for invocada.
func display(no1: Int) -> Int {
let a = no1
return a
}
print(display(no1: 100))
print(display(no1: 200))
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
100
200
Parâmetros e valores de retorno
O Swift 4 fornece parâmetros de função flexíveis e seus valores de retorno de valores simples a complexos. Semelhante ao de C e Objective C, funções em Swift 4 também podem assumir várias formas.
Funções com parâmetros
Uma função é acessada passando seus valores de parâmetro para o corpo da função. Podemos passar valores de parâmetros únicos para múltiplos como tuplas dentro da função.
func mult(no1: Int, no2: Int) -> Int {
return no1*no2
}
print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
40
45
120
Funções sem Parâmetros
Também podemos ter funções sem parâmetros.
Sintaxe
func funcname() -> datatype {
return datatype
}
A seguir está um exemplo com uma função sem um parâmetro -
func votersname() -> String {
return "Alice"
}
print(votersname())
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Alice
Funções com valores de retorno
As funções também são usadas para retornar valores de tipo de dados string, inteiro e float como tipos de retorno. Para descobrir o maior e o menor número em uma determinada função de matriz, 'ls' é declarado com tipos de dados inteiros pequenos e grandes.
Uma matriz é inicializada para conter valores inteiros. Em seguida, a matriz é processada e cada valor na matriz é lido e comparado com seu valor anterior. Quando o valor é menor que o anterior, ele é armazenado no argumento 'pequeno', caso contrário, é armazenado no argumento 'grande' e os valores são retornados ao chamar a função.
func ls(array: [Int]) -> (large: Int, small: Int) {
var lar = array[0]
var sma = array[0]
for i in array[1..<array.count] {
if i < sma {
sma = i
} else if i > lar {
lar = i
}
}
return (lar, sma)
}
let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Largest number is: 98 and smallest number is: -5
Funções sem valores de retorno
Algumas funções podem ter argumentos declarados dentro da função sem nenhum valor de retorno. O seguinte programa declaraa e bcomo argumentos para a função sum (). dentro da própria função, os valores dos argumentosa e b são passados invocando a chamada de função sum () e seus valores são impressos, eliminando assim os valores de retorno.
func sum(a: Int, b: Int) {
let a = a + b
let b = a - b
print(a, b)
}
sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
30 20
50 40
30 24
Funções com tipos de retorno opcionais
O Swift 4 apresenta o recurso 'opcional' para se livrar de problemas, introduzindo uma medida de segurança. Considere, por exemplo, que estamos declarando o tipo de retorno dos valores da função como inteiro, mas o que acontecerá quando a função retornar um valor de string ou um valor nulo. Nesse caso, o compilador retornará um valor de erro. 'opcional' são introduzidos para se livrar desses problemas.
As funções opcionais terão duas formas 'valor' e 'nulo'. Mencionaremos 'Opcionais' com o caractere reservado chave '?' para verificar se a tupla está retornando um valor ou um valor nulo.
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
min is -6 and max is 109
'' Opcionais 'são usados para verificar valores' nulos 'ou lixo, consumindo muito tempo na depuração e tornando o código eficiente e legível para o usuário.
Funções locais e nomes de parâmetros externos
Nomes de parâmetros locais
Os nomes dos parâmetros locais são acessados somente dentro da função.
func sample(number: Int) {
print(number)
}
Aqui o funco número do argumento de amostra é declarado como variável interna, pois é acessado internamente pela função sample (). Aqui, o 'número' é declarado como variável local, mas a referência à variável é feita fora da função com a seguinte instrução -
func sample(number: Int) {
print(number)
}
sample(number: 1)
sample(number: 2)
sample(number: 3)
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
1
2
3
Nomes de parâmetros externos
Nomes de parâmetros externos nos permitem nomear parâmetros de uma função para tornar sua finalidade mais clara. Por exemplo abaixo, você pode nomear dois parâmetros de função e, em seguida, chamar essa função da seguinte maneira -
func pow(firstArg a: Int, secondArg b: Int) -> Int {
var res = a
for _ in 1..<b {
res = res * a
}
print(res)
return res
}
pow(firstArg:5, secondArg:3)
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
125
Parâmetros Variadic
Quando queremos definir a função com vários argumentos, podemos declarar os membros como parâmetros 'variáveis'. Os parâmetros podem ser especificados como variáveis por (···) após o nome do parâmetro.
func vari<N>(members: N...){
for i in members {
print(i)
}
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures
Parâmetros Constantes, Variáveis e I / O
As funções, por padrão, consideram os parâmetros como 'constantes', enquanto o usuário também pode declarar os argumentos para as funções como variáveis. Já discutimos que a palavra-chave 'let' é usada para declarar parâmetros constantes e os parâmetros variáveis são definidos com a palavra-chave 'var'.
Os parâmetros de E / S no Swift 4 fornecem funcionalidade para reter os valores dos parâmetros, mesmo que seus valores sejam modificados após a chamada da função. No início da definição do parâmetro de função, a palavra-chave 'inout' é declarada para reter os valores do membro.
Ele deriva a palavra-chave 'inout', pois seus valores são passados 'in' para a função e seus valores são acessados e modificados pelo corpo da função e é retornado 'out' da função para modificar o argumento original.
As variáveis são passadas apenas como um argumento para o parâmetro in-out, uma vez que seus valores sozinhos são modificados dentro e fora da função. Portanto, não há necessidade de declarar strings e literais como parâmetros de entrada e saída. '&' antes de um nome de variável indica que estamos passando o argumento para o parâmetro in-out.
func temp(a1: inout Int, b1: inout Int) {
let t = a1
a1 = b1
b1 = t
}
var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Swapped values are 10, 2
Tipos de função e seu uso
Cada função segue a função específica, considerando os parâmetros de entrada e produz o resultado desejado.
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
A seguir está um exemplo -
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
2
6
Aqui a função é inicializada com dois argumentos no1 e no2 como tipos de dados inteiros e seu tipo de retorno também é declarado como 'int'
Func inputstr(name: String) -> String {
return name
}
Aqui, a função é declarada como string tipo de dados.
As funções também podem ter void tipos de dados e tais funções não retornarão nada.
func inputstr() {
print("Swift 4 Functions")
print("Types and its Usage")
}
inputstr()
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Swift 4 Functions
Types and its Usage
A função acima é declarada como uma função nula, sem argumentos e sem valores de retorno.
Usando Tipos de Função
As funções são primeiro passadas com argumentos do tipo inteiro, float ou string e, em seguida, são passadas como constantes ou variáveis para a função, conforme mencionado abaixo.
var addition: (Int, Int) -> Int = sum
Aqui sum é um nome de função com variáveis inteiras 'a' e 'b' que agora é declarado como uma variável para a adição do nome da função. Doravante, as funções de adição e soma têm o mesmo número de argumentos declarados como tipo de dados inteiro e também retornam valores inteiros como referências.
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Result: 129
Tipos de função como tipos de parâmetro e tipos de retorno
Também podemos passar a própria função como tipos de parâmetro para outra função.
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
print("Result: \(addition(a, b))")
}
another(sum, 10, 20)
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
Result: 129
Result: 30
Funções Aninhadas
Uma função aninhada fornece a facilidade de chamar a função externa invocando a função interna.
func calcDecrement(forDecrement total: Int) -> () -> Int {
var overallDecrement = 0
func decrementer() -> Int {
overallDecrement -= total
return overallDecrement
}
return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())
Quando executamos o programa acima usando playground, obtemos o seguinte resultado -
-30