
```shell
sed [options] commands [file] # Basic usage
sed '' <file> # Print contents of file; Automatically prints without options
cat <file> | sed '' # Equivalent to above
```

## Printing

```shell
sed 'p' <file> # Prints each line in file _twice_
sed -n 'p' <file> # Suppress automatic printing; Print each line once
sed 20q <file> # Print the first 20 lines of file
```

## Address ranges

```shell
sed -n '1p' <file> # Print first line
sed -n '1,5p' <file> # Print first 5 lines
sed -n '1,+4p' <file> # Equivalent to above
sed -n '1~2p' <file> # Print every other line
```

## Deleting text

```shell
sed '5d' <file> # Delete line 5
sed '1~2d' <file> # Delete every other line starting from the first
sed '6,$d' <file> # Delete from line 6 to end of file
sed -i '1~2d' <file> # Change file in-place
sed -i.bak '1~2d' <file> # Create a backup prior to editing file in-place
```

## Substituting text

```shell
sed 's/<regexp>/<replacement>/g' <file> # Basic usage

sed 's/prev/next/' <file> # Substitute the first instance of `prev` in each line with `next`
sed 's/prev/next/g' <file> # Substitute all instances of `prev` with `next`
sed 's/prev/next/2' <file> # Substitute the second instance of `prev` in each line with `next`
sed -n 's/prev/next/2p' <file> # Print only lines that were substituted
sed 's/PreV/next/i' <file> # Ignore case
sed 's_com/index_org/home_g' <file> # Use _ as delimiter; Replace `com/index` with `org/home`

sed 's/^.*at/(&)/' <file> # Referencing matched text in replacement string
sed 's/$[^ ][^ ]*$ $[^ ][^ ]*$/\2 \1/' <file> # Referencing regex groups; Switch the first two words of each line

sed 's/and/\&/' <file> | sed 's/people/horses/' # Multiple editing sequences
sed -e 's/and/\&/' -e 's/people/horses/' <file> # Equivalent to above
sed 's/and/\&/;s/people/horses/' <file> # Equivalent to above

sed '=' <file> # Insert a line-number on a new line between each existing line
sed 'G' <file> # Insert a blank line between each line

sed '1,3s/.*/Hello/' <file> # Replace the first 3 lines with `Hello`
sed -n '/bash$/p' <file> # Address matching with regex; Print lines ending with `bash`
sed '/^$/d' <file> # Delete blank lines
sed '/^START$/,/^END$/d' <file> # Delete lines between START and END
```

## Hold space and pattern space

```shell
# h/H: Copy/Append pattern space to hold space.
# g/G: Copy/Append hold space to pattern space.
# x: Swap the contents of pattern and hold spaces.

sed -n '1~2h;2~2{H;g;s/\n/ /;p}' <file> # Join adjacent lines
sed -n 'N;s/\n/ /p' <file> # Equivalent to above
```

## Scripting

```shell
sed -f script.sed <file> # Run script.sed on file
```

## Links

- [Chess implemented in sed](https://github.com/bolknote/SedChess)
- [2048 implemented in sed](https://github.com/themattrix/sed2048)


[Top]

Printing

Address ranges

Deleting text

Substituting text

Hold space and pattern space

Scripting

Links


## `grep`

### Basics

```shell
grep [options] <pattern> <file> # Basic usage
grep "spam" <file> # Search for lines that contain `spam` in file
grep -v "spam" <file> # Search for lines that do _not_ contain `spam` in file
grep -i "spam" <file> # Case-insentive search
grep -n "spam" <file> # Print line numbers
grep -nr 'string*' . # Recursively search current directory for `string`
```

### Regular expressions

See also: <Link href="/notes/regex">/notes/regex</Link>

```shell
grep "^eggs" <file> # Find all lines starting with `eggs`
grep "eggs$" <file> # Lines ending with `eggs`
grep "^[A-Z]" <file> # Lines beginning with an uppercase letter
grep "^[[:upper:]]" <file> # Equivalent to above; Using POSIX classes
```

### Extended regular expressions

Along with basic regular expressions (BREs, which is the default), `grep` also supports [extended regular expressions (EREs)](https://en.wikipedia.org/wiki/Regular_expression#Standards) by using the `-E` option or by calling the `egrep` command.

```shell
grep "$group$" <file> # Grouping
grep -E "(group)" <file> # Equivalent to above
grep -E "(GPL|General Public License)" <file> # Alternation
grep -E "(copy)?right" <file> # Quantification; Match `copy` zero or one time
grep -E "free[^[:space:]]+" <file> # Match the string `free` plus one or more characters that are not white space characters
grep -E "[AEIOUaeiou]{3}" <file> # Match lines that contain triple-vowels
grep -E "[[:alpha:]]{16,20}" <file> # Match any words that have between 16 and 20 characters
```

### Miscellaneous

```shell
grep . * # cat a bunch of files
```

- Find lines in one file that are not in another [[\*](https://stackoverflow.com/questions/18204904/fast-way-of-finding-lines-in-one-file-that-are-not-in-another)]

  ```shell
  grep -v -f file1 file2
  ```

## `ripgrep`

```shell
rg -S 'string' # Case-insentive search
```


g/re/p


## Basics

```shell
# Basic usage
awk [options] '/<search_pattern>/ { <action_1>; <action_2>; }' <file>
# Either of the search pattern or the action can be omited.
# Default action is print, default pattern is every line.

awk '{print}' <file> # Print every line
awk '/spam/' <file> # Print lines containing `spam`
awk '/^spam/' <file> # Print lines starting with `spam`

awk '/^spam/ {print $1;}' <file> # Print only the first column ($1)
# $2 refers to the second column, $0 to the entire line
```

## Built-in variables

`awk` built-in variables:

- **FILENAME**: Current input file.
- **NF**: Number of fields in the current record.
- **NR**: Number of the current record.
- **FNR**: Number of the current record relative to the current input file.
- **FS**: Current field separator (default: whitespace).
- **OFS**: Field separator for the output (default: whitespace).
- **RS**: Record separator for the input file (default: newline).
- **ORS**: Record separator for the output (default: newline).

```shell
# Print the first column of `/etc/passwd`
# Change the field separator variable to `:` before processing
awk 'BEGIN { FS=":"; }
{ print $1; }' /etc/passwd

awk -F ':' '{print $1;}' /etc/passwd # Equivalent to above
awk -F: '{print $1;}' /etc/passwd # Equivalent to above

# Transform the data into a table
awk 'BEGIN { FS=":"; print "User\t\tUID\t\tGID\t\tHome\t\tShell\n--------------"; }
{print $1,"\t\t",$3,"\t\t",$4,"\t\t",$6,"\t\t",$7;}
END { print "---------\nFile Complete" }' /etc/passwd
```

## Field searching

```shell
awk '$2 ~ /^bin/' <file> # Print lines where the second field starts with `bin`
awk '$2 !~ /^bin/' <file> # The second field does _not_ start with `bin`
awk '$2 !~ /^bin/ && $1 < 5' <file> # The second field does not start with `bin` _and_ the value of the first column is less than 5
```

## Scripting

```shell
awk -f script.awk <file> # Run script.awk on file
```

## Links

- [TheMozg/awk-raycaster](https://github.com/TheMozg/awk-raycaster) - Pseudo-3D shooter written completely in gawk using raycasting technique.
