Blockchain Smart Contracts with Solidity · Lektion

Libraries und abstrakte Contracts

Erkunden Sie die Verwendung von Libraries für reine, wiederverwendbare Funktionen und abstrakten Contracts zur Definition grundlegender Funktionalitäten.

Lektion 2 von 411 Schritte

Libraries und abstrakte Contracts ist eine kostenlose Blockchain Smart Contracts with Solidity-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. 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 Blockchain Smart Contracts with Solidity-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Blockchain Smart Contracts with Solidity-Kurs umfasst insgesamt 4 Lektionen.

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

Module: Code Reusability

Welcome to Libraries and Abstract Contracts! In this lesson, we'll explore two powerful Solidity features that enhance code reusability, modularity, and maintainability.

You'll learn how to build reusable utility functions with libraries and define common interfaces and base functionalities using abstract contracts.

What are Solidity Libraries?

Solidity Libraries are like special contracts that contain reusable code. They are designed for utility functions and cannot have state variables (with rare advanced exceptions) or hold Ether.

They are deployed once and their code can be used by many contracts.
This promotes code reuse and can be gas-efficient for complex operations.
Functions within a library are typically internal or public.

Defining a Utility Library

To create a library, you use the library keyword. Let's define a simple MathUtils library that provides basic arithmetic functions. Notice that library functions are often pure or view as they don't modify state.

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

library MathUtils {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) internal pure returns (uint) {
        require(b <= a, "Subtraction overflow");
        return a - b;
    }
}

Integrating a Library

To use our MathUtils library, we link it to a data type within our contract using the using A for B; syntax. This makes the library's functions available on that data type.

Try deploying the SimpleCalculator and calling its functions!

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

library MathUtils {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) internal pure returns (uint) {
        require(b <= a, "Subtraction overflow");
        return a - b;
    }
}

contract SimpleCalculator {
    using MathUtils for uint; // Attaches MathUtils functions to uint

    function performAddition(uint x, uint y) public pure returns (uint) {
        return x.add(y); // Using the library's add function
    }

    function performSubtraction(uint x, uint y) public pure returns (uint) {
        return x.subtract(y); // Using the library's subtract function
    }
}

What are Abstract Contracts?

An abstract contract is a contract that cannot be deployed on its own. It's like a blueprint or a partial implementation for other contracts.

They define functions without implementing them (abstract functions).
They can also have implemented functions and state variables.
They serve as a base for other "concrete" contracts to inherit from, ensuring a common structure.

Blueprint with Abstract Contract

An abstract contract is declared using the abstract contract keyword. It must have at least one function declared without an implementation (meaning, without curly braces {}).

These unimplemented functions must be marked virtual in the abstract contract and override in the inheriting concrete contract.

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

abstract contract BaseShape {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }

    // An abstract function - no implementation here
    function getArea() public view virtual returns (uint);

    // Can also have implemented functions
    function getName() public view returns (string memory) {
        return name;
    }
}

Implementing an Abstract Contract

To use an abstract contract, another contract must inherit from it using the is keyword and provide implementations for all its abstract functions.

This ensures that any contract inheriting from BaseShape will have a getArea function, guaranteeing a common interface for all shapes.

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

abstract contract BaseShape {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }

    function getArea() public view virtual returns (uint);

    function getName() public view returns (string memory) {
        return name;
    }
}

contract Circle is BaseShape {
    uint public radius;
    // For simplicity, we'll use radius^2 as area, ignoring Pi.

    constructor(uint _radius) BaseShape("Circle") {
        radius = _radius;
    }

    // Must implement the abstract function from BaseShape
    function getArea() public view override returns (uint) {
        return radius * radius;
    }
}

contract Square is BaseShape {
    uint public side;

    constructor(uint _side) BaseShape("Square") {
        side = _side;
    }

    function getArea() public view override returns (uint) {
        return side * side;
    }
}

Libraries: Key Benefits

Libraries are a great choice when you need:

Pure Functions: Operations that don't change state, like complex math, string utilities, or data conversions.
Gas Efficiency: For external libraries, the bytecode is deployed once and its functions are called via a low-cost DELEGATECALL.
Modularity: Keeps your main contracts cleaner by offloading utility logic.
Reusability: Avoids duplicating common code across multiple contracts.

Abstract Contracts: Key Benefits

Abstract contracts are essential for:

Interface Enforcement: Guaranteeing that inheriting contracts implement a specific set of functions.
Base Functionality: Providing common state variables and implemented functions that all derived contracts will share.
Design Patterns: Implementing patterns like 'template method' where a high-level algorithm is defined, but specific steps are left to concrete implementations.
Polymorphism: Allowing different concrete implementations to be treated as the same base type.

Check Your Understanding

Which of the following statements about Solidity Libraries and Abstract Contracts are TRUE?

Beantworte es in der interaktiven Lektion

Recap: Libraries & Abstract Contracts

In this lesson, we explored two powerful tools for structuring Solidity code: Libraries and Abstract Contracts.

Libraries provide reusable, stateless utility functions, promoting modularity and gas efficiency. They are linked to contracts to extend their functionality.
Abstract Contracts act as blueprints, defining common interfaces and base functionalities that concrete contracts must inherit and implement. They enforce structure and promote consistency.

Mastering these patterns helps you write cleaner, more maintainable, and robust smart contracts in Solidity.

Kostenlos starten

Lerne Blockchain Smart Contracts with Solidity mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 12
Lektionen: 48

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Libraries und abstrakte Contracts“ kostenlos?

Ja — der vollständige Text von „Libraries und abstrakte Contracts“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Blockchain Smart Contracts with Solidity-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Blockchain Smart Contracts with Solidity-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Libraries und abstrakte Contracts“?

Erkunden Sie die Verwendung von Libraries für reine, wiederverwendbare Funktionen und abstrakten Contracts zur Definition grundlegender Funktionalitäten. Du übst Blockchain Smart Contracts with Solidity 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 Blockchain Smart Contracts with Solidity zu starten?

Keine Vorkenntnisse erforderlich. Blockchain Smart Contracts with Solidity 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 4.

Wie lange dauert die Lektion „Libraries und abstrakte Contracts“?

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 Blockchain Smart Contracts with Solidity-Lektion Code schreiben und ausführen?

Ja. Jede Blockchain Smart Contracts with Solidity-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

Vererbung und Interfaces
Libraries und abstrakte Contracts
Fehlerbehandlung mit Revert/Require
Modifier und das Checks-Effects-Interactions-Pattern

← Zurück zu Blockchain Smart Contracts with Solidity