Există un singur liner care îmi permite să creez un director și să mă mut în el în același timp?

Acesta este one-liner de care aveți nevoie. Nu este necesară nicio altă configurare:

mkdir longtitleproject && cd $_ 

Variabila $_, în bash, este ultimul argument dat comenzii anterioare. În acest caz, numele directorului pe care tocmai l-ați creat. După cum este explicat în man bash:

_ At shell startup, set to the absolute pathname used to invoke the shell or shell script being executed as passed in the envi‐ ronment or argument list. Subsequently, expands to the last argument to the previous command, after expansion. Also set to the full pathname used to invoke each command executed and placed in the environment exported to that command. When check‐ ing mail, this parameter holds the name of the mail file cur‐ rently being checked."$_" is the last argument of the previous command. 

Utilizați cd $_ pentru a prelua ultimul argument mențiunea comenzii anterioare în loc de cd !$ deoarece cd !$ oferă ultimul argument al comenzii anterioare în istoricul shell :

cd ~/ mkdir folder && cd !$ 

ajungi acasă (sau ~ /)

cd ~/ mkdir newfolder && cd $_ 

ajungeți în folderul nou sub casă !! (sau ~ / newfolder)

Comentarii

• De ce pe Pământ acesta nu este răspunsul acceptat
• @JSmyth Sunt de acord , acesta este un singur liner care folosește funcționalitatea shell nativă
• Cred că OP încearcă să evite utilizarea celor două comenzi. Acest răspuns este (aproape) la fel de valabil ca și mkdir foo && cd foo, care nu este ‘ t la îndemână.
• OP este cererea unui singur liner care nu ‘ nu necesită repetarea numelui directorului și acesta este
• Prin voturile pozitive ‘ este evident că mulți oameni consideră că acest răspuns este util. ‘ voi spune de ce nu ‘ nu am selectat acest răspuns: ‘ m foarte probabil să scrie greșit && cd $_ deoarece tastele sunt atât de departe de rândul de acasă, deci, deși corect din punct de vedere tehnic, nu

Nu există nicio comandă încorporată, dar puteți scrie cu ușurință o funcție care apeluri mkdir apoi cd:

mkcd () { mkdir "$1" cd "$1" } 

Introduceți acest cod în fișierul dvs. ~/.bashrc (sau ~/.kshrc pentru utilizatorii ksh sau ~/.zshrc pentru utilizatorii zsh). Acesta definește o funcție numită mkcd. "$1" va fi înlocuit cu argumentul funcției atunci când o rulați.

Această versiune simplă are mai multe defecte:

• Nu puteți crea un lanț de subdirectoare simultan. Remediați: treceți opțiunea -p la mkdir. (Acest lucru poate fi sau nu de dorit, deoarece crește riscul ca o greșeală de tipar să nu fie detectată, de ex. mkcd mydierctory/newsub va crea fericit mydierctory și mydierctory/newsub când intenționați să creați newsub în interiorul existent mydirectory.)
• Dacă argumentul începe cu -, dar nu este doar -, apoi mkdir și cd îl vor interpreta ca o opțiune. Dacă este doar -, atunci cd îl va interpreta ca însemnând $OLDPWD. Dacă it „s + urmat de 0 sau mai multe cifre, apoi cd în zsh îl va interpreta ca un index în stiva de directoare. Puteți remedia prima problemă, dar nu și celelalte două, trecând -- înainte de argument. Puteți rezolva toate aceste probleme anticipând ./ la argument dacă este „o cale relativă.
• mkdir nu urmează CDPATH, dar cd o face, deci dacă ați setat CDPATH la o valoare care nu „începe cu . (o configurație oarecum oarecum neobișnuită), atunci cd vă poate duce la un director diferit cel care tocmai a fost creat.Prevederea ./ pentru căile relative remediază acest lucru¹ (face ca CDPATH să fie ignorat).
• Dacă mkdir eșuează, încearcă să execute cd. Remediere: utilizați && pentru a separa cele două comenzi.

