Guida di LibreOffice 25.2
Il servizio FileSystem comprende routine per gestire i file e le cartelle. Di seguito sono riportati alcuni esempi delle funzionalità fornite da questo servizio:
Verifica se un file o una cartella esiste.
Crea e cancella cartelle e file.
Avvia i riquadri di dialogo per aprire/salvare file.
Accede all'elenco dei file in una cartella, ecc.
I metodi del servizio FileSystem si basano principalmente sull'interfaccia XSimpleFileAccess di UNO.
La tabella sottostante elenca i principali parametri usati dalla maggior parte dei metodi del servizio FileSystem.
| Parametro | Descrizione | 
|---|---|
| FileName | Il nome completo del file, compreso il percorso e senza il carattere di separazione delle cartelle alla fine. | 
| FolderName | Il nome completo della cartella, incluso il percorso. Può terminare con o senza il carattere di separazione delle cartelle. | 
| Name | L'ultimo componente del nome della cartella (Folder Name) o del nome del file (File Name) compresa la sua estensione. Questo parametro viene sempre espresso usando il formato nativo del sistema operativo. | 
| BaseName | L'ultimo componente del nome della cartella (Folder Name) o del nome del file (File Name) esclusa la sua estensione. | 
| NamePattern | Qualsiasi nome di cui sopra contenente dei caratteri jolly come ultimo componente. I caratteri jolly ammessi sono: 
 | 
