Web3 & DApp Development Fundamentals · Ders

Değişkenler ve Veri Türleri

Solidity'nin temel veri türlerini (uint, address, bool, bytes) ve akıllı sözleşmeler içinde değişkenlerin nasıl bildirildiğini ve kullanıldığını keşfedin.

Değişkenler ve Veri Türleri, CoddyKit'te ücretsiz bir Web3 & DApp Development Fundamentals dersidir. Bu, 3 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Web3 & DApp Development Fundamentals öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Web3 & DApp Development Fundamentals kursu toplamda 3 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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!

Sıkça Sorulan Sorular

“Değişkenler ve Veri Türleri” dersi ücretsiz mi?

Evet — “Değişkenler ve Veri Türleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Web3 & DApp Development Fundamentals kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Web3 & DApp Development Fundamentals kursu toplamda 3 dersten oluşur.

“Değişkenler ve Veri Türleri” dersinde ne öğreneceğim?

Solidity'nin temel veri türlerini (uint, address, bool, bytes) ve akıllı sözleşmeler içinde değişkenlerin nasıl bildirildiğini ve kullanıldığını keşfedin. Web3 & DApp Development Fundamentals ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Web3 & DApp Development Fundamentals öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Web3 & DApp Development Fundamentals, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 2. dersidir.

“Değişkenler ve Veri Türleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Web3 & DApp Development Fundamentals dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Web3 & DApp Development Fundamentals dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Web3 & DApp Development Fundamentals Sayfasına Dön