脚本类型

在 M8Test 中，脚本类型有三种：

字符串脚本
文件脚本
项目脚本

启动字符串脚本

import com.m8test.script.GlobalVariables._console
import com.m8test.script.GlobalVariables._script

// 获取脚本引擎
val engine = _script.getEngine()
// 启动脚本字符串
engine.startString {
    // 设置需要执行的脚本内容
    setContent("import com.m8test.script.GlobalVariables.*\n_console.log(\"test-kotlin-from-start-file\")")
    // 设置脚本名称
    setName("test-kotlin-start-string")
    // 设置脚本语言
    setLanguage {
        // 设置脚本语言名称
        setName("Kotlin")
    }
}
_console.log("主脚本运行")

// 获取脚本引擎
def engine = $script.getEngine()
// 启动脚本字符串
engine.startString {
    // 设置需要执行的脚本内容
    it.setContent("\$console.log('test-groovy-from-start-string')")
    // 设置脚本名称
    it.setName("test-groovy-start-string")
    // 设置脚本语言
    it.setLanguage { l ->
        // 设置脚本语言名称
        l.setName("Groovy")
    }
}
$console.log("主脚本运行")

import com.m8test.script.core.api.config.ScriptStringConfig;
import com.m8test.script.core.api.engine.ScriptEngine;
import com.m8test.script.core.api.resource.WebResource;
import kotlin.jvm.functions.Function1;

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

// 获取脚本引擎
ScriptEngine engine = $script.getEngine();
// 启动脚本字符串
engine.startString(new Function1() {
    @Override
    public Object invoke(Object o) {
        ScriptStringConfig it = (ScriptStringConfig) o;
        // 设置需要执行的脚本内容
        it.setContent("import static com.m8test.script.GlobalVariables.*;\n$console.log(\"test-java-from-start-file\");");
        // 设置脚本名称
        it.setName("test-java-start-string");
        // 设置脚本语言
        it.setLanguage(new Function1() {
            @Override
            public Object invoke(Object o) {
                WebResource l = (WebResource) o;
                // 设置脚本语言名称
                l.setName("Java");
                return null;
            }
        });
        return null;
    }
});
$console.log("主脚本运行");

// 获取脚本引擎
let engine = $script.getEngine()
// 启动脚本字符串
engine.startString(function (it) {
    // 设置需要执行的脚本内容
    it.setContent("$console.log('test-javascript-from-start-string')")
    // 设置脚本名称
    it.setName("test-javascript-start-string")
    // 设置脚本语言
    it.setLanguage(function (l) {
        // 设置脚本语言名称
        l.setName("Javascript")
    })
})
$console.log("主脚本运行")

-- 获取脚本引擎
local engine = _script:getEngine()
-- 启动脚本字符串
engine:startString(function(it)
    -- 设置需要执行的脚本内容
    it:setContent("\_console:log('test-lua-from-start-string')")
    -- 设置脚本名称
    it:setName("test-lua-start-string")
    -- 设置脚本语言
    it:setLanguage(function(l)
        -- 设置脚本语言名称
        l:setName("Lua")
    end)
end)
_console:log("主脚本运行")

<?php
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
// 获取脚本引擎
$engine = $script->getEngine();
// 启动脚本字符串
$engine->startString(function ($it) {
    // 设置需要执行的脚本内容
    $it->setContent("<?php\n\$console->log('test-php-from-start-file');");
    // 设置脚本名称
    $it->setName("test-php-start-string");
    // 设置脚本语言
    $it->setLanguage(function ($l) {
        // 设置脚本语言名称
        $l->setName("Php");
    });
});
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
$console->log(javaString("主脚本运行"));

from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _script

# 获取脚本引擎
engine = _script.getEngine()
# 启动脚本字符串
engine.startString(lambda it:
                   # 设置需要执行的脚本内容
                   (it.setContent("_console.log('test-python-from-start-string')"),
                    # 设置脚本名称
                    it.setName("test-python-start-string"),
                    # 设置脚本语言
                    it.setLanguage(lambda l:
                                   # 设置脚本语言名称
                                   l.setName("Python")
                                   )
                    ))
_console.log("主脚本运行")

