# Unterminated string which will start a new line in the CLI
`````
## Strings as external commands
You can place the `^` sigil in front of any string (including a variable) to have Nushell execute the string as if it was an external command:
```nu
^'C:\Program Files\exiftool.exe'
let foo = 'C:\Program Files\exiftool.exe'
^$foo
```
You can also use the [`run-external`](/commands/docs/run-external.md) command for this purpose, which provides additional flags and options.
## Appending and Prepending to strings
There are various ways to pre, or append strings. If you want to add something to the beginning of each string closures are a good option:
```nu
['foo', 'bar'] | each {|s| '~/' ++ $s} # ~/foo, ~/bar
['foo', 'bar'] | each {|s| '~/' + $s} # ~/foo, ~/bar
```
You can also use a regex to replace the beginning or end of a string:
```nu
['foo', 'bar'] | str replace -r '^' '~/'# ~/foo, ~/bar
['foo', 'bar'] | str replace -r '$' '~/'# foo~/, bar~/
```
If you want to get one string out of the end then `str join` is your friend:
```nu
"hello" | append "world!" | str join " " # hello world!
```
You can also use reduce:
```nu
1..10 | reduce -f "" {|elt, acc| $acc + ($elt | into string) + " + "} # 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 +
```
Though in the cases of strings, especially if you don't have to operate on the strings, it's usually easier and more correct (notice the extra + at the end in the example above) to use `str join`.
Finally you could also use string interpolation, but that is complex enough that it is covered in its own subsection below.
## String interpolation
More complex string use cases also need a new form of string: string interpolation. This is a way of building text from both raw text and the result of running expressions. String interpolation combines the results together, giving you a new string.
String interpolation uses `$" "` and `$' '` as ways to wrap interpolated text.
For example, let's say we have a variable called `$name` and we want to greet the name of the person contained in this variable:
```nu
let name = "Alice"
$"greetings, ($name)"
# => greetings, Alice
```
By wrapping expressions in `()`, we can run them to completion and use the results to help build the string.
String interpolation has both a single-quoted, `$' '`, and a double-quoted, `$" "`, form. These correspond to the single-quoted and double-quoted strings: single-quoted string interpolation doesn't support escape characters while double-quoted string interpolation does.
As of version 0.61, interpolated strings support escaping parentheses, so that the `(` and `)` characters may be used in a string without Nushell trying to evaluate what appears between them:
```nu
$"2 + 2 is (2 + 2) \(you guessed it!)"
# => 2 + 2 is 4 (you guessed it!)
```
Interpolated strings can be evaluated at parse time, but if they include values whose formatting depends
on your configuration and your `config.nu` hasn't been loaded yet, they will use the default configuration.
So if you have something like this in your `config.nu`, `x` will be `"2.0 KB"` even if your config says to use
`MB` for all file sizes (datetimes will similarly use the default config).
```nu
const x = $"(2kb)"
```
## Splitting Strings
The [`split row`](/commands/docs/split_row.md) command creates a list from a string based on a delimiter.
```nu
"red,green,blue" | split row ","
# => ╭───┬───────╮
# => │ 0 │ red │
# => │ 1 │ green │
# => │ 2 │ blue │
# => ╰───┴───────╯
```
The [`split column`](/commands/docs/split_column.md) command will create a table from a string based on a delimiter. This applies generic column names to the table.
```nu
"red,green,blue" | split column ","
# => ╭───┬─────────┬─────────┬─────────╮
# => │ # │ column1 │ column2 │ column3 │
# => ├───┼─────────┼─────────┼─────────┤
# => │ 0 │ red │ green │ blue │
# => ╰───┴─────────┴─────────┴─────────╯
```
Finally, the [`split chars`](/commands/docs/split_chars.md) command will split a string into a list of characters.