1.轻松入门Move: 快速了解基本概念

2009年，中本聪发布比特币的开源软件，实现了去中心化的数字货币系统，开启了区块链1.0的时代。

比特币区块链虽然为去中心化的数字货币提供了一个安全的基础，但其功能受到了限制，只能用于简单的价值交换。 有没有一种机制可以在链上编写复杂的代码实现区块链智能化，让区块链能应用于更多场景呢？

2015年以太坊主网正式上线，为这个问题交出了答卷。也开启了区块链2.0的时代。 以太坊为去中心化应用提供一个通用的智能合约平台，使得开发者可以开始编写和部署智能合约，通过智能合约为区块链技术的应用提供了更广泛的可能性。

下图为区块链2.0的逻辑架构图，展示了智能合约在区块链中的位置：

区块链为智能合约提供执行环境，而智能合约为区块链扩展功能。智能合约赋予了区块链智能的特性，在区块链中智能合约的作用如同一个智能助理， 对区块链中的数据和事件按照预先设定的逻辑进行处理。它作为一个在区块链上可以自动执行的计算机程序，可以处理信息，接收、发送和存储资产。

智能合约部署到区块链中，作为区块链的一部分，自然具有区块链不可篡改的特点；部署后也会作为区块在区块链网络中广播，每个节点都会保存一份，所以分布式保证了它的高可靠性； 智能合约在满足一定条件后会自动执行，无需人工触发，更不需要三方担保。以上这些特点使得基于智能合约的交易更加安全，高效和低成本。

智能合约具有这么多优秀的特质，那我们如何编写它呢？就不得不说到Move语言了。Mysten Labs联合创始人兼首席技术官Sam Blackshear为Diem区块链开发了Move， 不过Move旨在成为一个跨平台的嵌入式语言，可以在Sui区块链网络中运行, 这就是Move。

Move准确来说应该是Move On Sui。是在Sui区块链平台上运行的原生语言。开发人员使用它可以创建、管理和操作数字资产，并编写智能合约。 Move 引入了以对象为中心的数据存储模型，这使得Sui可以并行处理事务，比串行事务的区块链具有更高性能。从开发的角度， Move 也无需在交易前后做大量关于资产所有权的处理；针对对象的处理也非常简单灵活。

接下来让我们使用一个简单的例子来演示一下，使用Move如何操作数据对象，如何在区块链上部署以及如何运行。需要注意的是，初学者先不要陷入细节，只需跟着我的例子，一探Move的宏观即可。

module test::test {
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;
    use std::string;
	//定义一个博客结构体
    public struct Blog has key{
        id: UID,
        content: string::String,
        like_cnt: u64,
    }
    //此函数用于发布博客，每次发布完成会返回博客对象信息
    public entry fun publish_blog(content: string::String, ctx: &mut TxContext){
         transfer::transfer(Blog {
            id: object::new(ctx),
            content: content,
            like_cnt: 0
        }, tx_context::sender(ctx));
    }
    //调用此函数，增加博客对象的点赞数
    public entry fun like_blog(blog: &mut Blog){
        blog.like_cnt = blog.like_cnt + 1;
    }
}

此合约包含两个函数，一个是publish_blog根据传入的content参数，新建一个Blog对象，并把这个Blog对象所有权赋给调用函数的用户地址。 另一个则是like_blog修改博客对象的属性，将指定的Blog对象的点赞数加1。

我们如何将这段代码发布到Sui区块链网络上呢？只需要使用Move命令行工具的publish命令即可。需要注意的是，这个操作会消耗gas(gas这里暂不多做介绍，我们简单理解为付费的一种形式)

sui client publish 

执行完这个命令后，会返回一个所有者为Immutable(不可改变的)的对象，这个对象的ID就是这个代码在区块链的地址。拿着这个地址，指定模块名和函数名，就可以在区块链上调用publish_blog函数：

sui client call --package <合约地址> --module <合约模块名> --function publish_blog --args "this is a blog" 

建好的对象会保存在区块链中，并返回一个对象ID。我们使用对象ID就可以查询到刚新建的Blog对象

sui client object <对象ID>

Web2.0的开发者可能对此感到惊奇，数据存储的过程没有连接数据库的操作，更没有繁琐的SQL语句执行。我们只需要新建一个对象指定所有权就保存了一个对象。是不是非常简单？

接下来我们继续调用like_blog函数

sui client call --package <合约地址> --module <合约模块名> --function publish_blog --args <Blog对象ID> 

通过sui client object 命令查看对象可以发现：虽然我们没有显式的对存储做任何操作，但是Blog对象的like_cnt属性值已经加1。

