[Normille]

I upvoted for this alone:

  Another neat short hand is !$ which is an alias for the last argument of the previous command. This can be handy if one creates a new directory and wants to change into it without typing the the directory again. So commands would be

  mkdir -p make/new/directory
  cd !$

You've no idea how many years I've been thinking "This is Linux fer gawd's sake. Surely there must be some easy way to make a new directory and 'cd' to it in a single command!" But was never able to find or guess the right incantation.

[RhysU]

I have an "mkcd" function in my startup files:

mkcd() { mkdir -vp "$1" && cd "$1"; }

[alsetmusic]

Wait, now I'm confused. I have:

mkcd() { mkdir -p "$@" && cd "$_"; }

Can someone please detail the differences between $! and $_? (Apologies if I'm missing something obvious)

[tyingq]

  $ echo "test" > /dev/null && echo !$
  /dev/null
  $ echo "test" > /dev/null && echo $_
  test

[karatinversion]

You're thinking of $_ and !$, and I think they are equivalent - $_ is explicitly the last argument of the previous command, whereas !$ is a history expansion command. ! starts a new history expansion command, and $ is a word designator for the last word of the selected history entry. To quote man bash, " If a word designator is supplied without an event specification, the previous command is used as the event."

I would not that !$ is a bash-ism, whereas $_ works at least on zsh and ksh as well as bash.

[forgotmypw17]

     alias tcd='a=`date +%s`;mkdir "$a" && cd "$a"'

[gpspake]

Yep, first thing I add to my dotfiles when I don't have it haha

[cutthegrass2]

+1, I do the same.

[bunsenhoneydew]

Me too

[lolive]

Typing Esc then . does the trick too.

[alex_smart]

Alt + . does the same thing as well, with the added advantage that you can keep pressing alt and then hit . several times to go through all the "last arguments" in your history one by one.

Further, holding Alt followed by numeric argument followed by dot, gives you an argument at a specific position. For example, Alt + 1, Alt + . copies the first argument.

[seesawtron]

Cool one. "Ctrl + R" also does the same thing to search through past commands and then "Tab" to select the command you are looking for.

[alex_smart]

May favorite bash "trick" is:

!-1:gs/hello/world

which runs the last command with all instances of hello replaced by world. !-1 can be any so called event designator, for instance !n to refer to any specific line number from history or !string for last command containing a particular string.

Seriously people, read the man page for bash. Your shell has so many cool features.

[tikkabhuna]

And if you only have a single instance to replace, you can use ^old^new^

$ echo "hello hello hello world" hello hello hello world $ ^hello^bonjour^ echo "bonjour hello hello world" bonjour hello hello world

[alex_smart]

I know that this expansion exists, but never use it in practice.

Why? The last command is more general, you can just drop the g from the command I wrote to only replace the first occurrence. Besides, :[g]s/old/new should already be familiar to anyone who has used vim, so that is almost like having to learn zero new things.

[dcassett]

This is great for removing an option from a prior command such as unzip -t ...:

^-t

[pupdogg]

[ESC + .] and [ALT + .] are most definitely news ones for me. Thank you. Always learn something new here!

[loulouxiv]

https://www.gnu.org/software/bash/manual/html_node/Bindable-... is a must read.

[alex_smart]

Thanks, I discovered C-o thanks to you (even though I have gone through the bash manual several times).

No, more having to press C-r multiple times just to get sequential group of commands from history.

[loulouxiv]

Yes I was also impressed when I found out about this one. However I use it far less frequently than ALT-. . ALT-# is also useful in the frequent cases where I am constructing a complicated commmand but I have to run another command before the current one.

Also keep in mind that most interactive command-line tools are built upon readline and can understand all those bindings (think python REPL, mysql/psql...)

[loulouxiv]

or man bash /Readline Command Names<Enter>

[rswail]

TIL! Oh this one is nice... now just to get my fingers to remember it.

[madacol]

More shortcuts like that https://stackoverflow.com/questions/38176514/re-run-previous...

[mraza007]

I have been looking for this Thanks for sharing :)

[emmelaich]

Only in emacs editing mode.

Real programmers use set -o vi

[stjohnswarts]

I use that on test machines a lot and had put it in bashrc and heard some cussing from other devs so now I just have to type it every time I spend more than acouple seconds in a terminal :) .

[gadiyar]

I didn't know this. Really neat!

[itsmarsu]

That's just magical

[thomasahle]

How does that work?

[saagarjha]

M-. is readline's yank-last-arg binding.

[a3n]

Nice.

