Sappiamo che l'utilizzo cd <directory>aprirà la directory, se esiste!

Inoltre, cd ..ci porterà su un livello dalla directory di lavoro corrente.

Ma, quando abbiamo una /home/thina/teams/td/tech/app/release/apksdirectory nidificata con un percorso più lungo , è stancante andare nella cartella apksed è anche difficile tornare a un altro nodo, diciamo qui /home/thina/teams.

C'è un modo per saltare la digitazione di cde cd ..? Sto usando Ubuntu 16.04.

C'è pushde popd:

pushd /home/thina/teams/td/tech/app/release/apks
# current directory now /home/thina/teams/td/tech/app/release/apks
popd
# current directory now what it was before pushd command

Prova help pushde help popdper ulteriori opzioni. Non c'è manpagina, perché pushde popdsono comandi incorporati bash.

Oltre alle ottime risposte già fornite, ecco alcuni suggerimenti per un utilizzo cdefficace.

• cd - ti riporterà all'ultima directory in cui ti trovavi.
• cd ../../..ti porterà su 3 livelli contemporaneamente, puoi usare la ..notazione incatenata insieme per 'salire' tutte le directory che vuoi.
• Se non si è sicuri di quante volte si desidera spostarsi verso l'alto, utilizzare cd .., quindi utilizzare la cronologia bash premendo il tasto freccia su per utilizzare nuovamente il comando.
• Utilizzare ~per sostituire la home directory degli utenti correnti, se si è effettuato l'accesso come thina utente cd ~/teams, verrà indirizzato a/home/thina/teams
• Usa il completamento automatico di Bash per i percorsi, il tasto tab completerà una sezione di un percorso nel cdcomando, se digiti parte di un segmento di percorso seguito da Tabquel segmento verrà completato se non c'è altra scelta valida. Ad esempio, se avessi digitato e cd /home/thina/teams/td/tpoi premuto Tab, la parola tech verrebbe riempita per te, purché non ci fossero altri file o directory nella directory td che iniziavano con la lettera t.

L'uso di questi suggerimenti insieme può rendere le directory di viaggio cdmolto meno dolorose.

Per salire su più livelli alla volta, puoi usare la seguente funzione (grazie a muru per la versione migliorata):

up ()
{
    local old="$PWD"
    for i in $(seq "${1:-1}"); do
        cd ..
    done
    OLDPWD="$old"
}

Quindi puoi fare:

$ pwd
/home/thina/teams/td/tech/app/release/apks
$ up 5
cd'ing into /home/thina/teams

Inoltre:

• chiamare upsenza un argomento equivale a cd ..causa del ${1:-1}quale sostituisce $1quando impostato e in 1altro modo
• impostare OLDPWD dopo l'ultimo cd ..obiettivo di preservare il solito cd -comportamento.

Per nomi di directory lunghi, utilizzare le variabili con il percorso completo. Per esempio,

APKS="/home/thina/teams/td/tech/app/release/apks"

Quindi puoi fare solo cd "$APKS"

Per quanto riguarda il numero di directory x, ho questa funzione definita nel mio .bashrc

goup() # go up x number of dirs
{
  num=$1
  while [ $num -ne 0  ];do
    cd ..
    num=$( expr $num - 1   )
  done
}

Per tornare /home/thina/teamsda apkste farebbe

goup  6

Ecco un esempio di utilizzo:

$> pwd
/sys/class/backlight/intel_backlight
$> goup 3
$> pwd
/sys
$> 

Un'altra piccola funzione che mi è venuta in mente, ma mai usata tanto è la bookmarkfunzione.

Ecco come funziona: salva la cartella corrente in un file, quindi puoi eseguire il cd in una directory specifica in base al numero di riga in quel file. Esempio:

$> cd /etc/lightdm
$> bookmark
$> cat ~/.dirsbookmarks                                                                                                  
/home/xieerqi
/sys/class/backlight
/etc/lightdm
$> cd $( awk 'NR==2' ~/.dirsbookmarks  )                                                                                 
$> pwd
/sys/class/backlight

Ed ecco la funzione stessa:

bookmark()
{ # bookmarks current dir
  pwd >> $HOME/.dirsbookmarks
}

UPDATE: C'è uno strumento ancora più potente autojump: fasdma io non sono familiarità con esso.

Sono sorpreso che nessuno abbia autojumpancora menzionato quale

funziona mantenendo un database delle directory che usi di più dalla riga di comando (le directory devono essere visitate prima di poterle saltare.)

È fondamentalmente ciò che ha creato @graipher, con alcune opzioni extra.

Come ho già detto in un'altra domanda:

Dopo aver effettuato il cd alcune volte in una directory (anche una volta è sufficiente):

cd /home/thina/teams/td/tech/app/release/apks

puoi utilizzare il collegamento jper spostarti rapidamente lì, indipendentemente dalla directory in cui ti trovi attualmente:

j apks

Nota che usare qualsiasi parte del percorso funziona, purché sia ​​il più alto dell'elenco: j appti porterà anche .../apksse ci sei andato più volte che a .../app.

Lo consiglierei invece di avere il proprio script dal momento che è ben mantenuto, distribuito per Ubuntu, e ha altre caratteristiche pulito, come il salto a figlio :

.../td/tech $ jc apk
.../release/apks $ 

Ti ha spostato in apksdentro td, piuttosto che in qualche altro apkssotto un albero diverso.

alias

Ho un elenco di directory usate di frequente direttamente disponibili tramite alias. Ciò include anche collegamenti per le directory nella gerarchia.

alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'
alias cdwork=/home/knub/Repositories/work
alias cduni=/home/knub/University

Ora, quando voglio salire di tre livelli, scrivo ....<Enter>e ci sono!

Attiva l' autocdopzione ( shopt -s autocd), in modo da non dover digitare cd. Ad esempio, hai solo bisogno del comando ..a due caratteri per andare alla directory principale.

Se stai navigando tra due directory, puoi passare da una all'altra cd -, che passa alla directory di lavoro precedente. L' autocdopzione non viene -eseguita cd -ma è possibile definire un alias o una funzione per questo.

È possibile memorizzare le directory su uno stack con i builtin pushde popd. Il builtin dirselenca lo stack di directory (trovo dirs -vpiù leggibile).

Se si passa frequentemente alle sottodirectory di una determinata directory e queste sottodirectory hanno un nome piuttosto univoco, aggiungerle alla CDPATHvariabile. Tuttavia, tieni presente che non ho mai trovato una situazione in cui CDPATHfosse effettivamente utile.

È possibile impostare una variabile su un nome di directory e modificarla con $foo.

Zsh ha alcune belle funzionalità che bash non ha. Alcuni di essi possono essere emulati scrivendo funzioni che svolgono lo stesso lavoro. In particolare, la forma a due argomenti cdconsente di passare comodamente a un'altra directory con un nome simile, ad es. Da /home/thina/teams/td/tech/app/release/apks/com.acme/v1, running cd release betava a /home/thina/teams/td/tech/app/beta/apks/com.acme/v1.

Poiché ho già risposto a una domanda correlata su UnixSE, per questo uso uno script chiamato z [github] .

Ricorda le directory in cui fai il cd, le classifica in base alla frequenza (frequenza + recency) e ti consente di passare a uno dei percorsi ricordati usando una parte del suo nome.

Dopo aver eseguito il cd in una directory almeno una volta, puoi fare ad es. Invece di:

$ cd ~user/very/long/path/with/many/subfolders/

Basta fare:

$ z sub

che funzionerà, usando la corrispondenza parziale dei nomi (supponendo che non ci sia altra directory che contenga nel suo percorso il termine sub e che abbia una frequenza maggiore).

Ho anche definito una funzione come questa, che prima prova un normale cd e se fallisce usa z:

function cd() {
    builtin cd "$1" 2> /dev/null || z "$1" || (echo "cd: File or Directory not found: $1" >&2 && exit 1)
}

Questo ti dà il meglio di entrambi. Se la cartella si trova nella directory corrente o viene fornito un percorso completo valido, verrà semplicemente cd lì, ma in caso contrario tenterà di trovare una corrispondenza nel database e cd lì. Questo elimina il (piccolo) dolore di dover usare cd (per addestrare il database, andare in una cartella in cui non sei mai stato prima) e talvolta ricordare di usare z, quando applicabile.