现在我们对Move有了大致的了解，得出了Move 不仅安全、性能高、开发也简单灵活的结论。那我们可以使用它做些什么呢？

1.创建智能合约来管理和转移各种类型的数字资产，包括加密货币、代币化资产、非同质化代币（NFT）等

2.Move可以用于编写智能合约，实现去中心化交易、借贷等金融服务；也可以利用智能合约实现去中心化的投票和治理机制；还可以用于NFT和数字艺术领域，确保数字内容的版权和所有权。

3.Move可以用于创建数字身份认证系统，使用户能够安全地管理和共享他们的身份信息，同时保护个人隐私。

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

2.轻松入门Move: 搭建开发环境

在编写Move程序之前，需要先安装开发环境，所以本章将介绍如何安装开发环境。

安装开发环境有三种方式：

• 1.使用二进制文件安装
• 2.使用源代码安装,比较复杂但是可以更多的控制安装过程
• 3.使用docker镜像安装

入门的朋友，我建议还是选择既能了解安装过程又不会太过复杂的二进制安装。

这篇文章将主要讲解如何在Windows上使用二进制文件安装本地开发环境。注意不是使用Windows子系统Ubuntu安装，而是直接安装到Windows系统。以下方法适用于win10、win11。

安装前准备

curl

这个一般Windows是自带的，检测是否自带运行命令：

curl http://www.baidu.com

git

详细的安装方法网络上已经有不少教程，详细参见：git安装方法

cmake

下载页面选择带有windows标志的.msi文件下载，具体下载x64、AMD64还是i386架构的，参见git安装方法。下载完成后，双击安装，一路点next完成安装

protocol buffer

下载页面下载最新版本，带有win字样的压缩包即可。下载完解压缩，把bin目录所在目录，添加到环境变量Path中，如下图：

LLVM Compiler Infrastructure

下载页面 点击进入，选择最新版本download跳到github页面，选择带有win字样的exe文件下载，并安装。一路next即可。

rustup

rustup是一个管理工具链，用于管理不同平台下的 Rust 构建版本并使其互相兼容。在Windows环境中，使用 rustup-ini.exe下载后，双击运行，会有一个选项，如下图，输入1回车即可安装。

安装完成后，enter键关闭窗口，重新打开cmd窗口，输入下图命令，判断是否安装成功：

安装Sui

下载页面，点击带有windows字样的压缩包，下载并解压，打开target/release文件夹，把其中可执行文件的名称中的-windows-x86_64去掉，并复制到.cargo/bin文件夹中。如下图：

打开一个cmd命令行窗口，输入以下命令验证安装是否成功:

安装编辑器及插件

vscode编辑器的安装教程，网上已经有很多，这里不再赘述。详见

这里要着重讲的是安装Move Analyzer

Move Analyzer是由MoveBit开发的适用于sui-move语言的Visual Studio代码插件，它有许多有用的功能，如高亮显示、自动完成、转到定义/引用等。

vscode安装好后，点击侧边栏EXTENSIONS,在搜索栏搜索Move Analyzer选中后，不要直接点击安装，先查看安装说明，这里有几点需要注意：

1.如果已经安装move-analyzer 或者 aptos-move-analyzer的需要先disable掉，避免产生冲突

2.要先安装sui-move-analyzer language server,然后再安装此插件。

申请开发环境gas

上文我们也讲到，无论是将代码部署到链上还是调用链上方法，都需要gas。那我们开发环境怎么办呢？难不成要付费开发？这倒是不用，我们可以免费申请devnet的gas。申请方法如下：

• 1.获取当前地址，第一次执行有一些交互，按照图示输入即可。生成完当前地址再执行sui client active-address就可以获取账户地址

  

• 2.在Discord中注册账号并通过验证

• 3.在#devnet-faucet频道输入框输入 !faucet <第一步获取到的地址> 。使用sui client gas几秒钟后就可以看到gas充值成功

  

现在既有编辑器、gas、运行环境都准备好了，那我们可以开始我们的Move之旅啦。

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

3.轻松入门Move: 清单文件和模块

按照国际惯例，学习一门语言,编写的第一个程序一定是输出一个Hello World。今天我们也来一起写一个Hello World并以此引出一些Move项目结构，并作详细介绍

首先我们新建一个名为hello_world的项目，使用命令：

sui move new hello_world

这个命令会自动新建一个名为hello_world的文件夹，文件夹结构如图：

