0Pricing
Blockchain Smart Contracts with Solidity · บทเรียน

ชนิดข้อมูลและตัวแปรใน Solidity

เรียนรู้เกี่ยวกับชนิดค่า ชนิดอ้างอิง และวิธีประกาศกับกำหนดค่าเริ่มต้นให้ตัวแปรใน Solidity

ชนิดข้อมูลและตัวแปรใน Solidity เป็นบทเรียน Blockchain Smart Contracts with Solidity ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Blockchain Smart Contracts with Solidity และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Blockchain Smart Contracts with Solidity มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Data Types: The Basics

Welcome to Solidity! Just like in any programming language, understanding data types is fundamental.

Data types tell Solidity what kind of information a variable will hold. This helps the Ethereum Virtual Machine (EVM) efficiently manage memory and prevent common errors.

Value Types Explained

Value types are the simplest data types. When you assign a value type variable or pass it to a function, a copy of its data is made.

Think of it like giving someone a photo – they get their own copy, and changes to their copy don't affect yours. They are stored directly in the variable's location.

Booleans and Integers

Let's start with common value types:

  • bool: Holds true or false.
  • uint: Unsigned integers (non-negative numbers). uint256 or simply uint is the default.
  • int: Signed integers (positive or negative numbers). int256 or int is the default.

Try running this simple contract to see them in action:

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

contract MyNumbers {
  bool public isActive = true;
  uint public quantity = 100;
  int public temperature = -5;

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

  function getQuantity() public view returns (uint) {
    return quantity;
  }

  function getTemperature() public view returns (int) {
    return temperature;
  }
}

The Address Type

The address type is crucial in Solidity. It's a 20-byte value representing an Ethereum account or a contract on the blockchain.

  • address: Can hold any Ethereum address.
  • address payable: Can also hold an Ethereum address, but specifically one that can receive Ether.

Here's how you might store a contract owner's address:

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

contract SimpleWallet {
  address public owner;

  constructor() {
    owner = msg.sender; // The address that deployed this contract
  }

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

Fixed-Size Byte Arrays

Solidity also has fixed-size byte arrays: bytes1 up to bytes32.

These are useful for storing small, fixed-length sequences of raw bytes, like cryptographic hashes or short identifiers. They are more efficient than dynamic arrays for known sizes.

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

contract DataStore {
  bytes32 public documentHash;

  constructor() {
    // Example: A hash of some document content
    documentHash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
  }

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

Reference Types Explained

Unlike value types, reference types don't store the data directly. Instead, they store a reference (a memory address) to where the data is located.

This means if you assign a reference type variable, both variables point to the same data. Changes made through one variable will be visible through the other.

Strings for Text

The string type is used for text data. It's a dynamic array of bytes that stores UTF-8 encoded characters.

Because its size can change, string is considered a reference type. You'll often see memory or calldata used with strings in function parameters or return types.

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

contract Greeter {
  string public currentMessage = "Hello, CoddyKit!";

  function setMessage(string memory _newMessage) public {
    currentMessage = _newMessage;
  }

  function getMessage() public view returns (string memory) {
    return currentMessage;
  }
}

Dynamic Bytes and Arrays

Solidity offers dynamic data structures:

  • bytes: A dynamic-sized byte array. Similar to string but for raw byte data.
  • Arrays (T[] or T[k]): Can hold a sequence of elements of the same type T. They can be fixed-size (T[k], where k is the length) or dynamic (T[]).
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataCollection {
  bytes public rawData = hex"1a2b3c"; // Dynamic bytes
  uint[] public dynamicNumbers; // Dynamic array of uints
  bool[2] public fixedBooleans = [true, false]; // Fixed-size array

  constructor() {
    dynamicNumbers.push(10);
    dynamicNumbers.push(20);
  }

  function getRawData() public view returns (bytes memory) {
    return rawData;
  }

  function getDynamicNumbersCount() public view returns (uint) {
    return dynamicNumbers.length;
  }
}

Custom Data with Structs

Sometimes, you need to group related data together. That's where structs come in handy!

A struct allows you to define your own custom data type by combining several variables of different types. Think of it like creating a blueprint for a record.

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

contract UserProfile {
  struct User {
    uint id;
    address userAddress;
    string name;
    bool isActive;
  }

  User public adminUser;

  constructor() {
    adminUser = User(1, msg.sender, "Alice", true);
  }

  function getAdminName() public view returns (string memory) {
    return adminUser.name;
  }
}

Declaring & Initializing

Declaring a variable is straightforward: DataType visibility variableName;

If you don't explicitly initialize a variable, Solidity assigns a default value:

  • bool: false
  • uint/int: 0
  • address: 0x00...00 (zero address)
  • string/bytes/arrays: Empty value

It's good practice to initialize variables explicitly when they're declared.

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

contract VariableLife {
  // Declared without explicit initialization (gets default values)
  uint public defaultBalance;
  bool public defaultStatus;

  // Declared and initialized
  uint public initialBalance = 1000;
  string public greeting = "Hello";

  function getDefaults() public view returns (uint, bool) {
    return (defaultBalance, defaultStatus);
  }
}

Data Type Challenge

Test your knowledge on Solidity data types!

Lesson Recap

Great job! In this lesson, you've learned about the fundamental data types in Solidity:

  • Value types (e.g., bool, uint, address, fixed bytesX) store data directly and are copied on assignment.
  • Reference types (e.g., string, dynamic bytes, arrays, structs) store a reference to data, allowing multiple variables to point to the same information.
  • You also learned how to declare and initialize variables, understanding their default values.

Next, we'll dive into how to control the flow of your smart contracts!

คำถามที่พบบ่อย

บทเรียน “ชนิดข้อมูลและตัวแปรใน Solidity” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ชนิดข้อมูลและตัวแปรใน Solidity” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Blockchain Smart Contracts with Solidity ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Blockchain Smart Contracts with Solidity มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูลและตัวแปรใน Solidity”

เรียนรู้เกี่ยวกับชนิดค่า ชนิดอ้างอิง และวิธีประกาศกับกำหนดค่าเริ่มต้นให้ตัวแปรใน Solidity คุณปฏิบัติ Blockchain Smart Contracts with Solidity ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Blockchain Smart Contracts with Solidity หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Blockchain Smart Contracts with Solidity บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ชนิดข้อมูลและตัวแปรใน Solidity” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Blockchain Smart Contracts with Solidity นี้ได้ไหม

ได้ บทเรียน Blockchain Smart Contracts with Solidity ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ชนิดข้อมูลและตัวแปรใน Solidity
  2. โครงสร้างควบคุมและลูป
  3. ฟังก์ชันและตัวปรับการมองเห็น
  4. โครงสร้างและแจกแจง
← กลับไปที่ Blockchain Smart Contracts with Solidity