Încă destul de simplu:

 mkcd () { case "$1" in /*) :;; *) set -- "./$1";; esac mkdir -p "$1" && cd "$1" }  

Această versiune are încă potențialul de a face ca cd să intre într-un director diferit de cel că mkdir tocmai a fost creat într-un caz de margine: dacă argumentul pentru mkcd conține .. și trece printr-o legătură simbolică. De exemplu, dacă directorul curent este /tmp/here și mylink este o legătură simbolică către /somewhere/else , apoi mkdir mylink/../foo creează /somewhere/else/foo în timp ce cd mylink/../foo se schimbă în foo. Nu este suficient să căutați legături simbolice în argument, deoarece shell-ul urmărește și link-uri simbolice în propriul director curent, astfel încât cd /tmp/mylink; mkdir ../foo; cd ../foo nu se schimbă în noul director (/somewhere/else/foo), dar în /tmp/foo. O soluție pentru aceasta este să lăsați cd integrat să rezolve toate .. componentele căii mai întâi (nu are sens să folosiți foo/.. dacă foo nu ” nu există, așa că mkdir nu trebuie să vadă niciodată ..).

Ajungem la acest lucru robust, dacă este ușor sângeros version:

 mkcd () { case "$1" in */..|*/../) cd -- "$1";; # that doesn"t make any sense unless the directory already exists /*/../*) (cd "${1%/../*}/.." && mkdir -p "./${1##*/../}") && cd -- "$1";; /*) mkdir -p "$1" && cd "$1";; */../*) (cd "./${1%/../*}/.." && mkdir -p "./${1##*/../}") && cd "./$1";; ../*) (cd .. && mkdir -p "${1#.}") && cd "$1";; *) mkdir -p "./$1" && cd "./$1";; esac }  

(Exercițiu: de ce folosesc un subshell pentru prima cd apel?)

Dacă mkdir nu reușește, vreau să fiu sigur că nu schimb directorul curent. Schimbarea înapoi cu cd – sau $ OLDPWD nu este suficient de bună dacă shell-ul nu are permisiunea de a se schimba în directorul său curent. De asemenea, apelarea cd-urilor actualizează OLDPWD, deci vrem să o facem o singură dată (sau să restaurăm OLDPWD).

Există și modalități mai puțin specializate pentru a nu fi necesar să tastați din nou cuvântul din linia anterioară:

• Tastați cd , apoi Esc . (sau Alt + . ) pentru a insera ultimul argument din comanda anterioară.
• cd !$ execută cd pe ultimul argument al comenzii anterioare.
• Apăsați Sus pentru a reaminti linia de comandă anterioară, apoi editați-o pentru a schimba mkdir în cd.

^{¹ ai grijă totuși că nu funcționează în ksh93 din versiunea u+ , fixată în 93u + m / 1.0.0-alfa + d1483150 2021-01-05}

Comentarii

• Mulțumesc! Esc. mi se pare cel mai convenabil, face secvența de taste au orice m special eaning?
• Este ‘ doar Bash (și moștenit de la ksh și funcționează și în zsh) secvență pentru ” repetați ultimul cuvânt al comenzii anterioare „. O folosesc destul de des.
• @Gilles ‘ încep să cred că ” Gilles ” contul este de fapt partajat de un grup de experți. 😉
• @StephaneChazelas /a/b/..// ar funcționa de fapt, dar nu /a/b/../c. Fix. Am ‘ am adresat întrebarea unui public mai larg.
• mkcd() { mkdir -p "$1" && cd "$1"; } nu ‘ pare a fi o problemă în (instanța mea) zsh. mkdir -p /var/tmp/somewhere/else /tmp/here; cd /tmp/here; ln -s /var/tmp/somewhere/else mylink; mkdir -p mylink/../foo && cd mylink/../foo; pwd (include configurarea și) afișează /tmp/here/foo care este ceea ce a fost creat (și ceea ce mă așteptam). bash în mod eronat creează și se modifică în /var/tmp/somewhere/foo.

