Erstellen von Zeichenfolgen-Arrays

Erstellen von Zeichenfolgen-Arrays aus Variablen

MATLAB® stellt Zeichenfolgen-Arrays zur Verfügung, um Textteile zu speichern. Jedes Element eines Zeichenfolgen-Arrays enthält eine 1-mal-n-Sequenz von Zeichen.

Sie können eine Zeichenfolge mit doppelten Anführungszeichen erstellen.

str = "Hello, world"

str = 
"Hello, world"

Alternativ können Sie einen Zeichenvektor mit der Funktion string in eine Zeichenfolge konvertieren. chr ist ein 1-mal-17-Zeichenvektor. str ist eine 1-mal-1-Zeichenfolge, die denselben Text wie der Zeichenvektor enthält.

chr = 'Greetings, friend'

chr = 
'Greetings, friend'

str = string(chr)

str = 
"Greetings, friend"

Erstellen Sie ein Zeichenfolgen-Array, das mehrere Zeichenfolgen enthält, mithilfe des Operators []. str ist ein 2-mal-3-Zeichenfolgen-Array, das sechs Zeichenfolgen enthält.

str = ["Mercury","Gemini","Apollo";
       "Skylab","Skylab B","ISS"]

str = 2×3 string
    "Mercury"    "Gemini"      "Apollo"
    "Skylab"     "Skylab B"    "ISS"   

Ermitteln Sie die Länge jeder Zeichenfolge in str mit der Funktion strlength. Verwenden Sie strlength anstelle von length, um die Anzahl der Zeichen in Zeichenfolgen zu ermitteln.

L = strlength(str)

L = 2×3

     7     6     6
     6     8     3

Alternativ können Sie ein Zellen-Array von Zeichenvektoren mit der Funktion string in ein Zeichenfolgen-Array konvertieren. MATLAB zeigt Zeichenfolgen in Zeichenfolgen-Arrays mit doppelten Anführungszeichen an und zeigt Zeichenvektoren in Zellen-Arrays mit einfachen Anführungszeichen an.

C = {'Mercury','Venus','Earth'}

C = 1×3 cell
    {'Mercury'}    {'Venus'}    {'Earth'}

str = string(C)

str = 1×3 string
    "Mercury"    "Venus"    "Earth"

Zusätzlich zu Zeichenvektoren können Sie numerische Werte, Datums- und Zeitangaben, Zeitdauern und kategoriale Werte mit der Funktion string in Zeichenfolgen konvertieren.

Konvertieren Sie ein numerisches Array in ein Zeichenfolgen-Array.

X = [5 10 20 3.1416];
string(X)

ans = 1×4 string
    "5"    "10"    "20"    "3.1416"

Konvertieren Sie einen Datums- und Zeitwert in eine Zeichenfolge.

d = datetime('now');
string(d)

ans = 
"09-Aug-2025 12:02:37"

Darüber hinaus können Sie Text aus Dateien mit den Funktionen readtable, textscan und fscanf in Zeichenfolgen-Arrays einlesen.

Erstellen von leeren und fehlenden Zeichenfolgen

Zeichenfolgen-Arrays können sowohl leere als auch fehlende Werte enthalten. Eine leere Zeichenfolge enthält keine Zeichen. Wenn Sie eine leere Zeichenfolge anzeigen, wird das Ergebnis als doppelte Anführungszeichen ohne Inhalt dazwischen dargestellt (""). Die fehlende Zeichenfolge entspricht NaN für numerische Arrays. Es zeigt an, wo in einem Zeichenfolgen-Array Werte fehlen. Wenn Sie eine fehlende Zeichenfolge anzeigen, lautet das Ergebnis <missing>, ohne Anführungszeichen.

Erstellen Sie ein leeres Zeichenfolgen-Array mit der Funktion strings. Wenn Sie strings ohne Argumente aufrufen, wird eine leere Zeichenfolge zurückgegeben. Bitte beachten Sie, dass die Größe von of str 1-mal-1 und nicht 0-mal-0 ist. Allerdings enthält str keine Zeichen.

str = strings

str = 
""

Erstellen Sie einen leeren Zeichenvektor mit einfachen Anführungszeichen. Beachten Sie, dass die Größe von chr 0-mal-0 ist.

chr = ''

chr =

  0×0 empty char array

Erstellen Sie ein Zeichenfolgen-Array, in dem jedes Element eine leere Zeichenfolge ist. Sie können ein Zeichenfolgen-Array mit der Funktion strings vorab zuweisen.

str = strings(2,3)

str = 2×3 string
    ""    ""    ""
    ""    ""    ""

Um eine fehlende Zeichenfolge zu erstellen, konvertieren Sie einen fehlenden Wert mit der Funktion string. Die fehlende Zeichenfolge wird als <missing> angezeigt.

