
## `fzf`

[`fzf`](https://github.com/junegunn/fzf) is a command line fuzzy finder. It can search through the entries in a list of files, command history, processes, hostnames, bookmarks, git commits, etc.

`fzf` provides 3 keyboard shortcuts:

### `Ctrl-t`

Paste the selected **files and directories** onto the command-line.

By default, `fzf` uses `find` to search for files. This can be re-configured by setting `FZF_CTRL_T_COMMAND` in `.bashrc`/`.zshrc`:

```shell title="~/.zshrc"
# Set fd as the default source for fzf
export FZF_DEFAULT_COMMAND='fd -type f --follow --hidden --exclude .git'

# Apply the command to CTRL-T as well
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# Preview contents of files
export FZF_CTRL_T_OPTS="--preview '(highlight -O ansi -l {} 2> /dev/null || cat {} || tree -C {}) 2> /dev/null | head -200'"

# Set color scheme to Dracula
export FZF_DEFAULT_OPTS=$FZF_DEFAULT_OPTS'
--color=dark
--color=fg:-1,bg:-1,hl:#5fff87,fg+:-1,bg+:-1,hl+:#ffaf5f
--color=info:#af87ff,prompt:#5fff87,pointer:#ff87d7,marker:#ff87d7,spinner:#ff87d7
'

# Start the finder in a tmux split pane
export FZF_TMUX=1
```

### `Ctrl-r`

Paste the selected **command from history** onto the command-line.

Pressing `Ctrl-r` again will show the commands in chronological order.

### `Alt-c`

**cd** into the selected directory.

```shell title="~/.zshrc"
# Use fd here as well
export FZF_ALT_C_COMMAND="fd -t d"

# Preview files
export FZF_ALT_C_OPTS="--preview 'tree -C {} | head -200'"
```

### Using the finder

- `Ctrl-k` / `Ctrl-j` (or `Ctrl-p` / `Ctrl-n`): Move cursor up/down.
- `Enter`: Select the item.
- `CTRL-C` / `CTRL-G` / `ESC`: Exit.
- On multi-select mode (`-m`), `Tab` and `Shift-Tab`: Mark multiple items.

## `fzf.vim`

`fzf.vim` provides `fzf`-like capabilities inside Vim. Some useful [commands](https://github.com/junegunn/fzf.vim#commands):

```shell
:Files # $FZF_DEFAULT_COMMAND
:GFiles # `git ls-files`
:GFiles? # `git status`
:Buffers # Open buffers
:Histoy: # Command history
:Maps # Normal mode mappings
:Colors # Color schemes
:Rg # Search in files (ripgrep)
:Tags # `ctags -R`
:Snippets # Snippets (UltiSnips)
:Commits # Git commits (fugitive.vim)
```

### Key bindings

- `Ctrl-t`: Open in a new tab.
- `Ctrl-x`: Open in a new split.
- `Ctrl-v`: Open in a new vertical split.

Append `!` to commands to open `fzf` in fullscreen.


[Top]

`fzf`

`Ctrl-t`

`Ctrl-r`

`Alt-c`

Using the finder

`fzf.vim`

Key bindings


## xargs

`xargs` (short for "eXtended ARGumentS") converts input from stdin into arguments to a command.

Unlike `grep` or `awk` which can take input either as command-line arguments or stdin, commands like `rm`, `cp` or `echo` can only take input as arguments, which is why `xargs` is necessary.

### Basic usage

```shell
xargs [options] [command [initial-arguments]]

find /path -type f -name '*.js' | xargs rm
# Find all files ending in `.js` in `/path` and remove them

find . -name '*.py' | xargs wc -l
# Recursively find Python files and count number of lines in them

find . -name '*.json' | xargs grep 'user'
# Recursively find JSON files and search them for `user`
```

### Separator problem

Line-oriented utilities will work with `xargs` as long as records do not contain spaces in them. But since `xargs` is not line-oriented (by default, it separates on newlines and blanks within lines), it may treat a single record as separate.

If records do contain spaces, you must use [`NUL`](https://en.wikipedia.org/wiki/Null_character) as the record separator. This can be set using

- `-0` for Perl,
- `-0` for `locate`,
- `-z`/`-Z` for `grep`,
- `-z` for `sort`,
- `-print0` for `find`

And then use the `-0` option with `xargs`:

```shell
find . -name "*.txt" -print0 | xargs -0 rm
# Separate entries by `NUL` instead of a newline

find . -name "*.txt" -print0 | xargs -d '\n' rm
# Equivalent to above, `-0` is preferred since this won't work on filenames with newline
```

### Placement of arguments

To insert the listed arguments at some position other than the end of the command line, pass a string to the `-I` option that will be replaced with the supplied input.

```shell
find /path -type f -name '*~' -print0 | xargs -0 -I % cp -a % ~/backups
```

### Operating on a subset of arguments at a time

```shell
echo {0..9} | xargs -n 2 # Break up the input into two arguments per line
# Useful for commands like `diff` that operate on 2 files at time
```

### Parallelize operations

```shell
time echo {1..5} | xargs -n 1 -P 5 sleep # ~5 seconds
time echo {1..5} | xargs -n 1 sleep # ~15 seconds

find /path -name '*.foo' | xargs -P 24 -I '{}' /cpu/bound/process '{}' -o '{}'.out
# Queue 24 processes and wait on each to finish before launching another
# To ensure output streams are synchronized, use `--output file` where possible
```

## GNU parallel

[parallel](https://www.gnu.org/software/parallel/) is an alternative to `xargs` that is designed to have the same options, but is line-oriented.

It does have the `-0` option like `xargs` but it is only needed if there are newlines in filenames you are dealing with.


xargs


## GET

```shell
curl [options] <URL> # Basic usage
curl https://github.com/robots.txt # Display the contents of remote file
curl -O https://github.com/robots.txt # Save the file with the original filename
curl -o main.txt https://github.com/robots.txt # Save the file as `main.txt`
curl -L https://github.com/robots.txt # Follow redirects

curl https://api.github.com/repos/3b1b/manim # Basic GET request to the GitHub API
curl -i https://github.com/robots.txt # Include HTTP-header in the output
curl -I https://github.com/robots.txt # Fetch HTTP-header only
curl -C - -O http://example.org/archive.tar.gz # Resume interrrupted download

# -u, --user: Specify the user name and password for server authentication
curl -u <username:password> https://api.example.com/endpoint # Basic authentication
curl -u <username> https://api.example.com/endpoint # Prompt for password; Avoid having password in history

# -m, --max-time: Set maximum time in seconds that you allow the whole operation to take
curl -m 1800 <URL> # Set a 30 minute timeout
```

## POST

```shell
# -d, --data: Send data in a POST request
curl -d '{"name": "Professor Fansworth", "phone": "1234567890"}' <URL>
curl -d "name=Professor%20Fansworth&phone=1234567890" <URL> # Equivalent to above
curl -d @data.json <URL> # Read data to POST from file

# -H, --header: Specify headers
curl -H "Content-Type: application/json" -H "Authorization: <token>" -d @data.json <URL>
# Can be used multiple times to add/replace/remove multiple headers

# -b, --cookie: Pass the data to the HTTP server as a cookie
curl -b "name=Fry" <URL>
curl --dump-header <file> <URL> # Save cookies received from the server to file
curl -b <file> <URL> # Use cookies from file
curl -c <file> <URL> # Save the incoming cookies using Netscape cookie format

# -x, --proxy: Use the specified HTTP proxy and port number (default: 1080)
curl -u <username:password> -x <proxyhost[:port]> <URL>

# -U, --proxy-user: Specify the user name and password for proxy authentication
curl -U <username:password> -x <proxyhost[:port]> <URL>

# -v, --verbose: Make the fetching more verbose/talkative
# -s, --silent: Make curl silent
```