Nu mi-ar fi trecut niciodată prin minte să scriu acest comportament, deoarece introduc următoarele în aproape o oră …

$ mkdir someDirectory<ENTER> $ cd !$ 

unde bash înlocuiește cu amabilitate !$ cu ultimul cuvânt din ultima linie; adică numele lung al directorului pe care l-ați introdus.

În plus, completarea numelui de fișier este prietenul dvs. în astfel de situații. Dacă noul dvs. director a fost singurul fișier din dosar, o dublă rapidă TAB vă va oferi noul director fără să îl reintroduceți.

Deși este bine că bash-ul vă permite pentru a crea sarcini obișnuite, așa cum sugerează celelalte răspunsuri, cred că este mai bine să învățați caracteristicile de editare pe linia de comandă pe care bash le oferă, astfel încât atunci când lucrați la o altă mașină să nu vă lipsească zahărul sintactic pe care îl oferă scripturile dvs.

Comentarii

• Există un loc bun pentru a afla despre cele mai importante ciudățenii bash ca acesta?
• @ dominicbri7 În general se află sub ” editarea liniei de comandă bash ” Googling același lucru dă următoarele ca rezultat de top web.mit.edu/gnu/doc/html/features_7.html Mai exact,! $ este un exemplu de Word Designator vezi gnu.org/software /bash/manual/bashref.html#Word-Designators

Dacă utilizați Oh, Zsh, există o comandă numită ia care face exact acest lucru. Ar arăta cam așa.

take myfolder 

De fapt l-am găsit accidental. Tocmai m-am uitat și este listat pe acest cheatsheat din wiki-ul Oh My Zsh GitHub. Este o comandă destul de utilă și aparent foarte ușor de creat.

Comentarii

• Nu am știut niciodată despre take 🙂 Perfect! btw – iTerm2 cu Oh My Zsh. Există de fapt 3 răspunsuri perfecte aici. Acesta, cel de @jes ú s-carrera și răspunsul selectat. Depinde de configurare și preferință.

Conform Ce personalizări ați făcut pe profilul dvs. de shell pentru a crește productivitatea? , așa o fac:

# make a directory and cd to it mcd() { test -d "$1" || mkdir "$1" && cd "$1" } 

înseamnă că funcționează și dacă directorul există deja.

Comentarii

• Opțiunea -p pentru mkdir va suprima erorile.
• mcd este o comandă deja existentă. Deși ‘ tocmai ați dat un exemplu, l-am folosit eu ca ‘ o literă mai scurtă decât mkcd.
• @Dharmit Shah: Care este comanda existentă mcd? Ce pachet sau proiect oferă această comandă?
• mtools furnizează comanda mcd. Pagina sa de manual spune ” Comanda mcd este utilizată pentru a schimba directorul de lucru mtools de pe discul MS-DOS. ”

Sau puteți crea o variabilă scurtă din mers și să o utilizați de două ori x = longproject ; mkdir $x ; cd $x – care recunosc că este încă mai lung decât utilizarea unei funcții shellscript 🙂

Acesta este un lucru simplu de făcut într-un script / funcție bash. Am creat un tutorial foarte lizibil și suficient de documentat, inclusiv scripturi care funcționează atât pe Linux, cât și pe MacOS (acest lucru va fi menținut și în viitor).

Scopul meu pentru complexitatea tutorialului este: scris pentru un public vizat cu singurele condiții prealabile pentru care utilizatorul are un impuls și poate citi limba engleză, așa că vă rugăm să oferiți feedback dacă aveți nevoie de asistență.

