Guida di LibreOffice 25.2
Il servizio String fornisce una raccolta di metodi per l'eleborazione delle stringhe. Questi metodi possono essere usati per:
Convalidare il contenuto delle stringhe
Formattare le stringhe rimuovendo spazi, giustificandole o adattando i loro contenuti
Usare le espressioni regolari per cercare e sostituire parti delle stringhe
Applicare algoritmi di hash alle stringhe, ecc.
Il servizio String riconosce i seguenti tipi di interruzione di riga:
| Nome simbolico | Numero ASCII | 
|---|---|
|              Nuova riga | 
             10  | 
Il servizio String riconosce i seguenti tipi di spazi:
| Nome simbolico | Numero ASCII | 
|---|---|
|              Spazio | 
             32  | 
Il seguente è un elenco delle sequenze di escape che potete usare nelle stringhe.
| Sequenza di escape | Nome simbolico | Numero ASCII | 
|---|---|---|
| 
             \n  |              A capo | 
             10  | 
Per fare in modo che la sequenza di escape "\n" sia interpretata alla lettera come una stringa, usate semplicemente "\\n" invece di "\" & Chr(10).
I caratteri che nel database dei caratteri Unicode sono definiti come “Altro” o “Separatore” sono considerati come caratteri non stampabili.
Anche i caratteri di controllo (codice ASCII <= 0x1F) sono considerati come non stampabili.
Per aggiungere delle virgolette all'interno delle stringhe usate \' (virgoletta) o \" (virgolette doppie). Per esempio:
La stringa [str\'i\'nga] è interpretata come [str'i'nga]
La stringa [str\"i\"nga] è interpretata come [str"i"nga]
Prima di usare il servizio ScriptForge.String è necessario caricare la libreria ScriptForge usando:
      GlobalScope.BasicLibraries.loadLibrary("ScriptForge")
  Il caricamento della libreria creerà l'oggetto SF_String che può essere usato per chiamare i metodi del servizio String.
Il seguente frammento di codice mostra i tre modi per chiamare i metodi del servizio String (il metodo Capitalize viene usato come esempio):
    Dim s as String : s = "abc def"
    s = SF_String.Capitalize(s) ' Abc Def
  
    Dim s as String : s = "abc def"
    Dim svc : svc = SF_String
    s = svc.Capitalize(s) ' Abc Def
  
    Dim s as String : s = "abc def"
    Dim svc : svc = CreateScriptService("String")
    s = svc.Capitalize(s) ' Abc Def
  Il frammento di codice seguente illustra come invocare i metodi del servizio String dagli script in Python. Il metodo IsIPv4 è usato come esempio.
    from scriptforge import CreateScriptService
    svc = CreateScriptService("String")
    ip_address = '192.168.0.14'
    svc.IsIPv4(ip_address) # True
  L'oggetto SF_String fornisce le seguenti proprietà per gli script in Basic:
| Nome | Sola lettura | Descrizione | 
|---|---|---|
| sfCR | Sì | Carattere di ritorno: Chr(13) | 
| sfCRLF | Sì | Carattere di ritorno + A capo: Chr(13) & Chr(10) | 
| sfLF | Sì | A capo: Chr(10) | 
| sfNEWLINE | Sì | Carattere di ritorno + A capo, che possono essere  | 
| sfTAB | Sì | Tabulazione orizzontale: Chr(9) | 
Potete usare le proprietà precedenti per identificare o inserire i corrispondenti caratteri all'interno delle stringhe. Per esempio, il carattere di A capo può essere sostituito da SF_String.sfLF.
Il primo argomento della maggior parte dei metodi è la stringa da prendere in considerazione. Questa viene sempre passata per riferimento e lasciata inalterata. Metodi come Capitalize, Escape, ecc., restituiscono una nuova stringa al termine dell'esecuzione.
Considerato che Python incorpora il supporto completo per le stringhe, la maggior parte dei metodi del servizio String è disponibile solamente per gli script in Basic. I metodi disponibili per Basic e Python sono: HashStr, IsADate, IsEmail, IsFileName, IsIBAN, IsIPv4, IsLike, IsSheetName, IsUrl, SplitNotQuoted e Wrap.
Rende maiuscolo il primo carattere di ogni parola della stringa di partenza.
svc.Capitalize(inputstr: str): str
inputstr: la stringa di cui rendere maiuscola l'iniziale.
    Dim sName as String : sName = "john smith"
    Dim sCapitalizedName as String
    sCapitalizedName = SF_String.Capitalize(sName)
    MsgBox sCapitalizedName 'John Smith
  Conta il numero di occorrenze di una sottostringa o di un'espressione regolare all'interno di una stringa.
svc.Count(inputstr: str, substring: str, [isregex: bool], [casesensitive: bool]): int
inputstr: la stringa inserita da esaminare
substring: la sottostringa o l'espressione regolare da usare durante la ricerca
isregex: usate True se la sottostringa è un'espressione regolare (predefinito = False)
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    'Conta le occorrenze della sottostringa "or" all'interno della stringa di partenza (restituisce 2)
    MsgBox SF_String.Count("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "or", CaseSensitive := False)
    'Conta il numero di parole con solo lettere minuscole (restituisce 7)
    MsgBox SF_String.Count("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "\b[a-z]+\b", IsRegex := True, CaseSensitive := True)
  Per saperne di più sulle espressioni regolari, fare riferimento alla documentazione di Python sulle Operazioni con le Espressioni regolari.
Restituisce True se una stringa termina con la sottostringa indicata.
La funzione restituisce False se la stringa o la sottostringa hanno una lunghezza pari a = 0, o se la sottostringa è più lunga della stringa.
svc.EndsWith(inputstr: str, substring: str, [casesensitive: bool]): bool
inputstr: la stringa da controllare.
substring: la sottostringa da cercare alla fine di inputstr.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    'Restituisce True perchè il metodo è stato chiamato con il valore predefinito di CaseSensitive = False
    MsgBox SF_String.EndsWith("abcdefg", "EFG")
    'Restituisce False a causa del parametro CaseSensitive
    MsgBox SF_String.EndsWith("abcdefg", "EFG", CaseSensitive := True)
  Converte le interruzioni di riga e le tabulazioni contenute nella stringa di partenza nella loro equivalente sequenza di escape (\\, \n, \r, \t).
svc.Escape(inputstr: str): str
inputstr: la stringa da convertire.
    'Restituisce la stringa "abc\n\tdef\\n"
    MsgBox SF_String.Escape("abc" & Chr(10) & Chr(9) & "def\n")
  Sostituisce i caratteri di tabulazione Chr(9) con caratteri di spazio in modo da replicare il comportamento degli stop del tabulatore.
Se trova un'interruzione di riga, va a capo e il contatore dei caratteri viene azzerato.
svc.ExpandTabs(inputstr: str, [tabsize: int]): str
inputstr: la stringa da espandere
tabsize: questo parametro viene usato per determinare gli stop del tabulatore usando la formula: TabSize + 1, 2 * TabSize + 1 , ... N * TabSize + 1 (predefinito = 8)
    Dim myText as String
    myText = "100" & SF_String.sfTAB & "200" & SF_String.sfTAB & "300" & SF_String.sfNEWLINE & _
             "X"  & SF_String.sfTAB & "Y" & SF_String.sfTAB & "Z"
    MsgBox SF_String.ExpandTabs(myText)
    '100     200     300
    'X       Y       Z
  Sostituisce tutti i caratteri non stampabili della stringa inserita con il carattere indicato.
svc.FilterNotPrintable(inputstr: str, [replacedby: str]): str
inputstr: la stringa in cui cercare
replacedby: zero, uno o più caratteri che sostituiranno tutti i caratteri non stampabili in inputstr (predefinito = "")
    Dim LF : LF = Chr(10)
    Dim myText as String
    myText = "àén ΣlPµ" & LF & " Русский" & "\n"
    MsgBox SF_String.FilterNotPrintable(myText)
    ' "àén ΣlPµ Русский\n"
  Trova, all'interno di una stringa, una sottostringa conforme all'espressione regolare precisata.
svc.FindRegex(inputstr: str, regex: str, [start: int], [casesensitive: bool], [forward: bool]): str
inputstr: la stringa in cui cercare
regex: l'espressione regolare
start: la posizione, all'interno della stringa, dalla quale inizierà la ricerca. Questo parametro viene passato come riferimento, perciò dopo l'esecuzione il valore di start punterà al primo carattere della sottostringa trovata. Se non viene trovata alcuna sottostringa corrispondente, start verrà impostato a 0.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
forward: determina la direzione della ricerca. Se True, la ricerca avviene in avanti. Se False la ricerca avviene all'indietro (predefinito = True)
Alla prima iterazione, se forward = True, start deve essere uguale a 1, mentre se forward = False, start deve essere uguale a Len(inputstr)
    Dim lStart As Long : lStart = 1
    Dim result as String
    result = SF_String.FindRegex("abCcdefghHij", "C.*H", lStart, CaseSensitive := True)
    MsgBox lStart & ": " & result
    '3: CcdefghH
  Nell'esempio sopra, il nuovo valore di lStart può essere usato per continuare a cercare la stessa stringa inserita, impostando il parametro Start a lStart + Len(result) all'iterazione successiva.
Le funzioni di hash sono usate in alcuni algoritmi crittografici, nelle firme digitali, nei codici di autenticazione dei messaggi, nel rilevamenti di manipolazioni, nelle "impronte digitali", nei checksum (controllo di integrità dei messaggi), nelle tabelle di hash, nella memorizzazione delle password e per molto altro ancora.
Il metodo HashStr restituisce il risultato di una funzione di hash, applicata alla stringa specificata, usando un algoritmo specifico, in formato stringa esadecimale con lettere minuscole.
Gli algoritmi di hash supportati sono: MD5, SHA1, SHA224, SHA256, SHA384 e SHA512.
svc.HashStr(inputstr: str, algorithm: str): str
inputstr: la stringa di cui calcolare l'hash. Si presume che sia codificata in UTF-8. L'algoritmo di hash considererà la stringa come un flusso di byte.
algorithm: uno degli algoritmi supportati ed elencati in precedenza, passato in formato stringa.
    MsgBox SF_String.HashStr("œ∑¡™£¢∞§¶•ªº–≠œ∑´®†¥¨ˆøπ‘åß∂ƒ©˙∆˚¬", "MD5")
    ' c740ccc2e201df4b2e2b4aa086f35d8a
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    a_string = "œ∑¡™£¢∞§¶•ªº–≠œ∑´®†¥¨ˆøπ‘åß∂ƒ©˙∆˚¬"
    hash_value = svc.HashStr(a_string, "MD5")
    bas.MsgBox(hash_value)
    # c740ccc2e201df4b2e2b4aa086f35d8a
  Codifica la stringa inserita nei codici carattere HTML, sostituendo i caratteri speciali con il loro corrispondente &.
Per esempio, il carattere é sarà sostituito con é o con un codice numerico HTML equivalente.
svc.HtmlEncode(inputstr: str): str
inputstr: la stringa da codificare
    MsgBox SF_String.HtmlEncode("<a href=""https://a.b.com"">From α to ω</a>")
    ' "<a href="https://a.b.com">From α to ω</a>"
  Restituisce True se la stringa inserita è una data valida secondo il formato data specificato.
svc.IsADate(inputstr: str, [dateformat: str]): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False
dateformat: il formato data, come stringa. Può essere uno tra "AAAA-MM-GG" (predefinito), "GG-MM-AAAA" o "MM-GG-AAAA"
Il trattino (-) può essere sostituito con un punto (.), una barra (/) o uno spazio.
Se il formato non è valido, il metodo restituisce False.
    MsgBox SF_String.IsADate("2020-12-31", "YYYY-MM-DD") ' True
  Questo metodo controlla il formato della stringa inserita senza eseguire alcun controllo specifico in base al calendario. Perciò non controlla se la stringa inserita rispetta gli anni bisestili o i mesi da 30 o 31 giorni. Per questo consultate la funzione incorporata IsDate.
L'esempio sottostante mostra la differenza tra i metodi IsADate (ScriptForge) e la funzione (incorporata) IsDate.
    Dim myDate as String : myDate = "2020-02-30"
    MsgBox SF_String.IsADate(myDate, "YYYY-MM-DD") 'True
    MsgBox IsDate(myDate) ' False
  
    svc = CreateScriptService("String")
    s_date = "2020-12-31"
    result = svc.IsADate(s_date) # True
  Restituisce True se tutti i caratteri della stringa sono alfabetici.
I caratteri alfabetici sono quei caratteri che nella documentazione Unicode Character Database sono definiti come Letter.
svc.IsAlpha(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsAlpha("àénΣlPµ") ' True
    MsgBox SF_String.IsAlpha("myVar3") ' False
  Restituisce True se tutti i caratteri della stringa sono alfabetici, numerici o "_" (trattino basso). Il primo carattere non deve essere una cifra.
svc.IsAlphaNum(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsAlphaNum("_ABC_123456_abcàénΣlPµ") ' True
    MsgBox SF_String.IsAlphaNum("123ABC") ' False
  Restituisce True se tutti i caratteri della stringa sono caratteri ASCII.
svc.IsAscii(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsAscii("a%?,25") ' True
    MsgBox SF_String.IsAscii("abcàénΣlPµ") ' False
  Restituisce True se tutti i caratteri della stringa sono cifre.
svc.IsDigit(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsDigit("123456") ' True
    MsgBox SF_String.IsDigit("_12a") ' False
  Restituisce True se la stringa è un indirizzo di posta elettronica valido.
svc.IsEmail(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsEmail("first.last@something.org") ' True
    MsgBox SF_String.IsEmail("first.last@something.com.br") ' True
    MsgBox SF_String.IsEmail("first.last@something.123") ' False
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsEmail("first.last@something.org")) # True
    bas.MsgBox(svc.IsEmail("first.last@something.com.br")) # True
    bas.MsgBox(svc.IsEmail("first.last@something.123")) # False
  Restituisce True se la stringa è un nome di file valido per il sistema operativo specificato.
svc.IsFileName(inputstr: str, [osname: str]): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
osname: il nome del sistema operativo, in formato stringa. Può essere "WINDOWS", "LINUX", "MACOSX" o "SOLARIS".
Il valore predefinito è il sistema operativo corrente nel quale lo script viene eseguito.
    MsgBox SF_String.IsFileName("/home/user/Documents/a file name.odt", "LINUX") ' True
    MsgBox SF_String.IsFileName("C:\home\a file name.odt", "LINUX") ' False
    MsgBox SF_String.IsFileName("C:\home\a file name.odt", "WINDOWS") ' True
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsFileName("/home/user/Documents/a file name.odt", "LINUX")) # True
    bas.MsgBox(svc.IsFileName(r"C:\home\a file name.odt", "LINUX")) # False
    bas.MsgBox(svc.IsFileName(r"C:\home\a file name.odt", "WINDOWS")) # True
  Restituisce True se tutti i caratteri della stringa sono cifre esadecimali.
svc.IsHexDigit(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
Le cifre esadecimali possono avere il prefisso "0x" o "&H".
    MsgBox SF_String.IsHexDigit("&H00FF") ' True
    MsgBox SF_String.IsHexDigit("08AAFF10") ' True
    MsgBox SF_String.IsHexDigit("0x18LA22") ' False
  Restituisce True se la stringa è un IBAN (International Bank Account Number) valido. Il confronto non distingue tra minuscole e maiuscole.
svc.IsIBAN(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
True se la stringa contiene un codice IBAN valido.
    ' Basic
    MsgBox SF_String.IsIBAN("BR15 0000 0000 0000 1093 2840 814 P2") ' True
  
    # Python
    result = svc.IsIBAN("BR15 0000 0000 0000 1093 2840 814 P2") # True
  Restituisce True se la stringa è un indirizzo IP(v4) valido.
svc.IsIPv4(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsIPv4("192.168.1.50") ' True
    MsgBox SF_String.IsIPv4("192.168.50") ' False
    MsgBox SF_String.IsIPv4("255.255.255.256") ' False
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsIPv4("192.168.1.50")) # True
    bas.MsgBox(svc.IsIPv4("192.168.50")) # False
    bas.MsgBox(svc.IsIPv4("255.255.255.256")) # False
  Restituisce True se l'intera stringa inserita corrisponde a un determinato schema contenente caratteri jolly.
svc.IsLike(inputstr: str, pattern: str, [casesensitive: bool]): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
pattern: lo schema in formato stringa. I caratteri jolly sono:
"?" rappresenta un singolo carattere qualsiasi;
"*" rappresenta zero, uno o più caratteri.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    MsgBox SF_String.IsLike("aAbB", "?A*") ' True
    MsgBox SF_String.IsLike("C:\a\b\c\f.odb", "?:*.*") ' True
    MsgBox SF_String.IsLike("name:host", "?*@?*") ' False
    MsgBox SF_String.IsLike("@host", "?*@?*") ' False
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsLike("aAbB", "?A*")) # True
    bas.MsgBox(svc.IsLike(r"C:\a\b\c\f.odb", "?:*.*")) # True
    bas.MsgBox(svc.IsLike("name:host", "?*@?*")) # False
    bas.MsgBox(svc.IsLike("@host", "?*@?*")) # False
  Restituisce True se tutti i caratteri della stringa sono lettere minuscole. I caratteri non alfabetici vengono ignorati.
svc.IsLower(inputstr: str): bool
InputStr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsLower("abc'(-xy4z") ' True
    MsgBox SF_String.IsLower("1234") ' True
    MsgBox SF_String.IsLower("abcDefg") ' False
  Restituisce True se tutti i caratteri della stringa sono stampabili.
svc.IsPrintable(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsPrintable("àén ΣlPµ Русский") ' True
    MsgBox SF_String.IsPrintable("First line." & Chr(10) & "Second Line.") ' False
  Restituisce True se l'intera stringa inserita corrisponde all'espressione regolare specificata.
svc.IsRegex(inputstr: str, regex: str, [casesensitive: bool]): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
regex: l'espressione regolare. Se vuota, il metodo restituisce False.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
        MsgBox SF_String.IsRegex("aAbB", "[A-Za-z]+") ' True
        MsgBox SF_String.IsRegex("John;100", "[A-Za-z]+;[0-9]+") ' True
        MsgBox SF_String.IsRegex("John;100;150", "[A-Za-z]+;[0-9]+") ' False
      Restituisce True se la stringa inserita è un nome valido di un foglio di Calc.
svc.IsSheetName(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsSheetName("1àbc + ""déf""") ' True
    MsgBox SF_String.IsSheetName("[MySheet]") ' False
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsSheetName("1àbc + ""déf""")) # True
    bas.MsgBox(svc.IsSheetName("[MySheet]")) # False
  Il nome di un foglio non deve contenere i caratteri [ ] * ? : / \ o il carattere ' (apostrofo) come primo o ultimo carattere.
Restituisce True se il primo carattere di ogni parola è maiuscolo e i restanti caratteri sono minuscoli.
svc.IsTitle(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsTitle("This Is The Title Of My Book") ' True
    MsgBox SF_String.IsTitle("This is the Title of my Book") ' False
    MsgBox SF_String.IsTitle("Result Number 100") ' True
  Restituisce True se tutti i caratteri della stringa sono maiuscoli. I caratteri non alfabetici vengono ignorati.
svc.IsUpper(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsUpper("ABC'(-XYZ") ' True
    MsgBox SF_String.IsUpper("A Title") ' False
  Restituisce True se la stringa è un indirizzo URL (Uniform Resource Locator) assoluto valido. Sono supportati solo i protocolli http, https e ftp.
svc.IsUrl(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsUrl("http://foo.bar/?q=Test%20URL-encoded%20stuff") ' True
    MsgBox SF_String.IsUrl("www.somesite.org") ' False
  
    svc = CreateScriptService("String")
    bas = CreateScriptService("Basic")
    bas.MsgBox(svc.IsUrl("http://foo.bar/?q=Test%20URL-encoded%20stuff")) # True
    bas.MsgBox(svc.IsUrl("www.somesite.org")) # False
  Restituisce True se tutti i caratteri della stringa sono spazi bianchi
svc.IsWhitespace(inputstr: str): bool
inputstr: la stringa da controllare. Se vuota, il metodo restituisce False.
    MsgBox SF_String.IsWhitespace("    ") ' True
    MsgBox SF_String.IsWhitespace(" " & Chr(9) & Chr(10)) ' True
    MsgBox SF_String.IsWhitespace("") ' False
  Restituisce la stringa inserita giustificata al centro.
Gli spazi iniziali e finali vengono rimossi e i rimanenti caratteri vengono completati a sinistra e a destra fino a una lunghezza length totale specificata con il carattere definito in padding.
svc.JustifyCenter(inputstr: str, [length: int], [padding: str]): str
inputstr: la stringa da allineare al centro. Se è vuota, il metodo restituisce una stringa vuota.
length: la lunghezza della stringa risultante (predefinito = la lunghezza della stringa inserita).
Se la lunghezza specificata è più corta della stringa inserita da allineare al centro, la stringa restituita è troncata.
padding: il singolo carattere da usare come riempimento (predefinito = lo spazio in codifica ASCII " ").
    MsgBox SF_String.JustifyCenter("Title", Length := 11) ' "   Title   "
    MsgBox SF_String.JustifyCenter("    ABCDEF", Padding := "_") ' "__ABCDEF__"
    MsgBox SF_String.JustifyCenter("A Long Title", Length := 5) ' "ong T"
  Restituisce la stringa inserita allineata a sinistra.
Gli spazi iniziali vengono rimossi e i rimanenti caratteri vengono completati a destra fino a una lunghezza length totale specificata con il carattere definito in padding.
svc.JustifyLeft(inputstr: str, [length: int], [padding: str]): str
inputstr: la stringa da allineare a sinistra. Se è vuota, il metodo restituisce una stringa vuota.
length: la lunghezza della stringa risultante (predefinito = la lunghezza della stringa inserita).
Se la lunghezza specificata è più corta della stringa inserita da allineare a sinistra, allora la stringa restituita è troncata.
padding: il singolo carattere da usare come riempimento (predefinito = lo spazio in codifica ASCII " ").
    MsgBox SF_String.JustifyLeft("Title", Length := 10) ' "Title     "
    MsgBox SF_String.JustifyLeft("    ABCDEF", Padding := "_") ' "ABCDEF____"
    MsgBox SF_String.JustifyLeft("A Long Title", Length := 5) ' "A Lon"
  Restituisce la stringa inserita allineata a destra.
Gli spazi iniziali vengono rimossi e i rimanenti caratteri vengono completati a sinistra fino a una lunghezza length totale specificata con il carattere definito in padding.
svc.JustifyRight(inputstr: str, [length: int], [padding: str]): str
inputstr: la stringa da allineare a destra. Se è vuota, il metodo restituisce una stringa vuota.
length: la lunghezza della stringa risultante (predefinito = la lunghezza della stringa inserita).
Se la lunghezza specificata è più corta della stringa inserita da allineare a destra, allora la stringa restituita è troncata.
padding: il singolo carattere da usare come riempimento (predefinito = lo spazio in codifica ASCII " ").
    MsgBox SF_String.JustifyRight("Title", Length := 10) ' "     Title"
    MsgBox SF_String.JustifyRight("  ABCDEF  ", Padding := "_") ' "____ABCDEF"
    MsgBox SF_String.JustifyRight("A Long Title", Length := 5) ' "Title"
  Restituisce la stringa inserita racchiusa tra virgolette singole o doppie. Le virgolette esistente rimangono invariate, comprese quelle iniziali e/o finali.
svc.Quote(inputstr: str, [quotechar: str]): str
inputstr: la stringa da racchiudere tra virgolette.
quotechar: una tra la virgoletta singola (') o quella doppia (") (predefinita).
    MsgBox SF_String.Quote("Text Value")
    ' "Text Value"
    MsgBox SF_String.Quote("Book Title: ""The Arabian Nights""", "'")
    ' 'Book Title: "The Arabian Nights"'
  Questo metodo può essere utile per preparare un campo stringa al fine di memorizzarlo in un tipo di file come il CSV, che richiede che i valori di testo siano racchiusi tra virgolette singole o doppie.
Sostituisce tutte le occorrenze del carattere specificato nel parametro Before con il corrispondente carattere specificato in After.
Se la lunghezza di Before è maggiore di quella di After, i caratteri residui in Before sono sostituiti con l'ultimo carattere di After.
svc.ReplaceChar(inputstr: str, before: str, after: str): str
inputstr: la stringa inserita nella quale avranno luogo le sostituzioni.
before: una stringa contenente i caratteri da cercare nella stringa inserita per la loro sostituzione.
after: una stringa contenente i nuovi caratteri che sostituiranno quelli definiti in before.
    ' Sostituisce i caratteri accentati
    MsgBox SF_String.ReplaceChar("Protégez votre vie privée", "àâãçèéêëîïôöûüýÿ", "aaaceeeeiioouuyy")
    ' "Protegez votre vie privee"
    MsgBox SF_String.ReplaceChar("Protégez votre vie privée", "àâãçèéêëîïôöûüýÿ", "")
    ' "Protgez votre vie prive"
    MsgBox SF_String.ReplaceChar("àâãçèéêëîïôöûüýÿ", "àâãçèéêëîïôöûüýÿ", "aaaceeeeiioouuyy")
    ' "aaaceeeeiioouuyy"
  Il servizio SF_String fornisce delle costanti pubbliche utili per i set di caratteri latini, come mostrato nel seguente esempio:
    MsgBox SF_String.ReplaceChar("Protégez votre vie privée", SF_String.CHARSWITHACCENT, SF_String.CHARSWITHOUTACCENT)
    ' "Protegez votre vie privee"
  Sostituisce tutte le occorrenze di un determinata espressione regolare con una nuova stringa.
svc.ReplaceRegex(inputstr: str, regex: str, newstr: str, [casesensitive: bool]): str
inputstr: la stringa inserita nella quale avranno luogo le sostituzioni.
regex: l'espressione regolare
newstr: la stringa che sostituisce la precedente.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    MsgBox SF_String.ReplaceRegex("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "[a-z]", "x", CaseSensitive := True)
    ' "Lxxxx xxxxx xxxxx xxx xxxx, xxxxxxxxxxx xxxxxxxxxx xxxx." (ogni lettera minuscola viene sostituita da una "x")
    MsgBox SF_String.ReplaceRegex("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "\b[a-z]+\b", "x", CaseSensitive := False)
    ' "x x x x x, x x x." (ogni parola viene sostituita da una "x")
  Sostituisce in una stringa alcune o tutte le occorrenze presenti in una matrice di stringhe con quelle di una matrice di nuove stringhe.
svc.ReplaceStr(inputstr: str, oldstr: str, newstr: str, [occurrences: int], [casesensitive: bool]): str
inputstr: la stringa inserita nella quale avranno luogo le sostituzioni.
oldstr: una singola stringa o una matrice di stringhe. Le stringhe di lunghezza pari a zero sono ignorate.
newstr: la stringa o la matrice di stringhe con cui effettuare le sostituzioni.
Se oldstr è una matrice, ogni occorrenza di uno degli elementi presenti in oldstr è sostituita da newstr.
Se oldstr e newstr sono matrici, le sostituzioni avvengono una per una fino al raggiungimento di UBound(newstr).
Se oldstr contiene più voci di newstr, gli elementi residui di oldstr vengono sostituiti dall'ultimo elemento di newstr.
occurrences: il numero massimo di sostituzioni. Il valore predefinito è 0, vale a dire che tutte le occorrenze saranno sostituite.
Quando oldstr è una matrice, il parametro occurrence è calcolato separatamente per ogni elemento della matrice.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    MsgBox SF_String.ReplaceStr("100 xxx 200 yyy", Array("xxx", "yyy"), Array("(1)", "(2)"), CaseSensitive := False)
    ' "100 (1) 200 (2)"
    MsgBox SF_String.ReplaceStr("abCcdefghHij", Array("c", "h"), Array("Y", "Z"), CaseSensitive := False)
    ' "abYYdefgZZij"
  Restituisce una stringa con una rappresentazione leggibile dell'argomento, troncata alla lunghezza indicata. Questa è utile principalmente per finalità di debug e di tracciamento.
Se il parametro anyvalue è un oggetto, verrà inserito tra parentesi quadre "[" e "]".
Nelle stringhe, i segni di tabulazione e le interruzioni di riga sono sostituite da \t, \n o \r.
Se la lunghezza finale eccede il parametro maxlength, l'ultima parte della stringa viene sostituita da " ... (N)" dove N è la lunghezza totale della stringa originale prima del troncamento.
svc.Represent(anyvalue: any, [maxlength: int]): str
anyvalue: il valore inserito che deve essere rappresentato. Può essere qualsiasi valore, come una stringa, una matrice, un oggetto di Basic, un oggetto UNO, ecc.
maxlength: la lunghezza massima della stringa risultante. Il valore predefinito è 0, vale a dire che non vi è alcun limite alla lunghezza della rappresentazione risultante.
    MsgBox SF_String.Represent("this is a usual string") ' "this is a usual string"
    MsgBox SF_String.Represent("this is a usual string", 15) ' "this i ... (22)"
    MsgBox SF_String.Represent("this is a" & Chr(10) & " 2-lines string") ' "this is a\n 2-lines string"
    MsgBox SF_String.Represent(Empty) ' "[EMPTY]"
    MsgBox SF_String.Represent(Null) ' "[NULL]"
    MsgBox SF_String.Represent(Pi) ' "3.142"
    MsgBox SF_String.Represent(CreateUnoService("com.sun.star.util.PathSettings")) ' "[com.sun.star.comp.framework.PathSettings]"
  Fate attenzione che la rappresentazione di tipi di dati come istanze di oggetti Matrice e dizionari ScriptForge.Dictionary comprendono sia il tipo di dati, sia i relativi valori:
    ' un esempio con una matrice incorporata di Basic
    MsgBox SF_String.Represent(Array(1, 2, "Text" & Chr(9) & "here"))
    ' "[ARRAY] (0:2) (1, 2, Text\there)"
    ' un esempio con una matrice di ScriptForge
    Dim aValues as Variant
    aValues = SF_Array.RangeInit(1, 5)
    MsgBox SF_String.Represent(aValues)
    ' "[ARRAY] (0:4) (1.0, 2.0, 3.0, 4.0, 5.0)"
    ' un esempio con un dizionario di ScriptForge
    Dim myDict As Variant : myDict = CreateScriptService("Dictionary")
    myDict.Add("A", 1) : myDict.Add("B", 2)
    MsgBox SF_String.Represent(myDict)
    ' "[Dictionary] ("A":1, "B":2)"
  Restituisce la stringa inserita in ordine inverso.
Questo metodo è equivalente alla funzione StrReverse incorporata in Basic.
Per usare la funzione StrReverse, l'istruzione OpTion VBASupport 1 deve essere presente nel modulo.
svc.Reverse(inputstr: str): str
inputstr: la stringa da invertire.
    MsgBox SF_String.Reverse("abcdefghij") ' "jihgfedcba"
  Restituisce una matrice di stringhe, con indice a partire da zero, con le righe della stringa inserita. Ogni elemento della matrice è ottenuto spezzando la stringa inserita in corrispondenza dei caratteri di interruzione di riga.
svc.SplitLines(inputstr: str, [keepbreaks: int]): str[0..*]
inputstr: la stringa da dividere.
keepbreaks: se impostato su True, le interruzioni di riga vengono mantenute nella matrice restituita (predefinito = False).
    Dim a as Variant
    a = SF_String.SplitLines("Line1" & Chr(10) & "Line2" & Chr(13) & "Line3")
    ' a = Array("Line1", "Line2", "Line3")
    a = SF_String.SplitLines("Line1" & Chr(10) & "Line2" & Chr(13) & "Line3" & Chr(10))
    ' a = Array("Line1", "Line2", "Line3", "")
    a = SF_String.SplitLines("Line1" & Chr(10) & "Line2" & Chr(13) & "Line3" & Chr(10), KeepBreaks := True)
    ' a = Array("Line1\n", "Line2\r", "Line3\n", "")
  Divide una stringa in una matrice di elementi usando uno specifico delimitatore.
Se una sottostringa racchiusa tra virgolette contiene un delimitatore, questo viene ignorato. Ciò è utile quando si elaborano record tipo CSV che contengono stringhe tra virgolette.
svc.SplitNotQuoted(inputstr: str, [delimiter: str], [occurrences: int], [quotechar: str]): str[0..*]
inputstr: la stringa da dividere.
delimiter: una stringa di uno o più caratteri che sarà usata come delimitatore. Il delimitatore predefinito è il carattere ASCII dello spazio " ".
occurrences: il numero massimo di sottostringhe da restituire. Il valore predefinito è 0, vale a dire che non c'è un limite al numero di stringhe da restituire.
quotechar: le virgolette singole (') o doppie (").
    arr1 = SF_String.SplitNotQuoted("abc def ghi")
    ' arr1 = Array("abc", "def", "ghi")
    arr2 = SF_String.SplitNotQuoted("abc,""def,ghi""", ",")
    ' arr2 = Array("abc", """def,ghi""")
    arr3 = SF_String.SplitNotQuoted("abc,""def\"",ghi""", ",")
     ' arr3 = Array("abc", """def\"",ghi""")
    arr4 = SF_String.SplitNotQuoted("abc,""def\"",ghi"""",", ",")
    ' arr4 = Array("abc", """def\"",ghi""", "")
  
    svc = CreateScriptService("String")
    arr1 = svc.SplitNotQuoted('abc def ghi')
    # arr1 = ('abc', 'def', 'ghi')
    arr2 = svc.SplitNotQuoted('abc,"def,ghi"', ",")
    # arr2 = ('abc', '"def,ghi"')
    arr3 = svc.SplitNotQuoted(r'abc,"def\",ghi"', ",")
    # arr3 = ('abc', '"def\\",ghi"')
    arr4 = svc.SplitNotQuoted(r'abc,"def\",ghi"",', ",")
    # arr4 = ('abc', '"def\\",ghi""', '')
  Fate attenzione alle differenze tra Basic e Python nella rappresentazione delle stringhe. Per esempio, in Basic due caratteri "" all'interno di una stringa sono interpretati come un singolo carattere ". In Python, le stringhe racchiuse tra virgolette singole possono contenere il carattere " senza la necessità di raddoppiarlo.
Restituisce True se i primi caratteri di una stringa sono identici alla sottostringa indicata.
Questo metodo restituisce False se una tra la stringa inserita o la sottostringa possiede una lunghezza pari a zero, oppure quando la sottostringa è più lunga della stringa inserita.
svc.StartsWith(inputstr: str, substring: str, [casesensitive: bool]): bool
inputstr: la stringa da controllare.
substring: la sottostringa da cercare all'inizio di inputstr.
casesensitive: la ricerca può distinguere o no tra minuscole e maiuscole (predefinito = False).
    MsgBox SF_String.StartsWith("abcdefg", "ABC") 'True
    MsgBox SF_String.StartsWith("abcdefg", "ABC", CaseSensitive := True) 'False
  Restituisce la stringa inserita senza gli spazi iniziali e finali.
svc.TrimExt(inputstr: str): str
inputstr: la stringa da cui rimuovere gli spazi.
    MsgBox SF_String.TrimExt(" Some text.  ") ' "Some text."
    MsgBox SF_String.TrimExt("   ABCDEF" & Chr(9) & Chr(10) & Chr(13) & " ") ' "ABCDEF"
  Converte qualsiasi sequenza di escape (\\, \n, \r, \t) presente nella stringa inserita nel corrispondente carattere ASCII.
svc.Unescape(inputstr: str): str
inputstr: la stringa da convertire.
    MsgBox SF_String.Unescape("abc\n\tdef\\n")
    ' "abc" & Chr(10) & Chr(9) & "def\n"
  Rimuove le virgolette singole o doppie che racchiudono la stringa inserita.
Questo è utile quando si elabora dei record tipo CSV che contengono stringhe tra virgolette.
svc.Unquote(inputstr: str, [quotechar: str]): str
inputstr: la stringa da cui rimuovere le virgolette.
quotechar: le virgolette singole (') o doppie (") (predefinite).
    Dim s as String
    ' s = "Testo di esempio" (senza virgolette)
    s = SF_String.Unquote("""Some text""")
    ' La stringa sottostante non è racchiusa tra virgolette, perciò rimane immutata
    ' s = "Testo di esempio" (immutato)
    s = SF_String.Unquote("Some text")
    ' Le virgolette all'interno della stringa non sono rimosse
    ' s = "Il ""vero"" significato" (immutato)
    s = SF_String.Unquote("The ""true"" meaning")
  Converte la stringa inserita in una matrice di sottostringhe, in modo che ogni elemento della matrice abbia al massimo il numero di caratteri indicato.
In pratica, questo metodo restituisce una matrice, con indice a partire da zero, di righe di output, senza caratteri di a capo alla fine, fatta eccezione delle interruzioni di riga preesistenti.
Le tabulazioni vengono espanse usando la stessa procedura eseguita dal metodo ExpandTabs.
Le interruzioni di riga simboliche sono sostituite con i rispettivi caratteri ASCII equivalenti.
Se l'output reimpaginato non ha contenuto, la matrice restituita è vuota.
svc.Wrap(inputstr: str, [width: int], [tabsize: int]): str
inputstr: la stringa da reimpaginare.
width: il numero massimo di caratteri per ciascuna riga (predefinito = 70).
tabsize: prima di reimpaginare il testo, i caratteri di tabulazione esistenti (TAB Chr(9)) vengono sostituiti con spazi. L'argomento tabsize definisce gli stop di tabulazione (TAB) nei punti TabSize + 1, 2 * TabSize + 1 , ... N * TabSize + 1 (predefinito = 8).
    a = "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit..."
    b = SF_String.Wrap(a, 20)
    ' Array("Neque porro ", "quisquam est qui ", "dolorem ipsum quia ", "dolor sit amet, ", "consectetur, ", "adipisci velit...")
  
    a = "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit..."
    b = svc.Wrap(a, 20)
    # ('Neque porro ', 'quisquam est qui ', 'dolorem ipsum quia ', 'dolor sit amet, ', 'consectetur, ', 'adipisci velit...')