Ask HN: What are your favorite one-liner shell commands you use?

[rajkumarsekar]

There are plenty of lists online with fancy or obscure one-liners, but I’m curious about the ones people actually use day to day.

[samgutentag]

I have had the alias `huh` for years, which is just `pwd; whoami` just to confirm I am where I think I am, and I am who I think I am

[andrei_says_]

Naming things is hard and this one is perfect.

[rajkumarsekar]

That’s clever and oddly reassuring.

[jauco]

I rarely use the exact samme command multiple times. But here are some bash pipe segments I enjoy.

using pv (pipeviewer) instead of cat to get a progress bar when grepping huge files.

Using httpie instead of curl so I can remember the flags.

The power of find -exec to run commands on a lot of specific files. The nice part is you can run it without exec first to see if you have the right set of files.

If you do a loop you can echo -e “$somevar\r” and then each write will overwrite the previous line so you screen doesn’t fill up but you do get a feel for the progress (to make it nice you need to pad with spaces, google for echo carriage return to learn more)

[gaws]

> using pv (pipeviewer) instead of cat to get a progress bar when grepping huge files.

How does this work?

[rajkumarsekar]

Some great power tips here, especially love the pv + grep combo for big files.

[scrapheap]

Find's -exec option is great when you need to automate removing old backups

[geocrasher]

