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

Quasi tutti i principali linguaggi di programmazione hanno una libreria per gestire i separatori di directory per te. Dovresti sfruttarli. Questo 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 tutti i casi, quando provengono da fonti diverse, è necessario considerare diversi possibili casi 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 ciascuna parte provenga da una fonte diversa significa che ciascuna fonte potrebbe avere le proprie idee su quali convenzioni seguire, se qualcuno ci avesse pensato affatto! Qualunque cosa stia chiamando il tuo codice non dovresti 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 fare una correzione. Ho avuto diverse spiacevoli occasioni in cui un collega ha assunto un'ipotesi su come i percorsi dovrebbero essere formattati in un file di configurazione, il che significa che dovevo dare la caccia al codice e capire cosa si aspettavano (o correggere il codice).

La maggior parte delle lingue principali fornisce un metodo per fare ciò che già gestisce 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 presupporre che un separatore di directory principale nel secondo argomento faccia riferimento a un percorso root e che questo significhi che il primo argomento debba essere completamente eliminato. Non so perché questo è considerato utile; per me, causa solo problemi. Non ho mai voluto combinare due porzioni di percorso e finire con la prima parte lasciata cadere. Leggi attentamente la documentazione per casi speciali e, se necessario, scrivi un wrapper che fa ciò che vuoi con questi invece della loro gestione speciale.

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

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

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

In Java, la risposta sarebbe "nessuno dei precedenti". La migliore pratica sarebbe quella di assemblare nomi di percorso usando la classe java.io.File ; per es.

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

La classe File si occupa anche dei separatori dei nomi dei percorsi specifici della piattaforma.

C'è un problema separato se il tuo percorso dovrebbe iniziare con una barra o meno. Ma questo ha più a che fare con la correttezza delle migliori pratiche. Un percorso che inizia con una barra significa qualcosa di diverso in un percorso che non lo fa !!

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

Nota che in .NET devi usare il metodo Path.Combine.

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

La ragione di ciò è che "sa" i caratteri corretti da utilizzare quando si costruiscono i nomi delle cartelle.

Questo elimina il "problema" del pre o post fixing.

Quando si costruiscono percorsi, spesso utilizzo 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.

Le cartelle e i file differiscono solo per un aspetto: le cartelle terminano con una barra in cui i file no. Inoltre, i percorsi assoluti iniziano con / dove i percorsi relativi non lo fanno. Se si utilizza questo coerente concatenazione di percorsi e file insieme, non dovrebbe esserci alcun 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 due percorsi assoluti insieme non ha senso, poiché il secondo percorso dovrebbe essere relativo al primo percorso. Concatenare insieme due percorsi relativi non è un problema, ma potrebbe portare a comportamenti non definiti se il programma non sa dove sia relativo 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 trattare i casi, ma potrebbe richiedere un po 'di sforzo. In particolare, dovresti stare attento a diverse piattaforme. Ad esempio, in Windows \ è il separatore mentre nei sistemi basati su Unix / è il separatore.

Non ho familiarità con le librerie Javascript, ma sono sicuro che ci dovrebbero essere delle librerie per gestire questi casi. In Java, ad esempio, puoi utilizzare l'API Path  per gestire le operazioni sui percorsi indipendenti dalla piattaforma.

La mia preferenza personale è questa:

var assets = "/images"

var sounds = assets+"/sounds"

Uso sempre percorsi assoluti ( /images/... ), mi sembra meno incline all'errore. È anche più ingannevole usare var sounds = assets+"/sounds" perché anche se assets ha una barra finale e hai finito con /images//sounds , si risolve comunque in /images/sounds . L'unico disclaimer è che dipende dal gestore della richiesta. Apache sembra gestirlo bene (almeno alcune versioni / configurazioni, vedi link ) . Con l'altro modo si finirebbe con /imagessounds , non così infallibile :) C'è anche l'opzione di controllare le doppie barre e pulirle. Non un'opzione con l'altro approccio.

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

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