search QUERY:
  lynx https://www.google.com/?q={{QUERY}}

你输入

$ just search "cat toupee"

just 将运行命令 lynx https://www.google.com/?q=cat toupee，它将被 sh 解析为 lynx，https://www.google.com/?q=cat 和 toupee，而不是你想要的 lynx 和 https://www.google.com/?q=cat toupee。

你可以通过添加引号来修复这个问题

search QUERY:
  lynx 'https://www.google.com/?q={{QUERY}}'

以 $ 开头的参数将被导出为环境变量。

foo $bar:
  echo $bar

依赖关系

依赖关系会在依赖于它们的配方之前运行

a: b
  @echo A

b:
  @echo B

$ just a
B
A

在 just 的给定调用中，具有相同参数的配方只会运行一次，无论它在命令行调用中出现多少次，或者作为依赖出现多少次

a:
  @echo A

b: a
  @echo B

c: a
  @echo C

$ just a a a a a
A
$ just b c
A
B
C

多个配方可能依赖于执行某种设置的配方，并且当这些配方运行时，该设置只会执行一次

build:
  cc main.c

test-foo: build
  ./a.out --test foo

test-bar: build
  ./a.out --test bar

$ just test-foo test-bar
cc main.c
./a.out --test foo
./a.out --test bar

只有当配方接收到相同的参数时，才会跳过给定运行中的配方

build:
  cc main.c

test TEST: build
  ./a.out --test {{TEST}}

$ just test foo test bar
cc main.c
./a.out --test foo
./a.out --test bar

在配方末尾运行配方

配方的正常依赖关系始终在配方开始之前运行。也就是说，被依赖的总是先于依赖者运行。这些依赖关系被称为“优先依赖关系”。

配方还可以有后续依赖关系，这些依赖关系在配方之后运行，并使用 && 引入

a:
  echo 'A!'

b: a && c d
  echo 'B!'

c:
  echo 'C!'

d:
  echo 'D!'

运行 b 会打印

$ just b
echo 'A!'
A!
echo 'B!'
B!
echo 'C!'
C!
echo 'D!'
D!

在配方中间运行配方

just 不支持在另一个配方的中间运行配方，但你可以在配方的中间递归地调用 just。给定以下 justfile

a:
  echo 'A!'

b: a
  echo 'B start!'
  just c
  echo 'B end!'

c:
  echo 'C!'

运行 b 会打印

$ just b
echo 'A!'
A!
echo 'B start!'
B start!
echo 'C!'
C!
echo 'B end!'
B end!

这有一些限制，因为配方 c 是用全新的 just 调用运行的：赋值将被重新计算，依赖关系可能运行两次，并且命令行参数不会传播到子 just 进程。

用其他语言编写配方

以 #! 开始的配方称为 shebang 配方，通过将配方主体保存到文件中并运行它来执行。这让你可以用不同的语言编写配方

polyglot: python js perl sh ruby nu

python:
  #!/usr/bin/env python3
  print('Hello from python!')

js:
  #!/usr/bin/env node
  console.log('Greetings from JavaScript!')

perl:
  #!/usr/bin/env perl
  print "Larry Wall says Hi!\n";

sh:
  #!/usr/bin/env sh
  hello='Yo'
  echo "$hello from a shell script!"

nu:
  #!/usr/bin/env nu
  let hello = 'Hola'
  echo $"($hello) from a nushell script!"

ruby:
  #!/usr/bin/env ruby
  puts "Hello from ruby!"

$ just polyglot
Hello from python!
Greetings from JavaScript!
Larry Wall says Hi!
Yo from a shell script!
Hola from a nushell script!
Hello from ruby!

在包括 Linux 和 MacOS 在内的类 Unix 操作系统中，shebang 配方通过将配方主体保存到临时目录中的文件，将该文件标记为可执行，并执行它来执行。然后操作系统将 shebang 行解析为命令行并调用它，包括文件的路径。例如，如果配方以 #!/usr/bin/env bash 开始，操作系统运行的最终命令可能类似于 /usr/bin/env bash /tmp/PATH_TO_SAVED_RECIPE_BODY。

shebang 行分割依赖于操作系统。当传递带有参数的命令时，你可能需要使用 -S 标志明确告诉 env 进行分割

