Ottieni il percorso dell’applicazione

Di recente ho cercato come ottenere la directory dell’applicazione in Java. Ho finalmente trovato la risposta, ma ho avuto bisogno sorprendentemente a lungo perché la ricerca di un termine così generico non è facile. Penso che sarebbe una buona idea compilare un elenco di come ottenere ciò in più lingue.

Sentiti libero / a svantaggio se non ti piace l’idea e per favore contribuisci se ti piace.

Una precisazione:

C’è una bella distinzione tra la directory che contiene il file eseguibile e la directory di lavoro corrente (data da pwd sotto Unix). Inizialmente ero interessato al primo, ma mi sento libero di postare metodi per determinare anche quest’ultimo (chiarendo quale intendi).

In Java le chiamate

 System.getProperty("user.dir") 

e

 new java.io.File(".").getAbsolutePath(); 

restituisce la directory di lavoro corrente.

La chiamata a

 getClass().getProtectionDomain().getCodeSource().getLocation().getPath(); 

restituisce il percorso del file JAR contenente la class corrente o l’elemento CLASSPATH (percorso) che ha restituito la class corrente se si esegue direttamente dal filesystem.

Esempio:

  1. La tua applicazione si trova a

      C:\MyJar.jar 
  2. Aprire la shell (cmd.exe) e cd nella sottodirectory C: \ test \.

  3. Avviare l’applicazione utilizzando il comando java -jar C:\MyJar.jar .

  4. Le prime due chiamate restituiscono ‘C: \ test \ subdirectory’; la terza chiamata restituisce “C: \ MyJar.jar”.

Quando si esegue da un filesystem piuttosto che da un file JAR, il risultato sarà il percorso alla radice dei file di class generati, ad esempio

 c:\eclipse\workspaces\YourProject\bin\ 

Il percorso non include le directory dei pacchetti per i file di class generati.

Un esempio completo per ottenere la directory dell’applicazione senza il nome del file .jar, o il percorso corrispondente ai file di class se si esegue direttamente dal filesystem (ad esempio durante il debug):

 String applicationDir = getClass().getProtectionDomain().getCodeSource().getLocation().getPath(); if (applicationDir.endsWith(".jar")) { applicationDir = new File(applicationDir).getParent(); } // else we already have the correct answer 

