8

I seem to remember that bash had a bang-shortcut for referring to something in the same line. I know and use !$, !! and friends regularly. I recall reading being able to do something like the following:

mkdir tmp && cd !_

where !_ represents the combination I can't remember. (The goal of the above is to make a directory and immediately cd into it upon success.) Google only yields reposts of the same 2 reference tables which don't have this combination.

Right now I'm using the less-efficient

mkdir tmp
cd !$

which gets the job done but not the way I want to do it.

Does anyone know this elusive shortcut?

In case it matters, I use zsh with oh-my-zsh, not vanilla bash.

Ryan Kennedy
  • 3,275
  • 4
  • 30
  • 47

4 Answers4

8
mkdir tmp && cd "$_"

is what you're looking for, I believe (you can drop the double quotes if you're sure that quoting is not needed).

$_ expands differently in different contexts, but the one that matters here (from man bash , v3.2.51):

expands to the last argument to the previous command, after expansion.

Background:

Note: the following discusses bash, but it seems to apply to zsh in principle as well.

$_ is a so-called special parameter, which you'll find listed among others (without the $ prefix) in the Special Parameters section of man bash:

  • Works both in interactive shells and in scripts.
  • Works at the individual command level, not at the line level.

By contrast, !-prefixed tokens (such as !$ to recall the most recent line's last token) relate to the shell's [command] history expansion (section HISTORY EXPANSION of man bash):

  • By default they work only in interactive shells, but that can be changed with set -o history and set -o histexpand (thanks, @chepner)).
  • Work at the line level (more accurately: everything that was submitted with one Enter keystroke, no matter how many individual commands or lines it comprised).
mklement0
  • 382,024
  • 64
  • 607
  • 775
7

!# refers to the command line so far, and you can extract specific words from it:

mkdir tmp && cd !#:1

The same syntax works in zsh as well.

chepner
  • 497,756
  • 71
  • 530
  • 681
  • Works well in the case at hand, but the `1` in `!#:1` is an _absolute token index_ from the _start of the line_, which means the solution doesn't generalize well; e.g., `mkdir -p tmp/sub && cd !#:1` would break; you'd have to pay attention and count all tokens on the line to find the right index. Also, since the shell _expands_ the history reference and stores the _expanded_ command in the history (in addition to printing it before executing), you _couldn't go back and edit the command as typed_ - e.g., to create another dir. - you'd only get the _expanded_ version. (cont'd below). – mklement0 Jan 30 '14 at 05:04
  • (cont'd from above) Provided the intent is to get the _previous simple command's_ _LAST_ (expanded) token (if not, then the `!#`-based solution IS needed): all these problems go away when you use `$_`, e.g. `mkdir -p tmp/sub && cd "$_"` (I double-quoted `$_`, to be safe). I know the OP was looking for a history-expansion token, which you provided, but given the question's _intent_, I think `$_` is the better choice. – mklement0 Jan 30 '14 at 05:04
  • There is a shell option (`histverify`) that allows you to edit the command before executing it. `$_` *only* works if the intent is to use the last argument. `!#` may require a little more work, but it *can* work with any command line you might use. – chepner Jan 30 '14 at 13:22
  • That's a good summary, thanks; didn't know about `shopt -s histverify` - handy (for bash; zsh equivalent: `setopt HIST_VERIFY`). (And, just to be clear: I learned from your post and from your comments on mine.) – mklement0 Jan 30 '14 at 13:36
1

What about this:

mkdir foo; cd $_

Works for me.

Marlon
  • 148
  • 6
1

(Old news, but in case someone else lands here looking for this, like I just did)

OP seemed to be looking for !#[X][-Y] zsh syntax

where X and Y are indexes for shell words in history event for current line

X and Y are assumed to refer to the start or end of line - respectively - when omitted

(keep in mind that end of line in this context is actually the occurrence of the !#[X][-Y] event call within the line)

this gives us the following variants:

  • !# current line up to !#

  • !#-Y current line up the Y-th word

  • !#X X-th word only

  • !#X-Y words X through Y

  • !#X- from X-th word, until !#X-

in direct response to example given:

mkdir tmp && cd !#2

or, taking it a step further:

alias mktmpd='mkdir -p tmp /tmp/${PWD:t}; cd ${(@)${~:-${=^:-!#2-3}(N/)}[1]}; pwd; ls'

the path /tmp/${PWD:t} would be created also and act as an alternative to cd to if for some reason ./tmp could not be created (which would have failed silently)

this assumes user can mkdir in /tmp and is willing to let some useless paths be generated (and left untouched) when ./tmp is perfectly usable and in fact chosen

potential problem arises when /tmp/${PWD:t} already exists and its contents are unrelated and not be disturbed, hence the pwd; ls

aliasing helps with use cases such as somecommand; mktmpd where normally the !#2-3 would no longer refer to the appropriate parameters tmp /tmp/${PWD:t}

Note however that I am decidedly not advocating for this use case as an especially helpful one (or even its fitness as an example, really - but I wanted to point out the alias particularity since I have yet to see it mentioned elsewhere)

jhdmpp
  • 11
  • 1