str = string(missing)

str = 
<missing>

Sie können ein Zeichenfolgen-Array mit sowohl leeren als auch fehlenden Zeichenfolgen erstellen. Verwenden Sie die Funktion ismissing, um zu ermitteln, welche Elemente Zeichenfolgen mit fehlenden Werten sind. Beachten Sie, dass eine leere Zeichenfolge keine fehlende Zeichenfolge darstellt.

str(1) = "";
str(2) = "Gemini";
str(3) = string(missing)

str = 1×3 string
    ""    "Gemini"    <missing>

ismissing(str)

ans = 1×3 logical array

   0   0   1

Vergleichen Sie eine fehlende Zeichenfolge mit einer anderen Zeichenfolge. Das Ergebnis ist immer 0 (false), selbst wenn Sie eine fehlende Zeichenfolge mit einer anderen fehlenden Zeichenfolge vergleichen.

str = string(missing);
str == "Gemini"

ans = logical
   0

str == string(missing)

ans = logical
   0

Zugreifen auf Elemente eines Zeichenfolgen-Arrays

Zeichenfolgen-Arrays unterstützen Array-Operationen wie Indizierung und Umformung. Verwenden Sie die Array-Indizierung, um auf die erste Zeile von str und alle Spalten zuzugreifen.

str = ["Mercury","Gemini","Apollo";
       "Skylab","Skylab B","ISS"];
str(1,:)

ans = 1×3 string
    "Mercury"    "Gemini"    "Apollo"

Greifen Sie auf das zweite Element in der zweiten Zeile von str zu.

str(2,2)

ans = 
"Skylab B"

Weisen Sie eine neue Zeichenfolge außerhalb der Grenzen von str zu. MATLAB erweitert das Array und füllt nicht zugewiesene Elemente mit fehlenden Werten.

str(3,4) = "Mir"

str = 3×4 string
    "Mercury"    "Gemini"      "Apollo"     <missing>
    "Skylab"     "Skylab B"    "ISS"        <missing>
    <missing>    <missing>     <missing>    "Mir"    

Zugreifen auf Zeichen innerhalb von Zeichenfolgen

Sie können mithilfe von geschweiften Klammern ({}) in einem Zeichenfolgen-Array indizieren, um direkt auf Zeichen zuzugreifen. Verwenden Sie geschweifte Klammern, wenn Sie auf Zeichen innerhalb eines Zeichenfolgenelements zugreifen und diese ändern möchten. Die Indizierung mit geschweiften Klammern gewährleistet Kompatibilität für Code, der sowohl mit Zeichenfolgen-Arrays als auch mit Zellen-Arrays von Zeichenvektoren funktionieren könnte. Wenn möglich, sollten Sie jedoch Zeichenfolgenfunktionen verwenden, um mit den Zeichen in Zeichenfolgen zu arbeiten.

Greifen Sie mit geschweiften Klammern auf das zweite Element in der zweiten Zeile zu. chr ist ein Zeichenvektor, keine Zeichenfolge.

str = ["Mercury","Gemini","Apollo";
       "Skylab","Skylab B","ISS"];
chr = str{2,2}

chr = 
'Skylab B'

Greifen Sie auf den Zeichenvektor zu und geben Sie die ersten drei Zeichen zurück.

str{2,2}(1:3)

ans = 
'Sky'

Suchen Sie die Leerzeichen in einer Zeichenfolge und ersetzen Sie sie durch Bindestriche. Verwenden Sie die Funktion isspace, um einzelne Zeichen innerhalb der Zeichenfolge zu überprüfen. isspace gibt einen logischen Vektor zurück, der überall dort einen true-Wert enthält, wo ein Leerzeichen vorhanden ist. Zeigen Sie abschließend das geänderte Zeichenfolgenelement str(2,2) an.

TF = isspace(str{2,2})

TF = 1×8 logical array

   0   0   0   0   0   0   1   0

str{2,2}(TF) = "-";
str(2,2)

ans = 
"Skylab-B"

Beachten Sie, dass Sie in diesem Fall Leerzeichen auch mit der Funktion replace ersetzen können, ohne auf geschweifte Klammern zurückgreifen zu müssen.

replace(str(2,2)," ","-")

ans = 
"Skylab-B"

Verketten von Zeichenfolgen zu einem Zeichenfolgen-Array

Verketten Sie Zeichenfolgen zu einem Zeichenfolgen-Array, genau wie Sie Arrays jeder anderen Art verketten würden.

Verketten Sie zwei Zeichenfolgen-Arrays mithilfe von eckigen Klammern ([]).

