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