run:
  #!/usr/bin/env -S bash -x
  ls

Windows不支持shebang行。在Windows上，just将shebang行拆分为命令和参数，将配方主体保存到文件中，然后调用拆分的命令和参数，将保存的配方主体路径作为最后一个参数。例如，在Windows上，如果配方以#! py开始，操作系统最终运行的命令将类似于py C:\Temp\PATH_TO_SAVED_RECIPE_BODY。

更安全的Bash Shebang配方

如果您正在编写bash shebang配方，请考虑添加set -euxo pipefail

foo:
  #!/usr/bin/env bash
  set -euxo pipefail
  hello='Yo'
  echo "$hello from Bash!"

虽然这不是强制性的，但set -euxo pipefail将打开一些有用的功能，使bash shebang配方更类似于正常的逐行just配方

• set -e使得bash在命令失败时退出。

• set -u使得bash在变量未定义时退出。

• set -x使得bash在运行前打印每行脚本。

• set -o pipefail使得bash在管道中的命令失败时退出。这是bash特有的，因此在正常的逐行just配方中没有打开。

这些功能一起可以避免许多shell脚本的陷阱。

Windows上Shebang配方执行

在Windows上，包含/的shebang解释器路径将使用Cygwin中提供的实用程序cygpath从Unix风格路径转换为Windows风格路径。

例如，要在Windows上执行此配方

echo:
  #!/bin/sh
  echo "Hello!"

在执行之前，解释器路径/bin/sh将使用cygpath转换为Windows风格路径。

如果解释器路径不包含/，它将执行而不进行转换。如果cygpath不可用，或者您希望将Windows风格路径传递给解释器，这很有用。

在配方中设置变量

配方行由shell而不是just解释，因此不可能在配方中间设置just变量

foo:
  x := "hello" # This doesn't work!
  echo {{x}}

虽然可以使用shell变量，但还有一个问题。每个配方行都由一个新的shell实例运行，因此在一行中设置的变量不会在下一行中设置

foo:
  x=hello && echo $x # This works!
  y=bye
  echo $y            # This doesn't, `y` is undefined here!

解决这个问题的最佳方法是用shebang配方。Shebang配方主体被提取并作为脚本运行，因此单个shell实例将运行整个内容

foo:
  #!/usr/bin/env bash
  set -euxo pipefail
  x=hello
  echo $x

在配方之间共享环境变量

每个配方行的每一行都由一个新的shell执行，因此不可能在配方之间共享环境变量。

使用Python虚拟环境

一些工具，如Python的venv，需要加载环境变量才能工作，这使得它们难以与just一起使用。作为解决方案，您可以直接执行虚拟环境二进制文件

venv:
  [ -d foo ] || python3 -m venv foo

run: venv
  ./foo/bin/python3 main.py

在配方中更改工作目录

每个配方行都由一个新的shell执行，因此如果您在一行中更改工作目录，它对后续行没有影响

foo:
  pwd    # This `pwd` will print the same directory…
  cd bar
  pwd    # …as this `pwd`!

有几种方法可以解决这个问题。一种是在要运行的命令同一行上调用cd

foo:
  cd bar && pwd

另一种方法是使用shebang配方。Shebang配方主体被提取并作为脚本运行，因此单个shell实例将运行整个程序，因此在一行中执行pwd将影响后续行，就像shell脚本一样

foo:
  #!/usr/bin/env bash
  set -euxo pipefail
  cd bar
  pwd

缩进

配方行可以用空格或制表符缩进，但不能混合使用。配方中所有行的缩进类型必须相同，但同一justfile中的不同配方可以使用不同的缩进。

每个配方至少必须从recipe-name缩进一个级别，但之后可以进一步缩进。

下面是一个使用空格缩进，表示为·，和制表符缩进，表示为→的配方。

set windows-shell := ["pwsh", "-NoLogo", "-NoProfileLoadTime", "-Command"]

set ignore-comments

list-space directory:
··#!pwsh
··foreach ($item in $(Get-ChildItem {{directory}} )) {
····echo $item.Name
··}
··echo ""