这个文件夹包含一个sources文件夹和一个Move.toml清单文件，其中sources目录是存放我们编写的代码，里面的一个文件对应一个模块。Move.toml文件则是一个清单文件，用于申明包的元数据信息、依赖、地址等。详情请看下面代码块：

[package]
#在这个部分申明包的元数据信息,比如名称、版本信息、证书信息等
name = "hello_world"

# edition = "2024.alpha" # 使用Move 2024 alpha 版本 
# license = ""           # 申明证书，比如, "MIT", "GPL", "Apache 2.0"
# authors = ["..."]      # 申明作者，比如 ["Joe Smith (joesmith@noemail.com)", "John Snow (johnsnow@noemail.com)"]

[dependencies]
#在这个部分列出这个包依赖的其他包
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "framework/testnet" }

# 对于远程包的引用，请使用 `{ git = "...", subdir = "...", rev = "..." }`.
# 其中rev可以是一个分支，一个tag或者一个提交哈希，如下例：
# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }

# 如果是本地包的引用，使用 `local = path`即可. Path 是包的根目录下的相对路径
# Local = { local = "../path/to" }

# 如果有版本冲突，则指定版本号，并且使用`override = true`来解决冲突
# Override = { local = "../conflicting/version", override = true }

[addresses]
# 申明这个包的地址，在后续可以使用hello_world代指这个包。默认情况这个地址是"0x0"，但在发布到链上会替换成区块链上的地址。这个名称甚至不局限于在包内使用，比如std标准包，我们直接在自己的包中使用std引用。
hello_world = "0x0"

[dev-dependencies]
# 这个部分用于声明开发或者测试模式下才需要的依赖。
# 额外提一句，开发或测试模式是编译时通过指定--test(--dev)来指定模式的。
# Local = { local = "../path/to/dev-build" }

[dev-addresses]
# 这个部分用于申明开发或者测试模式下的包地址。

上面代码块中提到的package就是所谓的包，包是一组模块的集合，是发布代码到链上的单元。

那什么又是模块呢？模块是一组函数和结构体的集合。模块是一种组织代码的方式，可以将相关的功能组织在一起，并且通过模块可以控制代码的可见性和访问权限，提高代码的可维护性和可扩展性。

现在我们在sources文件夹内新建一个文件，命名为helloworld.move,然后编写一个名为hello_world的模块：

#![allow(unused)]
fn main() {
module hello_world::hello_world {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    public struct HelloWorldObject has key, store {
        id: UID,
        text: std::string::String 
    }

    #[lint_allow(self_transfer)]
    public fun mint(ctx: &mut TxContext) {
        let object = HelloWorldObject {
            id: object::new(ctx), 
            text: std::string::utf8(b"Hello World!") 
        };
        transfer::public_transfer(object, tx_context::sender(ctx));
    }
}
}

上面这段代码申明了一个名称为HelloWorldObject的结构体，在mint方法中创建一个HelloWorldObject对象并将所有权转交给当前上下文的用户。此段代码包含以下几个知识点：

1.模块的申明方法

module <包的地址>::<模块名称> {
	模块内容
}

包的地址和模块名称可以标识一个模块，包的地址可以是包名也可以是清单文件中申明的包地址。

在一个包内，模块名必须唯一。模块文件名与模块名不一致可以通过编译也不影响其他模块的调用，但不建议这么做。模块名建议使用小写字母和下划线组成。

2.模块之间的关系：引用

模块之间可以互相引用，引用方式分为以下几种：

• 直接引用:

  #![allow(unused)]
  fn main() {
  public struct HelloWorldObject has key, store {
  	id: UID,
      text: std::string::String //直接引用std::string模块的utf8方法
  }
  }

• 使用use引用结构体或者函数

  #![allow(unused)]
  fn main() {
  use sui::object::UID //申明引用UID结构体（或函数）
  public struct HelloWorldObject has key, store {
  	id: UID, //直接使用结构体名（或函数）
      text: std::string::String 
  }
  }

• 使用use 引用模块

  #![allow(unused)]
  fn main() {
  use sui::transfer;
  transfer::public_transfer(object, tx_context::sender(ctx));
  }

• 使用Self关键字引用模块自身

  #![allow(unused)]
  fn main() {
   use sui::tx_context::{Self, TxContext};
   tx_context::sender(ctx)//使用模块名调用函数
   //直接使用TxContext引用TxContext结构体
  }

• 同一个模块多个引用

  #![allow(unused)]
  fn main() {
  使用花括号括起来，并逗号隔开
  use sui::tx_context::{Self, TxContext};
  }

不同的申明方式之间也可以转换使用，效果是一样。比如：

