Web3 & DApp Development Fundamentals · Lektion

Variablen und Datentypen

Erkunden Sie die grundlegenden Datentypen von Solidity (uint, address, bool, bytes) und erfahren Sie, wie Variablen in Smart Contracts deklariert und verwendet werden.

Variablen und Datentypen ist eine kostenlose Web3 & DApp Development Fundamentals-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Web3 & DApp Development Fundamentals-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Variables & Data Types: The Basics

Welcome to Lesson 2! In Solidity, just like other programming languages, we need ways to store and manage information.

This is where variables and data types come in handy. They are fundamental for building any smart contract.

Variables: Think of them as containers that hold a specific piece of data.
Data Types: Define what kind of data a variable can hold (e.g., numbers, text, true/false).

Storing Whole Numbers: `uint`

The uint data type is used to store unsigned integers. 'Unsigned' means they can only hold positive whole numbers (including zero).

uint can range from uint8 (8 bits) up to uint256 (256 bits).
uint256 is the default if you just write uint.
These are perfect for token balances, counts, or IDs.

`uint` Variable Example

Let's see how to declare and use uint variables in a simple contract. Notice how we use public to make them accessible from outside the contract.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyNumbers {
    uint public myFavoriteNumber; // Default uint256
    uint8 public smallCount;     // uint with 8 bits

    constructor() {
        myFavoriteNumber = 42;
        smallCount = 100;
    }

    function getFavoriteNumber() public view returns (uint) {
        return myFavoriteNumber;
    }

    function getSmallCount() public view returns (uint8) {
        return smallCount;
    }
}

True or False: The `bool` Type

The bool data type is simple but powerful. It can only hold one of two values: true or false.

Booleans are essential for conditional logic, like checking if a user has permission or if a process is complete.
By default, a bool variable is initialized to false if not explicitly set.

`bool` Variable Example

Here's a contract demonstrating how to declare and manipulate bool variables. We can set their initial state and update them later.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyFlags {
    bool public isActive;  // Default false, set to true in constructor
    bool private isAdmin; // Only accessible within the contract

    constructor() {
        isActive = true;
        isAdmin = false;
    }

    function getIsActive() public view returns (bool) {
        return isActive;
    }

    function setIsAdmin(bool _isAdmin) public {
        isAdmin = _isAdmin;
    }

    function checkAdmin() public view returns (bool) {
        return isAdmin;
    }
}

Handling Accounts: The `address` Type

The address data type is unique to blockchain development. It stores a 20-byte value, which represents an Ethereum account or contract address.

Every user wallet and smart contract on Ethereum has an address.
There's also address payable, which is an address that can receive Ether. You'll learn more about this later!
address types are crucial for managing ownership, permissions, and interactions between accounts.

`address` Variable Example

This example shows how a contract can store and retrieve addresses. msg.sender is a special global variable that always refers to the address that initiated the current transaction.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AccountManager {
    address public owner; // Stores the contract deployer's address
    address public lastInteractedUser;

    constructor() {
        owner = msg.sender; // Set owner to the deployer
    }

    function setLastInteractedUser() public {
        lastInteractedUser = msg.sender; // Update with current caller
    }

    function getOwner() public view returns (address) {
        return owner;
    }

    function getLastInteractedUser() public view returns (address) {
        return lastInteractedUser;
    }
}

Raw Data: `bytes` & `bytesN`

When you need to store raw byte sequences, Solidity provides the bytes and bytesN types.

bytes: A dynamically-sized array of bytes. Use it when the size of the data isn't fixed.
bytes1 to bytes32: Fixed-size byte arrays, where N specifies the exact number of bytes (e.g., bytes32 for a cryptographic hash).
These are often used for cryptographic hashes, arbitrary binary data, or short strings where gas efficiency is critical.

`bytes` Variable Example

Here, we store a fixed-size hash using bytes32 and a dynamic sequence of bytes using bytes. Notice the hexadecimal literal for the hash and the hex"..." prefix for byte values.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataStorage {
    bytes32 public documentHash; // Fixed 32-byte hash
    bytes public dynamicData;    // Dynamic byte array

    constructor() {
        // Example hash (0x prefixed hex literal)
        documentHash = 0x123456789012345678901234567890123456789012345678901234567890abcd;
        // Example dynamic data (hex string "hello")
        dynamicData = hex"68656c6c6f"; 
    }

    function updateDynamicData(bytes memory _newData) public {
        dynamicData = _newData;
    }

    function getDocumentHash() public view returns (bytes32) {
        return documentHash;
    }

    function getDynamicData() public view returns (bytes memory) {
        return dynamicData;
    }
}

Data Type Challenge

Choosing the right data type is crucial for efficiency and security in smart contracts. Test your knowledge!

Variables & Types: Key Takeaways

Great job! You've learned the fundamental data types in Solidity:

uint: For positive whole numbers (balances, counts).
bool: For true/false values (flags, conditions).
address: For Ethereum accounts and contract addresses.
bytes/bytesN: For raw, uninterpreted byte sequences (hashes, arbitrary data).

Choosing the correct data type is vital for writing efficient and secure smart contracts. Next, we'll explore how to define functions and control the flow of your contract's logic!

Häufig gestellte Fragen

Ist die Lektion „Variablen und Datentypen“ kostenlos?

Ja — der vollständige Text von „Variablen und Datentypen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Web3 & DApp Development Fundamentals-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Variablen und Datentypen“?

Erkunden Sie die grundlegenden Datentypen von Solidity (uint, address, bool, bytes) und erfahren Sie, wie Variablen in Smart Contracts deklariert und verwendet werden. Du übst Web3 & DApp Development Fundamentals mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Web3 & DApp Development Fundamentals zu starten?

Keine Vorkenntnisse erforderlich. Web3 & DApp Development Fundamentals auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Variablen und Datentypen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Web3 & DApp Development Fundamentals-Lektion Code schreiben und ausführen?

Ja. Jede Web3 & DApp Development Fundamentals-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Web3 & DApp Development Fundamentals