Esiste un modo convenzionale per combinare le stringhe del percorso del file?

In un esempio:

var assets = "images/"

var sounds = assets+"sounds/"

È più convenzionale inserire la barra sul retro di un percorso di file?

var assets = "/images"

var sounds = assets+"/sounds"

Esiste un altro metodo che è una buona pratica comune?

Quasi tutti i principali linguaggi di programmazione hanno una libreria per gestire i separatori di directory per te. Dovresti sfruttarli. Ciò semplifica il tuo codice e previene i bug .

Nella mia esperienza, la solita ragione per combinare stringhe come questa è che provengono da fonti diverse. A volte sono pezzi diversi da un file di configurazione. A volte è una costante combinazione con un argomento di funzione. In ogni caso, quando provengono da fonti diverse, è necessario considerare diversi casi possibili riguardanti i separatori alle estremità da combinare:

• Entrambe le estremità potrebbero avere un separatore: "images/"e"/sounds"
• Solo uno ha un separatore: "images"e "/sounds"o "images/"e"sounds"
• Nessuno dei due ha un separatore: "images"e"sounds"

Il fatto che ogni parte provenga da una fonte diversa significa che ogni fonte potrebbe avere le sue idee su quali convenzioni seguire, se qualcuno ci pensasse su! Qualunque cosa stia chiamando il tuo codice non dovrebbe preoccuparti di questo . Il tuo codice dovrebbe gestire tutti i casi perché qualcuno violerà la tua convenzione . Ciò comporterà uno spreco di tempo per indagare sulla causa di un errore e apportare una correzione. Ho avuto diverse spiacevoli occasioni in cui un collega ha fatto un'ipotesi su come i percorsi dovrebbero essere formattati in un file di configurazione, il che significa che ho dovuto andare a cercare il codice e capire cosa si aspettavano (o correggere il codice).

La maggior parte delle lingue principali fornisce un metodo per farlo che gestisce già molti dei casi:

• os.path.join per Python
• File.join per Ruby
• Path.join per Node.js
• Paths.get per Java (7 e versioni successive)
• Path.Combine per .NET

C'è un avvertimento con questi. Alcuni di questi sembrano supporre che un separatore di directory principale nel secondo argomento si riferisca a un percorso di root e che ciò significhi che il primo argomento deve essere eliminato completamente. Non so perché questo sia considerato utile; per me, causa solo problemi. Non ho mai voluto combinare due parti del percorso e finire con la prima parte che viene abbandonata. Leggi attentamente la documentazione per casi speciali e, se necessario, scrivi un wrapper che fa quello che vuoi con questi invece della loro gestione speciale.

Questo aiuta ulteriormente se hai bisogno di supportare diversi sistemi operativi. Queste classi spiegano quasi ovunque la scelta del separatore corretto. Le librerie di solito hanno anche un modo di normalizzare i percorsi per adattarsi alle convenzioni del sistema operativo.

Nel caso in cui il tuo linguaggio di programmazione non abbia una libreria prontamente disponibile, dovresti scrivere un metodo che gestisca tutti questi casi e lo usi liberamente e in tutti i progetti.

Questo rientra nella categoria "non fare ipotesi" e "usa strumenti che ti aiutano".

In Java, la risposta sarebbe "nessuna delle precedenti". La migliore pratica sarebbe quella di assemblare i percorsi usando la java.io.Fileclasse; per esempio

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

La Fileclasse si occupa anche dei separatori di percorsi specifici della piattaforma.

C'è un problema a parte se il tuo percorso deve iniziare con una barra o meno. Ma ciò ha più a che fare con la correttezza che con le migliori pratiche. Un percorso che inizia con una barra significa qualcosa di diverso da un percorso che non lo fa !!

Non esiste un supporto esplicito per la gestione dei percorsi nella libreria Javascript (ECMA) principale, ma (almeno) Node.js fornisce supporto tramite il modulo Path.

Si noti che in .NET è necessario utilizzare il metodo Path.Combine.

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

La ragione di ciò è che "conosce" i caratteri corretti da utilizzare durante la costruzione dei nomi delle cartelle.

Questo elimina il "problema" della correzione pre o post.

Quando costruisco percorsi uso spesso una funzione che aggiunge la barra finale se non è già presente. Quindi i percorsi possono essere costruiti come:

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

dove fs () aggiunge una barra finale se necessario.

Cartelle e file differiscono solo per un aspetto: le cartelle terminano con una barra in cui i file non lo sono. Inoltre, i percorsi assoluti iniziano con un /dove i percorsi relativi no. Se si utilizzano questi percorsi e file concatenati in modo coerente, non dovrebbe essere un 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

Concatenare insieme due percorsi assoluti non ha senso, poiché il secondo percorso dovrebbe essere relativo al primo. Concatenare insieme due percorsi relativi non è un problema, ma potrebbe portare a comportamenti indefiniti se il programma non sa dove si trova il percorso relativo.

Penso che non ci sia magia o "pratica comune" su come implementare i percorsi, ma certamente la concatenazione delle stringhe non è la strada da percorrere. Puoi sviluppare la tua API per gestire i casi, ma potrebbe richiedere qualche sforzo. In particolare, dovresti stare attento alle diverse piattaforme. Ad esempio, in Windows\ è il separatore mentre in sistemi basati su Unix /è il separatore.

Non ho familiarità con le librerie Javascript, ma sono sicuro che ci dovrebbero essere librerie per la gestione di questi casi. In Java, ad esempio, è possibile utilizzare l' API Path per gestire operazioni di percorso indipendenti dalla piattaforma.

La mia preferenza personale è questa:

var assets = "/images"

var sounds = assets+"/sounds"

Uso sempre percorsi assoluti ( /images/...), mi sembra meno soggetto a errori. È anche più folle da usare var sounds = assets+"/sounds"perché anche se assetsavessi una barra finale e tu finissi /images//sounds, sarebbe comunque risolto /images/sounds. L'unica dichiarazione di non responsabilità è che dipende dal gestore della richiesta. Apache sembra gestirlo bene (almeno alcune versioni / configurazioni, vedi http://www.amazon.com//gp//site-directory//ref=nav_sad ). Con l'altro modo in cui ti ritroveresti /imagessounds, non così infallibile :) C'è anche la possibilità di verificare la presenza di doppie barre e di pulirle. Non un'opzione con l'altro approccio.

In Smalltalk è semplice definire il metodo / in String in modo che funzioni così:

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

Ecco una semplice implementazione del metodo (puoi renderlo migliore):

/ 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 : si potrebbe anche voler prestare maggiore attenzione ai casi di confine, come '' / '', 'x/' / ''ecc, al fine di determinare il comportamento corretto.