Return values in Blockchain / Solidity

Introduction

Return values let a function send back a result after it finishes. This helps you use that result later in your program.

When you want to get the outcome of a calculation from a function.

When you need to pass data from one part of your blockchain code to another.

When you want to check if a transaction was successful and get its details.

When you want to reuse a function's result without repeating the work.

Syntax

Blockchain / Solidity

function functionName(parameters) returns (returnType) {
    // code
    return value;
}

The returns keyword specifies the type of value the function will send back.

Use return inside the function to send the value back.

Examples

This function returns the balance of the current contract as an unsigned integer.

Blockchain / Solidity

function getBalance() public view returns (uint) {
    return address(this).balance;
}

This function adds two numbers and returns the result.

Blockchain / Solidity

function add(uint a, uint b) public pure returns (uint) {
    return a + b;
}

This function returns a fixed string.

Blockchain / Solidity

function getName() public pure returns (string memory) {
    return "Blockchain";
}

Sample Program

This contract has a function multiply that returns the product of two numbers. The testMultiply function calls multiply and returns a string showing the result.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleCalculator {
    function multiply(uint x, uint y) public pure returns (uint) {
        return x * y;
    }

    function testMultiply() public pure returns (string memory) {
        uint result = multiply(3, 4);
        return string(abi.encodePacked("3 times 4 is ", uint2str(result)));
    }

    function uint2str(uint _i) internal pure returns (string memory str) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint length;
        while (j != 0) {
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint k = length;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(_i - _i / 10 * 10));
            bstr[k] = bytes1(temp);
            _i /= 10;
        }
        str = string(bstr);
    }
}

Important Notes

Functions can return only one value or multiple values using tuples.

Remember to match the return type in the function signature with the actual returned value.

In blockchain smart contracts, returning values helps verify results without changing the blockchain state.

Summary

Return values let functions send results back to where they were called.

Use returns to specify the type and return to send the value.

Return values help reuse results and check outcomes in blockchain code.

Practice

1.

What does the return statement do in a blockchain smart contract function?

easy

A. It sends a value back to the caller of the function.

B. It stops the contract from deploying.

C. It creates a new transaction on the blockchain.

D. It changes the contract's address.

Solution

1. Step 1: Understand the purpose of return

   The return statement is used inside a function to send a value back to whoever called the function.

2. Step 2: Identify what return does in blockchain functions

   In smart contracts, returning a value allows the caller to receive data from the function execution.

3. Final Answer:

   It sends a value back to the caller of the function. -> Option A

4. Quick Check:

   Return sends value back [OK]

Hint: Return sends data back to caller, not change contract [OK]

Common Mistakes:

• Thinking return creates transactions
• Confusing return with contract deployment
• Believing return changes contract address

2.

Which of the following is the correct syntax to specify a function that returns an uint in Solidity?

function getValue() _____ { return 42; }

easy

A. returns uint

B. return uint

C. return (uint)

D. returns (uint)

Solution

1. Step 1: Recall Solidity function return syntax

   In Solidity, the correct way to specify a return type is returns (type) after the function parentheses.

2. Step 2: Match the syntax with options

   returns (uint) uses returns (uint), which is the correct syntax.

3. Final Answer:

   returns (uint) -> Option D

4. Quick Check:

   Solidity uses returns (type) [OK]

Hint: Remember: returns keyword with parentheses for type [OK]

Common Mistakes:

• Omitting parentheses around type
• Using return instead of returns
• Placing return type inside function body

3.

What will be the output of this Solidity function call?

function multiply(uint a, uint b) public pure returns (uint) { return a * b; }

Calling multiply(3, 4) returns:

medium

A. 7

B. 12

C. 34

D. Error

Solution

1. Step 1: Understand the function logic

   The function multiplies two unsigned integers a and b and returns the product.

2. Step 2: Calculate the product of 3 and 4

   3 multiplied by 4 equals 12, so the function returns 12.

3. Final Answer:

   12 -> Option B

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply inputs and return result [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Expecting syntax error

4.

Identify the error in this Solidity function that is supposed to return a bool:

function isEven(uint num) public pure returns (bool) { if (num % 2 == 0) { true; } else { false; } }

medium

A. Missing return statements before true and false.

B. The function should return uint instead of bool.

C. The modulus operator % is not allowed in Solidity.

D. The function should be marked as view instead of pure.

Solution

1. Step 1: Check the return statements

   The function uses true; and false; without return, so it does not actually return any value.

2. Step 2: Understand Solidity return requirements

   Every return value must be preceded by the return keyword to send the value back.

3. Final Answer:

   Missing return statements before true and false. -> Option A

4. Quick Check:

   Return keyword needed before values [OK]

Hint: Always use return before the value to send back [OK]

Common Mistakes:

• Omitting return keyword
• Confusing pure and view modifiers
• Thinking modulus operator is invalid

5.

You want to write a Solidity function that returns the sum of all elements in a uint[] array. Which of the following implementations correctly returns the sum?

function sumArray(uint[] memory arr) public pure returns (uint) { uint total = 0; for (uint i = 0; i < arr.length; i++) { total += arr[i]; } _____ }

hard

A. return arr.length;

B. return i;

C. return total;

D. return arr;

Solution

1. Step 1: Understand the function logic

   The function sums all elements in the array by adding each element to total.

2. Step 2: Identify the correct return value

   After the loop, the sum is stored in total, so returning total gives the correct sum.

3. Final Answer:

   return total; -> Option C

4. Quick Check:

   Return the sum variable total [OK]

Hint: Return the accumulator variable holding the sum [OK]

Common Mistakes:

• Returning array length instead of sum
• Returning loop index variable
• Returning the whole array instead of a value