Altre tre opzioni che trovo per funzionare bene (anche se in futuro pushdpotrò usarne di più, ne ho appena appreso):

• Organizza i tuoi percorsi in modo da non dover prima cdaccedere a directory profondamente annidate, o meglio: quindi i luoghi che devi visitare spesso sono a portata di mano. Il modo per raggiungere questo obiettivo è con i collegamenti simbolici : mantenere le directory esplicite e ben gerarchizzate come sono, ma creare un collegamento ad accesso rapido per la propria comodità.

  ln -s ~/teams/td/tech/app/release/apks ~/apks

  Quindi, invece di digitare il lungo percorso per cd, basta usare cd ~/apkse cd ../teams(o, in quell'esempio preferibile,~/teams ) per tornare indietro.

• Non usare una singola shell e cd avanti e indietro tra i percorsi, ma mantieni una shell in esecuzione per ciascuno dei percorsi in cui devi lavorare. Esistono più livelli su cui realizzare questo multitasking:

  • Usa più finestre terminali. Funziona meglio se le finestre vivono su aree di lavoro diverse .
  • Usa più schede in una singola finestra. Questo è particolarmente adatto per eseguire solo alcuni comandi in alcune directory: per tornare indietro, basta chiudere la scheda del terminale!
  • (IMO non molto ragionevole, ma per completezza :) utilizzare un terminale multiplexer come tmux.

  • Basta avviare un'azione in un comando monouso che si trova cdnella cartella, fa una cosa lì e restituisce immediatamente il controllo sulla cartella originale: invece di

    $ cd /home/thina/teams/td/tech/app/release/apks
    $ some_command this_file_here
    $ cd ../../../../..

    fai semplicemente il one-liner

    $ (cd ~/teams/td/tech/app/release/apks; some_command this_file_here)

    o equivalentemente

    $ sh -c 'cd ~/teams/td/tech/app/release/apks
    > some_command this_file_here'

• Non cd per niente , ma semplicemente eseguire il comando direttamente dalla vostra directory home. Le espansioni di parentesi graffe possono aiutare molto qui: invece di

  $ cd /home/thina/teams/td/tech/app/release/apks
  $ some_command this_file_here other_file_also_apks
  $ cd ../../../../..

  tu puoi fare

  $ some_command ~/teams/td/tech/app/release/apks/{this_file_here,other_file_also_apks}

Pushd e Popd

I comandi pushde popdsono i miei preferiti. Il pushdcomando ricorderà le directory che hai visitato, visualizzabili con il comando dirse quando sei pronto per saltare indietro, usa popdper tornare.

Ecco un esempio usando le funzioni e gli alias bash:

sd ()
{
    pushd "$1" > /dev/null
}

po ()
{
    popd
}

alias d='dirs'

Uso costantemente una combinazione di questi comandi in vari modi.

alias

Un'altra opzione per le directory a cui si accede frequentemente è semplicemente alias dei comandi cdo pushd. Quindi, usando gli esempi dal tuo post:

alias cdapks='cd /home/thina/teams/td/tech/app/release/apks'
alias cdteams='cd /home/thina/teams'

Combinazione

Combina le due idee e puoi persino avere questo:

alias sdapks='sd /home/thina/teams/td/tech/app/release/apks'
alias sdteams='sd /home/thina/teams'

Il che quindi ti dà molta flessibilità nell'attraversare le directory. Tengo le cd***e sd***alias a portata di mano per le cose come Desktop, Documents, Music, Downloads, ecc ed è molto comodo!

Prova z.lua - Un nuovo comando cd che ti aiuta a navigare più velocemente imparando le tue abitudini.

• cd in una directory contiene foo:

  z foo

• cd in una directory termina con foo:

  z foo$

• usa più argomenti:

  Supponendo il seguente database:

  10   /home/user/work/inbox
  30   /home/user/mail/inbox

  "z in"verrebbe inserito /home/user/mail/inboxcome voce più ponderata. Tuttavia, è possibile passare più argomenti a z.lua per preferire una voce diversa. Nell'esempio sopra, "z w in"cambierebbe quindi directory in /home/user/work/inbox.

• cd con selezione interattiva:

  Quando vengono trovate più corrispondenze, usando z -iverrà visualizzato un elenco:

  $ z -i soft
  3:  0.25        /home/data/software
  2:  3.75        /home/skywind/tmp/comma/software
  1:  21          /home/skywind/software
  > {CURSOR}

  Quindi è possibile inserire il numero e scegliere dove andare prima del cd effettivo. per esempio. input da 3 a cd a /home/data/software. E se premi INVIO e non inserisci nulla, si chiuderà e rimarrà dove eri.

  z.luasupporta anche la fzfselezione interattiva o il completamento dell'argomento:

  completamento con fzf

• tornare rapidamente al genitore senza digitare cd ../../..:

  La nuova opzione "-b"può tornare rapidamente a una directory padre specifica in bash invece di digitare "cd ../../ .." in modo ridondante:

  • (Nessun argomento) : cdnella radice del progetto, nella radice del progetto la directory principale più vicina con .git/ .hg/ .svnal suo interno.

  • (Un argomento) : cdnel genitore più vicino che inizia con la parola chiave, se non trova, vai al genitore che contiene la parola chiave.

  • (Due argomenti) : sostituisce il primo valore con il secondo (nel percorso corrente).

  ...

  Cominciamo con l'aliasing z -bper zb:

  # go all the way up to the project root (in this case, the one that has .git in it)
  ~/github/lorem/src/public$ zb
    => cd ~/github/lorem
  
  # cd into to the first parent directory named g*
  ~/github/vimium/src/public$ zb g
    => cd ~/github
  
  # substitute jekyll with ghost
  ~/github/jekyll/test$ zb jekyll ghost
    => cd ~/github/ghost/test

Vorrei che potesse adattarsi alle tue necessità.

il pesce ha diverse belle strutture per spostarsi rapidamente.

• Se si digita cd freccia destra invio, ripete il cd più recente.
• Usando cd freccia su freccia destra invio, ripete il secondo cd più recente.
• Eccetera.
• Ha prevd e nextd, che sono spesso più facili da usare rispetto a pushd e popd.

Inoltre, mantengo le mie directory preferite collegate a ~ / f, così posso cd ~ / f / x per arrivare a ~ / foo / bar / baz / sperimentali-dati.

Ho usato a lungo gli alias per le directory a cui si accede frequentemente.

Ho anche una funzione bash chiamata ccb (abbreviazione di creare cd bat file - questo ha avuto origine in dos / windows dove lo script di shell .bat ccb.bat creerebbe un altro file .bat per saltare alla directory corrente) che crea / aggiunge alias (nel file .bash_aliases) nella directory corrente.

ad esempio: $ ccb myfav creerà un alias nella directory corrente con un alias myfav nel file .bash_aliases e genererà il file .bashrc in modo che l'alias sia immediatamente disponibile.

Ho appena trovato una nuova soluzione. È una funzione bash

## USAGE : lj <your_dir>
### lj -- short for LongJump -- (kinda similar to a C function which would jump to an address outside of your current function)
function lj() {
        pushd `find . -type d -name $1 -print | head -n 1`
}

$ lj deeply_nested_dir_name

questo non ha bisogno di imparare nulla dall'uso precedente. Il problema che questo potrebbe non essere risolto è: se ci sono più di 1 directory denominate "deep_nested_dir_name" nella struttura della sottodirectory, passerà alla prima della directory trovata da find.

Inoltre, questa soluzione non sarà in grado di andare a qualche altro albero di directory.

tra alias hardcoded e alias generati e questa nuova funzione lj (), la maggior parte delle mie esigenze sono soddisfatte.

Ecco la mia funzione bash ccb () per chiunque voglia usarla

function ccb() {
        foo=$PWD
        echo "" >> ~/.bash_aliases
        echo "alias $1='pushd $foo > /dev/null'" >> ~/.bash_aliases
        source ~/.bashrc
}