Existe-t-il un moyen conventionnel de combiner des chaînes de chemin de fichier?

Dans un exemple:

var assets = "images/"

var sounds = assets+"sounds/"

Est-il plus conventionnel de mettre la barre oblique à l'arrière d'un chemin de fichier?

var assets = "/images"

var sounds = assets+"/sounds"

Y at-il une autre méthode qui est une bonne pratique courante?

Presque tous les principaux langages de programmation ont une bibliothèque pour gérer les séparateurs de répertoires pour vous. Vous devriez les exploiter. Cela simplifiera votre code et évitera les bugs .

D'après mon expérience, la raison habituelle pour combiner des chaînes de ce type est qu'elles proviennent de sources différentes. Parfois, il s'agit de pièces différentes d'un fichier de configuration. Parfois, c'est une combinaison constante avec un argument de fonction. Dans tous les cas, quand ils proviennent de sources différentes, vous devez considérer plusieurs cas possibles concernant les séparateurs aux extrémités à combiner:

• Les deux extrémités pourraient avoir un séparateur: "images/"et"/sounds"
• Un seul a un séparateur: "images"et "/sounds"ou "images/"et"sounds"
• Ni un séparateur: "images"et"sounds"

Le fait que chaque partie provienne d'une source différente signifie que chaque source peut avoir ses propres idées sur les conventions à suivre, si quelqu'un y réfléchit du tout! Tout ce qui appelle votre code ne devrait pas avoir à s'inquiéter de cela . Votre code doit gérer tous les cas, car quelqu'un violera votre convention . Cela se traduira par une perte de temps pour rechercher la cause d'une erreur et apporter une solution. À plusieurs reprises, un collègue a supposé que les chemins d'accès devaient être formatés dans un fichier de configuration, ce qui signifiait que je devais rechercher le code et déterminer ce à quoi il s'attendait (ou le corriger).

La plupart des langues principales fournissent une méthode pour le faire pour vous, qui gère déjà de nombreux cas:

• os.path.join pour Python
• File.join pour Ruby
• Path.join pour Node.js
• Paths.get pour Java (7 ans et plus)
• Path.Combine pour .NET

Il y a une mise en garde avec ceux-ci. Un certain nombre d'entre eux semblent supposer qu'un séparateur de répertoire en tête dans le deuxième argument fait référence à un chemin racine, ce qui signifie que le premier argument doit être entièrement supprimé. Je ne sais pas pourquoi c'est considéré comme utile. pour moi, cela ne fait que poser des problèmes. Je n'ai jamais voulu combiner deux portions de chemin et finir par abandonner la première. Lisez attentivement la documentation pour les cas particuliers et, si nécessaire, écrivez un wrapper qui fait ce que vous voulez avec ceux-ci au lieu de leur traitement spécial.

Cela aide également si vous avez besoin de prendre en charge différents systèmes d'exploitation. Presque partout, ces classes expliquent le choix du bon séparateur. Les bibliothèques disposent généralement d’un moyen de normaliser les chemins pour s’adapter aux conventions du système d’exploitation.

Au cas où votre langage de programmation ne dispose pas d'une bibliothèque facilement disponible, vous devez écrire une méthode qui gère tous ces cas et l'utiliser de manière libérale et entre projets.

Cela tombe dans la catégorie "ne faites pas de suppositions" et "utilisez des outils qui vous aident".

En Java, la réponse serait "ni l'un ni l'autre". La meilleure pratique serait d’assembler des noms de chemins en utilisant la java.io.Fileclasse; par exemple

File assets = new File("images");
File sounds = new File(assets, "sounds");

La Fileclasse prend également en charge les séparateurs de noms de chemins spécifiques à la plate-forme.

Il y a une question distincte de savoir si votre chemin doit commencer par une barre oblique ou non. Mais cela relève plus de l’exactitude que de la meilleure pratique. Un chemin qui commence par un slash signifie autre chose qu'un chemin qui ne le fait pas !!

