多文件项目

M8Test 支持多文件项目，即一个项目可以包含多个脚本源文件，但必须有且仅有一个入口文件。只有在入口文件中才能直接使用全局变量，而非入口文件中的脚本若需要使用全局变量，则必须通过方法参数传递的方式获取。也就是说，在入口文件中调用非入口脚本时，需要将全局变量作为参数传递进去。

多文件项目的优势在于可以将代码分散到不同的文件中，每个文件各自实现特定功能，避免所有逻辑堆积在入口文件中，从而减轻维护难度。

下面展示一个简单的多文件项目，目录结构如下：

其中，ToolB 会调用 ToolA，而入口文件则会调用 ToolB。这样一来，在入口文件中通过调用 ToolB 也间接使用了 ToolA。通过将代码拆分至不同文件并相互调用，最终实现所需的功能。

首先是 ToolA 文件，内容如下：

package com.example.tool

import com.m8test.script.core.api.console.Console

class ToolA {
    // 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
    fun methodA(console: Console) {
        console.log("Method A in ToolA called.")
    }
}

package com.example.tool

import com.m8test.script.core.api.console.Console

class ToolA {
    // 此方法只是使用全局变量(参数传递的方式接收)简单输出日志，会在 ToolB 中调用
    void methodA(Console console) {
        console.log("Method A in ToolA called.")
    }
}

package com.example.tool;

import com.m8test.script.core.api.console.Console;

public class ToolA {
    // 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
    public void methodA(Console console) {
        console.log("Method A in ToolA called.");
    }
}

// 定义 ToolA 类
function ToolA() {
    // 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
    /**
     * @param {Packages.com.m8test.script.core.api.console.Console} console
     */
    this.methodA = function (console) {
        console.log("Method A in ToolA called.");
    };
}

// 导出 ToolA 类
module.exports = ToolA;

local ToolA = {}
-- 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用

function ToolA.methodA(console)
    console:log("Method A in ToolA called.")
end

return ToolA

<?php

// 声明命名空间，和当前文件所在文件夹的相对src的路径一样
namespace com\example\tool;

class ToolA
{
    // 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
    public static function methodA($console)
    {
        $console->log("Method A in ToolA called.");
    }
}

from m8test_java.com.m8test.script.core.api.console.Console import Console


class ToolA:
    # 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
    def methodA(self, console: Console):
        console.log("Method A in ToolA called.")

java_import "com.m8test.script.core.api.console.Console"

class ToolA
  # 此方法只是使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在 ToolB 中调用
  # @param console [Console]
  def methodA(console)
    console.log("Method A in ToolA called.")
  end
end

接着是 ToolB 文件，内容如下：

package com.example.tool

import com.m8test.script.core.api.console.Console

class ToolB {
    // 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    fun methodB(console: Console) {
        val toolA = ToolA()
        toolA.methodA(console)
        console.log("Method B in ToolB called.")
    }
}

package com.example.tool

import com.m8test.script.core.api.console.Console

class ToolB {
    // 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    void methodB(Console console) {
        def toolA = new ToolA()
        toolA.methodA(console)
        console.log("Method B in ToolB called.")
    }
}

package com.example.tool;

import com.m8test.script.core.api.console.Console;

public class ToolB {
    // 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    public void methodB(Console console) {
        ToolA toolA = new ToolA();
        toolA.methodA(console);
        console.log("Method B in ToolB called.");
    }
}

// 假设 ToolA 已经被定义在另一个模块中
// 不能使用./, 需要使用相对于src目录的路径
// const ToolA = require('./ToolA'); // 错误示例
const ToolA = require('com/example/tool/ToolA');

// 定义 ToolB 类
function ToolB() {
    // 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    /**
     * @param {Packages.com.m8test.script.core.api.console.Console} console
     */
    this.methodB = function (console) {
        // ToolB 调用 ToolA 的方法
        const toolA = new ToolA();
        toolA.methodA(console);
        console.log("Method B in ToolB called.");
    };
}

// 导出 ToolB 类
module.exports = ToolB;

