Funzioni e valori restituiti

Question

Sono un principiante in Swift quindi alcune cose non mi sono ancora chiare. Spero che qualcuno me lo spieghi:

// Creating Type Properties and Type Methods 
class BankAccount { 

    // stored properties 
    let accountNumber: Int 
    let routingCode = 12345678 
    var balance: Double 
    class var interestRate: Float { 
     return 2.0 
    } 

    init(num: Int, initialBalance: Double) { 
     accountNumber = num 
     balance = initialBalance 
    } 

    func deposit(amount: Double) { 
     balance += amount 
    } 

    func withdraw(amount: Double) -> Bool { 
     if balance > amount { 
      balance -= amount 
      return true 
     } else { 
      println("Insufficient funds") 
      return false 
     } 
    } 

    class func example() { 
     // Type methods CANNOT access instance data 
     println("Interest rate is \(interestRate)") 
    } 
} 

var firstAccount = BankAccount(num: 11221122, initialBalance: 1000.0) 
var secondAccount = BankAccount(num: 22113322, initialBalance: 4543.54) 

BankAccount.interestRate 

firstAccount.deposit(520) 

Quindi questo è il codice. Mi chiedo perché lo deposit() non abbia una freccia di ritorno e una parola chiave di restituzione e lo fa withdraw(). Quando uso una freccia di ritorno, in quali situazioni, esiste una regola o qualcosa del genere? Non capisco.

Inoltre ... Ognuno è così gentile con le tue risposte, mi sta diventando più chiaro ora.

In All'inizio di questo tutorial è presente un codice di pratica per le funzioni

// Function that return values 
func myFunction() -> String { 
    return “Hello” 
} 

Immagino che questo valore di ritorno non è necessario qui, ma in esercitazione hanno voluto mostrarci che esiste, ho ragione?

Inoltre, è possibile effettuare un "errore" e utilizzare la freccia di ritorno e il valore nella funzione di deposito in qualche modo? Ho provato con questo:

func deposit(amount : Double) -> Double { 
    return balance += amount 
} 

... ma ha generato errore.

Ho visto la codifica avanzata nella mia ultima azienda, stavano creando un negozio online con molte funzioni personalizzate e interessanti e tutto il codice era pieno di frecce di ritorno. Questo mi ha confuso e ho pensato che fosse un default per fare metodi/funzioni in OOP.

Domanda aggiuntiva! Volevo giocare con le funzioni, quindi voglio creare una funzione transferFunds() che trasferisce denaro da un account a un altro. Ho funzionato in questo modo

func transferFunds(firstAcc : Int, secondAcc : Int, funds : Double) { 
    // magic part 
    if firstAcc == firstAccount.accountNumber { 
      firstAccount.balance -= funds 
    } else { 
     println("Invalid account number! Try again.") 
    } 

    if secondAcc == secondAccount.accountNumber { 
      secondAccount.balance += funds 
    } else { 
     println("Invalid account number! Try again.") 
    } 
} 

Questo è un codice semplice che mi è venuto in mente ma so che forse è anche stupido. So che dovrebbe esserci un codice che controlla se ci sono abbastanza fondi nel primo conto da cui prendo i soldi, ma va bene ... giochiamo con questo. Voglio specificare accountNumbers o qualcos'altro nei parametri all'interno della funzione transferFunds() e voglio cercare tra tutti gli oggetti/client nella mia banca immaginaria che usano la classe BankAccount per trovarne uno e quindi trasferire denaro. Non so se ho descritto correttamente il mio problema, ma spero che tu capisca cosa voglio fare. Qualcuno mi puó aiutare per piacere?

Answer 1

Quindi, in Swift, una funzione che non ha freccia ha un tipo di ritorno di Void:

func funcWithNoReturnType() { 
    //I don't return anything, but I still can return to jump out of the function 
} 

Questo potrebbe essere riscritta come:

func funcWithNoReturnType() -> Void { 
    //I don't return anything, but I still can return to jump out of the function 
} 

