File size: 3,887 Bytes
8d756d3 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
# Scripts
In Nushell, you can write and run scripts in the Nushell language. To run a script, you can pass it as an argument to the `nu` commandline application:
```nu
> nu myscript.nu
```
This will run the script to completion in a new instance of Nu. You can also run scripts inside the _current_ instance of Nu using [`source`](/commands/docs/source.md):
```nu
> source myscript.nu
```
Let's look at an example script file:
```nu
# myscript.nu
def greet [name] {
["hello" $name]
}
greet "world"
```
A script file defines the definitions for custom commands as well as the main script itself, which will run after the custom commands are defined.
In the above, first `greet` is defined by the Nushell interpreter. This allows us to later call this definition. We could have written the above as:
```nu
greet "world"
def greet [name] {
["hello" $name]
}
```
There is no requirement that definitions have to come before the parts of the script that call the definitions, allowing you to put them where you feel comfortable.
## How scripts are processed
In a script, definitions run first. This allows us to call the definitions using the calls in the script.
After the definitions run, we start at the top of the script file and run each group of commands one after another.
## Script lines
To better understand how Nushell sees lines of code, let's take a look at an example script:
```nu
a
b; c | d
```
When this script is run, Nushell will first run the `a` command to completion and view its results. Next, Nushell will run `b; c | d` following the rules in the ["Semicolons" section](pipelines.html#semicolons).
## Parameterizing Scripts
Script files can optionally contain a special "main" command. `main` will be run after any other Nu code, and is primarily used to add parameters to scripts. You can pass arguments to scripts after the script name (`nu <script name> <script args>`).
For example:
```nu
# myscript.nu
def main [x: int] {
$x + 10
}
```
```nu
> nu myscript.nu 100
110
```
## Argument Type Interpretation
By default, arguments provided to a script are interpreted with the type `Type::Any`, implying that they are not constrained to a specific data type and can be dynamically interpreted as fitting any of the available data types during script execution.
In the previous example, `main [x: int]` denotes that the argument x should possess an integer data type. However, if arguments are not explicitly typed, they will be parsed according to their apparent data type.
For example:
```nu
# implicit_type.nu
def main [x] {
$"Hello ($x | describe) ($x)"
}
# explicit_type.nu
def main [x: string] {
$"Hello ($x | describe) ($x)"
}
```
```nu
> nu implicit_type.nu +1
Hello int 1
> nu explicit_type.nu +1
Hello string +1
```
## Subcommands
A script can have multiple sub-commands like `run`, `build`, etc. which allows to execute a specific main sub-function. The important part is to expose them correctly with `def main [] {}`. See more details in the [Custom Command](custom_commands.html#sub-commands) section.
For example:
```nu
# myscript.nu
def "main run" [] {
print "running"
}
def "main build" [] {
print "building"
}
# important for the command to be exposed to the outside
def main [] {}
```
```nu
> nu myscript.nu build
building
> nu myscript.nu run
running
```
## Shebangs (`#!`)
On Linux and macOS you can optionally use a [shebang](<https://en.wikipedia.org/wiki/Shebang_(Unix)>) to tell the OS that a file should be interpreted by Nu. For example, with the following in a file named `myscript`:
```nu
#!/usr/bin/env nu
"Hello World!"
```
```nu
> ./myscript
Hello World!
```
For script to have access to standard input, `nu` should be invoked with `--stdin` flag:
```nu
#!/usr/bin/env -S nu --stdin
echo $"stdin: ($in)"
```
```nu
> echo "Hello World!" | ./myscript
stdin: Hello World!
```
|