Nushell cheat sheet
Data types
> "12" | into int
converts string to integer
> date now | date to-timezone "Europe/London"
converts present date to provided time zone
> {'name': 'nu', 'stars': 5, 'language': 'Python'} | upsert language 'Rust'
updates a record's language and if none is specified inserts provided value
> [one two three] | to yaml
converts list of strings to yaml
> [[framework, language]; [Django, Python] [Lavarel, PHP]]
prints the table
> [{name: 'Robert' age: 34 position: 'Designer'}
{name: 'Margaret' age: 30 position: 'Software Developer'}
{name: 'Natalie' age: 50 position: 'Accountant'}
] | select name position
selects two columns from the table and prints their values
Strings
> let name = "Alice"
> $"greetings, ($name)!"
prints
greetings, Alice!
> let string_list = "one,two,three" | split row ","
$string_list
╭───┬───────╮
│ 0 │ one │
│ 1 │ two │
│ 2 │ three │
╰───┴───────╯
splits the string with specified delimiter and saves the list to
string_listvariable
"Hello, world!" | str contains "o, w"
checks if a string contains a substring and returns
boolean
let str_list = [zero one two]
$str_list | str join ','
joins the list of strings using provided delimiter
> 'Hello World!' | str substring 4..8
created a slice from a given string with start (4) and end (8) indices
> 'Nushell 0.80' | parse '{shell} {version}'
╭───┬─────────┬─────────╮
│ # │ shell │ version │
├───┼─────────┼─────────┤
│ 0 │ Nushell │ 0.80 │
╰───┴─────────┴─────────╯
parses the string to columns
> "acronym,long\nAPL,A Programming Language" | from csv
parses comma separated values (csv)
> $'(ansi purple_bold)This text is a bold purple!(ansi reset)'
ansi command colors the text (alsways end with
ansi resetto reset color to default)
Lists
> [foo bar baz] | insert 1 'beeze'
╭───┬───────╮
│ 0 │ foo │
│ 1 │ beeze │
│ 2 │ bar │
│ 3 │ baz │
╰───┴───────╯
inserts
beezevalue at st index in the list
> [1, 2, 3, 4] | update 1 10
updates 2nd value to 10
> let numbers = [1, 2, 3, 4, 5]
> $numbers | prepend 0
adds value at the beginning of the list
> let numbers = [1, 2, 3, 4, 5]
> $numbers | append 6
adds value at the end of the list
> let flowers = [cammomile marigold rose forget-me-not]
> let flowers = ($flowers | first 2)
> $flowers
creates slice of first two values from
flowerslist
> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune]
> $planets | each { |it| $"($it) is a planet of solar system" }
iterates over a list;
itis current list value
> $planets | enumerate | each { |it| $"($it.index + 1) - ($it.item)" }
iterates over a list and provides index and value in
it
> let scores = [3 8 4]
> $"total = ($scores | reduce { |it, acc| $acc + $it })"
reduces the list to a single value,
reducegives access to accumulator that is applied to each element in the list
> $"total = ($scores | reduce --fold 1 { |it, acc| $acc * $it })"
initial value for accumulator value can be set with
--fold
> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune]
> $planets.2
> Earth
gives access to the 3rd item in the list
> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune]
> $planets | any {|it| $it | str starts-with "E" }
> true
checks if any string in the list starts with
E
> let cond = {|x| $x < 0 }; [-1 -2 9 1] | take while $cond
╭───┬────╮
│ 0 │ -1 │
│ 1 │ -2 │
╰───┴────╯
creates slice of items that satisfy provided condition
Tables
> ls | sort-by size
sorting table by size of files
> ls | sort-by size | first 5
sorting table by size of files and show first 5 entries
> let $a = [[first_column second_column third_column]; [foo bar snooze]]
> let $b = [[first_column second_column third_column]; [hex seeze feeze]]
> $a | append $b
╭───┬──────────────┬───────────────┬──────────────╮
│ # │ first_column │ second_column │ third_column │
├───┼──────────────┼───────────────┼──────────────┤
│ 0 │ foo │ bar │ snooze │
│ 1 │ hex │ seeze │ feeze │
╰───┴──────────────┴───────────────┴──────────────╯
concatenate two tables with same columns
> let teams_scores = [[team score plays]; ['Boston Celtics' 311 3] ['Golden State Warriors', 245 2]]
> $teams_scores | drop column
╭───┬───────────────────────┬───────╮
│ # │ team │ score │
├───┼───────────────────────┼───────┤
│ 0 │ Boston Celtics │ 311 │
│ 1 │ Golden State Warriors │ 245 │
╰───┴───────────────────────┴───────╯
remove the last column of a table
Files & Filesystem
> start file.txt
opens a text file with the default text editor
> 'lorem ipsum ' | save file.txt
saves a string to text file
> 'dolor sit amet' | save --append file.txt
appends a string to the end of file.txt
> { a: 1, b: 2 } | save file.json
saves a record to file.json
> glob **/*.{rs,toml} --depth 2
searches for
.rsand.tomlfiles recursively up to 2 folders deep
> watch . --glob=**/*.rs {|| cargo test }
runs cargo test whenever a Rust file changes
Custom Commands
def greet [name: string] {
$"hello ($name)"
}
custom command with parameter type set to string
def greet [name = "nushell"] {
$"hello ($name)"
}
custom command with default parameter set to nushell
def greet [
name: string
--age: int
] {
[$name $age]
}
> greet world --age 10
passing named parameter by defining flag for custom commands
def greet [
name: string
--age (-a): int
--twice
] {
if $twice {
[$name $age $name $age]
} else {
[$name $age]
}
}
> greet -a 10 --twice hello
using flag as a switch with a shorthand flag (-a) for the age
def greet [...name: string] {
print "hello all:"
for $n in $name {
print $n
}
}
> greet earth mars jupiter venus
custom command which takes any number of positional arguments using rest params
Variables & Subexpressions
> let val = 42
> print $val
42
an immutable variable cannot change its value after declaration
> let val = 42
> do { let val = 101; $val }
101
> $val
42
shadowing variable (declaring variable with the same name in a different scope)
> mut val = 42
> $val += 27
> $val
69
declaring a mutable variable with mut key word
> mut x = 0
> [1 2 3] | each { $x += 1 }
closures and nested defs cannot capture mutable variables from their environment. This expression results in error.
> const plugin = 'path/to/plugin'
> register $plugin
a constant variable is immutable value which is fully evaluated at parse-time
> let files = (ls)
> $files.name?.0?
using question mark operator to return null instead of error if provided path is incorrect
> let big_files = (ls | where size > 10kb)
> $big_files
using subexpression by wrapping the expression with parentheses ()
Modules
> module greetings {
export def hello [name: string] {
$"hello ($name)!"
}
export def hi [where: string] {
$"hi ($where)!"
}
}
> use greetings hello
> hello "world"
using inline module
# greetings.nu
export-env {
$env.MYNAME = "Arthur, King of the Britons"
}
export def hello [] {
$"hello ($env.MYNAME)"
}
> use greetings.nu
> $env.MYNAME
Arthur, King of the Britons
> greetings hello
hello Arthur, King of the Britons!
importing module from file and using its environment in current scope
# greetings.nu
export def hello [name: string] {
$"hello ($name)!"
}
export def hi [where: string] {
$"hi ($where)!"
}
export def main [] {
"greetings and salutations!"
}
> use greetings.nu
> greetings
greetings and salutations!
> greetings hello world
hello world!
using main command in module