#![allow(unused)]
fn main() {
use sui::tx_context::{Self, TxContext};
tx_context::sender(ctx)//使用模块名调用函数
//直接使用TxContext引用TxContext结构体
}

等价于：

#![allow(unused)]
fn main() {
use sui::tx_context;
tx_context::sender(ctx)//使用模块名调用函数
//TxContext结构体则使用tx_context::TxContext引用
}

还等价于：

#![allow(unused)]
fn main() {
use sui::tx_context::{sender, TxContext};
sender(ctx)//直接调用函数
//直接使用TxContext引用TxContext结构体
}

3.模块如何控制访问权限?

我们上面讲了如何引用模块，那如果模块不愿意被引用怎么办呢？这就涉及到访问权限的问题。访问模块内容分为访问结构体和函数。而结构体内部的字段不能跨模块使用，只能通过调用与结构体同模块的函数实现，如下图：

#![allow(unused)]
fn main() {
 struct HelloWorldObject has key, store {
        id: UID,
        text: std::string::String 
  }
  //通过调用此方法访问结构体内部值
  public fun getText(obj: &HelloWorldObject) :std::string::String {
        obj.text
  }
}

所以，访问权限其实主要就是对函数的访问权限的控制。对函数的访问权限控制粒度从粗到细分为：

• 所有模块都可以调用

  所有模块都可调用，使用关键字public申明函数即可

• 部分模块可以调用

  使用关键词public(package)申明函数，那就只有在模块内申明了是“朋友”的模块才可以调用。如下：

  #![allow(unused)]
  fn main() {
  //申明朋友模块
  //只有朋友模块才可以引用的函数
  public(package) fun getName(obj: &Game) :std::string::String {
      obj.name
  }
  }

• 只有同模块可调用

​ 只有同模块都可调用，使用关键字private申明函数即可。private是默认权限，也可以省略。

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

4.轻松入门Move: 基础语法

本章将介绍Move的基础语法。

基本类型

Move语言是一个强调数据类型的语言，在声明任何变量时，必须将该变量定义为一种数据类型。Move中的数据类型包括基本数据类型和自定义类型（也就是结构体）。结构体不属于本章所讲述的内容，本章主要介绍数据的基本类型。Move程序中，总共有三种基本类型：其中包括整型、布尔型和地址。

整型

整型有分五种，分别是u8,u32,u64,u128,u256。u代表unsigned说明不支持负数,u后面的数字代表可以存储的位数，也可以根据这个位数，推算出能存储的最大值：

注意：基本类型只支持正整数，负数将会导致编译报错。

两个不同类型的正整数，要比较大小怎么办呢？可以使用as做类型转换后在进行比较，如下：

#![allow(unused)]
fn main() {
public fun compare() :bool {
	let a:u8 = 10;
    let b:u32 = 30;

    (a as u32) >= b
}
}

布尔型

布尔类型使用bool表示，值有两个true和false。

地址

地址类型用于标识区块链中的地址，如果引入包的包地址、钱包地址或者发送方地址。

地址一般是0x开头，代表十六进制数。

注释

像大多数编程语言，注释分为单行注释和多行注释。

#![allow(unused)]
fn main() {
//单行注释
/*

多行注释

*/
}

变量

变量可以使用以下方式声明和初始化:

let :

let <VARIABLE> = <EXPRESSION>

let : =

#![allow(unused)]
fn main() {
let a:u8;
let a=10;
let a:u8=10;
let a=true;
let a=0x0
}

如果直接对变量赋值正整数，不指定类型，默认类型是u64

#![allow(unused)]
fn main() {
let a=10;//a类型是u64
}

Move不允许申明变量之后不使用。我们可以使用_去标记该变量不使用：

#![allow(unused)]
fn main() {
public fun compare() :bool {
	let a = 10;
    let b = 10;
    let _ = returnNum(); //丢弃函数返回值
    a > b
}
public fun returnNum():u64 {
    13
}
}

变量作用域

变量的作用域用一句话就能描述清楚：变量只在声明它的代码块中生效，代码块结束变量就无效。代码块由花括号标记，模块的花括号代表一个代码块，函数的花括号也是一个代码块。

#![allow(unused)]
fn main() {
//参数a,b作用域：整个函数代码块
public fun varLifetimes(a:u8, b:u8) :bool {
	let c = a + b;//变量c作用域：整个函数代码块
    if (c > 10) {
        let d = 12; //变量d作用域：if{}内
        _ = d;
    } else {
        let e = 13;//变量e作用域：else{}内
        _ = e;
    };
    {
    	let f=1;//变量f作用域：{}内
        _ = f;
     };

     c > 100
}
}

