Dienst ScriptForge.String

Der Dienst String stellt eine Sammlung von Methoden zur Verarbeitung von Zeichenfolgen bereit. Diese Methoden können verwendet werden, um:

• Überprüfen des Inhalts von Zeichenfolgen

• Formatieren von Zeichenfolgen, indem Sie ihren Inhalt kürzen, ausrichten oder umbrechen

• Verwenden Sie reguläre Ausdrücke, um Teilzeichenfolgen zu suchen und zu ersetzen

• Anwenden von Hash-Algorithmen auf Zeichenfolgen, …

Definitionen

Zeilenumbrüche

Der Dienst String erkennt die folgenden Zeilenumbrüche:

Leerzeichen

Der Dienst String erkennt die folgenden Leerzeichen:

Escape-Sequenzen

Nachfolgend finden Sie eine Liste von Escape-Sequenzen, die in Zeichenfolgen verwendet werden können.

Um die Escape-Sequenz "\n" als tatsächliche Zeichenfolge interpretieren zu lassen, verwenden Sie einfach "\\n" anstelle von "\" & Chr(10).

Nicht druckbare Zeichen:

Zeichen, die in der Unicode-Zeichendatenbank als „Andere“ oder „Trennzeichen“ definiert sind, gelten als nicht druckbare Zeichen.

Steuerzeichen (ASCII-Code <= 0x1F) gelten ebenfalls als nicht druckbar.

Anführungszeichen innerhalb von Zeichenfolgen:

Um Anführungszeichen in Zeichenfolgen einzufügen, verwenden Sie \' (einfaches Anführungszeichen) oder \" (doppeltes Anführungszeichen). Beispielsweise:

• Die Zeichenfolge [Ze\'i\'chenfolge] wird als [Ze'i'chenfolge] interpretiert

• Die Zeichenfolge [Ze\"i\"chenfolge] wird als [Ze"i"chenfolge] interpretiert

Dienstaufruf

Vor der Verwendung des Dienstes ScriptForge.String muss die Bibliothek ScriptForge geladen werden mit:

      GlobalScope.BasicLibraries.loadLibrary("ScriptForge")
  

Durch das Laden der Bibliothek wird das Objekt SF_String erstellt, das verwendet werden kann, um die Methoden im Dienst String aufzurufen.

Die folgenden Codeschnipsel zeigen die drei Möglichkeiten zum Aufrufen von Methoden aus dem Dienst String (die Methode Capitalize wird als Beispiel verwendet):

    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
  

Der folgende Codeschnipsel veranschaulicht, wie Methoden aus dem Dienst String in Python-Skripten aufgerufen werden. Als Beispiel wird die Methode IsIPv4 verwendet.

    from scriptforge import CreateScriptService
    svc = CreateScriptService("String")
    ip_address = '192.168.0.14'
    svc.IsIPv4(ip_address) # True
  

Eigenschaften

Das Objekt SF_String stellt die folgenden Eigenschaften für Basic-Skripte bereit:

Sie können die obigen Eigenschaften verwenden, um die entsprechenden Zeichen in Zeichenfolgen zu identifizieren oder einzufügen. Beispielsweise kann der Zeilenvorschub mittels SF_String.sfLF ersetzt werden.

Das erste Argument der meisten Methoden ist die zu berücksichtigende Zeichenfolge. Sie wird immer als Referenz übergeben und unverändert gelassen. Methoden wie Capitalize, Escape und so weiter geben nach ihrer Ausführung eine neue Zeichenfolge zurück.

Da Python über eine umfassende integrierte Zeichenfolgenunterstützung verfügt, sind die meisten Methoden im Dienst String nur für Basic-Skripte verfügbar. Die für Basic und Python verfügbaren Methoden sind: HashStr, IsADate, IsEmail, IsFileName, IsIBAN, IsIPv4, IsLike, IsSheetName, IsUrl, SplitNotQuoted und Wrap.

Capitalize

Schreibt das erste Zeichen jedes Wortes in der Eingabezeichenfolge groß.

svc.Capitalize(inputstr: str): str

inputstr: Die Zeichenfolge, die groß geschrieben werden soll.

    Dim sName as String : sName = "john smith"
    Dim sCapitalizedName as String
    sCapitalizedName = SF_String.Capitalize(sName)
    MsgBox sCapitalizedName 'John Smith
  

Count

Zählt die Anzahl der Vorkommen einer Teilzeichenfolge oder eines regulären Ausdrucks innerhalb einer Zeichenfolge.

svc.Count(inputstr: str, substring: str, [isregex: bool], [casesensitive: bool]): int

inputstr: Die zu untersuchende Eingabezeichenfolge

substring: Die Teilzeichenfolge oder der reguläre Ausdruck, die/der während der Suche verwendet werden soll

isregex: Verwenden Sie True, wenn die Teilzeichenfolge ein regulärer Ausdruck ist (Standard = False)

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = False).

    ' Zählt die Vorkommen der Teilzeichenfolge "or" innerhalb der Eingabezeichenfolge (gibt 2 zurück)
    MsgBox SF_String.Count("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "or", CaseSensitive := False)
    ' Zählt die Anzahl der Wörter mit nur Kleinbuchstaben (gibt 7 zurück)
    MsgBox SF_String.Count("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "\b[a-z]+\b", IsRegex := True, CaseSensitive := True)
  

Weitere Informationen zu regulären Ausdrücken finden Sie in der Python-Dokumentation unter Regular Expression Operations .

EndsWith

Gibt True zurück, wenn eine Zeichenfolge mit einer angegebenen Teilzeichenfolge endet.

Die Funktion gibt False zurück, wenn entweder die Zeichenfolge oder die Teilzeichenfolge eine Länge = 0 haben oder wenn die Teilzeichenfolge länger als die Zeichenfolge ist.

svc.EndsWith(inputstr: str, substring: str, [casesensitive: bool]): bool

inputstr: Die zu testende Zeichenfolge.

substring: Die zu durchsuchende Teilzeichenfolge am Ende von inputstr.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = False).

    ' Gibt "True" zurück, weil die Methode mit dem Standard "CaseSensitive = False" aufgerufen wurde
    MsgBox SF_String.EndsWith("abcdefg", "EFG")
    ' Gibt aufgrund des Parameters "CaseSensitive" "False" zurück
    MsgBox SF_String.EndsWith("abcdefg", "EFG", CaseSensitive := True)
  

Escape

Konvertiert Zeilenumbrüche und Tabulatoren, die in der Eingabezeichenfolge enthalten sind, in ihre entsprechende Escape-Sequenz (\\, \n, \r, \t).

svc.Escape(inputstr: str): str

inputstr: Die zu konvertierende Zeichenfolge.

    ' Gibt die Zeichenfolge "abc\n\tdef\\n" zurück
    MsgBox SF_String.Escape("abc" & Chr(10) & Chr(9) & "def\n")
  

ExpandTabs

Ersetzt Tabulatoren Chr(9) durch Leerzeichen, um das Verhalten von Tabulatoren zu replizieren.

Wird ein Zeilenumbruch gefunden, wird eine neue Zeile begonnen und der Zeichenzähler zurückgesetzt.

svc.ExpandTabs(inputstr: str, [tabsize: int]): str

inputstr: Die zu erweiternde Zeichenfolge

tabsize: Mit diesem Parameter werden die Tabulatoren bestimmt nach der Formel: TabSize + 1, 2 * TabSize + 1 , … N * TabSize + 1 (Standard = 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
  

FilterNotPrintable

Ersetzt alle nicht druckbaren Zeichen in der Eingabezeichenfolge durch ein vorgegebenes Zeichen.

svc.FilterNotPrintable(inputstr: str, [replacedby: str]): str

inputstr: Die zu durchsuchende Zeichenfolge

replacedby: Null, ein oder mehrere Zeichen, die alle nicht druckbaren Zeichen in inputstr ersetzen (Standard = "")

    Dim LF : LF = Chr(10)
    Dim myText as String
    myText = "àén ΣlPµ" & LF & " Русский" & "\n"
    MsgBox SF_String.FilterNotPrintable(myText)
    ' "àén ΣlPµ Русский\n"
  

FindRegex

Findet in einer Zeichenfolge eine Teilzeichenfolge, die mit einem vorgegebenen regulären Ausdruck übereinstimmt.

svc.FindRegex(inputstr: str, regex: str, [start: int], [casesensitive: bool], [forward: bool]): str

inputstr: Die zu durchsuchende Zeichenfolge

regex: Der reguläre Ausdruck

start: Die Position in der Zeichenfolge, an der die Suche beginnt. Dieser Parameter wird als Referenz übergeben, sodass nach der Ausführung der Wert von start auf das erste Zeichen der gefundenen Teilzeichenfolge zeigt. Wenn keine passende Teilzeichenfolge gefunden wird, wird start auf 0 gesetzt.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = False).

forward: Bestimmt die Suchrichtung. Wenn True, geht die Suche vorwärts. Wenn False, geht die Suche rückwärts (Standard = True)

Bei der ersten Wiederholung, wenn forward = True, sollte start gleich 1 sein, wohingegen, wenn forward = False ist, sollte start gleich Len(inputstr) sein.

    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
  

Im obigen Beispiel kann der neue Wert von lStart verwendet werden, um weiterhin dieselbe Eingabezeichenfolge zu suchen, indem der Parameter Start bei der nächsten Wiederholung auf lStart + Len(result) gesetzt wird.

HashStr

Hash-Funktionen werden in einigen kryptografischen Algorithmen, in digitalen Signaturen, Nachrichtenauthentifizierungscodes, Manipulationserkennung, Fingerabdrücken, Prüfsummen (Nachrichtenintegritätsprüfung), Hash-Tabellen, Kennwortspeicherung und vielem mehr verwendet.

Die Methode HashStr gibt das Ergebnis einer Hash-Funktion, die auf eine gegebene Zeichenfolge angewendet wird und einen angegebenen Algorithmus verwendet, als eine Zeichenfolge aus hexadezimalen Ziffern in Kleinbuchstaben zurück.

Die unterstützten Hash-Algorithmen sind: MD5, SHA1, SHA224, SHA256, SHA384 und SHA512.

svc.HashStr(inputstr: str, algorithm: str): str

inputstr: Die zu hashende Zeichenfolge. Es wird angenommen, dass es in UTF-8 codiert ist. Der Hash-Algorithmus betrachtet die Zeichenfolge als eine Folge von Bytes.

algorithm: Einer der oben aufgeführten unterstützten Algorithmen, der als Zeichenfolge übergeben wird.

    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
  

HtmlEncode

Kodiert die Eingabezeichenfolge in die HTML-Zeichencodes und ersetzt Sonderzeichen durch ihre Entsprechungen mit &.

Beispielsweise würde das Zeichen é durch &eacute; oder einen entsprechenden numerischen HTML-Code ersetzt.

svc.HtmlEncode(inputstr: str): str

inputstr: Die zu codierende Zeichenfolge.

    MsgBox SF_String.HtmlEncode("<a href=""https://a.b.com"">From α to ω</a>")
    ' "&lt;a href=&quot;https://a.b.com&quot;&gt;From &#945; to &#969;&lt;/a&gt;"
  

IsADate

Gibt True zurück, wenn die Eingabezeichenfolge ein gültiges Datum gemäß einem angegebenen Datumsformat ist.

svc.IsADate(inputstr: str, [dateformat: str]): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück

dateformat: Das Datumsformat als Zeichenfolge. Kann "YYYY-MM-DD" (Standard), "DD-MM-YYYY" oder "MM-DD-YYYY" sein

Der Bindestrich (-) kann durch einen Punkt (.), einen Schrägstrich (/) oder ein Leerzeichen ersetzt werden.

Wenn das Format ungültig ist, gibt die Methode False zurück.

    MsgBox SF_String.IsADate("2020-12-31", "YYYY-MM-DD") ' True
  

Diese Methode prüft das Format der Eingabezeichenfolge, ohne kalenderspezifische Prüfungen durchzuführen. Daher wird die Eingabezeichenfolge nicht auf Schaltjahre oder Monate mit 30 oder 31 Tagen getestet. Siehe hierzu die integrierte Funktion IsDate.

Das folgende Beispiel zeigt den Unterschied zwischen den Methoden IsADate (ScriptForge) und der Funktion IsDate (eingebaut).

    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
  

IsAlpha

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge alphabetisch sind.

Alphabetische Zeichen sind die Zeichen, die in der Unicode-Zeichendatenbank als Buchstaben definiert sind.

svc.IsAlpha(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsAlpha("àénΣlPµ") ' True
    MsgBox SF_String.IsAlpha("myVar3") ' False
  

IsAlphaNum

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge alphabetisch, Ziffern oder "_" (Unterstrich) sind. Das erste Zeichen darf keine Ziffer sein.

svc.IsAlphaNum(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsAlphaNum("_ABC_123456_abcàénΣlPµ") ' True
    MsgBox SF_String.IsAlphaNum("123ABC") ' False
  

IsAscii

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge ASCII-Zeichen sind.

svc.IsAscii(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsAscii("a%?,25") ' True
    MsgBox SF_String.IsAscii("abcàénΣlPµ") ' False
  

IsDigit

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge Ziffern sind.

svc.IsDigit(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsDigit("123456") ' True
    MsgBox SF_String.IsDigit("_12a") ' False
  

IsEmail

Gibt True zurück, wenn die Zeichenfolge eine gültige E-Mail-Adresse ist.

svc.IsEmail(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    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
  

IsFileName

Gibt True zurück, wenn die Zeichenfolge ein gültiger Dateiname in einem bestimmten Betriebssystem ist.

svc.IsFileName(inputstr: str, [osname: str]): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

osname: Der Name des Betriebssystems als Zeichenfolge. Kann "WINDOWS", "LINUX", "MACOSX" oder "SOLARIS" sein.

Der Standardwert ist das aktuelle Betriebssystem, auf dem das Skript ausgeführt wird.

    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
  

IsHexDigit

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge Hexadezimalziffern sind.

svc.IsHexDigit(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

Den Hexadezimalziffern kann „0x“ oder „&H“ vorangestellt werden.

    MsgBox SF_String.IsHexDigit("&H00FF") ' True
    MsgBox SF_String.IsHexDigit("08AAFF10") ' True
    MsgBox SF_String.IsHexDigit("0x18LA22") ' False
  

IsIBAN

Gibt True zurück, wenn die Zeichenfolge eine gültige internationale Bankkontonummer (IBAN) ist. Beim Vergleich wird die Groß-/Kleinschreibung nicht beachtet.

svc.IsIBAN(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

True, wenn die Zeichenfolge eine gültige IBAN-Nummer enthält.

    ' 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
  

IsIPv4

Gibt True zurück, wenn die Zeichenfolge eine gültige IP(v4)-Adresse ist.

svc.IsIPv4(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    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
  

IsLike

Gibt True zurück, wenn die gesamte Eingabezeichenfolge mit einem bestimmten Muster übereinstimmt, das Platzhalter enthält.

svc.IsLike(inputstr: str, pattern: str, [casesensitive: bool]): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

pattern: Das Muster als Zeichenfolge. Platzhalter sind:

• "?" stellt ein beliebiges einzelnes Zeichen dar;

• "*" steht für null, ein oder mehrere Zeichen.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = 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
  

IsLower

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge in Kleinbuchstaben geschrieben sind. Nicht alphabetische Zeichen werden ignoriert.

svc.IsLower(inputstr: str): bool

InputStr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsLower("abc'(-xy4z") ' True
    MsgBox SF_String.IsLower("1234") ' True
    MsgBox SF_String.IsLower("abcDefg") ' False
  

IsPrintable

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge druckbar sind.

svc.IsPrintable(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsPrintable("àén ΣlPµ Русский") ' True
    MsgBox SF_String.IsPrintable("First line." & Chr(10) & "Second Line.") ' False
  

IsRegex

Gibt True zurück, wenn die gesamte Eingabezeichenfolge mit einem gegebenen regulären Ausdruck übereinstimmt.

svc.IsRegex(inputstr: str, regex: str, [casesensitive: bool]): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

regex: Der reguläre Ausdruck. Wenn leer, gibt die Methode False zurück.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = 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
      

IsSheetName

Gibt True zurück, wenn die Eingabezeichenfolge ein gültiger Calc-Tabellenname ist.

svc.IsSheetName(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    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
  

Ein Tabellenname darf nicht die Zeichen [ ] * ? : / \ oder das Zeichen ' (Apostroph) als erstes oder letztes Zeichen enthalten.

IsTitle

Gibt True zurück, wenn das erste Zeichen jedes Wortes in Großbuchstaben und die anderen Zeichen in Kleinbuchstaben geschrieben sind.

svc.IsTitle(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    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
  

IsUpper

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge in Großbuchstaben geschrieben sind. Nicht alphabetische Zeichen werden ignoriert.

svc.IsUpper(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsUpper("ABC'(-XYZ") ' True
    MsgBox SF_String.IsUpper("A Title") ' False
  

IsUrl

Gibt True zurück, wenn die Zeichenfolge eine gültige absolute URL-Adresse (Uniform Resource Locator) ist. Es werden nur die Protokolle http, https und ftp unterstützt.

svc.IsUrl(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    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
  

IsWhitespace

Gibt True zurück, wenn alle Zeichen in der Zeichenfolge Leerzeichen sind

svc.IsWhitespace(inputstr: str): bool

inputstr: Die zu prüfende Zeichenfolge. Wenn leer, gibt die Methode False zurück.

    MsgBox SF_String.IsWhitespace("    ") ' True
    MsgBox SF_String.IsWhitespace(" " & Chr(9) & Chr(10)) ' True
    MsgBox SF_String.IsWhitespace("") ' False
  

JustifyCenter

Gibt die Eingabezeichenfolge zentriert zurück.

Die führenden und abschließenden Leerzeichen werden entfernt und die restlichen Zeichen werden links und rechts bis zu einer angegebenen Gesamtlänge lenght mit dem Zeichen padding aufgefüllt.

svc.JustifyCenter(inputstr: str, [length: int], [padding: str]): str

inputstr: Die Zeichenfolge, die zentriert werden soll. Wenn leer, gibt die Methode eine leere Zeichenfolge zurück.

length: Die Länge der resultierenden Zeichenfolge (Standard = die Länge der Eingabezeichenfolge).

Wenn die angegebene Länge kürzer als die zentrierte Eingabezeichenfolge ist, wird die zurückgegebene Zeichenfolge abgeschnitten.

padding: Das einzelne Zeichen, das als "padding" verwendet werden soll (Standard = das ASCII-Leerzeichen " ").

    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"
  

JustifyLeft

Gibt die Eingabezeichenfolge linksbündig zurück.

Die führenden Leerzeichen werden entfernt und die restlichen Zeichen bis zu einer vorgegebenen Gesamtlänge length mit dem Zeichen padding nach rechts aufgefüllt.

svc.JustifyLeft(inputstr: str, [length: int], [padding: str]): str

inputstr: Die linksbündig auszurichtende Zeichenfolge. Wenn leer, gibt die Methode eine leere Zeichenfolge zurück.

length: Die Länge der resultierenden Zeichenfolge (Standard = die Länge der Eingabezeichenfolge).

Wenn die angegebene Länge kürzer als die linksbündige Eingabezeichenfolge ist, wird die zurückgegebene Zeichenfolge abgeschnitten.

padding: Das einzelne Zeichen, das als "padding" verwendet werden soll (Standard = das ASCII-Leerzeichen " ").

    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"
  

JustifyRight

Gibt den Eingabestring rechtsbündig zurück.

Dabei werden die führenden Leerzeichen entfernt und die restlichen Zeichen nach links bis zu einer vorgegebenen Gesamtlänge length mit dem Zeichen padding aufgefüllt.

svc.JustifyRight(inputstr: str, [length: int], [padding: str]): str

inputstr: Die rechtsbündig auszurichtende Zeichenfolge. Wenn leer, gibt die Methode eine leere Zeichenfolge zurück.

length: Die Länge der resultierenden Zeichenfolge (Standard = die Länge der Eingabezeichenfolge).

Wenn die angegebene Länge kürzer als die rechtsbündige Eingabezeichenfolge ist, wird die zurückgegebene Zeichenfolge abgeschnitten.

padding: Das einzelne Zeichen, das als "padding" verwendet werden soll (Standard = das ASCII-Leerzeichen " ").

    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"
  

Quote

Gibt die in einfache oder doppelte Anführungszeichen eingeschlossene Eingabezeichenfolge zurück. Vorhandene Anführungszeichen werden unverändert gelassen, einschließlich vorangestellter und/oder nachgestellter Anführungszeichen.

svc.Quote(inputstr: str, [quotechar: str]): str

inputstr: Die zu zitierende Zeichenfolge.

quotechar: Entweder das einfache (') oder das doppelte (") Anführungszeichen (Standard).

    MsgBox SF_String.Quote("Text Value")
    ' "Text Value"
    MsgBox SF_String.Quote("Book Title: ""The Arabian Nights""", "'")
    ' 'Book Title: "The Arabian Nights"'
  

Diese Methode kann nützlich sein, wenn ein Zeichenfolgenfeld vorbereitet wird, das in einer CSV-ähnlichen Datei gespeichert werden soll, was erfordert, dass Textwerte in einfache oder doppelte Anführungszeichen gesetzt werden.

ReplaceChar

Ersetzt alle Vorkommen der im Parameter Before angegebenen Zeichen durch die entsprechenden Zeichen, die in After angegeben sind.

Wenn die Länge von Before größer als die Länge von After ist, werden die Restzeichen in Before durch das letzte Zeichen in After ersetzt.

svc.ReplaceChar(inputstr: str, before: str, after: str): str

inputstr: Die Eingabezeichenfolge, bei der Ersetzungen erfolgen.

before: Eine Zeichenfolge mit den Zeichen, nach denen in der Eingabezeichenfolge zur Ersetzung gesucht werden.

after: Eine Zeichenfolge mit den neuen Zeichen, welche die in before definierten ersetzen.

    ' Ersetzt akzentuierte Zeichen
    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"
  

Der Dienst SF_String stellt nützliche öffentliche Konstanten für die lateinischen Zeichensätze bereit, wie im folgenden Beispiel gezeigt:

    MsgBox SF_String.ReplaceChar("Protégez votre vie privée", SF_String.CHARSWITHACCENT, SF_String.CHARSWITHOUTACCENT)
    ' "Protegez votre vie privee"
  

ReplaceRegex

Ersetzt alle Vorkommen eines bestimmten regulären Ausdrucks durch eine neue Zeichenfolge.

svc.ReplaceRegex(inputstr: str, regex: str, newstr: str, [casesensitive: bool]): str

inputstr: Die Eingabezeichenfolge, bei der Ersetzungen erfolgen.

regex: Der reguläre Ausdruck.

newstr: Die ersetzende Zeichenfolge.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = False).

    MsgBox SF_String.ReplaceRegex("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "[a-z]", "x", CaseSensitive := True)
    ' "Lxxxx xxxxx xxxxx xxx xxxx, xxxxxxxxxx xxxxxxxxxx xxxx." (jeder Kleinbuchstabe wird durch ein "x" ersetzt)
    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." (jedes Wort wird durch ein "x" ersetzt)
  

ReplaceStr

Ersetzt in einer Zeichenfolge einige oder alle Vorkommen einer Matriv von Zeichenfolgen durch eine Matrix neuer Zeichenfolgen.

svc.ReplaceStr(inputstr: str, oldstr: str, newstr: str, [occurrences: int], [casesensitive: bool]): str

inputstr: Die Eingabezeichenfolge, bei der Ersetzungen erfolgen.

oldstr: Eine einzelne Zeichenfolge oder eine Matrix mit Zeichenfolgen. Zeichenfolgen der Länge Null werden ignoriert.

newstr: Die ersetzende Zeichenfolge oder die Matrix mit ersetzenden Zeichenfolgen.

Wenn oldstr eine Matrix ist, wird jedes Vorkommen eines der Elemente in oldstr durch newstr ersetzt.

Wenn oldstr und newstr Matrizen sind, erfolgt die Ersetzung nacheinander bis zu UBound(newstr).

Wenn oldstr mehr Einträge hat als newstr, dann werden die restlichen Elemente in oldstr durch das letzte Element in newstr ersetzt.

occurrences: Die maximale Anzahl von Ersetzungen. Der Standardwert ist 0, was bedeutet, dass alle Vorkommen ersetzt werden.

Wenn oldstr eine Matrix ist, wird der Parameter occurrence für jedes Element in der Matrix separat berechnet.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = 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"
  

Represent

Gibt eine Zeichenfolge, die bei einer bestimmten Länge abgeschnitten wird, mit einer lesbaren Darstellung des Arguments zurück. Dies ist hauptsächlich für Debugging- oder Protokollierungszwecke nützlich.

Wenn der Parameter anyvalue ein Objekt ist, wird es in eckige Klammern "[" und "]" eingeschlossen.

In Zeichenfolgen werden Tabulatoren und Zeilenumbrüche durch \t, \n oder \r ersetzt.

Wenn die endgültige Länge den Parameter maxlength überschreitet, wird der letzte Teil der Zeichenfolge durch " … (N)" ersetzt, wobei N die Gesamtlänge der ursprünglichen Zeichenfolge vor dem Abschneiden ist.

svc.Represent(anyvalue: any, [maxlength: int]): str

anyvalue: Der darzustellende Eingabewert. Dies kann ein beliebiger Wert sein, beispielsweise eine Zeichenfolge, eine Matrix, ein Basic-Objekt, ein UNO-Objekt …

maxlength: Die maximale Länge der resultierenden Zeichenfolge. Der Standardwert ist 0, was bedeutet, dass die Länge der resultierenden Darstellung unbegrenzt ist.

    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]"
  

Beachten Sie, dass die Darstellung von Datentypen wie Matrizen und Objektinstanzen ScriptForge.Dictionary sowohl den Datentyp als auch ihre Werte enthalten:

    ' Ein Beispiel mit einer eingebauten Matrix in Basic
    MsgBox SF_String.Represent(Array(1, 2, "Text" & Chr(9) & "here"))
    ' "[ARRAY] (0:2) (1, 2, Text\there)"
    ' Ein Beispiel mit einer Matrix in 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)"
    ' Ein Beispiel mit einem Wörterbuch in 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)"
  

Reverse

Gibt die Eingabezeichenfolge in umgekehrter Reihenfolge zurück.

Diese Methode entspricht der integrierten Basic-Funktion StrReverse.

Um die Funktion StrReverse zu verwenden, muss die Anweisung Option VBASupport 1 im Modul vorhanden sein.

svc.Reverse(inputstr: str): str

inputstr: Die umzukehrende Zeichenfolge.

    MsgBox SF_String.Reverse("abcdefghij") ' "jihgfedcba"
  

SplitLines

Gibt eine nullbasierte Matrix von Zeichenfolgen mit den Zeilen in der Eingabezeichenfolge zurück. Jedes Element in der Matrix wird erhalten, indem die Eingabezeichenfolge an Zeilenumbruchzeichen geteilt wird.

svc.SplitLines(inputstr: str, [keepbreaks: int]): str[0..*]

inputstr: Die zu teilende Zeichenfolge.

keepbreaks: Wenn True, werden Zeilenumbrüche in der Ausgabematrix beibehalten (Standard = 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", "")
  

SplitNotQuoted

Teilt eine Zeichenfolge mithilfe eines angegebenen Trennzeichens in eine Matrix von Elementen.

Wenn eine Teilzeichenfolge in Anführungszeichen ein Trennzeichen enthält, wird es ignoriert. Dies ist nützlich, wenn CSV-ähnliche Datensätze analysiert werden, die Zeichenfolgen in Anführungszeichen enthalten.

svc.SplitNotQuoted(inputstr: str, [delimiter: str], [occurrences: int], [quotechar: str]): str[0..*]

inputstr: Die zu teilende Zeichenfolge.

delimiter: Eine Zeichenfolge aus einem oder mehreren Zeichen, die als Trennzeichen verwendet werden. Das Standardtrennzeichen ist das ASCII-Leerzeichen " ".

occurrences: Die maximale Anzahl der zurückzugebenden Teilzeichenfolgen. Der Standardwert ist 0, was bedeutet, dass die Anzahl der zurückzugebenden Zeichenfolgen unbegrenzt ist.

quotechar: Entweder das einfache (') oder das doppelte (") Anführungszeichen.

    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""', '')
  

Achten Sie bei der Darstellung von Zeichenfolgen auf die Unterschiede zwischen Basic und Python. Beispielsweise werden in Basic zwei doppelte Anführungszeichen ("") innerhalb einer Zeichenfolge als einzelnes doppeltes Anführungszeichen (") interpretiert. In Python können in einfache Anführungszeichen eingeschlossene Zeichenfolgen doppelte Anführungszeichen (") enthalten, ohne sie verdoppeln zu müssen.

StartsWith

Gibt True zurück, wenn die ersten Zeichen einer Zeichenfolge mit einer gegebenen Teilzeichenfolge identisch sind.

Diese Methode gibt False zurück, wenn entweder die Eingabezeichenfolge oder die Teilzeichenfolge eine Länge = 0 haben oder wenn die Teilzeichenfolge länger als die Eingabezeichenfolge ist.

svc.StartsWith(inputstr: str, substring: str, [casesensitive: bool]): bool

inputstr: Die zu testende Zeichenfolge.

substring: Die zu durchsuchende Teilzeichenfolge am Anfang von inputstr.

casesensitive: Die Suche kann Groß- und Kleinschreibung beachten oder nicht (Standard = False).

    MsgBox SF_String.StartsWith("abcdefg", "ABC") 'True
    MsgBox SF_String.StartsWith("abcdefg", "ABC", CaseSensitive := True) 'False
  

TrimExt

Gibt die Eingabezeichenfolge ohne die führenden und abschließenden Leerzeichen zurück.

svc.TrimExt(inputstr: str): str

inputstr: Die zu trimmende Zeichenfolge.

    MsgBox SF_String.TrimExt(" Some text.  ") ' "Some text."
    MsgBox SF_String.TrimExt("   ABCDEF" & Chr(9) & Chr(10) & Chr(13) & " ") ' "ABCDEF"
  

Unescape

Konvertiert jede maskierte Sequenz (\\, \n, \r, \t) in der Eingabezeichenfolge in das entsprechende ASCII-Zeichen.

svc.Unescape(inputstr: str): str

inputstr: Die zu konvertierende Zeichenfolge.

    MsgBox SF_String.Unescape("abc\n\tdef\\n")
    ' "abc" & Chr(10) & Chr(9) & "def\n"
  

Unquote

Entfernt die einfachen oder doppelten Anführungszeichen, welche die Eingabezeichenfolge einschließen.

Dies ist nützlich, wenn CSV-ähnliche Datensätze analysiert werden, die Zeichenfolgen in Anführungszeichen enthalten.

svc.Unquote(inputstr: str, [quotechar: str]): str

inputstr: Die Zeichenfolge, deren Anführungszeichen entfernt werden sollen.

quotechar: Entweder das einfache (') oder das doppelte (") Anführungszeichen (Standard).

    Dim s as String
    ' s = "Some text" (ohne einschließende Anführungszeichen)
    s = SF_String.Unquote("""Some text""")
    ' Die folgende Zeichenfolge enthält keine einschließenden Anführungszeichen, sodass sie unverändert bleibt
    ' s = "Some text" (unverändert)
    s = SF_String.Unquote("Some text")
    ' Anführungszeichen innerhalb der Zeichenfolge werden nicht entfernt
    ' s = "The ""true"" meaning" (unverändert)
    s = SF_String.Unquote("The ""true"" meaning")
  

Wrap

Konvertiert die Eingabezeichenfolge in eine Matrix von Teilzeichenfolgen, sodass jedes Element in der Matrix höchstens eine bestimmte Anzahl von Zeichen enthält.

In der Praxis gibt diese Methode eine nullbasierte Matrix von Ausgabezeilen ohne Zeilenumbrüche am Ende zurück, mit Ausnahme der bereits vorhandenen Zeilenumbrüche.

Tabulatoren werden mit demselben Verfahren erweitert, das auch von der Methode ExpandTabs durchgeführt wird.

Symbolische Zeilenumbrüche werden durch die entsprechenden ASCII-Zeichen ersetzt.

Wenn die verpackte Ausgabe keinen Inhalt hat, ist die zurückgegebene Matrix leer.

svc.Wrap(inputstr: str, [width: int], [tabsize: int]): str

inputstr: Die umzubrechende Zeichenfolge.

width: Die maximale Anzahl von Zeichen in jeder Zeile (Standard = 70).

tabsize: Vor dem Umbruch des Textes werden die vorhandenen Tabulator-Zeichen Chr(9) durch Leerzeichen ersetzt. Das Argument tabsize definiert die Tabulatoren bei TabSize + 1, 2 * TabSize + 1 , … N * TabSize + 1 (Default = 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...')
  

Alle ScriptForge Basic-Routinen oder Bezeichner, denen ein Unterstrich "_" vorangestellt ist, sind für den internen Gebrauch reserviert. Sie sind nicht für die Verwendung in Basic-Makros oder Python-Skripten vorgesehen.