# indentation nesting works even when newlines are escaped
list-tab directory:
→ @foreach ($item in $(Get-ChildItem {{directory}} )) { \
→ → echo $item.Name \
→ }
→ @echo ""

PS > just list-space ~
Desktop
Documents
Downloads

PS > just list-tab ~
Desktop
Documents
Downloads

多行构造

没有初始shebang的配方将逐行评估和运行，这意味着多行构造可能不会按预期工作。

例如，以下justfile

conditional:
  if true; then
    echo 'True!'
  fi

在conditional配方第二行之前的额外前导空格将产生解析错误

$ just conditional
error: Recipe line has extra leading whitespace
  |
3 |         echo 'True!'
  |     ^^^^^^^^^^^^^^^^

为了解决这个问题，您可以一行内编写条件语句，使用斜杠转义换行符，或给配方添加shebang。这里提供了一些多行构造的示例供参考。

if语句

conditional:
  if true; then echo 'True!'; fi

conditional:
  if true; then \
    echo 'True!'; \
  fi

conditional:
  #!/usr/bin/env sh
  if true; then
    echo 'True!'
  fi

for循环

for:
  for file in `ls .`; do echo $file; done

for:
  for file in `ls .`; do \
    echo $file; \
  done

for:
  #!/usr/bin/env sh
  for file in `ls .`; do
    echo $file
  done

while循环

while:
  while `server-is-dead`; do ping -c 1 server; done

while:
  while `server-is-dead`; do \
    ping -c 1 server; \
  done

while:
  #!/usr/bin/env sh
  while `server-is-dead`; do
    ping -c 1 server
  done

配方体外部

括号表达式可以跨越多行

abc := ('a' +
        'b'
         + 'c')

abc2 := (
  'a' +
  'b' +
  'c'
)

foo param=('foo'
      + 'bar'
    ):
  echo {{param}}

bar: (foo
        'Foo'
     )
  echo 'Bar!'

以反斜杠结尾的行将继续到下一行，就好像这些行通过空格连接一样^1.15.0

a := 'foo' + \
     'bar'

foo param1 \
  param2='foo' \
  *varparam='': dep1 \
                (dep2 'foo')
  echo {{param1}} {{param2}} {{varparam}}

dep1: \
    # this comment is not part of the recipe body
  echo 'dep1'

dep2 \
  param:
    echo 'Dependency with parameter {{param}}'

反斜杠行续行也可以用于插值。反斜杠后面的行必须缩进。

recipe:
  echo '{{ \
  "This interpolation " + \
    "has a lot of text." \
  }}'
  echo 'back to recipe body'

命令行选项

just支持一些有用的命令行选项，用于列出、转储和调试配方和变量

$ just --list
Available recipes:
  js
  perl
  polyglot
  python
  ruby
$ just --show perl
perl:
  #!/usr/bin/env perl
  print "Larry Wall says Hi!\n";
$ just --show polyglot
polyglot: python js perl sh ruby

一些命令行选项可以使用环境变量设置。例如

$ export JUST_UNSTABLE=1
$ just

等同于

$ just --unstable

查阅just --help以查看哪些选项可以由环境变量设置。

私有配方

名称以_开头的配方和别名将不会从just --list中省略

test: _test-helper
  ./bin/test

_test-helper:
  ./bin/super-secret-test-helper-stuff

$ just --list
Available recipes:
    test

也不会从just --summary中省略

$ just --summary
test

可以使用[private]属性^1.10.0来隐藏配方或别名，而无需更改名称

[private]
foo:

[private]
alias b := bar

bar:

$ just --list
Available recipes:
    bar

这对于仅作为其他配方依赖的辅助配方非常有用。

静默配方

配方名称前可以加@来反转每行前的@的含义

@quiet:
  echo hello
  echo goodbye
  @# all done!

现在只有以@开始的行将被回显

$ just quiet
hello
goodbye
# all done!

可以使用set quiet将Justfile中的所有配方都设置为静默

set quiet

foo:
  echo "This is quiet"

@foo2:
  echo "This is also quiet"

[no-quiet]属性覆盖此设置

set quiet

foo:
  echo "This is quiet"

[no-quiet]
foo2:
  echo "This is not quiet"

Shebang配方默认是静默的