常量

使用const关键字 申明一个常量，常量用大写字母和下划线组成。值可以是基本类型、数组和一部分表达式。

值得注意的是，常量只能模块内部访问！

#![allow(unused)]
fn main() {
const LEVEL:u64=10;
}

流程控制

任何一门语言都需要基本的流程控制语句，其思想也符合人类判断问题或做事的逻辑过程。什么是流程控制呢？流程就是做一件事情的顺序。在程序设计中，流程就是要完成一个功能，而流程控制则是指如何在程序设计中控制完成某种功能的顺序。

条件语句

在现实生活中，经常听人说：如果中彩票了，我就...。其实这就是程序设计中所说的条件语句。例如“如果……就……”“否则……”

在Move中的if语法是：

if (<bool_expression>) <expression> else <expression>;

if语句的几种形式：

#![allow(unused)]
fn main() {
let i = 10;
//单行不加花括号
if (i > 5) i = i + 1;
//多行要加花括号
if (i > 5) {
	i = i + 1;
};
//if...else
if (i > 5) {
	i = i + 1;
} else {
	i = i - 1;
};
}

注意: 跟大多数语言不同的是，这里最后一个表达式后加了分号代表结束。

循环语句

• while循环：有条件的循环

  #![allow(unused)]
  fn main() {
   //满足条件才会循环
   while (i < 5) {
       i = i + 1;
   };
  }

• loop循环：无条件循环

  无条件循环如果内部没有使用break跳出循环，会一直循环下去，也就是所谓的死循环。

  #![allow(unused)]
  fn main() {
  //这个代码与while中的示例代码作用一样
  loop {
  	if (i >= 5) {
  		break;
  	};
  }
  }

• continue

  continue代表跳过本次循环，进入下一个循环。break则是结束循环，这俩需要注意区分。

退出语句

如果程序满足某些条件就要停止运行，可以使用关键字abort

也可以使用封装好的内建函数assert

#![allow(unused)]
fn main() {
//这两行代码是等价的
if (i > 5) abort 0;
assert(i <= 5, 0);
}

函数

函数结构：

#![allow(unused)]
fn main() {
fun function_name(arg1: u64, arg2: bool): (u8, bool){
	//函数体
}
}

函数名由小写字母和下划线组成

函数返回值

使用return + 返回值，可以结束函数执行并返回数据，如果是最后一行返回则可以缺省return关键字。如下：

#![allow(unused)]
fn main() {
public fun compare(a: u64, b: u64): u8 { 
	if (a == b ) {
        return 0 //中断函数执行，直接返回
     };
     //最后一个表达式，可以无return返回  
     if (a > b) {
        1
      } else {
        2 
      }
}
}

值得注意的是，无论是何种返回方式，表达式最后都没有逗号

Move支持多个返回值，多个返回值的返回和使用，详见代码：

#![allow(unused)]
fn main() {
public fun call_return_nums(): u64{
        let (a,b) = return_nums();//接收多个函数返回值，必须有括号
        if (b) {
            a
        } else {
            0    
        }
    }
    public fun return_nums():(u64, bool) {//多个返回值的申明方法
        (19, true)//返回多个函数返回值，必须有括号
    }
}

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

5.轻松入门Move: Debug、单元测试和命令行工具

单元测试

单元测试函数是没有参数，也没有返回值，带有一个#[test]的标记的public函数。命令建议使用test_作为前缀加上被测试函数名称。单元测试函数跟被测试函数可以放置在同一个module内，也可以单独放置在跟sources文件夹同级别的tests文件夹内。

#![allow(unused)]
fn main() {
public fun a_greater_than_b(a: u64, b: u64): bool{ 
    a >= b
}
 #[test]
 public fun test_a_greater_than_b() {
    let a = 10;
    let b = 12;
    assert!(!a_greater_than_b(a, b), 0);
 }
}

assert即将被丢弃，建议使用assert!。assert!函数第一个参数是一个表达式，表达式值为false表示断言失败，单元测试报错不通过。

编写好单元测试后，在项目根目录执行如下命令即可运行单元测试

sui move test

单元测试报告解读：

INCLUDING DEPENDENCY Sui
INCLUDING DEPENDENCY MoveStdlib
BUILDING hello_world
Running Move unit tests
[ PASS    ] 0x0::hello_world::test_a_greater_than_b    #通过的单元测试名
Test result: OK. Total tests: 1; passed: 1; failed: 0  #单元测试数，通过数，失败数
Total number of linter warnings suppressed: 1 (filtered categories: 1)

