Kontrak Pintar Rantaian Blok dengan Solidity · Pelajaran

Pemetaan dan Tatasusunan Dinamik

Laksanakan struktur data kompleks seperti pemetaan untuk pasangan kunci-nilai dan tatasusunan dinamik untuk senarai data yang fleksibel.

Pelajaran 2 daripada 412 langkah

Pemetaan dan Tatasusunan Dinamik ialah pelajaran Kontrak Pintar Rantaian Blok dengan Solidity percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kontrak Pintar Rantaian Blok dengan Solidity, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kontrak Pintar Rantaian Blok dengan Solidity merangkumi sejumlah 4 pelajaran.

Struktur Data Fleksibel

Selamat datang! Dalam Solidity, pengurusan koleksi data dengan cekap merupakan kunci kepada kontrak pintar yang kompleks. Hari ini, kita akan mendalami dua struktur data yang berkuasa: pemetaan dan tatasusunan dinamik.

Alat ini membolehkan kontrak anda menyimpan dan mendapatkan maklumat dengan cara yang fleksibel serta boleh diskalakan, yang penting untuk membina aplikasi terdesentralisasi yang kukuh.

Apakah Pemetaan?

Anggap pemetaan seperti kamus atau jadual cincangan. Ia menyimpan data sebagai pasangan kunci-nilai.

Anda memberikan kunci unik (seperti alamat atau ID).
Pemetaan mengembalikan nilai yang berkaitan dengan kunci tersebut (seperti baki atau nama pengguna).
Kunci tidak disimpan; hanya cincangan kriptografinya yang disimpan, menjadikan carian sangat cekap.

Mengisytiharkan Pemetaan

Untuk mengisytiharkan pemetaan, anda menentukan jenis kunci dan jenis nilai. Pemetaan biasanya diisytiharkan sebagai pemboleh ubah keadaan public.

Beginilah cara anda mengisytiharkan pemetaan untuk menyimpan uint (nilai) bagi setiap address (kunci):

pragma solidity ^0.8.0;

contract MyMappings {
    // A mapping from address to unsigned integer
    mapping(address => uint) public balances;

    // Another mapping: from uint ID to string name
    mapping(uint => string) public userNames;
}

Menyimpan Data dalam Pemetaan

Anda boleh menetapkan atau mengemas kini nilai dalam pemetaan dengan mudah menggunakan kuncinya. Jika kunci belum wujud, kunci itu akan dicipta.

Mari tambahkan fungsi untuk mengemas kini baki pengguna:

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    // Try calling setBalance with your address and a number,
    // then check balances(yourAddress) in Remix.
}

Mendapatkan Data daripada Pemetaan

Mengakses data adalah mudah: gunakan sahaja kuncinya. Jika anda cuba mendapatkan nilai bagi kunci yang belum ditetapkan, Solidity mengembalikan nilai lalai untuk jenis tersebut (contohnya, 0 untuk uint, rentetan kosong untuk string, address(0) untuk address).

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    function getBalance(address _user) public view returns (uint) {
        return balances[_user];
    }

    // Deploy, call setBalance, then getBalance.
    // Try getBalance for an address not yet set.
}

Apakah Tatasusunan Dinamik?

Tatasusunan dinamik ialah senarai elemen daripada jenis yang sama, tetapi tidak seperti tatasusunan bersaiz tetap, saiznya boleh berubah semasa masa jalan. Ini menjadikannya sesuai untuk keadaan apabila anda tidak mengetahui jumlah item yang tepat terlebih dahulu.

Saiznya boleh bertambah atau berkurang.
Elemen diakses melalui indeksnya (bermula daripada 0).
Penggunaannya untuk storage memerlukan lebih banyak gas berbanding tatasusunan bersaiz tetap.

Mengisytiharkan Tatasusunan Dinamik

Untuk mengisytiharkan tatasusunan dinamik, anda hanya perlu meninggalkan saiz dalam kurungan siku. Anda boleh mengisytiharkannya sebagai pemboleh ubah keadaan atau pemboleh ubah setempat (menggunakan memory atau calldata).

Berikut ialah contoh tatasusunan dinamik bagi uint:

pragma solidity ^0.8.0;

contract MyArrays {
    // A dynamic array of unsigned integers stored in state
    uint[] public numbers;

    // A dynamic array of strings (for memory use)
    function createNameList() public pure returns (string[] memory) {
        string[] memory names = new string[](0); // Initialize empty
        return names;
    }
}

Menambah Elemen pada Tatasusunan Dinamik

Cara yang paling biasa untuk menambah elemen pada tatasusunan dinamik adalah dengan menggunakan kaedah push(). Kaedah ini menambahkan elemen baharu pada hujung tatasusunan.