foo:
  #!/usr/bin/env bash
  echo 'Foo!'

$ just foo
Foo!

在shebang配方名称中添加@会使just在执行之前打印配方

@bar:
  #!/usr/bin/env bash
  echo 'Bar!'

$ just bar
#!/usr/bin/env bash
echo 'Bar!'
Bar!

just 在配方行失败时通常会打印错误消息。可以使用 [no-exit-message]^1.7.0 属性来抑制这些错误消息。这对于包装工具的配方特别有用。

git *args:
    @git {{args}}

$ just git status
fatal: not a git repository (or any of the parent directories): .git
error: Recipe `git` failed on line 2 with exit code 128

添加此属性以抑制工具以非零代码退出时的退出错误消息。

[no-exit-message]
git *args:
    @git {{args}}

$ just git status
fatal: not a git repository (or any of the parent directories): .git

使用交互式选择器选择要运行的配方

--choose 子命令使得 just 调用一个选择器以选择要运行的配方。选择器应从标准输入读取包含配方名称的行，并将一个或多个这些名称以空格分隔打印到标准输出。

由于目前没有使用 --choose 运行需要参数的配方的方法，因此这些配方不会提供给选择器。私有配方和别名也会被跳过。

可以使用 --chooser 标志来覆盖选择器。如果没有给出 --chooser，那么 just 首先检查 $JUST_CHOOSER 是否已设置。如果没有设置，则选择器默认为流行的模糊查找器 fzf。

可以将参数包含在选择器中，例如 fzf --exact。

选择器的调用方式与配方行相同。例如，如果选择器是 fzf，它将以 sh -cu 'fzf' 调用，如果覆盖了 shell 或 shell 参数，选择器调用将尊重这些覆盖。

如果您希望 just 默认使用选择器选择配方，您可以使用此作为默认配方

default:
  @just --choose

在其他目录中调用 justfile

如果传递给 just 的第一个参数包含一个 /，则发生以下情况

1. 在最后一个 / 处拆分参数。

2. 最后一个 / 之前的部分被视为目录。 just 将在该处开始搜索 justfile，而不是在当前目录中。

3. 最后一个斜杠之后的部分被视为普通参数，如果它是空的，则忽略。

这可能看起来有点奇怪，但如果您想在子目录中的 justfile 中运行命令，则很有用。

例如，如果您在一个包含名为 foo 的子目录的目录中，该子目录包含一个具有默认配方 build 的 justfile，以下都是等效的

$ (cd foo && just build)
$ just foo/build
$ just foo/

在第一个配方之后寻找的附加配方在相同的 justfile 中。例如，以下两者都是等效的

$ just foo/a b
$ (cd foo && just a b)

并且都会在 foo/justfile 中调用配方 a 和 b。

导入

一个 justfile 可以使用 import 语句包含另一个的内容。

如果您有以下 justfile

import 'foo/bar.just'

a: b
  @echo A

并且以下文本在 foo/bar.just

b:
  @echo B

foo/bar.just 将被包含在 justfile 中，并且将定义 recipe b

$ just b
B
$ just a
B
A

import 路径可以是绝对路径，也可以相对于包含它的 justfile 位置。在导入路径中，开头的 ~/ 被替换为当前用户的家目录。

Justfiles 对顺序不敏感，因此包含的文件可以引用在 import 语句之后定义的变量和 recipe。

导入的文件本身可以包含 import，这些导入会递归处理。

当设置 allow-duplicate-recipes 时，父模块中的 recipe 会覆盖导入中的 recipe。类似地，当设置 allow-duplicate-variables 时，父模块中的变量会覆盖导入中的变量。

可以在 import 关键字后放置一个 ? 来使导入可选。

import? 'foo/bar.just'

对于可选导入缺失的源文件不会产生错误。

从 ^1.19.0 版本开始

justfile 可以使用 mod 语句声明模块。由于 mod 语句目前不稳定，因此您需要使用 --unstable 标志，或者设置 JUST_UNSTABLE 环境变量来使用它们。

如果您有以下 justfile

mod bar

a:
  @echo A

在 bar.just 中的以下文本

b:
  @echo B

