Flutter脚本执行插件flight_script的使用

Flutter脚本执行插件flight_script的使用

在Flutter项目中嵌入一个小的脚本语言可以带来很多灵活性。本文将介绍如何使用flight_script插件来实现这一功能。

特性

  • 轻量级脚本：定义函数、创建循环、赋值变量等。
  • 从Dart调用Flight脚本或从Flight脚本调用Dart。
  • 解释器可以在运行时动态适应。
  • 虚拟机与解析器分离，以增加可扩展性。

入门

初始化解释器并运行脚本

首先，你需要引入flight_script包：

import 'package:flight_script/flight_script.dart';

然后初始化解释器并运行脚本：

void main() {
  final interpreter = Interpreter();
  interpreter.eval('"The answer to the ultimate question is " << 42 print');
}

运行结果：

The answer to the ultimate question is 42

注意：返回值是以数组形式返回的，因为允许多个返回值。

示例

示例1：基础语法

/* "
  The flight-script interpreter is similar to the Forth language's compiler
  it reads left to right, using spaces (space, tab, newline) to identify when the
  next item starts. Each item is evaluated as it is reached.

  there are only three things it recognises:
  numbers - anything that dart recognises with `double.tryParse`
  strings - strings start with either double or single quotes, and end with the matching quotation mark. Standard escape characters (e.g. \n for newline) are recognised
  identifiers - any sequence of characters that is not one of those

  the example program would therefore be: [ String, Identifier, Number, Identifier ]

  Numbers and strings are pushed onto a stack. Identifiers are looked up in the heap
  and then evaluated - if they're an object (number, string, or another dart object)
  they are pushed onto the stack. If they are a function (or a flight macro, or a DartFunction)
  they are immediately called - due to the immediate execution and the stack-based call, function names go after their arguments (usually)

  Even comments follow this pattern - /* is an identifier that is bound to a function that causes the interpretter to discard
  everything it sees until it sees the end comment identifier (and for the parser's sake, we wrap the comment text in a string)
  "
*/

"The answer to the ultimate question is " << 42 print

运行结果：

The answer to the ultimate question is 42.0

示例2：变量赋值

/* "
  values can be assigned with `-> variable_name`, and retrieved with `variable_name`
  anything left on the stack at the end of the run will be returned to dart

  Multiple values can be returned, so the returned result is an array
  Extra whitespace can be added and is ignored

  Arithmetic operators are 'infix' they go between their parameters instead of after them

  This example sets the a, b, c and x variables and evaluates the general
  quadratic equation (ax^2 + bx + c) => 2*4*4 -3*4 + 1 => 21

  Operators are evaluated left to right - not by normal operator precedence
  here we've used the `y` variable as the running total - there are other methods
  to achieve this (macros and functions would make it a one-line equation)
"
 */

4 -> x

1 -3 2 -> a -> b -> c /* " multiple assignment is allowed, but it's not easy to read " */

a * x * x -> y
b * x + y -> y
c + y -> y

y print

运行结果：

21.0

示例3：宏定义

/* "
  macros are defined starting with `#{` and ending with `}`
  A macro can either be immediately called using (), or it can
  be assigned to a variable, after which it will be called immediately when that
  variable is loaded

  Macros do not create new scopes, they are simply executed in whatever scope they
  are called. They may retrieve values from the stack or push to the stack, but care
  must be taken with variable assignment inside a macro

  (the dup command duplicates the top of the stack, the _operators (_+, _*) are the postfix forms of the
  arithmetic operators)
 " */

1 -> c
-3 -> b
2 -> a

4 -> x

<{ dup _* }> -> square

<{ x square * a }> ()
<{ b * x }> ()
<{ c }> ()
_+ _+

print

运行结果：

21.0

示例4：函数定义

/* "
  Functions are 'heavyweight' macros. Functions create a new scope when called,
  which has access to its parent scope at the point it was declared.

  Like macros, functions can be called anonymously. Also like macros, they use the stack for parameters and
  return values
" */

{ dup _+ } -> double

5 double print

运行结果：

10.0

示例5：条件语句

/* "
  Conditions are unusual. First a boolean expression should be pushed. Then the true function (or macro), then
  false. Finally the condition keyword evaluates the stack.
 " */

3 -> x

x > 5 <{ "Larger" print }> <{ "Smaller" print }> if

true { "This is always true so we use the do-nothing function" } { } if print

运行结果：

Smaller
This is always true so we use the do-nothing function

示例6：作用域管理

/* "
  Functions have access to the scopes that were available when they were defined
  This gives them access to variables that may otherwise be inaccessible
  We can use this to create private variables - accessing n from outside the
  outer function here would be impossible if we do not call `getter`
  notice we return the two inner functions and assign them both - multiple returns are allowed as
  we just push to the stack
" */

{
    5 => n
    { n }
    { n + 1 -> n }
} () -> add_one -> getter

add_one
add_one
getter print