Il servizio FileSystem permette di eseguire operazioni su più file contemporaneamente. Usando modelli di nome, gli script dell'utente possono copiare, spostare o eliminare più file. Al contrario, i metodi incorporati in Basic possono gestire solamente singoli file.
La notazione usata per esprimere i nomi dei file e delle cartelle, sia negli argomenti, sia nei valori restituiti, è definita dalla proprietà FileNaming del servizio FileSystem.
In breve, i possibili tipi di rappresentazione sono: "URL" (notazione dell'URL del file), "SYS" (notazione del sistema operativo) e "ANY" (predefinita). Per maggiori informazioni vedere la tabella seguente.
Un esempio di notazione URL è file:///C:/Documents/my_file.odt. Considerate di utilizzare la notazione URL ogni qualvolta ciò sia possibile, in quanto è un'alternativa più versatile.
L'uso della scorciatoria "~" (tilde), comune nei sistemi operativi basati su Linux, non è supportato per esprimere il percorso di una cartella e di un nome file. Invece di usare "~/Documents/my_file.odt" usate il percorso completo "/home/user/Documents/my_file.odt".
Il seguente frammento di codice invoca il servizio FileSystem. Il metodo BuildPath è stato usato come esempio.
      GlobalScope.BasicLibraries.LoadLibrary("ScriptForge")
      Dim FSO As Object
      Set FSO = CreateScriptService("FileSystem")
      FSO.BuildPath(...)
    
      from scriptforge import CreateScriptService
      fs = CreateScriptService("FileSystem")
      fs.BuildPath(...)
    I file dei documenti di LibreOffice sono dei file ZIP compressi che contengono i file e le cartelle che rappresentano i contenuti del documento vero e proprio. Mentre il documento è aperto, è possibile accedere a questo file system virtuale, esplorare la sua struttura, così come leggere e creare file e cartelle.
L'esempio seguente mostra come creare un file di testo denominato mioFile.txt e memorizzarlo all'interno del file system virtuale del documento.
    GlobalScope.BasicLibraries.LoadLibrary("ScriptForge")
    Dim oDoc As Object, fso As Object, oFile As Object
    Dim sRoot, sFile, sMyDir
    Set fso = CreateScriptService("FileSystem")
    Set oDoc = CreateScriptService("Document", ThisComponent)
    ' Ottiene l'URL in forma di percorso che punta alla radice del file system virtuale
    sRoot = oDoc.FileSystem()
    sMyDir = sRoot & "myDir"
    ' Crea la cartella "myDir" se non esiste
    If Not fso.FolderExists(sMyDir) Then
        fso.CreateFolder(sMyDir)
    End If
    ' Crea il file e scrive del testo al suo interno
    sFile = fso.BuildPath(sMyDir, "myFile.txt")
    oFile = fso.CreateTextFile(sFile)
    oFile.WriteLine("Hello!")
    oFile.CloseFile()
  
    from scriptforge import CreateScriptService
    bas = CreateScriptService("Basic")
    doc = CreateScriptService("Document", bas.ThisComponent)
    fso = CreateScriptService("FileSystem")
    sRoot = doc.FileSystem
    sMyDir = sRoot + "myDir"
    if not fso.FolderExists(sMyDir):
        fso.CreateFolder(sMyDir)
    sFile = fso.BuildPath(sMyDir, "myFile.txt")
    oFile = fso.CreateTextFile(sFile)
    oFile.WriteLine("Hello!")
    oFile.CloseFile()
  In generale, tutti i metodi del servizio FileSystem possono essere usati per manipolare i file nel file system virtuale del documento. Però, trovano applicazione le seguenti restrizioni:
Non è possibile creare file nella cartella radice. Si devono usare delle sottocartelle o creare delle nuove cartelle per memorizzare i file nel file system del documento.
La notazione FileNaming è sempre considerata come se fosse un "URL".
I metodi CompareFiles, GetFileModified, HashFile, PickFile e PickFolder non sono applicabili.
Il metodo GetFileLen restituisce sempre zero.
Il metodo Normalize restituisce sempre la stringa inserita senza modifiche.
Il percorso al file system virtuale non è un indirizzo fisico sul disco fisso del computer. È possibile accedervi solo tramite uno script di LibreOffice ed esiste solamente fino a quando il file del documento è aperto.
| Nome | Sola lettura | Tipo | Descrizione | 
|---|---|---|---|
| FileNaming | No | String | Imposta o restituisce la notazione corrente per i file e le cartelle, che sia "ANY", "URL" o "SYS": 
 Una volta impostata, la proprietà FileNaming rimane immutata fino alla fine della sessione di LibreOffice o fino a che viene reimpostata. | 
| ConfigFolder | Sì | String | Restituisce la cartella della configurazione di LibreOffice. | 
| ExtensionsFolder | Sì | String | Restituisce la cartella in cui sono installate le estensioni. | 
| HomeFolder | Sì | String | Restituisce la cartella personale dell'utente. | 
| InstallFolder | Sì | String | Restituisce la cartella in cui è installato LibreOffice. | 
| TemplatesFolder | Sì | String | Restituisce la cartella che contiene i file dei modelli di sistema. | 
| TemporaryFolder | Sì | String | Restituisce la cartella dei file temporanei definita nelle impostazioni dei percorsi di LibreOffice. | 
| UserTemplatesFolder | Sì | String | Restituisce la cartella contenente i file dei modelli definiti dall'utente. | 
Unisce il percorso di una cartella al nome di un file e restituisce il nome del file completo usando un carattere di separazione delle cartelle valido. Il carattere di separazione delle cartelle è aggiunto solo se necessario.
svc.BuildPath(foldername: str, name: str): str
foldername: il percorso con cui verrà combinato il nome del file (name). Non è necessario che il percorso specificato sia quello di una cartella esistente.
name: il nome del file da aggiungere al percorso foldername. Questo parametro usa la notazione del sistema operativo corrente.
      Dim FSO as Object
      Set FSO = CreateScriptService("FileSystem")
      Dim aFileName as String
      FSO.FileNaming = "URL"
      aFileName = FSO.BuildPath("file:///home/user", "sample file.odt")
      ' file:///home/user/sample%20file.odt
    
      fs = CreateScriptService("FileSystem")
      fs.FileNaming = "URL"
      aFileName = fs.BuildPath("file:///home/user", "sample file.odt")
      # file:///home/user/sample%20file.odt
    Confronta due file e restituisce True se sembrano identici.
A seconda del valore dell'argomento comparecontents, il confronto tra i file può essere basato solo sui rispettivi attributi (come la data dell'ultima modifica), o anche sul loro contenuto.
svc.CompareFiles(filename1: str, filename2: str, comparecontents: bool = False): bool
filename1, filename2: i file da confrontare.
comparecontents: se impostato su True, viene confrontato il contenuto dei file (predefinito = False).
      FSO.FileNaming = "SYS"
      If FSO.CompareFiles("C:\myFile1.txt", "C:\myFile2.txt", CompareContents := False) Then
          ' ...
      End If
    
      fs.FileNaming = "SYS"
      if fs.CompareFiles(r"C:\myFile1.txt", r"C:\myFile2.txt", comparecontents = False):
          # ...
    Copia uno o più file da una posizione a un'altra. Restituisce True se almeno un file è stato copiato o False se si è verificato un errore.
