Quelle est la manière correcte de joindre plusieurs composants de chemin en un seul chemin complet dans emacs lisp ?

Question

Supposons que j'ai des variables dir y file contenant des chaînes de caractères représentant un répertoire et un nom de fichier, respectivement . Quelle est la façon correcte, dans emacs lisp, de les joindre en un chemin complet vers le fichier ?

Par exemple, si dir est "/usr/bin" y file est "ls" alors je veux "/usr/bin/ls" . Mais si à la place dir est "/usr/bin/" je veux toujours la même chose, sans barre oblique répétée.

Answer 1

En lisant le manuel de Noms de répertoire vous trouverez la réponse :

Étant donné un nom de répertoire, vous pouvez le combiner avec un nom de fichier relatif en utilisant concat :

 (concat dirname relfile)

Assurez-vous de vérifier que le nom du fichier est relatif avant de le faire. Si vous utilisez un nom de fichier absolu, les résultats pourraient être syntaxiquement invalides ou faire référence au mauvais fichier.

Si vous souhaitez utiliser un nom de fichier de répertoire dans une telle combinaison, vous devez devez d'abord le convertir en nom de en utilisant file-name-as-directory :

 (concat (file-name-as-directory dirfile) relfile) 

N'essayez pas de concaténer un slash à la main, comme dans

 ;;; Wrong!
 (concat dirfile "/" relfile) 

parce que ce n'est pas portable. Toujours utiliser file-name-as-directory .

D'autres commandes utiles sont : file-name-directory , file-name-nondirectory et d'autres dans le Nom du fichier Composants section.

Answer 2

Vous pouvez utiliser expand-file-name pour ça :

(expand-file-name "ls" "/usr/bin")
"/usr/bin/ls"
(expand-file-name "ls" "/usr/bin/")
"/usr/bin/ls"

Edit : cela ne fonctionne qu'avec des noms de répertoire absolus. Je pense que la réponse de Trey est la solution préférable.

Answer 3

Je voulais joindre plusieurs répertoires imbriqués sur un chemin. À l'origine, j'utilisais plusieurs expand-file-name appels, comme ça :

(expand-file-name "b" (expand-file-name "a" "/tmp"))
"/tmp/a/b"

Cependant, cela est plutôt verbeux et se lit à l'envers.

Au lieu de cela, j'ai écrit une fonction qui agit comme la fonction de Python os.path.join :

(defun joindirs (root &rest dirs)
  "Joins a series of directories together, like Python's os.path.join,
  (dotemacs-joindirs \"/tmp\" \"a\" \"b\" \"c\") => /tmp/a/b/c"

  (if (not dirs)
      root
    (apply 'joindirs
           (expand-file-name (car dirs) root)
           (cdr dirs))))

Cela fonctionne comme suit :

(joindirs "/tmp" "a" "b")
"/tmp/a/b"
(joindirs "~" ".emacs.d" "src")
"/Users/dbr/.emacs.d/src"
(joindirs "~" ".emacs.d" "~tmp")
"/Users/dbr/.emacs.d/~tmp"

Answer 4

Cette question a été posée en 2010, mais à l'heure où nous écrivons ces lignes, elle arrive en tête des recherches telles que "joindre les chemins de fichiers en elisp" alors j'ai pensé que je devais mettre à jour la réponse.

Depuis 2010, les choses ont beaucoup évolué dans le monde d'Emacs. Il s'agit en quelque sorte d'une réponse en double, puisqu'elle a été brièvement mentionnée dans une réponse en dessous de mais je vais l'étoffer un peu. Il y a maintenant un bibliothèque dédiée pour les interactions entre fichiers, f.el :

Très inspiré par @magnars de l'excellent s.el y dash.el , f.el est une API moderne pour travailler avec les fichiers et les répertoires dans Emacs.

N'essayez pas de réinventer la roue. Vous devriez utiliser cette bibliothèque pour les manipulations de chemins de fichiers. La fonction que vous voulez est f-join :

(f-join "path")                   ;; => "path"
(f-join "path" "to")              ;; => "path/to"
(f-join "/" "path" "to" "heaven") ;; => "/path/to/heaven"

Vous devrez peut-être d'abord installer le paquet. Il devrait être disponible sur MELPA.

Answer 5

Si vous utilisez une bibliothèque pratique de manipulation de fichiers et de répertoires f.el vous avez seulement besoin f-join . Le code ci-dessous est destiné à ceux qui, pour une raison quelconque, refusent d'utiliser cette bibliothèque.

(defun os-path-join (a &rest ps)
  (let ((path a))
    (while ps
      (let ((p (pop ps)))
        (cond ((string-prefix-p "/" p)
               (setq path p))
              ((or (not path) (string-suffix-p "/" p))
               (setq path (concat path p)))
              (t (setq path (concat path "/" p))))))
    path))

Cela se comporte exactement comme l'outil Python os.path.join .

ELISP> (os-path-join "~" "a" "b" "")
"~/a/b/"
ELISP> (os-path-join "~" "a" "/b" "c")
"/b/c"

string-suffix-p n'existe pas avant Emacs 24.4 J'ai donc écrit le mien à Vérifier si une chaîne se termine par un suffixe en Emacs Lisp .