Debug

Move暂时没有本地的调试器，可以使用std::debug模块来调试代码，打印变量。

调用print函数打印变量值到命令行,注意print参数传递的不是变量本身，而是变量的引用。

#![allow(unused)]
fn main() {
std::debug::print(&v);
//在命令行输出中带有[debug]标记的就是打印结果
}

也调用print_stack_trace函数打印堆栈轨迹

std::debug::print_stack_trace();

结合单元测试，就可以在命令行打印数据，调试代码：

#![allow(unused)]
fn main() {
public fun a_greater_than_b(a: u64, b: u64): bool{ 
    std::debug::print(&a);
    std::debug::print(&b);//调试打印
    a >= b
}
#[test]
public fun test_a_greater_than_b() {
    let a = 13;
    let b = 12;
      
    assert!(a_greater_than_b(a, b), 0);//单元测试调用函数
}
}

现在只需运行单元测试，就可以打印信息进行调试。

命令行工具

下面将讲解一些常用的命令：

sui move命令

创建一个新包

# 指定路劲创建新包
sui move new <package_name> -p <path>
#当前目录创建名为hello_world的包
sui move new hello_world

编译

sui move build
#想让编译更快，可以暂时不拉取最新依赖
sui move build --skip-fetch-latest-git-deps
#使用Move.toml申明的dev依赖和地址
sui move build --dev

单元测试

单元测试是先编译后运行单元测试，所以上述编译的选项也可以用在单元测试中

sui move test
#列出所有单元测试
sui move test -l 
#指定运行单元测试的线程数，默认八个
sui move test -t 10
#使用dev模式编译并运行单元测试,--test同理
sui move test --dev
#在单元测试结尾生成统计信息并打印到终端
sui move test -s
#限制每个单元测试函数消耗的gas
sui move test -i 1
#收集覆盖率相关数据，以支持sui move coverage命令的使用。
sui move test --coverage

注意：单元测试的覆盖率只有debug模式的客户端支持，想使用此功能，可以使用源码构建sui move cli

覆盖率统计

获取覆盖率数据之前，需要使用--coverage运行单元测试

#获取覆盖率的汇总信息
sui move coverage summary 
#根据源代码显示有关模块的覆盖率信息
sui move coverage source
#根据反汇编的字节码显示有关模块的覆盖率信息
sui move coverage bytecode

sui client命令

sui client提供与Sui网络交互的命令

列出可用网络环境

sui client envs

创建新的网络环境

sui client new-env --alias=mainnet --rpc https://fullnode.mainnet.sui.io:443

切换当前网络环境

sui client switch --env mainnet

新建地址

#选择ed25519密钥对方案，生成新的密钥对和地址，并设置地址别名为test
 sui client new-address  ed25519 test

切换当前地址

sui client switch --address <address别名>

获取当前活跃地址

当前活跃地址可以理解为是当前用户在Sui网络的标识符

sui client active-address

使用对象ID获取对象信息

sui client object <object id>
#使用json格式返回对象数据
sui client object <object id> --json

查看当前地址拥有的所有对象

sui client objects
#输出json
sui client objects --json

获取动态字段信息

sui client dynamic-field <DYNAMIC-FIELD-ID>

获取余额

sui client balance
sui client gas

在devnet申请gas

# 执行前需要确认当前网络是否是devnet.执行后一分钟内就能到账
sui client faucet --address <你的地址>

合并gas的余额

如果有多个gas对象，不想每次使用--gas选项指定，就可以合并gas对象的余额到一个gas对象中去

sui client merge-coin --primary-coin <gas coin id> --coin-to-merge <gas coin id> --gas-budget <GAS_BUDGET>

• --primary-coin 余额都合并到这个gas对象中
• --coin-to-merge 被合并余额的gas对象

发布包之前，检查字节码是否超过规定值

强烈建议在发包之前执行此操作，避免发布失败，消耗不必要的gas

sui client verify-bytecode-meter

发布包

#发布当前目录的包
sui client publish 
#发布指定目录的包
sui client publish  /home/root/packages/hello_world
#发布时消耗指定的gas对象的gas
sui client publish--gas <gas coin id> 0 

注意：

• gas可以适当指定大一点，因为gas不够导致的发布失败，并不会退回gas

• gas coin id可以通过sui client gas获取

• 发布之前要进行编译，所以编译的选项在这个命令也是生效的

调用已经发布包的方法