# encoding: utf-8
# 获取脚本引擎
engine = $script.getEngine()
java_import "com.m8test.script.core.api.config.ScriptStringConfig"
# 启动脚本字符串
engine.startString {
  # @type it [ScriptStringConfig]
  |it|
  # 设置需要执行的脚本内容
  it.setContent("$console.log('test-ruby-from-start-string')")
  # 设置脚本名称
  it.setName("test-ruby-start-string")
  java_import "com.m8test.script.core.api.resource.WebResource"
  # 设置脚本语言
  it.setLanguage {
    # @type l [WebResource]
    |l|
    # 设置脚本语言名称
    l.setName("Ruby")
  }
}
$console.log("主脚本运行")

启动文件脚本

启动本地的脚本文件

import com.m8test.script.GlobalVariables.*

// 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
val scriptFile = _files.buildFile {
    // 设置文件路径
    setPath("/sdcard/M8Test", "start-groovy-file.kts")
}
// 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("import com.m8test.script.GlobalVariables.*\n_console.log(\"test-kotlin-from-start-file\")", "utf-8")
// 获取脚本引擎
val engine = _script.getEngine()
// 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile {
    // 设置需要启动的脚本文件路径
    setFile(scriptFile)
}
_console.log("主脚本运行")

// 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
def scriptFile = $files.buildFile {
    // 设置文件路径
    it.setPath("/sdcard/M8Test", "start-groovy-file.groovy")
}
// 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("\$console.log('test-groovy-from-start-file')", "utf-8")
// 获取脚本引擎
def engine = $script.getEngine()
// 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile {
    // 设置需要启动的脚本文件路径
    it.setFile(scriptFile)
}
$console.log("主脚本运行")

import com.m8test.script.core.api.config.ScriptFileConfig;
import com.m8test.script.core.api.engine.ScriptEngine;
import com.m8test.script.core.api.file.FileBuilder;
import com.m8test.script.core.api.file.ScriptFile;
import kotlin.jvm.functions.Function1;

import static com.m8test.script.GlobalVariables.*;

// 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
final ScriptFile scriptFile = $files.buildFile(new Function1() {
    @Override
    public Object invoke(Object o) {
        FileBuilder fileBuilder = (FileBuilder) o;
        // 设置文件路径
        fileBuilder.setPath("/sdcard/M8Test", "start-java-file.javas");
        return null;
    }
});
// 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("import static com.m8test.script.GlobalVariables.*;\n$console.log(\"test-java-from-start-file\");", "utf-8");
// 获取脚本引擎
ScriptEngine engine = $script.getEngine();
// 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile(new Function1() {
    @Override
    public Object invoke(Object o) {
        ScriptFileConfig it = (ScriptFileConfig) o;
        // 设置需要启动的脚本文件路径
        it.setFile(scriptFile);
        return null;
    }
});
$console.log("主脚本运行");

// 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
let scriptFile = $files.buildFile(function (it) {
    // 设置文件路径
    it.setPath("/sdcard/M8Test", "start-javascript-file.js")
})
// 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("$console.log('test-javascript-from-start-file')", "utf-8")
// 获取脚本引擎
let engine = $script.getEngine()
// 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile(function (it) {
    // 设置需要启动的脚本文件路径
    it.setFile(scriptFile)
})
$console.log("主脚本运行")

-- 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
local scriptFile = _files:buildFile(function(it)
    -- 设置文件路径
    it:setPath("/sdcard/M8Test", "start-lua-file.lua")
end)
-- 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile:writeText("\_console:log('test-lua-from-start-file')", "utf-8")
-- 获取脚本引擎
local engine = _script:getEngine()
-- 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine:startFile(function(it)
    -- 设置需要启动的脚本文件路径
    it:setFile(scriptFile)
end)
_console:log("主脚本运行")

<?php
/** @var m8test_java\com\m8test\script\core\api\file\Files $files */
// 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
$scriptFile = $files->buildFile(function ($it) {
    // 设置文件路径
    $it->setPath("/sdcard/M8Test", "start-php-file.php");
});
// 在子脚本中简单打印日志表示子脚本已经成功运行
$scriptFile->writeText("<?php\n\$console->log('test-php-from-start-file')", "utf-8");
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
// 获取脚本引擎
$engine = $script->getEngine();
// 启动脚本文件，这里我们使用上面动态生成的脚本文件
$engine->startFile(function ($it) use ($scriptFile) {
    // 设置需要启动的脚本文件路径
    $it->setFile($scriptFile);
});
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
$console->log(javaString("主脚本运行"));

from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _files
from m8test_java.com.m8test.script.GlobalVariables import _script

# 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
scriptFile = _files.buildFile(lambda it:
                              # 设置文件路径
                              it.setPath("/sdcard/M8Test", "start-python-file.py")
                              )
