6

I am a beginner in Swift so some things aren't quite clear to me yet. I hope somebody would explain this to me:

// 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)

So this is the code. I am wondering why deposit() doesn't have a return arrow and return keyword and withdraw() does. When do I use a return arrow, in what situations, is there a rule or something? I don't understand.

In addition... Everyone is so kind with your answers, it is getting clearer to me now.

In beginning of this tutorial there is practice code for functions

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

I imagine this return value is not needed here but in tutorial they wanted to show us that it exists, am I right?

Furthermore, can I make a "mistake" and use return arrow and value in my deposit function somehow? I tried with this:

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

... but it generated error.

I saw advanced coding in my last firm, they were creating online shop with many custom and cool features and all code was full of return arrows. That confused me and I thought that it is a default for making methods/functions in OOP.

Additional question! I wanted to play with functions so I want to create a function transferFunds() which transfers money from one account to another. I made function like this

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.")
     }
}

This is a simple code that came to my mind but I know it is maybe even stupid. I know there should be a code that check if there is enough funds in first account from which I am taking money, but okay... Lets play with this. I want to specify accountNumbers or something else in parameters within function transferFunds() and I want to search through all objects/clients in my imaginary bank which use class BankAccount in order to find one and then transfer money. I don't know if I described my problem correctly but I hope you understand what I want to do. Can somebody help me, please?

Improve this question
8
  • 1
    This isn't a Swift question as such, but rather a general programming question. I imagine, never having used Swift, the arrow indicates a return type. In this case, withdraw returns a boolean to say whether or not withdraw was a successful operation or not. You could also do the same for deposit, return a boolean to say whether or not the deposit was successful. There is no hard and fast rule for this, it's something that comes with practice. Commented Jun 23, 2015 at 16:59
  • I am so glad I started on Pascal when function without a return type were called procedures. Commented Jun 23, 2015 at 17:06
  • @Antonija, The return type 'String' is actually needed. You must declare the type of the variable being returns in the function. As for the last example, you cannot use return before the expression that uses the '+=' operator. You'll have to add a new line: return balance, or maybe in one line: return ++balance (in some programming languages). Pay attention that this type of method violates the CQS principle as described in my answer, because it is both a command and a query. Commented Jun 23, 2015 at 18:05
  • A-ha! moment. Thanks. func deposit(amount : Double) -> Double { balance += amount return balance } and it works. Is it a mistake to write functions like that all the time? Commented Jun 23, 2015 at 18:10
  • @Antonija, you welcome. It is not a mistake, but can cause ambiguity when you work with other developers. You should have a standard for everyone to go with. When you want to deposit, you want a function to do it and forget about it. Getting the result back is not the role of the command. He can get confuse: 'Why did it return a value?', 'I just told it to deposit!'. It is better to separate concerns. If someone want to get balance it is better to have getBalance() method [=query]. Because sometimes you have logic in getting the balance. Like fees and etc.So, you better have one central place. Commented Jun 23, 2015 at 18:41

5 Answers 5

Reset to default
7

So in Swift, a function that has no arrow has a return type of Void:

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

This could be rewritten as:

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

so in your case...

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

your method deposit takes a single parameter of Type Double and this returns nothing, which is exactly why you do not see a return statement in your method declaration. This method is simply adding, or depositing more money into your account, where no return statement is needed.

However, onto your withdraw method:

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

This method takes a single parameter of Type Double, and returns a Boolean. In regard to your withdraw method, if your balance is less than the amount you're trying to withdraw (amount), then that's not possible, which is why it returns false, but if you do have enough money in your account, it gracefully withdraws the money, and returns true, to act as if the operation was successful.

I hope this clears up a little bit of what you were confused on.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

Welcome to programming! Good questions, stick with it and you'll do well.

The functions that have a return value are providing the calling code with information. For example, for the deposit function, there is the expectation that nothing unusual will happen, so it's not bothering to return anything that could be checked by the caller.

In the withdrawal function, it's possible that the amount to be withdrawn could be greater than the balance available. If this is the case, the function will return false. The calling function could check that value and notify the user that they're attempting to withdraw more than is available. Otoh, if a value of true is returned, then the program will deduct that amount from the balance and presumably provide the customer with the funds requested.

Improve this answer

Comments

1

Check out Function Parameters and Return Values in the Swift docs:

Functions are not required to define a return type. Here’s a version of the sayHello function, called sayGoodbye, which prints its own String value rather than returning it:

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

Because it does not need to return a value, the function’s definition does not include the return arrow (->) or a return type.

In your example, deposit(_:) doesn't return anything, it just modifies an instance variable. This is typical of functions which will always succeed.

withdraw(:_), on the other hand, might fail (due to insufficient funds), so it returns a Bool indicating whether it worked or not.

Improve this answer

2 Comments

To play the part of a pedant, there is a chance the double could overflow without any checks (unless that's not possible in Swift), so it could fail.
@TEK Right. (Swift will report an error for overflow). Also the caller could pass a negative value which would be unintended.
0

This question can be referred as a language-agnostic one, so be my answer to you.

A method is a code block that contains a series of statements. Methods can return a value to the caller, but doesn't have to do so. It is the decision of you as the developer. Method that returns a value to the caller will consist the keyword: "return", and a value type declared in the method signature.

I would mention the Command Query Separation (CQS) principle coined by Bertrand Meyer. Martin Fowler rephrased: The fundamental idea is that we should divide an object's methods into two sharply separated categories:

  • Queries: Return a result and do not change the observable state of the system (are free of side effects). Mark Seemann said queries do not mutate observable state. They are idempotent and safe to invoke.
  • Commands: Change the state of a system but do not return a value. You can, and it is safe to invoke queries from commands, but not vice versa.
Improve this answer

2 Comments

In iOS and Mac development, it's a very common pattern for a command to return a Bool indicating whether the command was executed successfully. (I think CQS could still apply.)
@AaronBrager, that's an interesting fact. The key is to be consistent about the conventions.
0

Source: https://thenucleargeeks.com/2019/05/08/functions-in-swift/ In swift a function is defined by “func” keyword. When a function is declared based on requirement it may take one or more parameter, process it and return the valueFunction with no parameters and no return value.

Function with no parameter and no return type.

Syntax:
func function_name() {
--
}
func addTwoNumbers() {
let a = 1
let b = 2
let c = a+b
print(c)  // 3
}

addTwoNumbers()

Function with no parameter and return type

Syntax:
func function_name() -> Data Type {
 --
return some values
}
func addTwoNumbers()->Int {
let a = 1
let b = 2
let c = a+b
return c 
}

let sum = addTwoNumbers()
print(sum) // 3

Function with parameter and return type

Syntax: 
func function_name(arguments parameter_name: Data Type) -> Data Type { 
------ 
return some values 
}
func addTwoNumbers(arg param: Int)->Int {
let a = param
let b = 2
let c = a+b
return c
}

let sum = addTwoNumbers(arg: 4)
print(sum) // 6

Alternately you can skip the arg and directly pass the value to the function.

func addTwoNumbers(param: Int)->Int {
let a = param
let b = 2
let c = a+b
return c
}

let sum = addTwoNumbers(param: 4)
print(sum) // 6

Function with parameter and no return type

Syntax: 
func function_name(arguments parameter_name: Data Type)  {
  ----
 return some values
}
func addTwoNumbers(arg param: Int){
let a = param
let b = 2
let c = a+b
print(c)  //6
}
addTwoNumbers(arg: 4)
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.