Parâmetro opcional padrão na função Swift

Quando eu definir firstThingcomo padrão, nilisso funcionará, sem o valor padrão de nil, recebo um erro informando que há um parâmetro ausente ao chamar a função.

Ao digitar Int?, pensei que era opcional com um valor padrão de nil, estou certo? E se sim, por que não funciona sem o = nil?

func test(firstThing: Int? = nil) {
    if firstThing != nil {
        print(firstThing!)
    }
    print("done")
}
test()

Opcionais e parâmetros padrão são duas coisas diferentes.

Um opcional é uma variável que pode ser nil, é isso.

Os parâmetros padrão usam um valor padrão quando você omite esse parâmetro, este valor padrão é especificado assim:func test(param: Int = 0)

Se você especificar um parâmetro opcional, deverá fornecê-lo, mesmo que o valor que deseja passar seja nil. Se sua função for assim func test(param: Int?), você não poderá chamá-la assim test(). Embora o parâmetro seja opcional, ele não possui um valor padrão.

Você também pode combinar os dois e ter um parâmetro que leva um opcional que nilé o valor padrão, como este: func test(param: Int? = nil).

O argumento padrão permite que você chame a função sem passar um argumento. Se você não passar o argumento, o argumento padrão será fornecido. Então, usando seu código, isso ...

test()

... é exatamente o mesmo que este:

test(nil)

Se você deixar o argumento padrão como este ...

func test(firstThing: Int?) {
    if firstThing != nil {
        print(firstThing!)
    }
    print("done")
}

... então você não pode mais fazer isso ...

test()

Se o fizer, obterá o erro "argumento ausente" que descreveu. Você deve passar um argumento todas as vezes, mesmo que esse argumento seja apenas nil:

test(nil)   // this works

Swift não é como linguagens como JavaScript, onde você pode chamar uma função sem passar os parâmetros e ela ainda será chamada. Portanto, para chamar uma função em Swift, você precisa atribuir um valor a seus parâmetros.

Os valores padrão dos parâmetros permitem que você atribua um valor sem especificá-lo ao chamar a função. É por isso que test()funciona quando você especifica um valor padrão na declaração do teste.

Se você não incluir esse valor padrão, você precisa fornecer o valor na chamada: test(nil).

Além disso, e não diretamente relacionado a esta questão, mas provavelmente vale a pena notar, você está usando a maneira "C ++" de lidar com ponteiros possivelmente nulos, para lidar com possíveis opcionais nulos em Swift. O código a seguir é mais seguro (especialmente em software multithreading) e permite que você evite o desembrulhamento forçado do opcional:

func test(firstThing: Int? = nil) {
    if let firstThing = firstThing {
        print(firstThing)
    }
    print("done")
}
test()

Você está confundindo Optionalcom um padrão. Um Optionalaceita um valor ou nulo. Ter um padrão permite que o argumento seja omitido na chamada da função. Um argumento pode ter um valor padrão com ou sem ser do Optionaltipo.

func someFunc(param1: String?,
          param2: String = "default value",
          param3: String? = "also has default value") {
    print("param1 = \(param1)")

    print("param2 = \(param2)")

    print("param3 = \(param3)")
}

Chamadas de exemplo com saída:

someFunc(param1: nil, param2: "specific value", param3: "also specific value")

param1 = nil
param2 = specific value
param3 = Optional("also specific value")

someFunc(param1: "has a value")

param1 = Optional("has a value")
param2 = default value
param3 = Optional("also has default value")

someFunc(param1: nil, param3: nil)

param1 = nil
param2 = default value
param3 = nil

Para resumir:

• Digite com? (por exemplo, String?) é um Optionalpode ser nulo ou pode conter uma instância de Tipo
• O argumento com o valor padrão pode ser omitido de uma chamada para a função e o valor padrão será usado
• Se Optionale tiver o padrão, ele pode ser omitido da chamada de função OU pode ser incluído e pode ser fornecido com um valor nulo (por exemplo, param1: nulo)

"Parâmetro opcional" significa "o tipo deste parâmetro é opcional". Isso não significa "Este parâmetro é opcional e, portanto, pode ser ignorado ao chamar a função".

O termo "parâmetro opcional" parece confuso. Para esclarecer, é mais preciso dizer "parâmetro de tipo opcional" em vez de "parâmetro opcional", pois a palavra "opcional" aqui se destina apenas a descrever o tipo de valor do parâmetro e nada mais.

caso você precise usar um parâmetro bool, basta atribuir o valor padrão.

func test(WithFlag flag: Bool = false){.....}

então você pode usar sem ou com o parâmetro:

test() //here flag automatically has the default value: false
test(WithFlag: true) //here flag has the value: true

Se você quiser chamar o funccom ou sem o parâmetro, você pode criar um segundo funccom o mesmo nome que chama o outro.

func test(firstThing: Int?) {
    if firstThing != nil {
        print(firstThing!)
    }
    print("done")
}

func test() {
    test(firstThing: nil)
}

agora você pode chamar uma função chamada testsem ou sem o parâmetro.

// both work
test()
test(firstThing: 5)

É um pouco complicado quando você tenta combinar parâmetro opcional e valor padrão para esse parâmetro. Como isso,

func test(param: Int? = nil)

Esses dois são ideias completamente opostas. Quando você tem um parâmetro de tipo opcional, mas também fornece um valor padrão para ele, ele não é mais um tipo opcional, pois tem um valor padrão. Mesmo se o padrão for nulo, o swift simplesmente remove a ligação opcional sem verificar qual é o valor padrão.

Portanto, é sempre melhor não usar nil como valor padrão.

O valor padrão não significa o valor padrão do tipo de dados. Aqui, o valor padrão significa o valor definido no momento da definição da função. temos que declarar o valor padrão da variável enquanto definimos a variável na função.