#调用一个没有参数的函数
sui client call [OPTIONS] --package <package id> --module <module名称> --function <函数名> --gas-budget <GAS_BUDGET>
#调用带参数的函数
sui client call [OPTIONS] --package <package id> --module <module名称> --function <函数名> --gas-budget <GAS_BUDGET>  --args <参数1> <参数2>
#调用泛型函数,必须指定所有的类型参数否则会报错
sui client call [OPTIONS] --package <package id> --module <module名称> --function <函数名> --gas-budget <GAS_BUDGET>  ----type-args <类型参数1> <类型参数2>

查看交易消耗gas的详细信息

sui client profile-transaction --tx-digest <交易的digest>

转移资产

#转移指定资产给指定地址
sui client pay --input-coins <被转移的coin id> --recipients <收款地址>--amounts <转账金额>--gas-budget <本次操作可消费最大gas>
#转移Sui资产给指定地址
sui client sui-pay --input-coins <被转移的coin id> --recipients <收款地址>--amounts <转账金额>--gas-budget <本次操作最大可消耗gas>

转移对象所有权

sui client transfer --to <收到对象所有权的地址> --object-id <对象id> --gas-budget <本次交易最大可消耗gas>

sui console

有没有觉得sui client相关的命令每次都要输入sui client 很麻烦？可以使用sui console进入sui的命令行，省略sui client字符直接输入命令即可。比如：

#获取gas对象余额
gas
#切换当前地址
switch --address mystifying-sphene

退出sui命令行模式

exit

清屏

clear

查看历史命令

history

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

6.轻松入门Move: 结构体

我们前面讲解基本数据类型的时候，讲到基本数据类型只有三种：整型，布尔型和地址。细心的朋友可能会疑惑，为什么连字符串类型都没有？我想使用Move程序保存一段文本如何实现？ 这时候就要用到自定义类型，也就是结构体。

创建String结构体类型

我们可以使用结构体定义一个String类型：使用基本数据类型u8组成的数组来存储字符串。那我们自己实现一个String类型? 大可不必！Sui框架已经为我们实现了String类型，源码如下：

#![allow(unused)]
fn main() {
//struct <type name> <has abilities>
public struct String has copy, drop, store {
    bytes: vector<u8>,
}
}

结构体名称要使用大写字母开头，首字母后可以包含大小写字母、下划线和数字（建议使用大驼峰命名法）。结构体内的字段名则由小写字母、数字和下划线组成。

那我们如何使用这个自定义的类型呢？

#![allow(unused)]
fn main() {
//先引用String类型
use std::string::String;
//申明一个HelloWorld类型，包含String类型
public struct HelloWorld has drop {
    no: u64,
    text: string::String //申明text字段类型是String类型
}
public fun new_hello_world():HelloWorld{
    //实例化一个结构体
    HelloWorld{
        no: 1,
        //调用string模块提供的utf8函数实例化String类型
        text: string::utf8(b"hello world")
    } 
}
}

上述例子中，结构体HelloWorld带有两个字段，字段no是u64类型,另一个字段text则是标准库定义的结构体。 我们可以得出一个结论：**结构体是一种自定义类型，可以包含基础数据类型和自定义类型的字段。**但是值得注意的是，结构体不能包含自身类型。比如说：

#![allow(unused)]
fn main() {
public struct HelloWorld has drop {
    no: u64,
    text: string::String,
    hello_world: HelloWorld //包含自身类型
}
}

以上代码在编译的时候会报错：Invalid field containing 'HelloWorld' in struct 'HelloWorld'.

访问结构体字段值

模块内访问

我们使用一个单元测试用例来演示如何访问HelloWorld类型的text字段：

#![allow(unused)]
fn main() {
#[test]
public fun test_create_hello_world() {
    let hw = create_hello_world();//先实例化一个类型
    let text = hw.text;//使用符号.即可访问结构体内字段
    assert!(string::utf8(b"hello world") == text, 0);
}
}

注意：有的文档说只有基本数据类型的访问能使用.符号，本人在sui-move 1.20.0上测试发现自定义类型也能使用！也就是说不管字段是什么类型都可以使用.访问。

上面的代码通过了单元测试。那我们用同样的方法访问text字段的bytes字段是不是也能通过？

#![allow(unused)]
fn main() {
#[test]
public fun test_create_hello_world() {
    let hw = create_hello_world();
    let bytes = hw.text.bytes;
    assert!(b"hello world" == bytes, 0);
}
}

运行sui move test直接报错：Invalid access of field 'bytes' on 'std::string::String'. Fields can only be accessed inside the struct's module（只有在模块内才有访问结构体字段的权限）

