Move on Aptos Spring Training Camp Notes

Move on Aptos Spring Training Camp Notes | 01 & 02

Mar 6, 2024#Web3 #Move #开发 #区块链 #blockchain #Aptos243

AI Translation

This post is translated from Chinese into English through AI.View Original

AI-generated summary

02 Move language and variables Variables are named objects that store values in memory, which are interpreted as bytes based on their type. Values can be stored in the stack for value types like boolean, integer, and float, or in the heap for reference types like objects, arrays, classes, and functions. Move language differs from other languages by using "ownership" to handle reference types, allowing only one owner at a time and transferring ownership to other variables. This approach helps prevent memory leaks, improves memory efficiency, and enhances readability and maintainability. 03 uint, String, Bool, address types - uint type: Supports various ways of defining unsigned integers. - Bool type: Represents boolean values true and false. - String type: Represents strings encoded in UTF-8 format. - address type: Represents addresses with automatic zero padding.

02 Move Language and Variables#

Variables#

Variables: named objects;
Objects: memory regions that store values of a certain type; (similar to pointers in C++)
Values: collections of bytes interpreted according to their type;
Types: define the possible values and operations

Storage#

Value types
- Stored on the stack
- Simple types: boolean, integer, floating point...
Reference types
- Stored on the heap
- Complex types: objects, arrays, classes, functions...

When we define a variable as an object, its value is stored on the heap, and the index of its heap memory is stored on the stack, with the index on the stack pointing to the reference type data stored on the heap. (Variable points to object)

Core Differences in Move#

In terms of the relationship between value types and reference types, it differs from other languages in terms of indexing. Instead, it uses "ownership" as the operation for reference types.

Ownership can only be held by one "person" at a time;
Ownership can be transferred to other variables;

For example:

B = A;

C = B;

At this point, B is empty, and C points to A.

Benefits of this approach:

Avoids memory leaks, unlike other languages, memory can be reclaimed at compile time;
Improves memory usage efficiency by avoiding unnecessary copying of reference types;
Better readability and maintainability;

03 The Four Major Types: uint, String, Bool, address#

uint Type#

Multiple ways to write it

#[test]
    fun test_num(){
        let num_u8: u8 = 42; // 0-2**8-1
        let num_u8_2: u8 = 43u8;
        let num_u8_3: u8 = 0x2A;//hash
        let num_u256:u256 = 100_000;
        let num_sum: u256 = (num_u8 as u256) + num_u256;
        print(&num_u8); //42
        print(&num_u8_2); //43
        print(&num_u8_3); // 42
        print(&num_u256); //100000
    }

Bool Type#

#[test]
    fun test_bool(){
        let bool_true: bool = true;
        let bool_false: bool = false;
        print(&bool_true); //true
        print(&bool_false); //false
        print(&(bool_true == bool_false)); //false
    }

String Type#

#[test]
    fun test_string(){
        let str:String = utf8(b"hello world");
        print(&str); //"hello world"
    }

address Type#

The output is @0×2a, but zeros are automatically padded in between.

#[test]
    fun test_addr(){
        let addr:address = @0x2A;
        let addr2:address = @0x000000000000000000000000000000000000000000000A;
        print(&addr); //@0x2a -> @0x(0000...)2a
        print(&addr2); //@xa
    }