الدوال ومعدّلات الرؤية

Welcome to Lesson 3! Today, we'll dive into functions in Solidity. Think of functions as the actions or operations your smart contract can perform.

They allow you to organize your code, make it reusable, and define how users (or other contracts) can interact with your contract's data and logic.

Every function needs a name and a body where its code lives. Here's the basic structure:

• Keyword function
• Function name (e.g., greet)
• Parentheses () for parameters
• Curly braces {} for the code block

Let's see a very simple example.

This contract has a function named getName. It doesn't take any inputs and simply returns a string. We'll add visibility soon!

Try running it to see how a function can return a value.

Solidity functions, like variables, have visibility modifiers. These define who can call a function and how.

Understanding visibility is crucial for security and proper contract design. There are four types: public, external, internal, and private.

A public function is the most accessible. It can be called:

• From outside the contract (by users or other contracts).
• From inside the contract (by other functions within the same contract).

If you don't specify a visibility, functions are public by default. It's good practice to always specify it explicitly.

Here, setValue and getValue are both public. You can call them directly from an external account or another contract.

Run this example and try calling both functions after deploying.

external functions can only be called from outside the contract. They cannot be called internally by other functions within the same contract.

This is often used for functions that are entry points for external interactions. It's also more gas-efficient for receiving large arrays of data.

Notice how onlyExternal can only be called from outside. If another function inside ExternalExample tried to call it, it would result in a compilation error.

Run this to see the external interaction.

internal functions can only be called from within the current contract or by contracts that inherit from it.

private functions are the most restricted. They can only be called from within the contract they are defined in. Even inheriting contracts cannot call them.

These are great for helper functions that shouldn't be exposed externally.

Functions can accept parameters (inputs) and return values (outputs).

• Parameters are defined inside the parentheses ().
• Return types are specified using the returns (type) keyword.

This allows functions to be dynamic and process different data.

Which of the following function visibility modifiers means a function can ONLY be called from outside the contract, but NOT from another function within the same contract?

Great job! You've learned the fundamentals of Solidity functions.

• Functions organize contract logic.
• public: Callable from anywhere.
• external: Callable only from outside.
• internal: Callable from within & by derived contracts.
• private: Callable only from within the defining contract.
• Functions can take parameters and return values.

Next, we'll explore more complex data structures like mappings and dynamic arrays!