# 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("_console.log('test-python-from-start-file')", "utf-8")
# 获取脚本引擎
engine = _script.getEngine()
# 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile(lambda it:
                 # 设置需要启动的脚本文件路径
                 it.setFile(scriptFile)
                 )
_console.log("主脚本运行")

# encoding: utf-8
java_import "com.m8test.script.core.api.file.FileBuilder"
# 简单的创建一个本地脚本文件, 如果实际开发的话，可以使用预编写的脚本文件
scriptFile = $files.buildFile {
  # @type it [FileBuilder]
  |it|
  # 设置文件路径
  it.setPath("/sdcard/M8Test", "start-ruby-file.rb")
}
# 在子脚本中简单打印日志表示子脚本已经成功运行
scriptFile.writeText("$console.log('test-ruby-from-start-file')", "utf-8")
# 获取脚本引擎
engine = $script.getEngine()
java_import "com.m8test.script.core.api.config.ScriptFileConfig"
# 启动脚本文件，这里我们使用上面动态生成的脚本文件
engine.startFile {
  # @type it [ScriptFileConfig]
  |it|
  # 设置需要启动的脚本文件路径
  it.setFile(scriptFile)
}
$console.log("主脚本运行")

启动网络脚本文件

import com.m8test.script.GlobalVariables.*

val scriptFile = _files.buildFile {
    // 设置文件路径
    setPath("/sdcard/M8Test", "start-kotlin-file-with-url.kts")
}
// 获取脚本引擎
val engine = _script.getEngine()
// 启动脚本文件
engine.startFile {
    // 设置需要启动脚本的下载地址、保存路径以及超时时间
    setUrl(
        "https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/kotlin/api/Console/log.kts",
        scriptFile,
        10000
    )
}
_console.log("主脚本运行")

def scriptFile = $files.buildFile {
    // 设置文件路径
    it.setPath("/sdcard/M8Test", "start-groovy-file-with-url.groovy")
}
// 获取脚本引擎
def engine = $script.getEngine()
// 启动脚本文件
engine.startFile {
    // 设置需要启动脚本的下载地址、保存路径以及超时时间
    it.setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/groovy/api/Console/log.groovy", scriptFile, 10000)
}
$console.log("主脚本运行")

import com.m8test.script.core.api.config.ScriptFileConfig;
import com.m8test.script.core.api.engine.ScriptEngine;
import com.m8test.script.core.api.file.FileBuilder;
import com.m8test.script.core.api.file.ScriptFile;
import kotlin.jvm.functions.Function1;

import static com.m8test.script.GlobalVariables.*;

final ScriptFile scriptFile = $files.buildFile(new Function1() {
    @Override
    public Object invoke(Object o) {
        FileBuilder fileBuilder = (FileBuilder) o;
        // 设置文件路径
        fileBuilder.setPath("/sdcard/M8Test", "start-java-file-with-url.javas");
        return null;
    }
});
// 获取脚本引擎
ScriptEngine engine = $script.getEngine();
// 启动脚本文件
engine.startFile(new Function1() {
    @Override
    public Object invoke(Object o) {
        ScriptFileConfig it = (ScriptFileConfig) o;
        // 设置需要启动脚本的下载地址、保存路径以及超时时间
        it.setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/java/api/Console/log.javas", scriptFile, 10000);
        return null;
    }
});
$console.log("主脚本运行");

let scriptFile = $files.buildFile(function (it) {
    // 设置文件路径
    it.setPath("/sdcard/M8Test", "start-javascript-file-with-url.js")
})
// 获取脚本引擎
let engine = $script.getEngine()
// 启动脚本文件
engine.startFile(function (it) {
    // 设置需要启动脚本的下载地址、保存路径以及超时时间
    it.setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/javascript/api/Console/log.js", scriptFile, 10000)
})
$console.log("主脚本运行")

local scriptFile = _files:buildFile(function(it)
    -- 设置文件路径
    it:setPath("/sdcard/M8Test", "start-lua-file-with-url.lua")
end)
-- 获取脚本引擎
local engine = _script:getEngine()
-- 启动脚本文件
engine:startFile(function(it)
    -- 设置需要启动脚本的下载地址、保存路径以及超时时间
    it:setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/lua/api/Console/log.lua",
        scriptFile, 10000)
end)
_console:log("主脚本运行")