Il n’existe pas de support explicite pour la gestion des noms de chemins dans la bibliothèque Javascript principale (ECMA), mais (au moins) Node.js fournit un support via le module Path.

Notez que dans .NET, vous devez utiliser la méthode Path.Combine.

var path = System.IO.Path.Combine("assets", "sounds");

La raison en est qu’elle «connaît» les caractères corrects à utiliser lors de la construction des noms de dossier.

Cela supprime le "problème" de pré ou post-fixation.

Lors de la construction de chemins, j'utilise souvent une fonction qui ajoute la barre oblique finale si elle n’y figure pas déjà. Ensuite, les chemins peuvent être construits comme:

filename := fs( 'assets') + fs( 'images') + fs( 'icons') + 'some.png';

où fs () ajoute une barre oblique finale si nécessaire.

Les dossiers et les fichiers ne diffèrent que par un aspect: les dossiers se terminent par une barre oblique, contrairement aux fichiers. De plus, les chemins absolus commencent par un /cas où les chemins relatifs ne le sont pas. Si vous utilisez ceci systématiquement, concaténer les chemins et les fichiers ne devrait poser aucun problème.

var absolutepath = "/my/path/";
var relativepath = "css/";
var filename = "test.css";
var relativepathtofilename = "js/test.js";

var a = absolutepath + relativepath + filename; //Output: /my/path/css/test.css
var b = absolutepath + relativepathtofilename;  //Output: /my/path/js/test.js

Concaténer deux chemins absolus n'a aucun sens, car le deuxième chemin doit être relatif au premier. La concaténation de deux chemins relatifs ne pose pas de problème, mais peut conduire à un comportement indéfini si le programme ne sait pas où le chemin relatif est relatif.

Je pense qu'il n'y a pas de magie ou de "pratique courante" sur la manière de mettre en œuvre des chemins, mais la concaténation de chaînes n'est certainement pas la solution. Vous pouvez développer votre propre API pour traiter les cas, mais cela peut nécessiter des efforts. En particulier, vous devez faire attention aux différentes plates-formes. Par exemple, dans Windows, \le séparateur, tandis que dans les systèmes Unix, il /est le séparateur.

Je ne connais pas bien les bibliothèques Javascript, mais je suis sûr qu'il devrait exister des bibliothèques pour gérer ces cas. En Java, par exemple, vous pouvez utiliser l' API Path pour gérer les opérations de chemin indépendantes de la plate-forme.

Ma préférence personnelle est la suivante:

var assets = "/images"

var sounds = assets+"/sounds"

J'utilise toujours des chemins absolus ( /images/...), cela me semble moins sujet aux erreurs. Il est également plus facile de l'utiliser var sounds = assets+"/sounds"car même si assetsune barre oblique de fin et vous avez fini avec /images//sounds, il serait toujours résoudre à /images/sounds. Le seul déni de responsabilité étant que cela dépend de votre gestionnaire de demandes. Apache semble bien le gérer (au moins certaines versions / configurations, voir http://www.amazon.com//gp//site-directory//ref=nav_sad ). Dans l’autre cas, vous vous retrouveriez avec /imagessounds, pas si mal à l’aise :) Il est également possible de vérifier les doubles barres obliques et de les nettoyer. Pas une option avec l'autre approche.

En Smalltalk, il est simple de définir la méthode / dans String afin qu’elle fonctionne comme suit:

'assets' / 'sounds' => 'assets/sounds'.
'assets/' / 'sounds' => 'assets/sounds'.
'assets' / '/sounds' => 'assets/sounds'.
'assets/' / '/sounds' => 'assets/sounds'.

Voici une implémentation simple de la méthode (vous pouvez l'améliorer):

/ aString
    | slash first second |
    slash := Directory separator.
    first := self.
    (first endsWith: slash) ifTrue: [first := first allButLast].
    second := aString.
    (second beginsWith: slash) ifTrue: [second := second allButFirst].
    ^first , slash , second

Remarque : vous pouvez également payer une plus grande attention aux cas frontaliers tels que '' / '', 'x/' / '', etc., afin de déterminer le comportement approprié.