str1 = ["Mercury","Gemini","Apollo"];
str2 = ["Skylab","Skylab B","ISS"];
str = [str1 str2]

str = 1×6 string
    "Mercury"    "Gemini"    "Apollo"    "Skylab"    "Skylab B"    "ISS"

Transponieren Sie str1 und str2. Verketten Sie diese und verketten Sie anschließend die Spaltenüberschriften vertikal mit dem Zeichenfolgen-Array. Wenn Sie Zeichenvektoren zu einem Zeichenfolgen-Array verknüpfen, werden die Zeichenvektoren automatisch in Zeichenfolgen konvertiert.

str1 = str1';
str2 = str2';
str = [str1 str2];
str = [["Mission:","Station:"] ; str]

str = 4×2 string
    "Mission:"    "Station:"
    "Mercury"     "Skylab"  
    "Gemini"      "Skylab B"
    "Apollo"      "ISS"     

Anhängen von Text an Zeichenfolgen

Um Text an Zeichenfolgen anzuhängen, verwenden Sie den Operator plus (+). Der Operator plus hängt Text an Zeichenfolgen an, verändert jedoch nicht die Größe eines Zeichenfolgen-Arrays.

Hängt einen Nachnamen an eine Reihe von Namen an. Wenn Sie einen Zeichenvektor an Zeichenfolgen anhängen, wird der Zeichenvektor automatisch in eine Zeichenfolge konvertiert.

names = ["Mary";"John";"Elizabeth";"Paul";"Ann"];
names = names + ' Smith'

names = 5×1 string
    "Mary Smith"
    "John Smith"
    "Elizabeth Smith"
    "Paul Smith"
    "Ann Smith"

Hängen Sie unterschiedliche Nachnamen an. Sie können Text aus einem Zeichenfolgen-Array oder aus einem Zellen-Array mit Zeichenvektoren an ein Zeichenfolgen-Array anhängen. Wenn Sie nicht skalare Arrays hinzufügen, müssen diese dieselbe Größe aufweisen.

names = ["Mary";"John";"Elizabeth";"Paul";"Ann"];
lastnames = ["Jones";"Adams";"Young";"Burns";"Spencer"];
names = names + " " + lastnames

names = 5×1 string
    "Mary Jones"
    "John Adams"
    "Elizabeth Young"
    "Paul Burns"
    "Ann Spencer"

Fügen Sie eine fehlende Zeichenfolge hinzu. Wenn Sie eine fehlende Zeichenfolge mit dem Plus-Operator anhängen, ist das Ergebnis eine fehlende Zeichenfolge.

str1 = "Jones";
str2 = string(missing);
str1 + str2

ans = 
<missing>

Teilen, Verknüpfen und Sortieren von Zeichenfolgen-Arrays

MATLAB bietet eine umfangreiche Reihe von Funktionen für die Arbeit mit Zeichenfolgen-Arrays. Beispielsweise können Sie die Funktionen split, join und sort verwenden, um das Zeichenfolgen-Array names so umzuordnen, dass die Namen in alphabetischer Reihenfolge nach Nachnamen sortiert sind.

Teilen Sie names an den Leerzeichen. Die Aufteilung ändert names von einem 5-mal-1-Zeichenfolgen-Array in ein 5-mal-2-Array.

names = ["Mary Jones";"John Adams";"Elizabeth Young";"Paul Burns";"Ann Spencer"];
names = split(names)

names = 5×2 string
    "Mary"         "Jones"  
    "John"         "Adams"  
    "Elizabeth"    "Young"  
    "Paul"         "Burns"  
    "Ann"          "Spencer"

Tauschen Sie die Spalten von names so, dass die Nachnamen in der ersten Spalte stehen. Fügen Sie nach jedem Nachnamen ein Komma ein.

names = [names(:,2) names(:,1)];
names(:,1) = names(:,1) + ','

names = 5×2 string
    "Jones,"      "Mary"     
    "Adams,"      "John"     
    "Young,"      "Elizabeth"
    "Burns,"      "Paul"     
    "Spencer,"    "Ann"      

Verknüpfen Sie den Nachnamen und den Vornamen. Die Funktion join fügt ein Leerzeichen zwischen den Zeichenfolgen ein, die sie verknüpft. Nach der Verknüpfung ist names ein 5-mal-1-Zeichenfolgen-Array.

names = join(names)

names = 5×1 string
    "Jones, Mary"
    "Adams, John"
    "Young, Elizabeth"
    "Burns, Paul"
    "Spencer, Ann"

Ordnen Sie die Elemente von names in alphabetischer Reihenfolge.

names = sort(names)

names = 5×1 string
    "Adams, John"
    "Burns, Paul"
    "Jones, Mary"
    "Spencer, Ann"
    "Young, Elizabeth"