<?php
/** @var m8test_java\com\m8test\script\core\api\file\Files $files */
$scriptFile = $files->buildFile(function ($it) {
    // 设置文件路径
    $it->setPath("/sdcard/M8Test", "start-php-file-with-url.php");
});
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
// 获取脚本引擎
$engine = $script->getEngine();
// 启动脚本文件
$engine->startFile(function ($it) use ($scriptFile) {
    // 设置需要启动脚本的下载地址、保存路径以及超时时间
    $it->setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/php/api/Console/log.php", $scriptFile, 10000);
});
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
$console->log(javaString("主脚本运行"));

from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _files
from m8test_java.com.m8test.script.GlobalVariables import _script

scriptFile = _files.buildFile(lambda it:
                              # 设置文件路径
                              it.setPath("/sdcard/M8Test", "start-python-file-with-url.py")
                              )
# 获取脚本引擎
engine = _script.getEngine()
# 启动脚本文件
engine.startFile(lambda it:
                 # 设置需要启动脚本的下载地址、保存路径以及超时时间
                 it.setUrl(
                     "https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/python/api/Console/log.py",
                     scriptFile, 10000)
                 )
_console.log("主脚本运行")

# encoding: utf-8
java_import "com.m8test.script.core.api.file.FileBuilder"
scriptFile = $files.buildFile {
  # @type it [FileBuilder]
  |it|
  # 设置文件路径
  it.setPath("/sdcard/M8Test", "start-ruby-file-with-url.rb")
}
# 获取脚本引擎
engine = $script.getEngine()
java_import "com.m8test.script.core.api.config.ScriptFileConfig"
# 启动脚本文件
engine.startFile {
  # @type it [ScriptFileConfig]
  |it|
  # 设置需要启动脚本的下载地址、保存路径以及超时时间
  it.setUrl("https://raw.githubusercontent.com/m8test/SampleCode/refs/heads/main/files/ruby/api/Console/log.rb", scriptFile, 10000)
}
$console.log("主脚本运行")

启动项目脚本

启动本地的脚本项目

import com.m8test.script.GlobalVariables.*

// 在本地保存的spa文件路径
val scriptFile = _files.buildFile {
    // 设置文件路径
    setPath("/sdcard/M8Test/spa", "com.example.script.kotlin-1.0.1.spa")
}
// 获取脚本引擎
val engine = _script.getEngine()
// 启动脚本项目
engine.startProject {
    // 设置需要启动的脚本项目路径
    setPath(scriptFile)
    // 让脚本独立运行到一个脚本引擎中
    setStandalone(true)
}
_console.log("主脚本运行")

// 在本地保存的spa文件路径
def scriptFile = $files.buildFile {
    // 设置文件路径
    it.setPath("/sdcard/M8Test/spa", "com.example.script.groovy-1.0.1.spa")
}
// 获取脚本引擎
def engine = $script.getEngine()
// 启动脚本项目
engine.startProject {
    // 设置需要启动的脚本项目路径
    it.setPath(scriptFile)
    // 让脚本独立运行到一个脚本引擎中
    it.setStandalone(true)
}
$console.log("主脚本运行")

import com.m8test.script.core.api.config.ScriptProjectConfig;
import com.m8test.script.core.api.engine.ScriptEngine;
import com.m8test.script.core.api.file.FileBuilder;
import com.m8test.script.core.api.file.ScriptFile;
import kotlin.jvm.functions.Function1;

import static com.m8test.script.GlobalVariables.*;

// 在本地保存的spa文件路径
final ScriptFile scriptFile = $files.buildFile(new Function1() {
    @Override
    public Object invoke(Object fileBuilder) {
        FileBuilder it = (FileBuilder) fileBuilder;
        // 设置文件路径
        it.setPath("/sdcard/M8Test/spa", "com.example.script.java-1.0.1.spa");
        return null;
    }
});
// 获取脚本引擎
ScriptEngine engine = $script.getEngine();
// 启动脚本项目
engine.startProject(new Function1() {
    @Override
    public Object invoke(Object scriptProjectConfig) {
        ScriptProjectConfig it = (ScriptProjectConfig) scriptProjectConfig;
        // 设置需要启动的脚本项目路径
        it.setPath(scriptFile);
        // 让脚本独立运行到一个脚本引擎中
        it.setStandalone(true);
        return null;
    }
});
$console.log("主脚本运行");