Bash is more than just bash. Composition is a killer technique.

[nmfisher]

You just blew my mind.

[teptoria]

Wow amazing! Thanks :)

[cerved]

what, what?

[W0lf]

For this exact use case I defined the following many years ago in my bash profile:

    # create a new directory and enter it
    function mkd() {
        mkdir -p "$@" && cd "$_";
    }

And use it like: mkd foo

[mfontani]

Beware that using "$@" there might not be what you want, as it passes space-separated arguments to mkdir.

What does: "mkd foo bar" do? It creates both directories, and cd's into "bar".

Might be worth checking that only one argument has been passed, or use "$*" which instead would treat all arguments as one parameter, and "mkd foo bar" would create a "foo bar" directory instead (and cd to it)

YMMV.

[W0lf]

Thanks a lot for pointing this out. I will happily fix this now!

[dvfjsdhgfv]

All Bash manuals and tutorials should start from explaining this issue. And I really mean it. I can't remember how many times I was bitten by it until I finally read it up.

[mfontani]

I feel one should also install shellcheck, and follow it religiously while looking up every warning they get - to understand what it's about, why it's a problem, and why the solution / "correct" incantation is so.

It's also a good way to "learn by doing", which works for many.

[samus]

I still have to read it up from time to time even though I know it already. The difference is huge.

[I_complete_me]

In zsh, you use -> % take <directory> which makes the dir and cd's into it.

[JNRowe]

That isn't standard zsh behaviour. I suspect it comes from oh-my-zsh¹, but wouldn't be surprised if it isn't a bunch of the configuration bundles.

¹ https://github.com/ohmyzsh/ohmyzsh/blob/master/lib/functions...

[Normille]

The bash version works in zsh too.

[henrik_w]

escpae-dot (.) also works for this: "It also works to use !$ instead of escape-dot, but that is slightly harder to type, so I don’t use that anymore."

Wrote about it here: https://henrikwarne.com/2018/08/11/my-favorite-command-line-...

[loulouxiv]

Which you can type as ALT-.

[yrro]

This is the `yank-last-arg` readline comment. Bound to M-. and M-_ by default.

"Insert last argument to the previous command (the last word of the previous history entry). With a numeric argument, behave exactly like yank-nth-arg. Successive calls to yank-last-arg move back through the history list, inserting the last word (or the word specified by the argument to the first call) of each line in turn."

https://tiswww.case.edu/php/chet/readline/readline.html#IDX9...

Its sibling is `yank-nth-arg`, bound to M-C-y. So if you want the 2nd argument from the last command, you can press M-1 followed by M-C-y (yeah, arguments are indexed from 0)...

https://tiswww.case.edu/php/chet/readline/readline.html#IDX9...

[joseluisq]

I got stuck with exactly that use case today and trying to figure out how I can enter directly to my dir without typing it again. Bash is no so neat at completions like Fish for example. However !$ does the thing and keeps my fingers healthy.

That's great set of tips BTW.

[llbeansandrice]

I know this is a bash thread but zsh/oh-my-zsh will replace !$ with the actual argument when you type a space so you can see and edit it before executing the command.

[JNRowe]

bash supports the same, also named magic-space. For bash you can chuck something like "Space: magic-space" in your $INPUTRC, although you'd probably want a guard(see Readline Conditional Constructs in the manpage).

FWIW, zsh without oh-my-zsh can be configured to do too this with "bindkey ' ' magic-space".

[rnestler]

I hava a mkcd alias to create a directory and changing into it.

[barrkel]

I have one called `enter`.

    enter () 
    { 
        mkdir -p "$1";
        cd "$1"
    }

[mlang23]

Also take a look at M-. (Meta+dot) which does the same thing while interactively editing a command...

[unvs]

Yes, that's a good one! My way of remembering is "bang for my buck" -> !$

[myicgygc843467]

Is !$ the same as $_ ?

[johncoltrane]

https://stackoverflow.com/questions/41385015/what-is-bang-do...

[tome]

Looks like !$ is a readline feature and $_ is a shell variable?

[yrro]

Yes. $_ is documented here: https://www.gnu.org/savannah-checkouts/gnu/bash/manual/bash....

And !$ is documented here: https://www.gnu.org/savannah-checkouts/gnu/bash/manual/bash....

[mturmon]

I don't think !$ is properly understood as a readline feature. It's a sh/bash abbreviation.

!! -> last whole command

!!:1 -> first argument of last command

!!:$ -> last argument of last command

!$ -> abbreviation for above

[mfontani]

mkdir -p foo && cd $_