Existe uma maneira convencional de combinar seqüências de caracteres de caminho de arquivo?

Em um exemplo:

var assets = "images/"

var sounds = assets+"sounds/"

É mais convencional colocar a barra na parte de trás do caminho de um arquivo?

var assets = "/images"

var sounds = assets+"/sounds"

Existe outro método que seja uma boa prática comum?

Quase todas as principais linguagens de programação possuem uma biblioteca para lidar com os separadores de diretório para você. Você deve aproveitá-los. Isso simplificará seu código e evitará erros .

Na minha experiência, o motivo usual para combinar seqüências de caracteres como essa é que elas vêm de diferentes fontes. Às vezes, são partes diferentes de um arquivo de configuração. Às vezes, é uma combinação constante com um argumento de função. Em todo e qualquer caso, quando eles vêm de fontes diferentes, é necessário considerar vários casos possíveis diferentes em relação aos separadores nas extremidades a serem combinados:

• Ambas as extremidades podem ter um separador: "images/"e"/sounds"
• Apenas um tem um separador: "images"e "/sounds"ou "images/"e"sounds"
• Nem tem um separador: "images"e"sounds"

O fato de cada parte vir de uma fonte diferente significa que cada fonte pode ter suas próprias idéias sobre quais convenções seguir, se alguém pensar em alguma coisa! O que quer que esteja chamando seu código não deve se preocupar com isso . Seu código deve lidar com todos os casos, porque alguém violará sua convenção . Isso resultará em perda de tempo investigando a causa de um erro e corrigindo. Eu tive várias ocasiões desagradáveis ​​em que um colega de trabalho assumiu como os caminhos devem ser formatados em um arquivo de configuração, o que significa que eu tive que procurar o código e descobrir o que eles estavam esperando (ou consertar o código).

A maioria dos idiomas principais fornece um método para fazer isso para você que já lida com muitos dos casos:

• os.path.join para Python
• File.join para Ruby
• Path.join para Node.js
• Paths.get para Java (7 ou superior)
• Path.Combine para .NET

Há uma ressalva com estes. Vários deles parecem supor que um separador de diretório principal no segundo argumento se refira a um caminho raiz e que isso significa que o primeiro argumento deve ser descartado inteiramente. Não sei por que isso é considerado útil; para mim, isso apenas causa problemas. Eu nunca quis combinar duas partes do caminho e terminar com a primeira parte sendo descartada. Leia a documentação cuidadosamente para casos especiais e, se necessário, escreva um invólucro que faça o que você deseja com eles, em vez de seu tratamento especial.

Isso também ajuda se você precisar de suporte para diferentes sistemas operacionais. Essas classes são quase onipresentes na escolha do separador correto. As bibliotecas geralmente também têm uma maneira de normalizar os caminhos para atender às convenções do sistema operacional.

No caso de sua linguagem de programação não ter uma biblioteca prontamente disponível, você deve escrever um método que lide com todos esses casos e use-o livremente e entre projetos.

Isso se enquadra na categoria de "não faça suposições" e "use ferramentas que o ajudem".

Em Java, a resposta seria "nenhuma das opções acima". A melhor prática seria montar nomes de caminho usando a java.io.Fileclasse; por exemplo

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

A Fileclasse também cuida dos separadores de nome de caminho específicos da plataforma.

Há uma questão separada sobre se o nome do caminho deve começar com uma barra ou não. Mas isso tem mais a ver com correção do que com as melhores práticas. Um nome de caminho que começa com uma barra significa algo diferente de um nome de caminho que não !!

Não há suporte explícito para manipulação de nome de caminho na biblioteca Javascript principal (ECMA), mas (pelo menos) o Node.js fornece suporte por meio do módulo Path.

Observe que no .NET você deve usar o método Path.Combine.

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

A razão para isso é que ele 'conhece' os caracteres corretos a serem usados ​​ao construir os nomes das pastas.

Isso elimina o 'problema' de pré ou pós-fixação.

Ao construir caminhos, geralmente uso uma função que adiciona a barra final, se ainda não estiver lá. Em seguida, os caminhos podem ser construídos como:

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

onde fs () adiciona uma barra final, se necessário.

Pastas e arquivos diferem apenas em um aspecto: as pastas terminam com uma barra onde os arquivos não. Além disso, os caminhos absolutos começam com um /onde os caminhos relativos não. Se você usar esse processo de concatenação consistente de arquivos e arquivos em conjunto, não haverá problema.

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

Concatenar dois caminhos absolutos juntos não faz sentido, pois o segundo caminho deve ser relativo ao primeiro caminho. Concatenar dois caminhos relativos juntos não é problema, mas pode levar a um comportamento indefinido se o programa não souber onde o caminho relativo é relativo.

Eu acho que não há mágica ou "prática comum" sobre como implementar caminhos, mas certamente a concatenação de strings não é o caminho a seguir. Você pode desenvolver sua própria API para lidar com casos, mas isso pode exigir algum esforço. Em particular, você deve ter cuidado com as diferentes plataformas. Por exemplo, no Windows \é o separador, enquanto nos sistemas baseados em Unix /é o separador.

Não conheço as bibliotecas Javascript, mas tenho certeza de que deve haver bibliotecas para lidar com esses casos. Em Java, por exemplo, você pode usar a API do Path para lidar com operações de caminho independentes da plataforma.

Minha preferência pessoal é esta:

var assets = "/images"

var sounds = assets+"/sounds"

Eu sempre uso caminhos absolutos ( /images/...), isso me parece menos propenso a erros. Também é mais à prova de idiotas de usar, var sounds = assets+"/sounds"porque, mesmo que assetstivesse uma barra à direita e você acabasse com /images//sounds, ainda assim resolveria /images/sounds. O único aviso é que depende do seu manipulador de solicitações. O Apache parece lidar bem com isso (pelo menos em determinadas versões / configurações, consulte http://www.amazon.com//gp//site-directory//ref=nav_sad ). Por outro lado, você não terá /imagessoundsprovas de idiotas :) Também existe a opção de verificar barras duplas e limpá-las. Não é uma opção com a outra abordagem.

No Smalltalk, é fácil definir o método / em String para que funcione assim:

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

Aqui está uma implementação simples do método (você pode torná-lo melhor):

/ 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

Nota : você também pode querer prestar mais atenção aos casos de fronteira, tais como '' / '', 'x/' / '', etc., a fim de determinar o comportamento adequado.