bar.just 将作为子模块包含在 justfile 中。在某个子模块中定义的 recipe、别名和变量不能在其他子模块中使用，并且每个模块使用自己的设置。

子模块中的 recipe 可以作为子命令调用

$ just --unstable bar b
B

或使用路径语法

$ just --unstable bar::b
B

如果模块名为 foo，Just 会搜索位于 foo.just、foo/mod.just、foo/justfile 和 foo/.justfile 的模块文件。在后两种情况下，模块文件可以有任意的大小写。

模块语句可以是以下形式

mod foo 'PATH'

它从 PATH 加载模块的源文件，而不是从常规位置。在 PATH 中，开头的 ~/ 被替换为当前用户的家目录。

只有根 justfile 才会加载环境文件，并且加载的环境变量在子模块中可用。影响环境文件加载的子模块设置将被忽略。

没有 [no-cd] 属性的子模块中的 recipe 将以包含子模块源文件的目录作为工作目录运行。

justfile() 和 justfile_directory() 总是返回根 justfile 的路径和包含它的目录，即使在从子模块 recipe 调用时也是如此。

可以在 mod 关键字后放置一个 ? 来使模块可选。

mod? foo

对于可选模块缺失的源文件不会产生错误。

没有源文件的可选模块不会冲突，因此您可以有多个具有相同名称的 mod 语句，只要最多只有一个源文件存在即可。

mod? foo 'bar.just'
mod? foo 'baz.just'

请参阅模块稳定跟踪问题获取更多信息。

隐藏justfile

just会查找名为justfile和.justfile的justfile，这可以用来隐藏justfile。

Just 脚本

通过在justfile的顶部添加shebang行并使其可执行，可以将just用作脚本的解释器。

$ cat > script <<EOF
#!/usr/bin/env just --justfile

foo:
  echo foo
EOF
$ chmod +x script
$ ./script foo
echo foo
foo

当执行带有shebang的脚本时，系统会将脚本的路径作为参数传递给shebang中的命令。因此，如果shebang是#!/usr/bin/env just --justfile，则命令将是/usr/bin/env just --justfile PATH_TO_SCRIPT。

使用上述shebang，just会将工作目录更改为脚本的所在位置。如果您希望保持工作目录不变，请使用#!/usr/bin/env just --working-directory . --justfile。

注意：操作系统之间的shebang行拆分并不一致。以下示例仅在macOS上进行了测试。在Linux上，您可能需要将-S标志传递给env

#!/usr/bin/env -S just --justfile

default:
  echo foo

格式化和转储justfile

每个justfile都有关于空白符和新行的规范格式。

您可以使用当前不稳定的--fmt标志用规范格式覆盖当前justfile

$ cat justfile
# A lot of blank lines





some-recipe:
  echo "foo"
$ just --fmt --unstable
$ cat justfile
# A lot of blank lines

some-recipe:
    echo "foo"

使用just --fmt --check --unstable调用运行--fmt的检查模式。如果格式正确，just将退出并返回0，如果格式不正确，则退出并打印diff。

您可以使用--dump命令将格式化的justfile输出到stdout

$ just --dump > formatted-justfile

使用--dump命令与--dump-format json可以打印justfile的JSON表示。

回退到父justfile

如果在justfile中找不到配方，并且已设置fallback设置，则just将查找父目录中的justfile，直到达到根目录。just将在遇到fallback设置为false或未设置justfile时停止。

set fallback
foo:
  echo foo

bar:
  echo bar

$ just bar
Trying ../justfile
echo bar
bar

foo argument:
  touch {{argument}}

$ just foo "some argument.txt"

foo argument:
  touch '{{argument}}'

set positional-arguments

foo argument:
  touch "$1"

set export

foo argument:
  touch "$argument"

foo $argument:
  touch "$argument"

recipe:
  echo one
  sleep 2
  echo two

$ just --timestamp recipe
[07:28:46] echo one
one
[07:28:46] sleep 2
[07:28:48] echo two
two

$ just --timestamp recipe --timestamp-format '%H:%M:%S%.3f %Z'
[07:32:11:.349 UTC] echo one
one
[07:32:11:.350 UTC] sleep 2
[07:32:13:.352 UTC] echo two
two