运行结果：

7.0

示例7：递归调用

/* "
  Because variables can be read from outer scopes but assignments may shadow,
  functions can be called recursively. This can also be used to create loops

  Since ! is normally the not= operator we redefined it, because we can
"  */

{
    dup > 1
    <{ dup - 1 ! _* }>
    <{ }>
    if
} -> !

5 ! print

运行结果：

120.0

示例8：可变参数函数

/* "
  min_n and max_n take a variable number of arguments. The infix argument should say how many values
  to test
" */

2 4 min_n 2 print

1 2 3 4 5 6 7 8 9 max_n 9 print

运行结果：

2.0
9.0

完整示例

下面是一个完整的示例，展示了如何加载并执行包含Flight脚本的文件。

文件结构

假设你的项目目录结构如下：

my_flutter_project/
├── example/
│   ├── main.dart
│   └── scripts/
│       ├── example.fss

main.dart

import 'dart:io';

import 'package:flight_script/flight_script.dart';

/// FlightScript is usually stored in .fss (flight-script-source) files (to avoid
/// confusion with F#'s .fs files
void main() {
  for (final script in _flightScriptExamples()) {
    print("---------------");
    print(script);
    print("---------------");

    final interpreter = Interpreter();
    interpreter.eval(script);

    print("---------------");
  }
}

Iterable<String> _flightScriptExamples() sync* {
  final Directory dir = Directory('.');
  for (final file in dir.listSync(recursive: true)
    ..sort((a, b) => a.path.compareTo(b.path))) {
    if (file is File &&
        file.path.endsWith(".fss") &&
        file.path.contains("example")) {
      yield file.readAsStringSync();
    }
  }
}

example.fss

"The answer to the ultimate question is " << 42 print

更多关于Flutter脚本执行插件flight_script的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter脚本执行插件flight_script的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


当然，以下是如何在Flutter项目中使用flight_script插件来执行脚本的一个基本示例。请注意，flight_script是一个假定的插件名称，因为在Flutter生态系统中并没有一个广泛知名的名为flight_script的插件。然而，我会根据一般的插件使用流程来展示如何集成和使用一个假想的脚本执行插件。

1. 添加插件依赖

首先，你需要在pubspec.yaml文件中添加插件依赖。如果flight_script是一个真实存在的插件，你可以像这样添加：

dependencies:
  flutter:
    sdk: flutter
  flight_script: ^x.y.z  # 替换为实际版本号

然后运行flutter pub get来安装依赖。

2. 导入插件

在你的Dart文件中，导入flight_script插件：

import 'package:flight_script/flight_script.dart';

3. 使用插件执行脚本

下面是一个简单的示例，展示如何使用flight_script插件来执行一个脚本。假设这个插件提供了一个execute方法，该方法接受一个脚本字符串并返回执行结果。

import 'package:flutter/material.dart';
import 'package:flight_script/flight_script.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Flight Script Example'),
        ),
        body: Center(
          child: ElevatedButton(
            onPressed: () async {
              // 定义要执行的脚本
              String script = """
              print("Hello from the script!");
              // 你可以在这里添加更多的脚本逻辑
              """;

              // 执行脚本并获取结果
              try {
                String result = await FlightScript.execute(script);
                // 显示结果
                ScaffoldMessenger.of(context).showSnackBar(
                  SnackBar(content: Text("Script result: $result")),
                );
              } catch (e) {
                // 处理错误
                ScaffoldMessenger.of(context).showSnackBar(
                  SnackBar(content: Text("Error executing script: $e")),
                );
              }
            },
            child: Text('Execute Script'),
          ),
        ),
      ),
    );
  }
}

// 假设插件中有一个FlightScript类，该类有一个静态的execute方法
// class FlightScript {
//   static Future<String> execute(String script) async {
//     // 这里是插件的内部实现，用于执行脚本并返回结果
//   }
// }

注意事项

  1. 插件实现：上面的代码示例假设flight_script插件中有一个FlightScript类和一个静态的execute方法。实际的插件可能会有不同的API和实现方式，所以请查阅插件的官方文档以获取准确的信息。

  2. 错误处理：在实际应用中，你应该更细致地处理错误情况，例如网络错误、脚本解析错误等。

  3. 安全性：执行动态脚本可能带来安全风险，特别是当脚本内容来自不可信的源时。确保你有适当的安全措施来防止恶意脚本的执行。

  4. 平台限制：某些脚本执行功能可能受到平台（iOS、Android、Web等）的限制。请查阅插件的文档以了解它是否支持你的目标平台。

由于flight_script是一个假定的插件名称，所以上述代码只是一个示例，你需要根据你的实际插件进行调整。如果你正在寻找一个真实的插件来执行脚本，请考虑使用像dart_vm_service这样的插件，它允许你在Flutter应用中与Dart虚拟机进行交互，但这通常用于调试和性能分析，而不是直接执行脚本。

回到顶部