Cfrtjryk

If I saw that situation coming as a one-off, I might:

a=`pwd`

cd /somewhere/else

cp "$a/myfile" .

If there were directories that I found myself copying files out of semi-regularly, I would probably define some mnemonic variables for them in my .profile.

Edited to add:

After sleeping on it, I wondered how closely I could get to other GUI / OS behaviors where you select some number of files, "cut" or "copy" them, then "paste" them somewhere else. The best selection mechanism I could come up with was your brain/preferences plus the shell's globbing feature. I'm not very creative with naming, but this is the basic idea (in Bash syntax):

function copyfiles {

  _copypastefiles=("$@")

  _copypastesrc="$PWD"

  _copypastemode=copy

}



function cutfiles {

  _copypastefiles=("$@")

  _copypastesrc="$PWD"

  _copypastemode=cut

}



function pastefiles {

  for f in "${_copypastefiles[@]}"

  do

    cp "${_copypastesrc}/$f" .

    if [[ ${_copypastemode} = "cut" ]]

    then

      rm "${_copypastesrc}/$f"

    fi

  done

}

To use it, put the code into ~/.bash_profile, then cd to the source directory and run either copyfiles glob*here or cutfiles glob*here. All that happens is that your shell expands the globs and puts those filenames into an array. You then cd to the destination directory and run pastefiles, which executes a cp command for each source file. If you had previously "cut" the files, then pastefiles also removes the source file (or, tries to). This doesn't do any error-checking (of existing files, before potentially clobbering them with the cp; or that you have permissions to remove the files during a "cut", or that you can re-access the source directory after you move out of it).

I think the ~- is the right answer, but note that bash has a built-in line editor that can copy/paste text.

If you are in emacs mode you can recall your cd command from the history, and use Control-u to kill the line into the bash "clipboard" called the kill-ring (there are other ways too). You can then yank this string into a new command at any time with Control-y. Obviously, in your example this depends on you having used an absolute directory name in your cd command.

You can also use the interesting default key-binding of Meta-.. This copies the last word from the previous command into your current line. If repeated, each time it goes back one command in the history. So if you do a cd /x, then cd /y followed by cdMeta-.Meta-. you will have /x in your input.

Expanding on the answer from Anderson M. Gomes, Bash allows you to refer to any prior directory in your directory stack by typing ~N (or ~+N) where N is the position on the dir stack. For example:

# go some places

$ cd /path/to/source/directory

$ pushd /path/to/destination/directory

$ pushd $HOME

$ pushd /tmp



# show the current dir stack

$ dirs -v

0 /tmp

1 ~

2 /path/to/destination/directory

3 /path/to/source/directory

Now you can copy a file between two past directories, neither of them the current one, with:

cp -v ~3/file1.txt ~2

To solve the original poster's problem, you would do:

$ cd /path/to/source/directory

$ pushd /path/to/destination/directory



# show the current dir stack

$ dirs -v

0 /path/to/destination/directory

1 /path/to/source/directory



# copy

cp -v ~1/file[123].txt .

With a large set of files, you could list their names in a manifest file and then do the copy from the source dir:

$ cd /path/to/destination/directory

$ pushd /path/to/source/directory



# copy

cp -v $(cat files_to_copy.list) ~1

See also: this section of the Bash man page

Similarly, in Tcsh, you can use the =2 notation (rather than ~2) to refer to the second dir on your dir stack.

See also: this section of the Tcsh man page

when you are in the first directory, lets say the source or src in short, execute

src=${PWD}

then cd in to second directory and execute:

cp -i ${src}/filename .

the -i option will ask if you want to overwrite, if there is a duplicate file

A variation on anderson-m-gomes response.
Using Bash, I would just visit the directories:

$ cd /path/to/source/directory

$ cd /path/to/destination/directory

Then, I would use the variable $OLDPWD, which points to the previous directory:

$ cp -v $OLDPWD/file1.txt .

If one wants to visit directories in reverse order, then:

$ cp -v fileA.txt $OLDPWD/

If in bash, I would use pushd and popd. These commands keep a handy FIFO stack of directories for later use. You can consult the stack anytime using dirs.

As such I would do:

pushd .

cd /somewhere/else

cp "`popd`/myfile"

You can use xclip:

NAME

       xclip - command line interface to X selections (clipboard)



SYNOPSIS

       xclip [OPTION] [FILE]...



DESCRIPTION

       Reads  from standard in, or from one or more files, and makes the data available as an X selection for pasting

       into X applications. Prints current X selection to standard out.

Example:

$ cd /path/to/dir1

$ xclip-copyfile file1 file2

$ cd /path/to/dir2

$ xclip-pastefile

file1 file2

Also visit xsel.