Find file then cd to that directory in Linux

In a shell script how wo开发者_运维知识库uld I find a file by a particular name and then navigate to that directory to do further operations on it?

From here I am going to copy the file across to another directory (but I can do that already just adding it in for context.)

You can use something like:

cd -- "$(dirname "$(find / -type f -name ls | head -1)")"

This will locate the first ls regular file then change to that directory.

In terms of what each bit does:

• The find will start at / and search down, listing out all regular files (-type f) called ls (-name ls). There are other things you can add to find to further restrict the files you get.
• The | head -1 will filter out all but the first line.
• $() is a way to take the output of a command and put it on the command line for another command.
• dirname can take a full file specification and give you the path bit.
• cd just changes to that directory, the -- is used to prevent treating a directory name beginning with a hyphen from being treated as an option to cd.

If you execute each bit in sequence, you can see what happens:

pax[/home/pax]> find / -type f -name ls
/usr/bin/ls

pax[/home/pax]> find / -type f -name ls | head -1
/usr/bin/ls

pax[/home/pax]> dirname "$(find / -type f -name ls | head -1)"
/usr/bin

pax[/home/pax]> cd -- "$(dirname "$(find / -type f -name ls | head -1)")"

pax[/usr/bin]> _

The following should be more safe:

cd -- "$(find / -name ls -type f -printf '%h' -quit)"

Advantages:

• The double dash prevents the interpretation of a directory name starting with a hyphen as an option (find doesn't produce such file names, but it's not harmful and might be required for similar constructs)
• -name check before -type check because the latter sometimes requires a stat
• No dirname required because the %h specifier already prints the directory name
• -quit to stop the search after the first file found, thus no head required which would cause the script to fail on directory names containing newlines

no one suggesting locate (which is much quicker for huge trees) ?

zsh:

cd $(locate zoo.txt|head -1)(:h)
cd ${$(locate zoo.txt)[1]:h}
cd ${$(locate -r "/zoo.txt$")[1]:h}   

or could be slow

cd **/zoo.txt(:h)

bash:

cd $(dirname $(locate -l1 -r "/zoo.txt$"))

Based on this answer to a similar question, other useful choice could be having 2 commands, 1st to find the file and 2nd to navigate to its directory:

find ./ -name "champions.txt"
cd "$(dirname "$(!!)")"

Where !! is history expansion meaning 'the previous command'.

Expanding on answers already given, if you'd like to navigate iteratively to every file that find locates and perform operations in each directory:

for i in $(find /path/to/search/root -name filename -type f)
do (
  cd $(dirname $(realpath $i));
  your_commands;
)
done

if you are just finding the file and then moving it elsewhere, just use find and -exec

find /path -type f -iname "mytext.txt" -exec mv "{}" /destination +;

function fReturnFilepathOfContainingDirectory {
    #fReturnFilepathOfContainingDirectory_2012.0709.18:19
    #$1=File

    local vlFl
    local vlGwkdvlFl
    local vlItrtn
    local vlPrdct

    vlFl=$1
    vlGwkdvlFl=`echo $vlFl | gawk -F/ '{ $NF="" ; print $0 }'`
    for vlItrtn in `echo $vlGwkdvlFl` ;do
        vlPrdct=`echo $vlPrdct'/'$vlItrtn`
    done
    echo $vlPrdct

}

Simply this way, isn't this elegant?

cdf yourfile.py

Of course you need to set it up first, but you need to do this only once:

Add following line into your .bashrc or .zshrc, whatever you use as your shell initialization script.

source ~/bin/cdf.sh 

And add this code into ~/bin/cdf.sh file that you need to create from scratch.

#!/bin/bash

function cdf() {
    THEFILE=$1
    echo "cd into directory of ${THEFILE}"
    # For Mac, replace find with mdfind to get it a lot faster. And it does not need args ". -name" part.
    THEDIR=$(find . -name ${THEFILE} |head -1 |grep -Eo "/[ /._A-Za-z0-9\-]+/")
    cd ${THEDIR}
}

If it's a program in your PATH, you can do:

cd "$(dirname "$(which ls)")"

or in Bash:

cd "$(dirname "$(type -P ls)")"

which uses one less external executable.

This uses no externals:

dest=$(type -P ls); cd "${dest%/*}"

If your file is only in one location you could try the following:

cd "$(find ~/ -name [filename] -exec dirname {} \;)" && ...

You can use -exec to invoke dirname with the path that find returns (which goes where the {} placeholder is). That will change directories. You can also add double ampersands ( && ) to execute the next command after the shell has changed directory.

For example:
cd "$(find ~/ -name need_to_find_this.rb -exec dirname {} \;)" && ruby need_to_find_this.rb

It will look for that ruby file, change to the directory, then run it from within that folder. This example assumes the filename is unique and that for some reason the ruby script has to run from within its directory. If the filename is not unique you'll get many locations passed to cd, it will return an error then it won't change directories.

try this. i created this for my own use.

cd ~
touch mycd
sudo chmod +x mycd
nano mycd
cd $( ./mycd search_directory target_directory )"

if [ $1 == '--help' ]
 then
    echo -e "usage: cd \$( ./mycd \$1 \$2 )"
    echo -e "usage: cd \$( ./mycd search_directory target_directory )"
else
  find "$1"/ -name "$2" -type d -exec echo {} \; -quit
  fi

cd -- "$(sudo find / -type d -iname "dir name goes here" 2>/dev/null)"

keep all quotes (all this does is just send you to the directory you want, after that you can just put commands after that)