Daily, and with enough general usability to share? I have a few. They are basic. You can probably figure out what industry I work in.

    df -h /; echo "----"; for fattable in $(find /var/lib/mysql/ -name *.ibd -size +1G -exec ls -lh {} \; | awk '{ print $9 }' );do echo BEFORE " " $(ls -lh $fattable| awk '{ print $5" " }'); db=$(echo $fattable| cut -d/ -f5); otable=$(echo $fattable| cut -d/ -f6| cut -d. -f1); echo mysql -qbse \"use $db \; optimize table  $otable\;\"|bash;echo AFTER" "" " $(ls -lh $fattable| awk '{ print $5" " }');echo "----" ;done; echo "----"; df -h /

    apachectl fullstatus | grep ^[0-9]| awk '{ print $12" "$14 }' | sort | uniq -c| sort -n |tail

    
    tail -100000 /var/log/nginx/access.log | sed "/$(hostname -i)/d" | awk '{ print $1" "$7 }' | sort | uniq -c | sort -n | tail -050


    find . -mtime -1 | cut -d/ -f2 |uniq

  
    pkill lsphp; sleep 2; while true; do sleep .4; strace -p $(ps aux | grep [i]ndex| awk '{ print $2 }' | head -01); done


    for file in /proc/*/status ; do awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $file 2>/dev/null; done| awk '{ print $2" "$3" "$1 }'  | sort -n | tail -20


    find . -size +200M -exec ls -lh {} \; | awk '{ print $5" "$9 }' 


    awk '{ print $4 }' 

https://explainshell.com/

[rajkumarsekar]

That’s an impressive collection. Definitely not basic! Love how practical these are for real-world ops work, especially the MySQL .ibd optimizer loop and swap memory check.

[bravesoul2]

Some kinda shared hosting?

[AnonHP]

Defined this in whatever init script the shell uses so that I get a long listing of files (first alias below) and long listing of files sorted from oldest to newest (second alias below):

alias ll=“ls -l”

alias lln=“ls -lrt”

Apart from this, I have a few aliases defined to get the size of specific folders and their subfolders (using ‘du -h’ for human readable sizes). The aliases are named like “duh”, “dut” and so on.

[rramadass]

1) Whenever building anything;

<make/build script> 2>&1 | tee build.log | grep <whatever>

2) Do everything within GNU Screen window with CTRL-A + Shift-H to log all output to logfile i.e. "screenlog.<window num>".

Both lifesavers when working with multiple systems and codebases.

3) Always use "set -o vi" with bash so that i can use vi/vim keybindings across everything.

[lozf]

> GNU Screen window with CTRL-A + Shift-H to log all output to logfile

tmux users can use it's `capture-pane` command, either before or after the fact if history is set big enough. There are several helpful flags worth researching.

e.g. `tmux capture-pane -pS - > ~/tmux.log` in a shell to save the history of that pane, or just `prefix+: capture-pane ...` from within tmux

[TheNewAndy]

Not really a shell one liner, but ctrl+r (a readline command to do an incremental search backwards through history) is something that has been present on every shell I've used for decades without realising it, One day I decided to take the time to read all the magic readline commands because I wanted a way to quickly edit the N-th argument of a command with lots of arguments, and there were way too many of them. There were so many commands that I had no hope of remembering them all, but I figured I could just remember a few useful ones - and ctrl+r was one of them (ctrl+w and alt+b were the other two)

More to the letter of the question, I use "cd -" frequently, "ps -e | grep some_process_i_would_like_the_pid_for", and while I don't use it frequently, I didn't know about "ssh-copy-id" for a long time, and would do it manually with a text editor in the past. Sorry if they are not sufficiently fancy - but for things to get used day to day for me, they will need to be short and sweet.

[vinhnx]

I also same here. Has since I discovered Ctrl+R, and equipped it with fzf (https://github.com/junegunn/fzf), every terminal command is in my hand, I can fuzzy search and not need to remember the exact command. This really saved me a lot of times.

[scrapheap]

`cd -` is great for when you just want to nip out of your current directory for a second and then come straight back - especially as I'm pretty sure that most of us never think about pushd/popd until after we've moved to the other directory with cd :)

[rajkumarsekar]

No need to be fancy. These are super practical! ctrl+r is a lifesaver once it clicks, and cd - is such a small thing that makes moving around so much smoother.

[000ooo000]

I have a super neat one but it's on my work machine. Not strictly a one-liner but definitely a CLI QoL improvement. It allows me to type a partial command, for e.g. up to where a file path might be, hit a hotkey to invoke (e.g.) fzf, and finally have fzf's output inserted where my cursor was in the command. Uses some vars that readline exposes. I haven't taken it beyond inserting paths yet, but you could imagine you could do a lot with inserting arbitrary output into a command you are midway through typing. I'll reply to this when I have it on hand.

[sshine]

> but it's on my work machine

Install Tailscale on your machines, and your work machine is always just one ssh command away.

[jjgreen]

All files in this git repository containing the string "foo"

    git grep foo | cut -d: -f1 | uniq

[sshine]

Using ripgrep,

  rg -l foo | uniq

[PeterWhittaker]

git grep -l foo | sort -u

[tmaly]

I use pgrep -fl <name> instead of ps to find running processes by name.

For complex one liners, I keep them in a simple txt file with a brief description so I can find them later when I need to use them again.

[rajkumarsekar]

Smart move with pgrep -fl—so much cleaner than piping through ps | grep. And keeping a personal cheat sheet of one-liners is underrated.

[UI_at_80x24]

Want the HTTP status code for a server?

```alias hstat="curl -Lo /dev/null --silent --head --write-out '%{http_code}\n'" $1 #HTTP status code```

example:

```$ hstat google.com 200```

[scrapheap]

This one gets uses a lot to compare two versions a JSON file

  vimdiff <( jq < /tmp/file1.json ) <( jq < /tmp/file2.json )

[willprice89]

dd if=/dev/zero bs=1M count=10 | nc -N -l -p 12345

Great simple test for network speed on a box without speedtest-cli or other tools installed.

[xiconfjs]

:(){ :|:& };:

[AnonHP]

This is an “I need a long coffee break” command, right?

[yjftsjthsd-h]

Do you, ah, find yourself using that a lot?:)

[peter-m80]

alias untar='tar -zxvf'

[bravesoul2]

Boring but

docker ps

docker kill

git switch

git commit

git push

[rajkumarsekar]

Not boring at all. These are the real “daily drivers” that keep things moving.

[noperator]

kind of meta, but one of my most-used commands is sol: a de-minifier (formatter, exploder, beautifier) for shell one-liners

https://github.com/noperator/sol