Y a-t-il un doubleur qui me permet de créer un directory et d'y entrer en même time?

Il n'y a pas de command embeddede, mais vous pouvez facilement écrire une fonction qui appelle mkdir puis cd :

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

Mettez ce code dans votre file ~/.bashrc (ou ~/.kshrc pour les users de ksh, ou ~/.zshrc pour les users de zsh). Il définit une fonction appelée mkcd . "$1" sera remplacé par l'argument de la fonction lorsque vous l'exécuterez.

Cette version simple comporte plusieurs défauts:

• Vous ne pouvez pas créer une string de sous-directorys à la fois. Corrigé: passez l'option -p à mkdir . (Cela peut ou ne pas être souhaitable, car il augmente le risque qu'une faute de frappe ne soit pas détectée, par exemple mkcd mydierctory/newsub créera joyeusement mydierctory et mydierctory/newsub lorsque vous créerez newsub dans le mydirectory existant).
• Si l'argument commence par - mais ce n'est pas juste - , alors mkdir et cd l'interpréteront comme une option. Si c'est juste - , alors cd interprétera pour signifier $OLDPWD . Si c'est + suivi de 0 ou plusieurs numbers, alors cd dans zsh l'interprétera comme un index dans la stack de directorys. Vous pouvez résoudre le premier problème, mais pas les deux autres, en passant -- avant l'argument. Vous pouvez résoudre tous ces problèmes en faisant précéder ./ de l'argument s'il s'agit d'un path relatif.
• mkdir ne suit pas CDPATH , mais cd , donc si vous avez placé CDPATH à une valeur qui ne commence pas par . (une configuration certes assez inhabituelle), alors cd peut vous amener dans un directory différent de celui qui vient d'être créé. Ajouter des paths ./ aux paths relatifs corrige ceci (cela fait que CDPATH est ignoré).
• Si mkdir échoue, il essaie d'exécuter cd . Corrigé: utilisez && pour séparer les deux commands.

Encore assez simple:

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

Cette version a encore le potentiel pour faire que cd dans un directory différent de celui que mkdir vient de créer dans un cas de bord: si l'argument de mkcd contient .. et passe par un lien symbolique. Par exemple, si le directory courant est /tmp/here et que mylink est un lien symbolique vers /somewhere/else , alors mkdir mylink/../foo crée /somewhere/else/foo tandis que cd mylink/../foo transforme en foo . Il ne suffit pas de searchr des liens symboliques dans l'argument, car le shell suit également les liens symboliques dans son propre directory courant, donc cd /tmp/mylink; mkdir ../foo; cd ../foo cd /tmp/mylink; mkdir ../foo; cd ../foo cd /tmp/mylink; mkdir ../foo; cd ../foo ne change pas dans le nouveau directory ( /somewhere/else/foo ) mais dans /tmp/foo . Un correctif pour cela est de laisser le cd embedded résoudre tous les composants du path d'access en premier (cela n'a pas de sens d'utiliser foo/.. si foo n'existe pas, donc mkdir n'a jamais besoin d'en voir).

Nous arrivons à cette version robuste mais légèrement sanglante:

 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 } 

(Exercice: pourquoi j'utilise un sous-shell pour le premier appel cd ?)

Si mkdir échoue, je veux être sûr de ne pas changer le directory courant. Revenir en arrière avec cd – ou $ OLDPWD n'est pas suffisant si le shell n'a pas la permission de changer dans son directory courant. En outre, l'appel des mises à jour de CD OLDPWD, donc nous voulons seulement le faire une fois (ou restaurer OLDPWD).

Il existe également des moyens less spécialisés pour ne pas avoir à retaper le mot de la ligne précédente:

• Tapez cd , puis Échap . (ou Alt + . ) pour insert le dernier argument de la command précédente.
• cd !$ exécute cd sur le dernier argument de la command précédente.
• Appuyez sur Haut pour callbacker la command line précédente, puis modifiez-la pour changer mkdir en cd .

C'est le one-liner dont vous avez besoin. Aucune autre configuration requirejse:

 mkdir longtitleproject && cd $_ 

La variable $_ , dans bash, est le dernier argument donné à la command précédente. Dans ce cas, le nom du directory que vous venez de créer. Comme expliqué dans l' 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. 

Utilisez cd $_ pour récupérer le dernier argument de la command précédente au lieu de cd !$ Car cd !$ Donne le dernier argument de la command précédente dans l'historique du shell :

 cd ~/ mkdir folder && cd !$ 

vous vous retrouvez à la maison (ou ~ /)

 cd ~/ mkdir newfolder && cd $_ 

vous vous retrouvez dans un nouveau dossier sous la maison !! (ou ~ / nouveau dossier)

Il ne m'est jamais venu à l'idée de scripter ce comportement parce que j'entre dans les suivantes sur une base quasi-horaire …

 $ mkdir someDirectory<ENTER> $ cd !$ 

où bash remplace gentiment !$ avec le dernier mot de la dernière ligne; c'est-à-dire le nom du directory long que vous avez entré.

En outre, la complétion de nom de file est votre ami dans de telles situations. Si votre nouveau directory était le seul file du dossier, une double tabulation rapide vous donnerait le nouveau directory sans le saisir de nouveau.

Bien que ce soit cool que bash vous permette de scripter des tâches aussi courantes que les autres réponses suggèrent je pense qu'il vaut mieux apprendre les fonctions d'édition de command line que bash a à offrir afin que lorsque vous travaillez sur une autre machine, vous ne manquez pas la syntaxe sucre que vos scripts personnalisés fournissent.

Selon Quelles personnalisations avez-vous effectuées sur votre profil de shell pour augmenter la productivité? , voici comment je le fais:

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

cela signifie que cela fonctionne aussi si le directory existe déjà.

Si vous utilisez Oh My Zsh, il y a une command appelée take qui fait exactement cela. Cela ressemblerait à quelque chose comme ça.

 take myfolder 

En fait, j'ai trouvé celui-ci par accident. Je viens de regarder et il est répertorié sur cette sortingche du wiki Oh My Zsh GitHub. C'est une command très utile, et apparemment très facile à créer vous-même.

Ou vous pourriez simplement créer une petite variable à la volée et l'utiliser deux fois x = longproject ; mkdir $x ; cd $x x = longproject ; mkdir $x ; cd $x x = longproject ; mkdir $x ; cd $x – ce que j'avoue est encore plus long que d'utiliser une fonction shellscript 🙂

J'ai fait un script qui crée le directory, puis des CD, puis je lui ai donné un alias. Et voici un essentiel où je le décris.

https://gist.github.com/rehnen/34236d6ff270ccaa74b6#mkdir-like-it-was-meant-to-be

Voici une légère variante qui mérite d'être mentionnée:

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

Ajoutez ceci à votre ~/.bash_profile et vous pouvez ensuite utiliser mkdir comme d'habitude (une fois que vous avez la source 'd it), sauf maintenant il va exécuter la fonction ci-dessus plutôt que la command standard mkdir .

Notez que ceci ne valide pas les inputs selon la réponse acceptée par Gilles , mais démontre comment vous pouvez (efficacement) passer outre les builtins.

De la documentation (paraphrasant légèrement):

command mkdir [args] exécute mkdir avec args ignorant toute fonction shell nommée mkdir . Seules les commands embeddedes au shell ou les commands trouvées en recherchant le PATH sont exécutées. S'il existe une fonction shell nommée ls , l'exécution de la command ls dans la fonction exécutera la command externe ls au lieu d'appeler la fonction récursivement

Je crois que builtin réalise un résultat similaire à la command .