Parâmetros e Valores de Retorno de Função Swift

Neste artigo, você aprenderá sobre diferentes funções definidas pelo usuário, que obterão diferentes tipos de entrada e retornarão saída por meio de exemplos.

No artigo anteriorFunção SwiftAgora, entendemos funções. Vamos explorar as diferentes maneiras e tipos de criação de funções no Swift, ou seja, lidar com entrada e saída em funções.

Função sem parâmetros nem valor de retorno

Esses tipos de funções não aceitam nenhuma entrada nem valor de retorno.

func funcname() {
　　　　//Sentença
}
Ou
func funcname()　-> () {
　　　　//Sentença
}
Ou
func funcname()　-> Void {
　　　　//Sentença
}

Todas as sintaxes acima são válidas para criar funções sem parâmetros e sem valor de retorno.

A sintaxe acima func funcname()->() também é equivalente a func funcname()->void, pois void é um alias de tipo para () . Você pode acessarNome de tipo de SwiftPara obter mais informações.

Exemplo1Sem parâmetros, nem valor de retorno

func greetUser() {
　　　　print("Good Morning!")
}
greetUser()

Quando você executar o programa acima, a saída será:

Good Morning!

Função sem parâmetros mas com valor de retorno

Esses tipos de funções não aceitam nenhum parâmetro de entrada, mas retornam um valor. Para adicionar o tipo de retorno, você precisa adicionar a seta (-E o tipo de retorno.

func funcname()　-> ReturnType {
　　　　//Sentença
　　　　return value
}

Exemplo2Sem parâmetros, mas com valor de retorno

func greetUser()　-> String {
　　　　return "Good Morning!"
}
let msg = greetUser()
print(msg)

Quando você executar o programa acima, a saída será:

Good Morning!

No programa acima, você definiu o tipo de retorno como String. Agora, essa instrução deve retornar uma string do interior da função, caso contrário, você lançará um erro.

A palavra-chave return transfere o controle do programa do corpo da função para a chamada da função. Se precisar retornar um valor da função, adicione o valor a ser retornado após a palavra-chave return.

A instrução return "Good Morning!" retorna um valor do tipo String da função. Note que o tipo e o valor do valor de retorno devem coincidir.

Você também pode atribuir o valor de retorno a uma variável ou constante. let msg = Atribui o valor de retorno a uma constante msg. Portanto, a instrução print(msg) exibe"Good Morning!"。

Se desejar ignorar esse valor, basta usar sublinhado _ , ou seja, let _ = .

Função com parâmetros mas sem valor de retorno

参数用于在函数中输入。参数包含参数名称和类型，后跟冒号（:）。这些类型的函数采用输入参数，但不返回值。

func funcname(parameterName: Type) {
　　　　//Sentença
}

Exemplo3：参数传递但没有返回值

func greetUser(msg: String) {
　　　　print(msg)
}
greetUser(msg: "Good Morning!")

Quando você executar o programa acima, a saída será:

Good Morning!

在上述程序中，该函数接受字符串类型的单个参数。该参数只能在函数内部使用。msg是参数的名称。

您可以通过向函数传递参数名称为 msg 的字符串值来调用函数 greetUser(msg: "Good Morning!")。该参数名称只在 greetUser() 函数内部可见。

因此，print(msg)语句输出 "Good Morning!"。

具有参数和返回值的函数

这些类型的函数使用参数并返回值。

func funcname(parameterName: Type)　-> ReturnType {
　　　　//Sentença
}

Exemplo4：传递参数并返回值

func greetUser(name: String)　-> String {
　　　　return "Good Morning! "　+　name
}
let msg = greetUser(name: "Jack")
print(msg)

Quando você executar o programa acima, a saída será:

Good Morning! Jack

在上面的程序中，该函数接受String类型的单个参数，并且还返回String类型的值“Good Morning! Jack”。

具有多个参数和多个返回值的函数

这些类型的函数采用以逗号分隔的多个参数，并且还返回多个值。您可以使用元组在Swift中返回多个值。

func funcname(parameterName: Type, parameterName2: Type, ...)　-> (ReturnType, ReturnType...) {
　　　　//Sentença
}

Exemplo5：传递了多个参数和多个返回值

func greetUser(name: String, age: Int)　-> (String, Int) {
　　　　
　　　　let msg = "Good Morning!"　+　name
　　　　var userage = age
　　　　if age < 0 {
　　　　　　　　　　　　userage = 0
　　　　}
　　　　return (msg, userage)
}
let msg = greetUser(name: "Jack", age:　-2)
print(msg.0)
print("You have \(msg.1) coins left")

Quando você executar o programa acima, a saída será:

Good Morning!Jack
You have 0 coins left

No programa acima, a função greetUser() aceita múltiplos parâmetros do tipo String e Int. A função também retorna múltiplos valores, do tipo String e Int.

Para acessar cada valor de retorno, usamos a posição de índice 0,1… Aqui, usamos msg.0 para acessar "Good Morning!Jack" e msg.1 Acessar "0".

Usar a posição de índice às vezes pode ser não intuitivo e não legível. Podemos resolver isso de maneira elegante nomeando os valores de retorno. O programa acima também pode ser rewritten da seguinte forma.

Exemplo6com múltiplos valores de retorno

func greetUser(name: String, coins: Int)　-> (name: String, coins: Int) {
　　　　
　　　　let msg = "Good Morning!"　+　name
　　　　var userCoins = coins
　　　　if coins < 0 {
　　　　　　　　userCoins = 0
　　　　}
　　　　return (msg, userCoins)
}
let msg = greetUser(name: "Jack", coins:　-2)
print(msg.name)
print("You have \(msg.coins) coins left")

Neste programa, o tipo de retorno é tupla, que contém nomes de variáveis com esse tipo. A principal vantagem disso é que você pode usar os nomes de variáveis msg.name e msg.coins em vez de msg.0 e msg.1 para acessar o resultado.

Função com rótulo de parâmetro

Ao definir uma função que aceita entrada, você pode usar o nome do parâmetro para definir o nome de entrada. No entanto, há outro nome que pode ser usado juntamente com o nome do parâmetro, chamado rótulo de parâmetro.

O uso do rótulo de argumento permite chamar a função de maneira expressiva, semelhante a uma frase, ao mesmo tempo que fornece um corpo de função legível e claro de intenção.

Cada parâmetro de função tem um rótulo de parâmetro e um nome de parâmetro. Pelo padrão, o parâmetro usa seu nome de parâmetro como seu rótulo de parâmetro. No entanto, se você definir explicitamente o nome do parâmetro, o rótulo de parâmetro será usado ao chamar a função.

A sintaxe de função com rótulo de argumento é

func funcname(argumentLabel parameterName: Type)-> Tipo de Retorno {
　　　　//Sentença
}

Vamos ver isso em um exemplo abaixo.

Exemplo7：不带参数标签的函数

func sum(a: Int, b: Int)　-> Int {
　　　　
　　　　return a　+　b
}
let result = sum(a:　2, b:　3)
print("A soma é \(result)")

Quando você executar o programa acima, a saída será:

A soma é　5

在上面的示例中，我们没有指定参数标签，因此在调用函数时它将使用默认参数名称a和b作为参数标签。

当调用函数时，您可能会注意到函数调用不是表达性的/句子。 如果您可以将函数调用设置为：

let result = sum(of:　2, and:　3)

现在让我们将函数更改为：

Exemplo8：具有更好的函数调用但不作为参数名称的函数

func sum(of: Int, and: Int)　-> Int {
　　　　return of　+　and
}
let result = sum(of:　2, and:　3)
print("A soma é \(result)")

现在，方法调用是可表达的。但是，现在我们必须使用参数名称of＆ and，return of + and 来查找两个数字的和。现在，这使得函数体可读性较差。在函数体内使用a和b代替of＆and将更有意义。

为此，我们必须将参数标签明确定义为：

Exemplo9：带有参数标签的函数

func sum(of a: Int, and b: Int)　-> Int {
　　　　return a　+　b
}
let result = sum(of:　2, and:　3)
print("A soma é \(result)")

在上述程序中，该函数接受Int类型的两个参数。函数调用使用参数标签of＆and，这在调用函数sum(of: 2, e: 3)，而不是 sum(a: 2, b: 3)。

另外，函数主体使用参数名称a和b，而不是of＆and，这在应用操作时也更有意义。

您还可以通过在参数名称前写一个下划线 _ 来省略参数标签。

func sum(_ a: Int, _ b: Int)　-> Int {
　　　　return a　+　b
}
let result = sum(2,　3)
print("A soma é \(result)")

具有默认参数值的函数

您可以为函数中的任何参数提供默认值，方法是在该参数的类型之后为该参数分配一个值。提供默认参数可以使您在调用函数时忽略该参数。

如果在调用函数时未将值传递给参数，则使用其默认值。但是，如果在调用时将值显式传递给参数，则使用指定的值。

func funcname(parameterName: Type = value)　-> Tipo de Retorno {
　　　　//Sentença
}

Exemplo10：具有默认参数值的函数

func sum(of a: Int =　7, and b: Int =　8)　-> Int {
　　　　return a　+　b
}
let result1　= sum(of:　2, and:　3)
print("A soma é \(result1))
let result2　= sum(of:　2)
print("A soma é \(result2))
let result3　= sum(and:　2)
print("A soma é \(result3))
let result4　= sum()
print("A soma é \(result4))

Quando você executar o programa acima, a saída será:

A soma é　5
A soma é　10
A soma é　9
A soma é　15

No programa acima, a função sum(of a : Int =}} 7 , e b:Int = 8) -> Int aceita dois parâmetros do tipo Int e especifica o parâmetro a=7e b=8o valor padrão.

Se você passar o valor como parâmetro na chamada da função, sum(of: 2, e: 3) então usa2e3em vez do valor padrão do parâmetro.

mas se você não passar o valor do parâmetro como sum(), então será usado7e8como valor do parâmetro.

função com parâmetros variáveis

Parâmetros variáveis podem aceitar zero ou mais valores de um tipo específico. Você pode especificar um parâmetro variável inserindo três pontos (...) após o nome do tipo do parâmetro.

Quando precisamos passar várias quantidades de valores de entrada para os parâmetros na chamada da função, geralmente usamos parâmetros variáveis. Por exemplo, lista de números, lista de letras, etc.

A sintaxe da função com parâmetros variáveis é:

func funcname(parameterName: Type...)　-> Tipo de Retorno {
　　　　//Sentença
}

Exemplo11função com parâmetros variáveis

func sum(of numbers: Int...) {
　　　　var result = 0
　　　　for num in numbers {
　　　　　　　　result　+= num
　　　　}
　　　　print("A soma dos números é \(result)")
}
sum(of:　1,　2,　3,　4,　5,　6,　7,　8)

No programa acima, a função sum(of numbers: Int...) aceita parâmetros variáveis do tipo Int. Parâmetros variáveis podem aceitar múltiplos valores separados por vírgula sum(of: 1, 2, 3, 4, 5, 6, 7, 8)。

como valor passado como parâmetro variável1,2,3,4,5,6,7,8No corpo da função, pode ser usado como um array de tipo Int. Portanto, podemos usar o for-a aplicação de in no loop é for num in numbers.

Quando você executar o programa acima, a saída será:

A soma dos números é　36

Atenção: A função embutida print() do Swift também aceita parâmetros variáveis de qualquer tipo.

Any representa qualquer tipo de dados no Swift, por exemplo, Int, Float, Double, String, etc.

função com parâmetros de entrada e saída

Quando você define um parâmetro de função, você não pode modificá-lo dentro do corpo da função. Portanto, por padrão, eles são constantes. Vamos ver um exemplo:

func process(name: String) {
　　　　if name == ""{
　　　　　　　　name = "guest"
　　　　}
}

O programa acima causará um erro de compilação porque você não pode alterar o valor do parâmetro.

Se você quiser que a função modifique o valor do parâmetro,则需要将参数定义为 in-parâmetro de saída. Você pode escrever um parâmetro de entrada e saída colocando a palavra-chave inout antes do tipo do parâmetro./parâmetro de saída.

No fundo, um-O parâmetro de saída possui um valor, que é passado para a função, modificado pela função, e então passado de volta para substituir o valor original. Portanto, o valor passado na chamada da função não pode ser uma constante. Você deve declara-lo como uma variável.

A sintaxe da função com parâmetro inout é:

func funcname(parameterName: inout Type)　-> Tipo de Retorno {
　　　　//Sentença
}

Exemplo12：Função com parâmetro inout

func process(name: inout String) {　
　　　　if name == ""{
　　　　　　　　name = "guest"
　　　　}
}
var userName = ""
process(name: &userName)
print(userName)

Quando você executar o programa acima, a saída será:

guest

No programa acima, declaramos uma função que aceita parâmetros inout, para que possamos modificá-la dentro do corpo da função/Mudar o parâmetro name.

Ao passar parâmetros para in-Quando se passa um parâmetro como saída, deve-se usar o símbolo & diretamente antes do nome da variável, para que a função possa modificá-lo.