-- 引入 ToolA , 必须相对于 src 目录, 将目录中的 / 改成 '.', 不需要加后缀 '.lua'
local ToolA = require("com.example.tool.ToolA")
local ToolB = {}
-- 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
function ToolB.methodB(console)
    ToolA.methodA(console)
    console:log("Method B in ToolB called.")
end

return ToolB

<?php

// 声明命名空间，和当前文件所在文件夹的相对src的路径一样
namespace com\example\tool;
// 引入 ToolA , 必须是相对于src目录的路径
require_once 'com/example/tool/ToolA.php';

class ToolB
{
    // 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    public static function methodB($console)
    {
        ToolA::methodA($console);
        $console->log("Method B in ToolB called.");
    }
}

from m8test_java.com.m8test.script.core.api.console.Console import Console
# 引入 ToolA, from 需要相对于 src 目录的路径
from python.com.example.tool.ToolA import ToolA


class ToolB:
    # 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
    def methodB(self, console: Console):
        toolA = ToolA()
        toolA.methodA(console)
        console.log("Method B in ToolB called.")

# 引入 ToolA ， 必须是相对于 src 目录的路径
require 'com/example/tool/ToolA'
java_import "com.m8test.script.core.api.console.Console"

class ToolB
  # 此方法只是简单调用ToolA中的方法并且使用全局变量(参数传递的方式接收)简单输出日志以标识方法正确执行，会在入口文件中调用
  # @param console [Console]
  def methodB(console)
    toolA = ToolA.new
    toolA.methodA(console)
    console.log("Method B in ToolB called.")
  end
end

最后是入口文件（primary），内容如下：

package com.example.script

// 引入 ToolB
import com.example.tool.ToolB
import com.m8test.script.GlobalVariables._console

fun run() {
    // 创建 ToolB 实例
    val tool = ToolB()
    // 调用 ToolB 的方法并肩全局变量作为参数传递
    tool.methodB(_console)
}

package com.example.script


// 引入 ToolB
import com.example.tool.ToolB

// 创建 ToolB 对象
ToolB tool = new ToolB()
// 调用 ToolB 的方法并肩全局变量作为参数传递
tool.methodB($console)

package com.example.script;

// 引入 ToolB

import com.example.tool.ToolB;

import static com.m8test.script.GlobalVariables.$console;

class MyScript {
    public static void run() {
        // 创建 ToolB 对象
        ToolB tool = new ToolB();
        // 调用 ToolB 的方法并肩全局变量作为参数传递
        tool.methodB($console);
    }
}

// 引入 ToolB 类，相对于src目录的路径
let ToolB = require('com/example/tool/ToolB');
// 创建 ToolB 实例
const toolBInstance = new ToolB();
// 调用 ToolB 的方法并肩全局变量作为参数传递
toolBInstance.methodB($console);

-- 引入 ToolB , 必须相对于 src 目录, 将目录中的 / 改成 '.', 不需要加后缀 '.lua'
local ToolB = require("com.example.tool.ToolB")
-- 调用 ToolB 的方法并肩全局变量作为参数传递
ToolB.methodB(_console)

<?php
// 引入 ToolB , 必须是相对于src目录的路径
require_once 'com/example/tool/ToolB.php';

// 命名空间不同使用 use 来引入 ToolB.php 中的 ToolB 类
use com\example\tool\ToolB;

/** 通过use使用java中的类, 不能使用 use xxx as xxx 只能使use,因为下面这句话会被替换为 import android.widget.Button, 这样写的目的是有代码提示 **/

// 声明全局变量, 如果不声明的话也可以但是没有代码提示
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
global $console;
ToolB::methodB($console);

from m8test_java.com.m8test.script.GlobalVariables import _console
# 引入 ToolB, from 需要相对于 src 目录的路径
from python.com.example.tool.ToolB import ToolB

# 创建 ToolB 实例
toolB = ToolB()
# 调用 ToolB 的方法并肩全局变量作为参数传递
toolB.methodB(_console)

# 引入 ToolB ， 必须是相对于 src 目录的路径
require 'com/example/tool/ToolB'
# 创建 ToolB 实例
toolB = ToolB.new
# 调用 ToolB 的方法并肩全局变量作为参数传递
toolB.methodB($console)

Last modified: 01 October 2025