// 在本地保存的spa文件路径
let scriptFile = $files.buildFile(function (it) {
    // 设置文件路径
    it.setPath("/sdcard/M8Test/spa", "com.example.script.javascript-1.0.1.spa")
})
// 获取脚本引擎
let engine = $script.getEngine()
// 启动脚本项目
engine.startProject(function (it) {
    // 设置需要启动的脚本项目路径
    it.setPath(scriptFile)
    // 让脚本独立运行到一个脚本引擎中
    it.setStandalone(true)
})
$console.log("主脚本运行")

-- 在本地保存的spa文件路径
local scriptFile = _files:buildFile(function(it)
    -- 设置文件路径
    it:setPath("/sdcard/M8Test/spa", "com.example.script.lua-1.0.1.spa")
end)
-- 获取脚本引擎
local engine = _script:getEngine()
-- 启动脚本项目
engine:startProject(function(it)
    -- 设置需要启动的脚本项目路径
    it:setPath(scriptFile)
    -- 让脚本独立运行到一个脚本引擎中
    it:setStandalone(true)
end)
_console:log("主脚本运行")

<?php
/** @var m8test_java\com\m8test\script\core\api\file\Files $files */
// 在本地保存的spa文件路径
$scriptFile = $files->buildFile(function ($it) {
    // 设置文件路径
    $it->setPath("/sdcard/M8Test/spa", "com.example.script.php-1.0.1.spa");
});
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
// 获取脚本引擎
$engine = $script->getEngine();
// 启动脚本项目
$engine->startProject(function ($it) use ($scriptFile) {
    // 设置需要启动的脚本项目路径
    $it->setPath($scriptFile);
    // 让脚本独立运行到一个脚本引擎中
    $it->setStandalone(true);
});
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
$console->log(javaString("主脚本运行"));

from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _files
from m8test_java.com.m8test.script.GlobalVariables import _script

# 在本地保存的spa文件路径
scriptFile = _files.buildFile(lambda it:
                              # 设置文件路径
                              it.setPath("/sdcard/M8Test/spa", "com.example.script.python-1.0.1.spa")
                              )
# 获取脚本引擎
engine = _script.getEngine()
# 启动脚本项目
engine.startProject(lambda it:
                    # 设置需要启动的脚本项目路径
                    (it.setPath(scriptFile),
                     # 让脚本独立运行到一个脚本引擎中
                     it.setStandalone(True)
                     ))
_console.log("主脚本运行")

# encoding: utf-8
java_import "com.m8test.script.core.api.file.FileBuilder"
# 在本地保存的spa文件路径
scriptFile = $files.buildFile {
  # @type it [FileBuilder]
  |it|
  # 设置文件路径
  it.setPath("/sdcard/M8Test/spa", "com.example.script.ruby-1.0.1.spa")
}
# 获取脚本引擎
engine = $script.getEngine()
java_import "com.m8test.script.core.api.config.ScriptProjectConfig"
# 启动脚本项目
engine.startProject {
  # @type it [ScriptProjectConfig]
  |it|
  # 设置需要启动的脚本项目路径
  it.setPath(scriptFile)
  # 让脚本独立运行到一个脚本引擎中
  it.setStandalone(true)
}
$console.log("主脚本运行")

启动网络脚本项目

import com.m8test.script.GlobalVariables.*

// 在本地保存的spa文件路径
val scriptFile = _files.buildFile {
    // 设置文件路径
    setPath("/sdcard/M8Test/spa", "com.example.script.kotlin-1.0.1.spa")
}
// 获取脚本引擎
val engine = _script.getEngine()
// 启动脚本项目
engine.startProject {
    // 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
    setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.kotlin-1.0.1.spa", scriptFile, 10000)
    // 让脚本独立运行到一个脚本引擎中
    setStandalone(true)
}
_console.log("主脚本运行")

// 在本地保存的spa文件路径
def scriptFile = $files.buildFile {
    // 设置文件路径
    it.setPath("/sdcard/M8Test/spa", "com.example.script.groovy-1.0.1.spa")
}
// 获取脚本引擎
def engine = $script.getEngine()
// 启动脚本项目
engine.startProject {
    // 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
    it.setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.groovy-1.0.1.spa", scriptFile, 10000)
    // 让脚本独立运行到一个脚本引擎中
    it.setStandalone(true)
}
$console.log("主脚本运行")

import com.m8test.script.core.api.config.ScriptProjectConfig;
import com.m8test.script.core.api.engine.ScriptEngine;
import com.m8test.script.core.api.file.FileBuilder;
import com.m8test.script.core.api.file.ScriptFile;
import kotlin.jvm.functions.Function1;