模块外访问

也就是说我们在自己编写的模块里不能直接访问标准库string模块的结构体字段值，那我们就”绕一个弯“，通过调用函数来访问其他模块的结构体字段值。

比如访问String类型的bytes字段，我们可以使用string模块提供的bytes方法，这个方法是公共方法所以任何模块都有权限调用。如下：

#![allow(unused)]
fn main() {
#[test]
public fun test_create_hello_world() {
    let hw = create_hello_world();//实例化一个HelloWorld类型
    let bytes = string::bytes(&hw.text);//bytes函数返回的不是bytes字段而是一个指针
    assert!(b"hello world" ==  *bytes, 0);//*号+指针表示指针指向的值，并断言值是"hello world"
}
}

同样的我们在自己模块定义结构体的时候，可以定义函数来开放结构体字段的访问。函数的名称建议直接延用字段的名称。比如：

#![allow(unused)]
fn main() {
public fun no(hw: &HelloWorld):u64 {
    return hw.no   
}
}

注意：实例化结构体、访问结构体字段值、修改结构体实例和销毁结构体都只能在定义这个结构体的模块内。

修改结构体字段值

方法如下：

#![allow(unused)]
fn main() {
public fun changeText(hw: &mut HelloWorld) {
    hw.text = string::utf8(b"change it");
}
}

这里值得注意的是函数参数引用结构体的方式，引用结构体分为可变引用（&mut）和不可变引用(&)。 因为上述代码块要修改结构体实例的值就必须使用&mut。如果只是访问结构体实例则使用&即可。

不仅仅是函数参数可以这么引用，变量赋值也是如此：

#![allow(unused)]
fn main() {
let s = S {f : 10};
let s_ref = &s;//不可变引用
let s_mutref = &mut s;//可变引用，可以使用s_mutref变量修改s实例的值
}

除了引用外，还可以直接使用按值传输对象也就是直接传输对象本身。按值传输对象用于销毁对象、嵌套在对象里或者移交。

销毁结构体实例

如果结构体含有drop的能力，会在使用后自动销毁。但是如果结构体没有drop能力且有销毁的需求，就需要编写函数并调用函数销毁。销毁的方法如下：

#![allow(unused)]
fn main() {
public fun drop(hello_world: HelloWorld) {
    let HelloWorld{text:_,test_vector:_} = hello_world;
}
}

注意：

• 官方建议统一使用drop命名销毁函数。

• 上述代码块是把结构体所有值都丢弃了，如果其中字段没有drop能力就不允许这么做。

• 参数就不允许传递实例的地址，必须是传递实例本身。

了解更多Move内容：

• telegram: t.me/move_cn
• QQ群: 79489587

7.轻松入门Move: 对象（上）

有过后端编程经验的小伙伴会发现：无论什么语言核心其实都是对数据的增删改查，Move也不例外，但是Move并不会跟其他语言一样连接数据库、使用特定的数据库语言存储数据，而是使用对象作为最小的存储单元。也就是说如果你想持久化一些数据，先申明一个对象模型，使用要存储的数据实例化对象即可。如下：

#![allow(unused)]
fn main() {
//申明对象模型
public struct Article has key {
    id: object::UID,
    title: string::String,
    content: string::String,
    word_cnt: u64,
}
public fun new(title: vector<u8>, content: vector<u8>, ctx: &mut tx_context::TxContext) {
 	let content = string::utf8(content);
    //实例化一个对象
    let article = Article{
        id: object::new(ctx),
        title: string::utf8(title),
        content: content,
        word_cnt: string::length(&content),
    };
	//对象设置为共享对象，所有用户皆可访问修改
    transfer::share_object<Article>(article);
}
}

在发布这段代码后，调用new方法就可以生成一个对象并返回对象的元数据，对象也保存在了链上。

对象模型是一种特殊的结构体，所以上一章讲到的结构体相关的用法对象也一样适用。那如何区分这是一个普通的结构体还是对象呢？对象一定具有key能力且对象的第一个字段是全局唯一ID ，这个全局唯一id可以确定对象在链上的位置，所以也可以理解为就是对象的地址。对象的其他字段则可以是基础数据类型、对象或者非对象结构体。

第一章我们也讲过，在发布代码的时候会返回一个所有者为Immutable(不可改变的)的对象,这个对象的ID就是对应的包地址。这句话隐含了一个信息，就是我们发布的包也是一个对象。这个对象永远不可改变或删除。所以发布代码的过程也可以理解为是把代码存储到区块链的过程。

对象的结构

使用sui client object