array.push(): Menambah elemen yang dimulakan dengan sifar.
array.push(value): Menambah nilai tertentu.

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public numbers;

    function addNumber(uint _num) public {
        numbers.push(_num); // Add _num to the end
    }

    function addDefault() public {
        numbers.push(); // Add a 0 to the end
    }

    function getLength() public view returns (uint) {
        return numbers.length;
    }
}

Mengakses dan Membuang Elemen

Anda boleh mengakses elemen melalui indeksnya (bermula daripada 0). Untuk membuang elemen, anda boleh menggunakan pop(), yang membuang elemen terakhir dan mengurangkan length tatasusunan.

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public data = [10, 20, 30, 40];

    function getElement(uint _index) public view returns (uint) {
        require(_index < data.length, "Index out of bounds");
        return data[_index];
    }

    function removeLast() public {
        data.pop(); // Removes 40
    }

    function getLength() public view returns (uint) {
        return data.length;
    }
}

Lanjutan: Pemetaan Tatasusunan

Anda boleh menggabungkan struktur ini! Corak yang biasa ialah pemetaan yang jenis nilainya merupakan tatasusunan dinamik. Ini membolehkan anda mengaitkan senarai item dengan satu kunci, seperti sejarah transaksi pengguna.

Berikut ialah contoh pemetaan alamat kepada tatasusunan dinamik uint:

pragma solidity ^0.8.0;

contract UserData {
    mapping(address => uint[]) public transactionHistory;

    function addTransaction(address _user, uint _amount) public {
        transactionHistory[_user].push(_amount);
    }

    function getUserTransactions(address _user) public view returns (uint[] memory) {
        return transactionHistory[_user];
    }

    // Add a few transactions for your address, then view them.
}

Uji Pemahaman Anda

Pertimbangkan petikan kod Solidity berikut:

pragma solidity ^0.8.0;

contract DataStructures {
    mapping(address => uint) public scores;
    uint[] public participants;

    function recordScore(address _player, uint _score) public {
        if (scores[_player] == 0) {
            participants.push(_player);
        }
        scores[_player] = _score;
    }

    function getParticipantCount() public view returns (uint) {
        return participants.length;
    }
}

Jika recordScore(0xabc..., 100) dipanggil, kemudian recordScore(0xdef..., 200), dan akhirnya recordScore(0xabc..., 150), apakah nilai yang akan dikembalikan oleh getParticipantCount()?

Jawab dalam pelajaran interaktif

Imbas Kembali: Pemetaan dan Tatasusunan Dinamik

Anda telah mempelajari dua struktur data penting dalam Solidity:

Pemetaan: Penyimpanan pasangan kunci-nilai yang cekap, sesuai untuk mengaitkan data dengan pengecam unik seperti alamat. Pemetaan mengembalikan nilai lalai bagi kunci yang belum ditetapkan.
Tatasusunan Dinamik: Senarai fleksibel yang saiznya boleh bertambah atau berkurang menggunakan push() dan pop(), sesuai apabila jumlah item tidak tetap.

Menguasai perkara ini akan meningkatkan keupayaan anda dengan ketara untuk mereka bentuk kontrak pintar yang kukuh dan boleh diskalakan!

Percuma untuk bermula

Pelajari Kontrak Pintar Rantaian Blok dengan Solidity 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: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pemetaan dan Tatasusunan Dinamik” percuma?

Ya — teks penuh “Pemetaan dan Tatasusunan Dinamik” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Kontrak Pintar Rantaian Blok dengan Solidity, tingkat taraf kepada CoddyKit PRO. Kursus Kontrak Pintar Rantaian Blok dengan Solidity merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pemetaan dan Tatasusunan Dinamik”?

Laksanakan struktur data kompleks seperti pemetaan untuk pasangan kunci-nilai dan tatasusunan dinamik untuk senarai data yang fleksibel. Anda berlatih Kontrak Pintar Rantaian Blok dengan Solidity 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 Kontrak Pintar Rantaian Blok dengan Solidity?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kontrak Pintar Rantaian Blok dengan Solidity 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 2 daripada 4.

Berapa lamakah pelajaran “Pemetaan dan Tatasusunan Dinamik” 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 Kontrak Pintar Rantaian Blok dengan Solidity ini?

Ya. Setiap pelajaran Kontrak Pintar Rantaian Blok dengan Solidity 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

Pemboleh Ubah Keadaan dan Susun Atur Storan
Pemetaan dan Tatasusunan Dinamik
Peristiwa dan Data Logging
Slot Storan dan Pengoptimuman Gas

← Kembali ke Kontrak Pintar Rantaian Blok dengan Solidity