Asas Pembangunan Web3 & DApp · Pelajaran

Teknik Pengoptimuman Gas

Pelajari strategi menulis kod Solidity yang cekap gas, mengurangkan kos transaksi dan meningkatkan prestasi DApp pada rantaian blok.

Pelajaran 3 daripada 311 langkah

Teknik Pengoptimuman Gas ialah pelajaran Asas Pembangunan Web3 & DApp percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Asas Pembangunan Web3 & DApp, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Asas Pembangunan Web3 & DApp merangkumi sejumlah 3 pelajaran.

Mengapa Pengoptimuman Gas Penting

Selamat datang ke pelajaran terakhir dalam Keselamatan & Pengauditan DApp! Hari ini, kita akan menguasai Teknik Pengoptimuman Gas.

Gas ialah bayaran yang dikenakan untuk melaksanakan transaksi pada rangkaian Ethereum. Ia seperti bahan api untuk kereta anda.

Pengurangan Kos: Yuran gas yang lebih rendah bermaksud transaksi yang lebih murah untuk pengguna.
Prestasi: Kontrak yang dioptimumkan dilaksanakan dengan lebih pantas.
Pengalaman Pengguna: Prestasi yang lebih baik menghasilkan pengguna yang lebih berpuas hati dan DApp yang lebih lancar.

Memahami Kos Gas

Setiap operasi yang dilakukan oleh Mesin Maya Ethereum (EVM) memerlukan jumlah gas tertentu. Operasi yang kompleks memerlukan lebih banyak gas.

Apabila anda menggunakan atau berinteraksi dengan kontrak pintar, anda membayar gas untuk:

Menyimpan data pada rantaian blok (paling mahal).
Melakukan pengiraan.
Menghantar Ether.

Matlamat kita adalah untuk menulis kod yang menggunakan lebih sedikit operasi mahal ini.

Storan berbanding Memori berbanding Data Panggilan

Memahami tempat data anda berada ialah kunci untuk menjimatkan gas. Setiap lokasi mempunyai kos yang berbeza:

Storan: Kekal, dalam rantaian. Paling mahal untuk dibaca/ditulis (SSTORE/SLOAD).
Memori: Sementara, hanya wujud semasa pelaksanaan fungsi. Lebih murah daripada storan.
Data panggilan: Tidak berubah, baca sahaja dan sementara. Digunakan untuk argumen fungsi luaran. Paling murah untuk input luaran.

Utamakan penggunaan calldata atau memory untuk pemboleh ubah yang tidak perlu kekal dalam rantaian.

Minimumkan Penulisan Storan (SSTORE)

Menulis ke storan (SSTORE) ialah operasi tunggal yang paling mahal dalam Solidity. Sentiasa tanya: adakah pemboleh ubah ini benar-benar perlu disimpan dalam rantaian?

Daripada mengemas kini pembilang dalam storan pada setiap lelaran, kirakannya sekali pada akhir atau gunakan peristiwa untuk merekodkan perubahan.

Pertimbangkan contoh mudah ini:

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

contract StorageCostExample {
    uint256 public counter;

    // High gas cost: writes to storage every call
    function incrementBad() public {
        counter++;
    }

    // Lower gas cost: only reads state
    function getCounter() public view returns (uint256) {
        return counter;
    }
}

Membungkus Pemboleh Ubah Storan

Solidity menyimpan pemboleh ubah dalam 'slot' 256 bit (32 bait). Jika anda mengisytiharkan beberapa pemboleh ubah yang boleh dimuatkan dalam satu slot, pemboleh ubah tersebut boleh 'dibungkus' bersama untuk menjimatkan gas.

Contohnya, tiga pemboleh ubah uint8 menggunakan storan yang lebih sedikit berbanding tiga pemboleh ubah uint256 jika diisytiharkan berturutan. Ini menjimatkan operasi SSTORE.

Isytiharkan jenis data yang lebih kecil (contohnya, uint8, bool) apabila boleh.
Kumpulkan pemboleh ubah yang mempunyai saiz serupa bersama-sama.

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

contract StoragePacking {
    // These will likely pack into one slot
    uint8 public value1;
    bool public isActive;
    uint8 public value2;

    // This will take a separate slot
    address public owner;

    function setValues(uint8 _v1, bool _active, uint8 _v2) public {
        value1 = _v1;
        isActive = _active;
        value2 = _v2;
    }
}

Pintasan Bersyarat

Apabila menggunakan operator logik seperti && (AND) atau || (OR), Solidity menggunakan 'pintasan'. Ini bermaksud penilaian syarat dihentikan sebaik sahaja hasilnya diketahui.

Anda boleh menjimatkan gas dengan meletakkan syarat yang lebih murah, lebih berkemungkinan gagal atau lebih berkemungkinan benar terlebih dahulu.

Untuk &&, letakkan syarat yang paling berkemungkinan false terlebih dahulu.
Untuk ||, letakkan syarat yang paling berkemungkinan true terlebih dahulu.

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