import static com.m8test.script.GlobalVariables.*;

// 在本地保存的spa文件路径
final ScriptFile scriptFile = $files.buildFile(new Function1() {
    @Override
    public Object invoke(Object fileBuilder) {
        FileBuilder it = (FileBuilder) fileBuilder;
        // 设置文件路径
        it.setPath("/sdcard/M8Test/spa", "com.example.script.java-1.0.1.spa");
        return null;
    }
});
// 获取脚本引擎
ScriptEngine engine = $script.getEngine();
// 启动脚本项目
engine.startProject(new Function1() {
    @Override
    public Object invoke(Object scriptProjectConfig) {
        ScriptProjectConfig it = (ScriptProjectConfig) scriptProjectConfig;
        // 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
        it.setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.java-1.0.1.spa", scriptFile, 10000);
        // 让脚本独立运行到一个脚本引擎中
        it.setStandalone(true);
        return null;
    }
});
$console.log("主脚本运行");

// 在本地保存的spa文件路径
let scriptFile = $files.buildFile(function (it) {
    // 设置文件路径
    it.setPath("/sdcard/M8Test/spa", "com.example.script.javascript-1.0.1.spa")
})
// 获取脚本引擎
let engine = $script.getEngine()
// 启动脚本项目
engine.startProject(function (it) {
    // 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
    it.setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.javascript-1.0.1.spa", scriptFile, 10000)
    // 让脚本独立运行到一个脚本引擎中
    it.setStandalone(true)
})
$console.log("主脚本运行")

-- 在本地保存的spa文件路径
local scriptFile = _files:buildFile(function(it)
    -- 设置文件路径
    it:setPath("/sdcard/M8Test/spa", "com.example.script.lua-1.0.1.spa")
end)
-- 获取脚本引擎
local engine = _script:getEngine()
-- 启动脚本项目
engine:startProject(function(it)
    -- 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
    it:setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.lua-1.0.1.spa", scriptFile,
        10000)
    -- 让脚本独立运行到一个脚本引擎中
    it:setStandalone(true)
end)
_console:log("主脚本运行")

<?php
/** @var m8test_java\com\m8test\script\core\api\file\Files $files */
// 在本地保存的spa文件路径
$scriptFile = $files->buildFile(function ($it) {
    // 设置文件路径
    $it->setPath("/sdcard/M8Test/spa", "com.example.script.php-1.0.1.spa");
});
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
// 获取脚本引擎
$engine = $script->getEngine();
// 启动脚本项目
$engine->startProject(function ($it) use ($scriptFile) {
    // 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
    $it->setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.php-1.0.1.spa", $scriptFile, 10000);
    // 让脚本独立运行到一个脚本引擎中
    $it->setStandalone(true);
});
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
$console->log(javaString("主脚本运行"));

from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _files
from m8test_java.com.m8test.script.GlobalVariables import _script

# 在本地保存的spa文件路径
scriptFile = _files.buildFile(lambda it:
                              # 设置文件路径
                              it.setPath("/sdcard/M8Test/spa", "com.example.script.python-1.0.1.spa")
                              )
# 获取脚本引擎
engine = _script.getEngine()
# 启动脚本项目
engine.startProject(lambda it:
                    # 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
                    (it.setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.python-1.0.1.spa", scriptFile, 10000),
                     # 让脚本独立运行到一个脚本引擎中
                     it.setStandalone(True)
                     ))
_console.log("主脚本运行")

# encoding: utf-8
java_import "com.m8test.script.core.api.file.FileBuilder"
# 在本地保存的spa文件路径
scriptFile = $files.buildFile {
  # @type it [FileBuilder]
  |it|
  # 设置文件路径
  it.setPath("/sdcard/M8Test/spa", "com.example.script.ruby-1.0.1.spa")
}
# 获取脚本引擎
engine = $script.getEngine()
java_import "com.m8test.script.core.api.config.ScriptProjectConfig"
# 启动脚本项目
engine.startProject {
  # @type it [ScriptProjectConfig]
  |it|
  # 设置需要启动的脚本项目的下载地址、本地保存的路径以及超时时间
  it.setUrl("https://github.com/m8test/dev-docs/raw/refs/heads/master/com.example.script.ruby-1.0.1.spa", scriptFile, 10000)
  # 让脚本独立运行到一个脚本引擎中
  it.setStandalone(true)
}
$console.log("主脚本运行")

Last modified: 01 October 2025