così nel tuo caso. ..

func deposit(amount : Double) { 
    balance += amount 
} 

il tuo metodo di deposito prende un singolo parametro di Tipodoppio e questo rendimenti nulla, che è esattamente il motivo per cui non si vede una ritorno dichiarazione nella vostra dichiarazione di metodo. Questo metodo è semplicemente aggiungendo, o depositando più denaro nel tuo account, dove non è necessaria alcuna dichiarazione di reso.

Tuttavia, sul vostro metodo di ritirarsi:

func withdraw(amount : Double) -> Bool { 
    if balance > amount { 
     balance -= amount 
     return true 
    } else { 
     println("Insufficient funds") 
     return false 
    } 
} 

Questo metodo prende un singolo parametro di Tipo Doppio, e restituisce una booleano. Per quanto riguarda il tuo ritirare metodo, se il vostro equilibrio è inferiore alla quantità che si sta cercando di prelevare (importo), allora questo non è possibile, è per questo che rendimentifalsa , ma se hai abbastanza soldi nel tuo account, con grazia ritira il denaro e restituisce true, per agire come se l'operazione fosse andata a buon fine.

Spero che questo chiarisca un po 'di quello su cui eri confuso.

Answer 2

Partenza Function Parameters and Return Values nella documentazione Swift:

Le funzioni non sono tenuti a definire un tipo di ritorno. Ecco una versione della funzione sayHello, chiamato sayGoodbye, che consente di stampare il proprio valore String invece di restituirla:

func sayGoodbye(personName: String) { 
    println("Goodbye, \(personName)!") 
} 
sayGoodbye("Dave") 
// prints "Goodbye, Dave!" 

Perché non ha bisogno di restituire un valore, definizione della funzione non include la freccia di ritorno (- >) o un tipo di reso.

Nell'esempio, deposit(_:) non restituisce nulla, modifica solo una variabile di istanza. Questo è tipico delle funzioni che avranno sempre successo.

withdraw(:_), d'altra parte, potrebbe non riuscire (a causa di fondi insufficienti), quindi restituisce un Bool che indica se ha funzionato o meno.

Answer 3

Benvenuti in programmazione! Buone domande, seguitela e farai bene.

Le funzioni con valore di ritorno forniscono informazioni sul codice chiamante. Ad esempio, per la funzione di deposito, c'è l'aspettativa che non accada nulla di insolito, quindi non si preoccupa di restituire tutto ciò che potrebbe essere controllato dal chiamante.

Nella funzione di prelievo, è possibile che l'importo da prelevare possa essere superiore al saldo disponibile. Se questo è il caso, la funzione restituirà false. La funzione di chiamata potrebbe controllare quel valore e avvisare l'utente che sta tentando di prelevare più di quanto sia disponibile. Otoh, se viene restituito un valore di true, il programma dedurrà tale importo dal bilancio e presumibilmente fornirà al cliente i fondi richiesti.

Answer 4

Questa domanda può essere definita come indipendente dalla lingua, quindi sii la mia risposta.

Un metodo è un blocco di codice che contiene una serie di istruzioni. I metodi possono restituire un valore al chiamante, ma non devono farlo. È la decisione di te come sviluppatore. Il metodo che restituisce un valore al chiamante sarà la parola chiave: "return" e un tipo di valore dichiarato nella firma del metodo.

vorrei menzionare il principioComando Query Separation (CQS) coniato da Bertrand Meyer. Martin Fowlerrephrased: L'idea fondamentale è che dovremmo dividere i metodi di un oggetto in due categorie nettamente separate:

• Query: restituire un risultato e non modificare lo stato osservabile del sistema (sono liberi di effetti collaterali). Mark Seemann ha detto che le query non mutano lo stato osservabile. Sono idempotenti e sicuri da invocare.
• Comandi: modifica lo stato di un sistema ma non restituisce un valore. È possibile, ed è sicuro richiamare query dai comandi, ma non viceversa.