In .NET (C #, VB, …) , è ansible interrogare l’istanza di Assembly corrente per la sua Location . Tuttavia, questo ha il nome del file eseguibile aggiunto. Il seguente codice disinfetta il percorso ( using System.IO e using System.Reflection ):

 Directory.GetParent(Assembly.GetExecutingAssembly().Location) 

In alternativa, è ansible utilizzare le informazioni fornite da AppDomain per cercare gli assembly di riferimento:

 System.AppDomain.CurrentDomain.BaseDirectory 

VB consente un’altra scorciatoia tramite il My spazio dei nomi:

 My.Application.Info.DirectoryPath 

In Windows , utilizzare la funzione WinAPI GetModuleFileName () . Passare in NULL per l’handle del modulo per ottenere il percorso per il modulo corrente.

Pitone

 path = os.path.dirname(__file__) 

Questo ottiene il percorso del modulo corrente.

Objective-C Cocoa (Mac OS X, non so per le specifiche dell’iPhone):

 NSString * applicationPath = [[NSBundle mainBundle] bundlePath]; 

In Java , ci sono due modi per trovare il percorso dell’applicazione. Uno è quello di utilizzare System.getProperty :

 System.getProperty("user.dir"); 

Un’altra possibilità è l’uso di java.io.File :

 new java.io.File("").getAbsolutePath(); 

Un’altra possibilità utilizza la riflessione:

 getClass().getProtectionDomain().getCodeSource().getLocation().getPath(); 

In VB6, è ansible ottenere il percorso dell’applicazione utilizzando la proprietà App.Path .

Si noti che questo non avrà un finale \ EXCEPT quando l’applicazione si trova nella root dell’unità.

Nell’IDE:

 ?App.Path C:\Program Files\Microsoft Visual Studio\VB98 

In .Net è ansible utilizzare

System.IO.Directory.GetCurrentDirectory

per ottenere la directory di lavoro corrente dell’applicazione, e in VB.NET in particolare è ansible utilizzare

My.Application.Info.DirectoryPath

per ottenere la directory dell’exe.

Delphi

Nelle applicazioni Windows:

 Unit Forms; path := ExtractFilePath(Application.ExeName); 

Nelle applicazioni della console:

Indipendentemente dalla lingua, il primo parametro della riga di comando è il nome dell’eseguibile completo:

 Unit System; path := ExtractFilePath(ParamStr(0)); 

libc
In ambiente di tipo * nix (anche Cygwin in Windows):

  #include  char *getcwd(char *buf, size_t size); char *getwd(char *buf); //deprecated char *get_current_dir_name(void); 

Vedi la pagina man

Unix

In unix è ansible trovare il percorso dell’eseguibile che è stato avviato utilizzando le variabili di ambiente. Non è necessariamente un percorso assoluto, quindi è necessario combinare la directory di lavoro corrente (nella shell: pwd ) e / o la variabile PATH con il valore dell’elemento 0’th dell’ambiente.

Il valore è limitato in unix, tuttavia, poiché l’eseguibile può essere richiamato ad esempio tramite un collegamento simbolico e viene utilizzato solo il collegamento iniziale per la variabile di ambiente. In generale le applicazioni su unix non sono molto solide se la usano per qualsiasi cosa interessante (come il caricamento delle risorse). Su Unix, è comune utilizzare posizioni con codice fisso per le cose, ad esempio un file di configurazione in /etc dove sono specificate le posizioni delle risorse.

In bash , il comando ‘pwd’ restituisce la directory di lavoro corrente.

In PHP :

  

in Android è

 getApplicationInfo().dataDir; 

per ottenere la scheda SD, io uso

 Environment.getExternalStorageDirectory(); Environment.getExternalStoragePublicDirectory(String type); 

dove quest’ultimo è utilizzato per memorizzare un tipo specifico di file (audio / filmati ecc.). Hai delle costanti per queste stringhe nella class Environment.

Fondamentalmente, per qualsiasi cosa con l’uso dell’applicazione class ApplicationInfo e per qualsiasi cosa da fare con i dati nella scheda SD / directory esterna utilizzando la class Ambiente.

Documenti: ApplicationInfo , Environment

In Tcl

Percorso dello script corrente:

 set path [info script] 

Percorso della shell Tcl:

 set path [info nameofexecutable] 

Se hai bisogno della directory di uno di questi, fai:

 set dir [file dirname $path] 

Ottieni la directory corrente (funzionante):

 set dir [pwd] 

in Ruby , il seguente snippet restituisce il percorso del file sorgente corrente:

 path = File.dirname(__FILE__) 

In CFML ci sono due funzioni per accedere al percorso di uno script:

 getBaseTemplatePath() getCurrentTemplatePath() 

La chiamata a getBaseTemplatePath restituisce il percorso dello script ‘base’, ovvero quello richiesto dal server web.
La chiamata a getCurrentTemplatePath restituisce il percorso dello script corrente, ovvero quello attualmente in esecuzione.

Entrambi i percorsi sono assoluti e contengono la directory completa + il nome del file dello script.

Per determinare solo la directory, utilizzare la funzione getDirectoryFromPath( ... ) sui risultati.

Quindi, per determinare il percorso della directory di un’applicazione, è ansible:

  

All’interno dell’evento onApplicationStart per Application.cfc


Per determinare il percorso in cui si trova il server dell’app su cui è in esecuzione il tuo motore CFML, puoi accedere ai comandi della shell con cfexecute, quindi (tenendo presente le discussioni sopra pwd / etc) puoi fare:

Unix:

  

per Windows, creare un pwd.bat contenente testo @cd , quindi:

  

(Utilizzare l’attributo variable di cfexecute per memorizzare il valore anziché l’output sullo schermo.)

In cmd (la shell della riga di comando di Microsoft)

Puoi ottenere il nome dello script con% * (potrebbe essere relativo a pwd)

Questo ottiene la directory di script:

 set oldpwd=%cd% cd %0\.. set app_dir=%pwd% cd %oldpwd% 

Se trovi qualche bug, quale lo farai. Quindi per favore aggiusta o commenta.

Ho rilasciato https://github.com/gpakosz/whereami che risolve il problema in C e ti offre:

  • il percorso dell’eseguibile corrente
  • il percorso del modulo corrente (diverso dal percorso all’eseguibile quando si chiama da una libreria condivisa).

Utilizza GetModuleFileNameW su Windows, analizza /proc/self/maps su Linux e Android e utilizza _NSGetExecutablePath o dladdr su Mac e iOS.

Giava:

Su tutti i sistemi (Windows, Linux, Mac OS X) funziona solo per me:

 public static File getApplicationDir() { URL url = ClassLoader.getSystemClassLoader().getResource("."); File applicationDir = null; try { applicationDir = new File(url.toURI()); } catch(URISyntaxException e) { applicationDir = new File(url.getPath()); } return applicationDir; } 

Nota per rispondere “20 sopra per quanto riguarda solo Mac OSX: se un eseguibile JAR viene trasformato in” app “tramite OSX JAR BUNDLER, quindi getClass (). GetProtectionDomain (). GetCodeSource (). GetLocation (); NON restituirà il directory corrente dell’app, ma aggiungerà la struttura di directory interna dell’app alla risposta Questa struttura interna di un’app è / theCurrentFolderWhereTheAppRideide / Contents / Resources / Java / yourfile

Forse questo è un piccolo bug in Java. Ad ogni modo, è necessario utilizzare il metodo uno o due per ottenere la risposta corretta ed entrambi forniranno la risposta corretta anche se l’app viene avviata, ad esempio tramite un collegamento situato in una cartella diversa o sul desktop.

carl

SoundPimp.com