https://github.com/craigopie/shellscripts

 mcdir() { if [ $# -eq 0 ] || [ $1 = "-h" ] || [ $1 = "--help" ] then echo "Usage: [option...] {directory}" echo " -p, --path Create all directories in path " echo " -h, --help Shows this helpful information " echo return 0 fi ## create directory with a path if [ $1 = "-p" ] || [ $1 = "--path" ] then mkdir -p "$2" &>/dev/null if [ $? -gt 0 ] then echo "There was a problem creating your directory." return 1 fi cd "$2" &>/dev/null if [ $? -gt 0 ] then echo "Unable to change into that directory." return 1 fi return 0 fi ## create directory in this location mkdir "$1" &>/dev/null if [ $? -gt 0 ] then echo "There was a problem creating your directory." return 1 fi cd "$1" &>/dev/null if [ $? -gt 0 ] then echo "Unable to change into that directory." return 1 fi return 0 } export -f mcdir  

Pentru a instala acest lucru aveți două opțiuni:

• Mai întâi este să adăugați funcția la fișierul dvs. .bashrc.
• Al doilea este să adăugați fișierul la calea dvs. și apoi sursați fișierul în fișierul .bash_profile.

Din nou, fișierul README este foarte detaliat despre cum să faceți acest lucru.

Noroc!

Aici „o variantă ușoară care merită menționată:

function mkdir() { local dir=$1 command mkdir "$dir" && cd "$dir" } 

Adăugați acest lucru la yo ur ~/.bash_profile și puteți utiliza apoi mkdir ca de obicei (odată ce ați „divizat source” d it), cu excepția acum, va rula funcția de mai sus, mai degrabă decât comanda standard mkdir.

Rețineți, acest lucru nu validează intrarea conform Răspunsul lui Gilles , dar demonstrează modul în care (efectiv) puteți suprascrie elementele încorporate.

docs (parafrazând ușor):

command mkdir [args] rulează mkdir cu args ignorând orice funcție shell denumită mkdir. Se execută numai comenzile încorporate în shell sau comenzile găsite prin căutarea în PATH. Dacă există o funcție shell denumită ls, rularea command ls în cadrul funcției va executa comanda externă ls în loc să apelați funcția recursiv

Cred că builtin obține un rezultat similar cu command.

Comentarii

• ar trebui să citați cu siguranță $dir
• @Jeff, a fost de acord, dar răspunsul acceptat are toate validările de care ar avea nevoie.’ doar prezint utilizarea command ca alternativă.

Adăugarea funcției de asistență la BASH, ZSH sau KSH

Creați comanda mkcd în mediul dvs. în o linie

echo -e "mkcd() {\n mkdir -p "$1" && cd $_\n}" >> ~/.${0//-/}rc && . ~/.${0//-/}rc 

Dacă utilizați Oh-my-zsh , take va face trucul. Aruncați o privire la foaia de înșelăciune .

Tocmai a automatizat răspunsurile de mai sus și a creat un script executabil o singură dată:

fun=" mkcd () { mkdir -p -- "$1" && cd -P -- "$1" }" echo "$fun" >> ~/.bashrc 

Doar copiați acest lucru într-un fișier nou mkcd.sh și rulați-l o singură dată în terminal de bash mkcd.sh. Apoi executați source ~/.bashrc pentru ca acesta să funcționeze în sesiunea curentă.

După aceasta, puteți utiliza mkcd some_dir pentru a crea și introduceți direct în acel director.

Comentarii

• Vă sugerăm să scrieți un script (într-un fișier) al cărui singur scop este să se atașeze la ~/.bashrc fișier (cu un răspuns care a fost deja dat)? Și cum sugerați să creați acest script mkcd.sh? Cu un editor, poate? Acest lucru pare a fi mai mult de lucru decât simpla editare ~/.bashrc. Ce avantaj are acest lucru față de răspunsul acceptat? ………………………………………………………………………… P.S. Acest lucru va eșua din cauza problemelor de citare, ceea ce îmi spune că nici măcar nu ați încercat-o singur.
• Îmi pare rău să spun, dar da, așa cum am scris în răspunsul meu, am folosit răspunsurile de mai sus. Funcționează. Dacă nu ‘ nu mă credeți, încercați. Și despre faptul că nu încerc, am folosit ziua mea completă pentru a scrie astăzi astfel de scripturi în bash și python.
• Am încercat ceea ce ați scris. Nu funcționează.