contract ShortCircuitExample {
    uint256 public data = 100;

    function checkCondition(uint256 _input) public view returns (bool) {
        // Cheaper check (input) before more expensive check (storage read)
        return (_input > 0 && data > 50); 
    }
}

Gelung & Lelaran yang Cekap

Gelung boleh menggunakan banyak gas, terutamanya jika melakukan lelaran pada tatasusunan besar yang disimpan dalam storan. Elakkan gelung tanpa had atau gelung pada tatasusunan dinamik dalam storan apabila boleh.

Proses data di luar rantaian jika boleh.
Gunakan tatasusunan bersaiz tetap dan bukannya tatasusunan dinamik jika saiznya diketahui.
Susun semula logik untuk mengelakkan gelung atau mengurangkan lelaran.
Pertimbangkan sistem berasaskan pengambilan untuk pembayaran, dan bukannya menghantar pembayaran kepada ramai penerima dalam satu transaksi.

Menggunakan Fungsi `view` dan `pure`

Fungsi yang ditandai sebagai view atau pure tidak mengubah keadaan rantaian blok. Apabila dipanggil secara luaran, fungsi ini tidak memerlukan sebarang gas!

view: Membaca pemboleh ubah keadaan tetapi tidak mengubahnya.
pure: Tidak membaca atau mengubah pemboleh ubah keadaan.

Panggilan dalaman kepada fungsi view/pure masih menggunakan gas (sebagai sebahagian daripada transaksi yang lebih besar), tetapi penggunaan yang betul untuk pertanyaan luaran dapat menjimatkan banyak gas pengguna.

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

contract ViewPureExample {
    uint256 public myNumber = 42;

    // Costs no gas for external calls
    function getNumber() public view returns (uint256) {
        return myNumber;
    }

    // Costs no gas for external calls
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
}

Kos Gas Pengendalian Ralat

Solidity menyediakan beberapa cara untuk mengendalikan ralat: require(), revert() dan assert().

require(): Digunakan untuk mengesahkan input dan syarat. Memulangkan gas yang tidak digunakan apabila gagal. (Disyorkan untuk kebanyakan semakan)
revert(): Serupa dengan require dan turut memulangkan gas yang tidak digunakan.
assert(): Digunakan untuk invarian dalaman dan sepatutnya *tidak pernah* gagal. Menggunakan SEMUA gas yang berbaki apabila gagal. (Gunakan secara terhad untuk semakan dalaman kritikal)

Kegagalan assert jauh lebih mahal berbanding kegagalan require, jadi pilih pengendalian ralat anda dengan bijak.

Soalan: Pengoptimuman Gas

Pertimbangkan petikan Solidity berikut. Perubahan yang manakah berkemungkinan menghasilkan penjimatan gas yang paling ketara untuk pengguna yang memanggil updateStatus?

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

contract GasPuzzle {
    uint256 public statusId;
    string public statusName;
    address public owner;

    constructor() {
        owner = msg.sender;
        statusId = 1;
        statusName = "Initial";
    }

    function updateStatus(uint256 _newId, string memory _newName) public {
        require(msg.sender == owner, "Not owner");
        statusId = _newId;
        statusName = _newName;
    }
}

Jawab dalam pelajaran interaktif

Imbas Kembali: Penguasaan Pengoptimuman Gas

Anda telah menguasai strategi utama untuk menulis kod Solidity yang cekap gas!

Ingat prinsip ini:

Minimumkan Penulisan Storan: Peraturan emas.
Bungkus Pemboleh Ubah: Kumpulkan pemboleh ubah kecil supaya muat dalam slot.
Gunakan Lokasi Data yang Cekap: Utamakan calldata/memory berbanding storage.
Optimumkan Gelung: Elakkan lelaran tanpa had atau lelaran yang besar.
Manfaatkan view/pure: Untuk pembacaan luaran tanpa gas.
Pengendalian Ralat yang Bijak: Gunakan require/revert, bukan assert untuk input pengguna.

Penggunaan teknik ini akan menghasilkan DApp yang lebih mampu milik, lebih pantas dan lebih mesra pengguna. Teruskan berlatih!

Percuma untuk bermula

Pelajari Asas Pembangunan Web3 & DApp dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 29
Pelajaran: 105

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Teknik Pengoptimuman Gas” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Asas Pembangunan Web3 & DApp, termasuk “Teknik Pengoptimuman Gas”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Asas Pembangunan Web3 & DApp merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Teknik Pengoptimuman Gas”?

Pelajari strategi menulis kod Solidity yang cekap gas, mengurangkan kos transaksi dan meningkatkan prestasi DApp pada rantaian blok. Anda berlatih Asas Pembangunan Web3 & DApp menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Asas Pembangunan Web3 & DApp?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Asas Pembangunan Web3 & DApp di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Teknik Pengoptimuman Gas” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Asas Pembangunan Web3 & DApp ini?

Ya. Setiap pelajaran Asas Pembangunan Web3 & DApp menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Asas Pembangunan Web3 & DApp