Si verifica un errore anche quando il parametro source fa uso di caratteri jolly e non individua alcun file.
Il metodo si interrompe immediatamente dopo aver incontrato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche fatte prima di incontrare l'errore.
svc.CopyFile(source: str, destination: str, overwrite: bool = True): bool
source: può essere un FileName o un NamePattern che indica uno o più file da copiare.
destination: può essere sia un FileName che specifica dove debba essere copiato il singolo file source, sia il nome di una cartella (FolderName) in cui copiare i diversi file indicati in source.
Se la cartella (destination) non esiste viene creata.
I caratteri jolly non sono permessi nella destinazione (destination).
overwrite: se è True (predefinito), i file possono essere sovrascritti. Il metodo fallisce se la destinazione (destination) è di sola lettura, indipendentemente dal valore specificato in overwrite.
Negli esempi sottostanti la prima riga copia un singolo file, mentre la seconda riga copia più file usando dei caratteri jolly.
      FSO.CopyFile("C:\Documents\my_file.odt", "C:\Temp\copied_file.odt")
      FSO.CopyFile("C:\Documents\*.*", "C:\Temp\", Overwrite := False)
    
      fs.CopyFile(r"C:\Documents\my_file.odt", r"C:\Temp\copied_file.odt")
      fs.CopyFile(r"C:\Documents\*.*", r"C:\Temp", overwrite = False)
    È bene notare che utilizzando i caratteri jolly all'interno dell'argomento source le sottocartelle e i loro contenuti non vengono copiati.
Copia una o più cartelle da una posizione a un'altra. Restituisce True se almeno una cartella è stata copiata o False se si è verificato un errore.
Si verifica un errore anche se il parametro source usa dei caratteri jolly e non individua alcuna cartella.
Il metodo si interrompe immediatamente dopo aver incontrato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche effettuate prima di incontrare l'errore.
svc.CopyFolder(source: str, destination: str, overwrite: bool = True): bool
source: può essere il nome di una cartella (FolderName) o un NamePattern che individua una o più cartelle da copiare.
destination: specifica il nome della cartella (FolderName) in cui copiare una o più cartelle definite in source.
Se la cartella (destination) non esiste viene creata.
I caratteri jolly non sono permessi nella destinazione (destination).
overwrite: se è True (predefinito), i file possono essere sovrascritti. Il metodo fallisce se la destinazione (destination) è di sola lettura, indipendentemente dal valore specificato in overwrite.
Negli esempi sottostanti tutti i file, cartelle e sottocartelle vengono copiati.
      ' Basic
      FSO.CopyFolder("C:\Documents\*", "C:\Temp\", Overwrite := False)
    
      # Python
      fs.CopyFolder(r"C:\Documents\*", r"C:\Temp", overwrite = False)
    Crea la cartella specificata in FolderName. Restituisce True se la cartella può essere creata correttamente.
Se la cartella specificata ha una cartella genitore che non esiste, questa viene creata.
svc.CreateFolder(foldername: str): bool
foldername: una stringa che rappresenta la cartella da creare. Se la cartella esiste già, si genera un'eccezione.
      ' Basic
      FSO.CreateFolder("C:\NewFolder")
    
      # Python
      fs.CreateFolder(r"C:\NewFolder")
    Crea il file specificato e restituisce un'istanza del servizio TextStream, che può essere usata per scrivere nel file.
Il metodo restituisce un oggetto Null se si verifica un errore.
svc.CreateTextFile(filename: str, overwrite: bool = True, encoding: str = 'UTF-8'): svc
filename: il nome del file da creare.
overwrite: un valore booleano che determina se il file filename può essere sovrascritto (predefinito = True).
encoding: il set di caratteri da usare. La codifica predefinita è "UTF-8".
      Dim myFile As Object
      FSO.FileNaming = "SYS"
      Set myFile = FSO.CreateTextFile("C:\Temp\ThisFile.txt", Overwrite := True)
    
      fs.FileNaming = "SYS"
      myFile = fs.CreateTextFile(r"C:\Temp\ThisFile.txt", overwrite = True)
    Per saperne di più in merito ai nomi delle codifiche dei caratteri, visitare la pagina Codifiche dei caratteri IANA. È bene notare che LibreOffice non implementa tutte le codifiche dei caratteri esistenti.
Elimina uno o più file. Restituisce True se almeno un file è stato eliminato o False se si verifica un errore.
Si verifica un errore anche quando il parametro filename utilizza caratteri jolly e non corrisponde ad alcun file.
I file da eliminare non devono essere di sola lettura.
Il metodo si interrompe immediatamente dopo aver rilevato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche effettuate prima della comparsa dell'errore.
svc.DeleteFile(filename: str): bool
filename: può essere il nome di un file (FileName) o un NamePattern che indica uno o più file da eliminare.
Negli esempi sottostanti vengono eliminati solo i file, le sottocartelle non vengono cancellate.
      ' Basic
      FSO.DeleteFile("C:\Temp\*.docx")
    
      # Python
      fs.DeleteFile(r"C:\Temp\*.docx")
    Elimina una o più cartelle. Restituisce True se almeno una cartella è stata eliminata o False se si verifica un errore.
Si verifica un errore anche quando il parametro foldername fa uso di caratteri jolly e non individua alcuna cartella.
Le cartelle da eliminare non devono essere di sola lettura.
Il metodo si interrompe immediatamente dopo aver rilevato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche effettuate prima della comparsa dell'errore.
svc.DeleteFolder(foldername: str): bool
foldername: può essere il nome di una cartella (FolderName) o un NamePattern che indica una o più cartelle da eliminare.
Negli esempi sottostanti sono eliminate solo le cartelle e i loro contenuti. I file nella cartella di origine "C:\Temp" non vengono eliminati.
      ' Basic
      FSO.DeleteFolder("C:\Temp\*")
    
      # Python
      fs.DeleteFolder(r"C:\Temp\*")
    Restituisce una stringa contenente la cartella in cui è installato il pacchetto dell'estensione specificata.
Il valore corrente della proprietà SF_FileSystem.FileNaming è usato per determinare la notazione usata dalla stringa restituita.
Usare la proprietà Extensions del servizio Platform per ottenere una matrice di stringhe con gli ID di tutte le estensioni installate.
svc.ExtensionFolder(extension: str): str
extension: una stringa con il valore dell'ID dell'estensione. Se l'estensione non è installata, viene sollevata un'eccezione.
Gli esempi seguenti in Basic e Python restituiscono la cartella in cui è installata l'estensione APSO.
      ' Basic
      sFolder = FSO.ExtensionFolder("apso.python.script.organizer")
      ' file:///home/username/.config/libreoffice/4/user/uno_packages/cache/uno_packages/lu10833wz3u2i.tmp_/apso_1_2_7.oxt
    
      # Python
      sFolder = fs.ExtensionFolder("apso.python.script.organizer")
    Restituisce True se un determinato nome di file è valido ed esistente, altrimenti il metodo restituisce False.
Se il parametro filename è in realtà il nome di una cartella, il metodo restituisce False.
svc.FileExists(filename: str): bool
filename: una stringa che rappresenta il file da verificare.
      FSO.FileNaming = "SYS"
      If FSO.FileExists("C:\Documents\my_file.odt") Then
          '...
      End If
    
      fs.FileNaming = "SYS"
      if fs.FileExists(r"C:\Documents\my_file.odt"):
          # ...
    Restituisce una matrice, con indice a partire da zero, dei file memorizzati in una determinata cartella. Ogni voce della matrice è una stringa che comprende l'intero percorso e il nome del file.
Se l'argomento foldername specifica una cartella che non esiste, si genera un'eccezione.
L'elenco risultante può essere filtrato usando dei caratteri jolly.
svc.Files(foldername: str, filter: str = '', includesubfolders: bool = False): str[0..*]
foldername: una stringa che rappresenta una cartella. La cartella deve esistere. Questo argomento non deve indicare un file.
filter: una stringa contenente caratteri jolly ("?" e "*") da applicare all'elenco di file risultante (predefinito = "").
includesubfolders: impostare questo documento su True per comprendere i contenuti delle sottocartelle (predefinito = False).
      Dim filesList As Variant, file As String
      FSO.FileNaming = "SYS"
      ' Restituisce tutti i file che rispettano il filtro "*.txt", compresi i file nelle sottocartelle
      filesList = FSO.Files("/home/user/", "*.txt", IncludeSubfolders := True)
      For Each file In filesList
          ' ...
      Next file
    
      fs.FileNaming = "SYS"
      filesList = fs.Files("/home/user/", "*.txt", includesubfolders = True)
      for file in fileList:
          # ...
    Restituisce True se la cartella specificata in FolderName è valida ed esistente, altrimenti il metodo restituisce False.
Se il parametro foldername corrisponde effettivamente al nome di un file esistente, il metodo restituisce False.
svc.FolderExists(foldername: str): bool
foldername: una stringa che rappresenta la cartella da verificare.
      FSO.FileNaming = "SYS"
      If FSO.FolderExists("C:\Documents\Thesis") Then
          '...
      End If
    
      fs.FileNaming = "SYS"
      if fs.FolderExists(r"C:\Documents\Thesis")
          # ...
    Restituisce il parametro BaseName (corrispondente all'ultimo componente) del nome di una cartella o di un file, senza estensione.
Il metodo non controlla se il file o la cartella specificata esiste.
svc.GetBaseName(filename: str): str
filename: una stringa che rappresenta il nome del file e il suo percorso.
Negli esempi sottostanti, la prima chiamata al metodo GetBaseName corrisponde a una cartella, quindi la funzione restituisce l'ultimo elemento del percorso. La seconda chiamata riceve come input il nome di un file, perciò viene restituito il nome del file senza la sua estensione.
      MsgBox FSO.GetBaseName("/home/user/Documents") ' "Documents"
      MsgBox FSO.GetBaseName("/home/user/Documents/my_file.ods") ' "my_file"
    
      bas = CreateScriptService("Basic")
      bas.MsgBox(fs.GetBaseName("/home/user/Documents")) # "Documents"
      bas.MsgBox(fs.GetBaseName("/home/user/Documents/my_file.ods")) # "my_file"
    Restituisce la parte relativa all'estensione dal nome di un file o di una cartella, senza il carattere del punto ".".
Il metodo non controlla l'esistenza del file o della cartella indicata.
Se questo metodo viene applicato al nome di una cartella o ad un file privo di estensione verrà restituita una stringa vuota.
svc.GetExtension(filename: str): str
filename: una stringa che rappresenta il nome del file e il suo percorso.
      ' Basic
      ext = FSO.GetExtension("C:\Windows\Notepad.exe")  ' "exe"
    
      # Python
      ext = fs.GetExtension(r"C:\Windows\Notepad.exe")  # "exe"
    La funzione FileLen incorporata in Basic restituisce il numero di byte contenuti in un file come valore di tipo Long, cioè fino a 2GB.
Il metodo GetFileLen può gestire file di dimensioni molto più grandi restituendo un valore di tipo Currency.
svc.GetFileLen(filename: str): num
filename: una stringa che rappresenta un file esistente.
      Dim fLen As Currency
      FSO.FileNaming = "SYS"
      fLen = FSO.GetFileLen("C:\pagefile.sys")
    
      fs.FileNaming = "SYS"
      fLen = fs.GetFileLen(r"C:\pagefile.sys")
    Restituisce la data dell'ultima modifica ad un determinato file.
svc.GetFileModified(filename: str): datetime
filename: una stringa che rappresenta un file esistente.
      Dim aDate As Date
      FSO.FileNaming = "SYS"
      aDate = FSO.GetFileModified("C:\Documents\my_file.odt")
    
      fs.FileNaming = "SYS"
      aDate = FSO.GetFileModified(r"C:\Documents\my_file.odt")
    Restituisce l'ultimo componente del nome di un file o di una cartella nel formato nativo del sistema operativo.
Il metodo non controlla se il file o la cartella specificata esiste.
svc.GetName(filename: str): str
filename: una stringa che rappresenta il nome del file e il suo percorso.
      ' Basic
      a = FSO.GetName("C:\Windows\Notepad.exe")  ' Notepad.exe
    
      # Python
      a = fs.GetName(r"C:\Windows\Notepad.exe")  # Notepad.exe
    Restituisce una stringa contenente il nome della cartella padre di un file o di una cartella specificata.
Il metodo non controlla se il file o la cartella specificata esiste.
svc.GetParentFolderName(filename: str): str
filename: una stringa con il nome del file o della cartella da analizzare.
      ' Basic
      a = FSO.GetParentFolderName("C:\Windows\Notepad.exe")  ' C:\Windows\
    
      # Python
      a = fs.GetParentFolderName(r"C:\Windows\Notepad.exe")  # C:\Windows\
    Restituisce un nome di file temporaneo generato in modo casuale e utile per eseguire operazioni che richiedono un file temporaneo.
Per impostazione predefinita, i nomi dei file restituiti non hanno un'estensione. Usare il parametro extension per specificare l'estensione del nome del file da generare.
Nella stringa restituita, la parte relativa alla cartella è la cartella temporanea del sistema.
Il metodo non crea il file temporaneo.
svc.GetTempName(extension: str): str
extension: l'estensione del nome del file temporaneo (predefinita = "").
      Dim fName As String
      FSO.FileNaming = "SYS"
      fName = FSO.GetTempName(Extension := "txt")
      ' "/tmp/SF_574068.txt"
    
      fs.FileNaming = "SYS"
      fName = FSO.GetTempName(extension = "txt")
      # "/tmp/SF_574068.txt"
    Le funzioni di hash sono usate da alcuni algoritmi crittografici, nelle firme digitali, nei codici di autenticazione dei messaggi, nel rilevamento delle frodi, nelle impronte digitali, nei checksum (controllo di integrità dei messaggi), nelle tabelle di hash, nell'archiviazione delle password e molto altro.
Il metodo HashFile restituisce il risultato di una funzione di hash applicata a un determinato file usando un algoritmo specificato. Il valore restituito è una stringa di cifre esadecimali con le lettere in minuscolo.
Gli algoritmi di hash supportati sono: MD5, SHA1, SHA224, SHA256, SHA384 e SHA512.
svc.HashFile(filename: str, algorithm: str): str
filename: una stringa che rappresenta un file esistente.
algorithm: uno degli algoritmi supportati.
      ' Basic
      sHash = FSO.HashFile("C:\pagefile.sys", "MD5")
    
      # Python
      sHash = FSO.HashFile(r"C:\pagefile.sys", "MD5")
    Sposta uno o più file da una posizione ad un'altra. Restituisce True se almeno un file è stato spostato o False se si verifica un errore.
Si verifica un errore anche quando il parametro source fa uso di caratteri jolly e non individua alcun file.
Il metodo si interrompe immediatamente dopo aver rilevato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche effettuate prima della comparsa dell'errore.
svc.MoveFile(source: str, destination: str): bool
source: può essere un nome di file (FileName) o un NamePattern che individua uno o più file da spostare.
destination: se source è un nome di file (FileName), allora questo parametro indica il nuovo percorso e il nome del file spostato.
Se l'operazione di spostamento coinvolge più file, allora destination deve essere il nome di una cartella. Se la cartella non esiste, verrà creata.
Se source e destination condividono la stessa cartella di origine, il metodo rinominerà source.
I caratteri jolly non sono permessi nella destinazione (destination).
Negli esempi seguenti vengono spostati solo i file, non le sottocartelle.
      ' Basic
      FSO.MoveFile("C:\Temp1\*.*", "C:\Temp2")
    
      # Python
      fs.MoveFile(r"C:\Temp1\*.*", r"C:\Temp2")
    Sposta una o più cartelle da una posizione ad un'altra. Restituisce True se almeno una cartella è stata spostata o False se si verifica un errore.
Si verifica un errore anche se il parametro source usa dei caratteri jolly e non individua alcuna cartella.
Il metodo si interrompe immediatamente dopo aver rilevato un errore. Il metodo non ritorna al punto di partenza e non annulla le modifiche effettuate prima della comparsa dell'errore.
svc.MoveFolder(source: str, destination: str): bool
source: può essere il nome di una cartella (FolderName) o un NamePattern che individua una o più cartelle da spostare.
destination: se l'operazione di spostamento riguarda una singola cartella, allora destination è il nome e il percorso del file spostato e non deve essere già esistente.
Se si spostano più cartelle, allora destination indica la posizione dove saranno spostate le cartelle presenti in source. Se la cartella destination non esiste, verrà creata.
I caratteri jolly non sono permessi nella destinazione (destination).
      ' Basic
      FSO.MoveFolder("C:\Temp1\*", "C:\Temp2")
    
      # Python
      fs.MoveFolder(r"C:\Temp1\*", r"C:\Temp2")
    Restituisce una stringa contenente il nome percorso normalizzato rimuovendo i separatori ridondanti e i riferimenti ai livelli superiore.
Per esempio, i nomi dei percorsi A//B, A/B/, A/./B e A/foo/../B sono tutti normalizzati in A/B.
In Windows, le barre "/" sono convertite in barre inverse "\" (backslash).
Il valore corrente della proprietà SF_FileSystem.FileNaming è usato per determinare la notazione dell'argomento filename così come il formato della stringa restituita.
svc.Normalize(filename: str): str
filename: una stringa rappresentante un nome valido di percorso. Il file o la cartella rappresentata da questo argomento può non esistere.
    FSO.FileNaming = "URL"
    ' file:///home/user/Documents
    normPath = FSO.Normalize("file:///home/user/Documents/")
    ' file:///home/user/Documents
    normPath = FSO.Normalize("file:///home//user//Documents/")
    ' file:///home/user
    normPath = FSO.Normalize("file:///home//user//Documents/../")
  
    fs.FileNaming = "URL"
    normPath = fs.Normalize("file:///home/user/Documents/")
    normPath = fs.Normalize("file:///home//user//Documents/")
    normPath = fs.Normalize("file:///home//user//Documents/../")
  Apre un file e restituisce un oggetto TextStream che può essere usato per leggere, scrivere o apportare aggiunte al file.
Fate attenzione che il metodo non controlla se il file indicato è effettivamente un file di testo.
Quando si verifica un errore, il metodo restituisce un oggetto Null (in Basic) o None (in Python).
svc.OpenTextFile(filename: str, iomode: int = 1, create: bool = False, encoding: str = 'UTF-8'): svc
filename: identifica il file da aprire.
iomode: indica la modalità di input/output. Può essere una delle tre costanti: svc.ForReading (predefinita), svc.ForWriting o svc.ForAppending.
create - valore logico (booleano) che indica se può essere creato un nuovo file nel caso in cui il nome del file (filename) specificato non esista:
se è True sarà creato un nuovo file e se non esistono saranno create anche le cartelle che lo contengono;
se è False non saranno creati nuovi file (predefinito).
encoding: il set di caratteri da usare. La codifica predefinita è "UTF-8".
      Dim myFile As Object
      FSO.FileNaming = "SYS"
      Set myFile = FSO.OpenTextFile("C:\Temp\ThisFile.txt", FSO.ForReading)
      If Not IsNull(myFile) Then
          ' ...
      End If
    
      fs.FileNaming = "SYS"
      myFile = fs.OpenTextFile(r"C:\Temp\ThisFile.txt", fs.ForReading)
      if myFile is not None:
          # ...
    Apre una finestra di dialogo per aprire o salvare file.
Se è impostata la modalità SAVE e il file selezionato esiste, sarà visualizzato un messaggio di avvertimento.
svc.PickFile(defaultfile: str ='', mode: str = 'OPEN', filter: str = ''): str
defaultfile - questo argomento è una stringa composta dal nome di una cartella e di un file:
la parte della cartella indica quella che sarà visualizzata all'apertura della finestra di dialogo (predefinita = l'ultima cartella selezionata);
la parte del file designa il file predefinito da aprire o salvare.
mode: un valore in formato stringa che può essere "OPEN" (per i file di input) o "SAVE" (per i file di output). Il valore predefinito è "OPEN".
filter: l'estensione dei file visualizzati nella finestra di dialogo quando è aperta (predefinito = nessun filtro).
Gli esempi sottostanti aprono una finestra per l'apertura dei file con il filtro "txt" applicato.
      ' Basic
      aFile = FSO.PickFile("C:\Documents", "OPEN", "txt")
    
      # Python
      aFile = fs.PickFile(r"C:\Documents", "OPEN", "txt")
    Apre un riquadro di dialogo per selezionare una cartella.
svc.PickFolder(defaultfolder: str = '', freetext: str = ''): str
defaultfolder: una stringa che contiene il nome della cartella che sarà visualizzata all'apertura della finestra di dialogo (predefinita = l'ultima cartella selezionata).
freetext: il testo da visualizzare nella finestra di dialogo (predefinito = "").
      ' Basic
      aFolder = FSO.PickFolder("C:\Documenti", "Seleziona una cartella o premi Annulla")
    
      # Python
      aFolder = fs.PickFolder(r"C:\Documenti", "Seleziona una cartella o premi Annulla")
    Restituisce una matrice con indice a partire da zero corrispondente alle cartelle memorizzate in una determinata cartella (foldername).
L'elenco può essere filtrato con i caratteri jolly.
svc.SubFolders(foldername: str, filter: str = '', includesubfolders: bool = False): str[0..*]
foldername: una stringa che rappresenta una cartella. La cartella deve esistere. foldername non deve indicare un file.
filter: una stringa contenente i caratteri jolly ("?" e "*") che sarà applicata all'elenco di cartelle risultante (predefinito = "").
includesubfolders: impostare questo documento su True per comprendere i contenuti delle sottocartelle (predefinito = False).
      Dim folderList As Variant, folder As String
      FSO.FileNaming = "SYS"
      folderList = FSO.SubFolders("/home/user/")
      For Each folder In folderList
          ' ...
      Next folder
    
      fs.FileNaming = "SYS"
      folderList = fs.SubFolders("/home/user/")
      for folder in folderList:
          # ...