Blockchain Smart Contracts with Solidity · Aula

Funções e modificadores de visibilidade

Entenda como definir funções, gerenciar sua visibilidade (public, private, internal, external) e lidar com parâmetros e valores de retorno.

Funções e modificadores de visibilidade é uma aula grátis de Blockchain Smart Contracts with Solidity no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Blockchain Smart Contracts with Solidity, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Functions: Your Contract's Actions

Bem-vindo à Lição 3! Hoje, vamos mergulhar nas **funções** em Solidity. Pense nas funções como as ações ou operações que seu contrato inteligente pode executar. Elas permitem organizar seu código, torná-lo reutilizável e definir como os usuários (ou outros contratos) podem interagir com os dados e a lógica do seu contrato.

Defining a Simple Function

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.

Basic Function 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.

pragma solidity ^0.8.0;

contract MyFirstFunctions {
    function getName() pure returns (string memory) {
        return "Coddy";
    }
}

Controlling Access: Visibility

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.

Public Functions: Open for All

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.

Public Function in Action

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.

pragma solidity ^0.8.0;

contract PublicExample {
    uint public myValue;

    function setValue(uint _newValue) public {
        myValue = _newValue;
    }

    function getValue() public view returns (uint) {
        return myValue;
    }
}

External Functions: External Calls Only

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.

External Function Example

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.

pragma solidity ^0.8.0;

contract ExternalExample {
    uint public count = 0;

    function incrementExternal() external {
        count++;
    }

    // This function can't call incrementExternal() directly.
    // Try adding 'incrementExternal();' inside this function to see the error.
    function getCount() public view returns (uint) {
        return count;
    }
}

Internal & Private: For Internal Use

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.

Parameters & Return Values

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.

Function Visibility Check

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?

Recap: Functions & Visibility

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!

Perguntas Frequentes

A aula “Funções e modificadores de visibilidade” é grátis?

Sim — o texto completo de “Funções e modificadores de visibilidade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Blockchain Smart Contracts with Solidity, atualize para CoddyKit PRO. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

O que vou aprender em “Funções e modificadores de visibilidade”?

Entenda como definir funções, gerenciar sua visibilidade (public, private, internal, external) e lidar com parâmetros e valores de retorno. Você pratica Blockchain Smart Contracts with Solidity com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Blockchain Smart Contracts with Solidity?

Nenhuma experiência prévia é necessária. Blockchain Smart Contracts with Solidity no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Funções e modificadores de visibilidade”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Blockchain Smart Contracts with Solidity?

Sim. Cada aula de Blockchain Smart Contracts with Solidity inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Blockchain Smart Contracts with Solidity