One place for hosting & domains

      Zeichenfolgen

      So indexieren und trennen Sie Zeichenfolgen in Python 3


      Einführung

      Der Python-Zeichenfolgen-Datentyp ist eine Sequenz, die aus einem oder mehreren einzelnen Zeichen besteht, die aus Buchstaben, Zahlen, Leerzeichen oder Symbolen bestehen können. Da es sich bei einer Zeichenfolge um eine Sequenz handelt, kann durch Indizieren und Schneiden auf dieselbe Weise wie bei anderen sequenzbasierten Datentypen auf sie zugegriffen werden.

      Dieses Tutorial führt Sie durch den Zugriff auf Zeichenfolgen durch Indizieren, sie durch ihre Zeichenfolgen schneiden und einige Zähl- und Zeichenortungsmethoden durchgehen.

      Wie Zeichenfolgen indiziert sind

      Wie der Listendatentyp mit Elementen, die einer Indexnummer entsprechen, entspricht auch jedes Zeichen einer Zeichenfolge einer Indexnummer, beginnend mit der Indexnummer 0.

      Für die Zeichenfolge Sammy Shark! die Indexaufschlüsselung sieht folgendermaßen aus:

      S a m m y S h a r k !
      0 1 2 3 4 5 6 7 8 9 10 11

      Wie Sie sehen können, beginnt das erste S bei Index 0 und die Zeichenfolge endet bei Index 11 mit dem ! -Symbol.

      Wir bemerken auch, dass das Leerzeichen zwischen Sammy und Shark auch seiner eigenen Indexnummer entspricht. In diesem Fall beträgt die dem Leerzeichen zugeordnete Indexnummer 5.

      Das Ausrufezeichen (!) hat auch eine Indexnummer zugeordnet. Alle anderen Symbole oder Satzzeichen wie *#$&. ;?, ist ebenfalls ein Zeichen und würde mit einer eigenen Indexnummer verknüpft.

      Die Tatsache, dass jedes Zeichen in einer Python-Zeichenfolge eine entsprechende Indexnummer hat, ermöglicht es uns, auf Zeichenfolgen auf dieselbe Weise wie bei anderen sequentiellen Datentypen zuzugreifen und diese zu bearbeiten.

      Zugriff auf Zeichen nach positiver Indexnummer

      Durch Verweisen von Indexnummern können wir eins der Zeichen in einer Zeichenfolge isolieren. Wir tun dies durch Einfügen der Indexnummern in quadratische Klammern. Lassen Sie uns eine Zeichenfolge deklarieren, drucken und die Indexnummer in quadratischen Klammern aufrufen:

      ss = "Sammy Shark!"
      print(ss[4])
      

      Output

      y

      Wenn wir auf eine bestimmte Indexnummer einer Zeichenfolge verweisen, gibt Python das Zeichen zurück, das sich in dieser Position befindet. Da sich der Buchstabe y an der Indexnummer 4 der Zeichenfolge ss = „Sammy Shark!“ befindet, erhalten wir beim Drucken von ss [4] y als Ausgabe.

      Indexnummern ermöglichen es uns, auf bestimmte Zeichen innerhalb einer Zeichenfolge zuzugreifen.

      Zugriff auf Zeichen nach negativer Indexnummer

      Wenn wir eine lange Zeichenfolge haben und ein Element am Ende anlegen möchten, können wir auch am Ende der Zeichenfolge rückwärts zählen, beginnend mit der Indexnummer -1.

      Für die gleiche Zeichenfolge Sammy Shark! sieht die negative Indexaufschlüsselung folgendermaßen aus:

      S a m m y S h a r k !
      -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

      Durch die Verwendung negativer Indexzahlen können wir das Zeichen r ausdrucken, indem wir uns wie folgt auf seine Position am -3-Index beziehen:

      print(ss[-3])
      

      Output

      r

      Die Verwendung negativer Indexnummern kann nützlich sein, um ein einzelnes Zeichen am Ende einer langen Zeichenfolge zu isolieren.

      Schneiden von Zeichenfolgen

      Wir können auch eine Reihe von Zeichen aus der Zeichenfolge aufrufen. Angenommen, wir möchten nur das Wort Shark drucken. Wir können dies tun, indem wir eine Scheibeerstellen, die eine Folge von Zeichen innerhalb einer ursprünglichen Zeichenfolge ist. Mit Scheiben können wir mehrere Zeichenwerte aufrufen, indem wir einen Bereich von Indexnummern erstellen, die durch einen Doppelpunkt [x:y] getrennt sind:

      print(ss[6:11])
      

      Output

      Shark

      Beim Erstellen einer Scheibe wie in [6:11] beginnt bei der ersten Indexnummer die Scheibe (einschließlich), und bei der zweiten Indexnummer endet die Scheibe (exklusiv), weshalb in unserem obigen Beispiel der Bereich der Indexnummer gilt, der unmittelbar nach dem Ende der Zeichenfolge auftreten würde.

      Beim Schneiden von Zeichenfolgen erstellen wir eine Teilzeichenfolge, bei der es sich im Wesentlichen um eine Zeichenfolge handelt, die in einer anderen Zeichenfolge vorhanden ist. Wenn wir ss[6:11] aufrufen, rufen wir den Teilstring Shark auf, der in der Zeichenfolge Sammy Shark! vorhanden ist.

      Wenn wir eines der Enden einer Zeichenfolge einschließen möchten, können wir eine der Zahlen in der ZeichenfolgenSyntax [n:n] auslassen. Wenn wir beispielsweise das erste Wort der Zeichenfolge ss – „Sammy“ – drucken möchten, können Sie dies tun, indem Sie Folgendes eingeben:

      print(ss[:5])
      

      Output

      Sammy

      Dazu haben wir die Indexnummer vor dem Doppelpunkt in der Scheiben-Syntax weggelassen und nur die Indexnummer nach dem Doppelpunkt eingefügt, die sich auf das Ende der Teilzeichenfolge bezieht.

      Um eine Teilzeichenfolge zu drucken, die in der Mitte einer Zeichenfolge beginnt und bis zum Ende druckt, können Sie dazu nur die Indexnummer vor dem Doppelpunkt einfügen:

      print(ss[7:])
      

      Output

      hark!

      Indem nur die Indexnummer vor dem Doppelpunkt eingefügt und die zweite Indexnummer aus der Syntax herausgelassen wird, wechselt die Teilzeichenfolge vom Zeichen der aufgerufenen Indexnummer zum Ende der Zeichenfolge.

      Sie können auch negative Indexnummern verwenden, um eine Zeichenfolge zu trennen. Wie bereits erwähnt, beginnen negative Indexzahlen einer Zeichenfolge bei -1 und zählen von dort herunter, bis wir den Anfang der Zeichenfolge erreichen. Wenn man negative Indexzahlen verwendet, beginnen wir zuerst mit der niedrigeren Zahl, wie sie früher in der Zeichenfolge vorkommt.

      Verwenden wir zwei negative Indexzahlen, um die Zeichenfolge ss zu schneiden:

      print(ss[-4:-1])
      

      Output

      ark

      Die Teilzeichenfolge „Arche“ ist aus der Zeichenfolge „Sammy Shark!“ , weil das Zeichen „a“ an der Position der Indexnummer -4 auftritt und das Zeichen „k“ unmittelbar vor der Position der Indexnummer -1 auftritt.

      Festlegen des Schrittes beim Schneiden von Zeichenfolgen

      Das Schneiden von Zeichenfolgen kann zusätzlich zu zwei Indexnummern einen dritten Parameter akzeptieren. Der dritte Parameter gibt den Schritt an, der angibt, wie viele Zeichen vorwärts bewegt werden sollen, nachdem das erste Zeichen aus der Zeichenfolge abgerufen wurde. Bisher haben wir den Schrittparameter weggelassen, und Python verwendet standardmäßig den Schritt 1, sodass jedes Zeichen zwischen zwei Indexnummern abgerufen wird.

      Schauen wir uns noch einmal das obige Beispiel an, in dem die Teilzeichenfolge „Shark“ ausgedruckt wird:

      print(ss[6:11])
      

      Output

      Shark

      Wir können die gleichen Ergebnisse erzielen, indem wir einen dritten Parameter mit einem Schritt von 1 einfügen:

      print(ss[6:11:1])
      

      Output

      Shark

      Ein Schritt von 1 nimmt also jedes Zeichen zwischen zwei Indexnummern eines Schrittes auf. Wenn wir den Schrittparameter weglassen, wird Python standardmäßig mit 1 angegeben.

      Wenn wir stattdessen den Schritt erhöhen, sehen wir, dass Zeichen übersprungen werden:

      print(ss[0:12:2])
      

      Output

      SmySak

      Die Angabe des Schrittes 2 als letzter Parameter in der Python-Syntax ss[0:12:2] überspringt jedes zweite Zeichen. Schauen wir uns die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      Beachten Sie, dass das Leerzeichen bei der Indexnummer 5 auch mit einem angegebenen Schritt von 2 übersprungen wird.

      Wenn wir eine größere Zahl für unseren Schrittparameter verwenden, haben wir eine deutlich kleinere Teilzeichenfolge:

      print(ss[0:12:4])
      

      Output

      Sya

      Die Angabe des Schrittes 4 als letzter Parameter in der Python-Syntax ss[0:12:4] druckt nur jedes vierte Zeichen. Schauen wir uns nochmals die Zeichen an, die in rot ausgedruckt werden:

      Sammy Shark!

      In diesem Beispiel wird auch das Leerzeichen übersprungen.

      Da wir die gesamte Zeichenfolge drucken, können wir die beiden Indexnummern weglassen und die beiden Doppelpunkte in der Syntax behalten, um das gleiche Ergebnis zu erzielen:

      print(ss[::4])
      

      Output

      Sya

      Durch Weglassen der beiden Indexnummern und Beibehalten von Doppelpunkten bleibt die gesamte Zeichenfolge im Bereich, während durch Hinzufügen eines letzten Parameters für den Schritt die Anzahl der zu überspringenden Zeichen angegeben wird.

      Zusätzlich können Sie einen negativen numerischen Wert für den Schritt angeben, mit dem wir die ursprüngliche Zeichenfolge in umgekehrter Reihenfolge drucken können, wenn wir den Schritt auf -1 setzen:

      print(ss[::-1])
      

      Output

      !krahS ymmaS

      Die beiden Doppelpunkte ohne angegebenen Parameter enthalten alle Zeichen aus der ursprünglichen Zeichenfolge. Ein Schritt von 1 enthält alle Zeichen ohne Überspringen. Wenn Sie diesen Schritt negieren, wird die Reihenfolge der Zeichen umgekehrt.

      Lassen Sie uns dies erneut tun, aber mit einem Schritt von -2:

      print(ss[::-2])
      

      Output

      !rh ma

      In diesem Beispiel, ss[::-2], handelt es sich um die Gesamtheit der ursprünglichen Zeichenfolge, da in den Parametern keine Indexnummern enthalten sind, und die Umkehrung der Zeichenfolge durch den negativen Schritt. Außerdem überspringen wir mit einem Schritt von -2 jeden zweiten Buchstaben der umgekehrten Zeichenfolge:

      ! krahS[Leerzeichen]ymmaS

      Das Leerzeichen wird in diesem Beispiel ausgedruckt.

      Indem Sie den dritten Parameter der Python-Scheiben-Syntax angeben, geben Sie den Schritt der Teilzeichenfolge an, den Sie aus der ursprünglichen Zeichenfolge ziehen.

      Zählmethoden

      Während wir über die relevanten Indexnummern nachdenken, die Zeichen in Zeichenfolgen entsprechen, lohnt es sich, einige der Methoden durchzugehen, die Zeichenfolgen zählen oder Indexnummern zurückgeben. Dies kann nützlich sein, um die Anzahl der Zeichen zu begrenzen, die wir in einem Benutzereingabeformular akzeptieren möchten, oder um Zeichenfolgen zu vergleichen. Wie bei anderen sequentiellen Datentypen können Zeichenfolgen mit verschiedenen Methoden gezählt werden.

      Wir werden uns zunächst die len() -Methode ansehen, mit der die Länge jedes Datentyps ermittelt werden kann, der eine geordnete oder ungeordnete Sequenz ist, einschließlich Zeichenfolgen, Listen, Tupeln und Wörterbüchern.

      Drucken wir die Länge der Zeichenfolge ss:

      print(len(ss))
      

      Output

      12

      Die Länge der Zeichenfolge „Sammy Shark!“ ist 12 Zeichen lang, einschließlich des Leerzeichens und des Ausrufezeichens.

      Anstatt eine Variable zu verwenden, können wir auch eine Zeichenfolge direkt an die len() -Methode übergeben:

      print(len("Let's print the length of this string."))
      

      Output

      38

      Die len() -Methode zählt die Gesamtzahl der Zeichen innerhalb einer Zeichenfolge.

      Wenn wir zählen möchten, wie oft entweder ein bestimmtes Zeichen oder eine Folge von Zeichen in einer Zeichenfolge angezeigt wird, können wir dies mit der str.count()-Methode tun. Arbeiten wir mit unserer Zeichenfolge ss = „Sammy Shark!“ und zählen die Anzahl der erscheinenden Zeichen „a“:

      print(ss.count("a"))
      

      Output

      2

      Wir können nach einem anderen Zeichen suchen:

      print(ss.count("s"))
      

      Output

      0

      Obwohl sich der Buchstabe „S“ in der Zeichenfolge befindet, ist es wichtig zu beachten, dass bei jedem Zeichen zwischen Groß- und Kleinschreibung unterschieden wird. Wenn wir unabhängig von der Groß- und Kleinschreibung nach allen Buchstaben in einer Zeichenfolge suchen möchten, können wir die Zeichenfolge mit der str.lower() -Methode zuerst in Kleinbuchstaben konvertieren. Weitere Informationen zu dieser Methode finden Sie unter „Eine Einführung in Zeichenfolgenmethoden in Python 3“.

      Versuchen wir str.count() mit einer Sequenz von Zeichen:

      likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile."
      print(likes.count("likes"))
      

      Output

      3

      In den Zeichenfolgen likes kommt die Zeichenfolge, die „likes“ entspricht, in der ursprünglichen Zeichenfolge dreimal vor.

      Wir können auch herausfinden, an welcher Position ein Zeichen oder eine Zeichenfolge in einer Zeichenfolge vorkommt. Wir können dies mit der str.find()-Methode tun, die die Position des Zeichens basierend auf der Indexnummer zurückgibt.

      Wir können überprüfen, wo das erste „m“ in der Zeichenfolge ss vorkommt:

      print(ss.find("m"))
      

      Ouput

      2

      Das erste Zeichen „m“ tritt an der Indexposition 2 in der Zeichenfolge „Sammy Shark!“ auf. Wir können die Indexnummerpositionen der oben beschriebenen Zeichenfolge ss überprüfen.

      Überprüfen wir, wo die erste Zeichenfolge „likes“ in der Zeichenfolge likes vorkommt:

      print(likes.find("likes"))
      

      Ouput

      6

      Die erste Instanz der Zeichenfolge „likes“ beginnt an der Indexnummernposition 6, an der sich das Zeichen l der Sequenz likes befindet.

      Was, wenn wir sehen möchten, wo die zweite Sequenz von „likes“ beginnt? Wir können dazu einen zweiten Parameter an die str.find()-Methode übergeben, die mit einer bestimmten Indexnummer beginnt. Anstatt also am Anfang der Zeichenfolge zu beginnen, beginnen wir nach der Indexnummer 9:

      print(likes.find("likes", 9))
      

      Output

      34

      In diesem zweiten Beispiel, das an der Indexnummer 9 beginnt, beginnt das erste Ereignis der Zeichenfolge „likes“ bei der Indexnummer 34.

      Zusätzlich können wir ein Ende für den Bereich als dritten Parameter angeben. Wie beim Schneiden können wir dies tun, indem wir mit einer negativen Indexzahl rückwärts zählen:

      print(likes.find("likes", 40, -6))
      

      Output

      64

      Dieses letzte Beispiel sucht nach der Position der Sequenz „likes“ zwischen den Indexnummern 40 und -6. Da der letzte eingegebene Parameter eine negative Zahl ist, zählt er vom Ende der ursprünglichen Zeichenfolge.

      Die Zeichenfolgemethoden len(), str.count() und str.find() können verwendet werden, um die Länge, die Zählungen von Zeichen oder Zeichenfolgen sowie Indexpositionen von Zeichen oder Zeichenfolgen in Zeichenfolgen zu bestimmen.

      Zusammenfassung

      Die Möglichkeit, bestimmte Indexnummern von Zeichenfolgen oder eine bestimmte Scheibe einer Zeichenfolge aufzurufen, bietet uns eine größere Flexibilität bei der Arbeit mit diesem Datentyp. Da Zeichenfolgen wie Listen und Tupel ein sequenzbasierter Datentyp sind, kann durch Indizieren und Schneiden auf sie zugegriffen werden.

      Sie können mehr über das Formatieren von Zeichenfolgen und Zeichenfolgenmethoden lesen, um weitere Informationen zu Zeichenfolgen zu erhalten.



      Source link

      So indizieren, teilen und bearbeiten Sie Zeichenfolgen in JavaScript


      Einführung

      Eine Zeichenfolge ist eine Sequenz von einem oder mehreren Zeichen, die aus Buchstaben, Zahlen oder Symbolen bestehen kann. Auf jedes Zeichen in einer JavaScript-Zeichenfolge kann über eine Indexnummer zugegriffen werden, und allen Zeichenfolgen stehen Methoden und Eigenschaften zur Verfügung.

      In diesem Tutorial lernen wir den Unterschied zwischen Zeichenfolgenprimitiven und dem Zeichenfolgenobjekt kennen, wie Zeichenfolgen indiziert werden, wie auf Zeichen in einer Zeichenfolge zugegriffen wird und welche allgemeinen Eigenschaften und Methoden für Zeichenfolgen verwendet werden.

      Zeichenfolgenprimitive und Zeichenfolgenobjekte

      Zuerst werden wir die beiden Arten von Zeichenfolgen klären. JavaScript unterscheidet zwischen der Zeichenfolgenprimitive, einem unveränderlichen Datentyp und dem Zeichenfolgenobjekt.

      Um den Unterschied zwischen den beiden zu testen, initialisieren wir eine Zeichenfolgenprimitive und ein Zeichenfolgenobjekt.

      // Initializing a new string primitive
      const stringPrimitive="A new string."
      
      // Initializing a new String object
      const stringObject = new String('A new string.')
      

      Wir können den Operator typeof verwenden, um den Typ eines Werts zu bestimmen. Im ersten Beispiel haben wir einer Variable einfach eine Zeichenfolge zugewiesen.

      typeof stringPrimitive
      

      Output

      string

      Im zweiten Beispiel haben wir eine neue Zeichenfolge() verwendet, um ein Zeichenfolgenobjekt zu erstellen und einer Variable zuzuweisen.

      typeof stringObject
      

      Output

      object

      Meistens erstellen Sie Zeichenfolgenprimitive. JavaScript kann auf die integrierten Eigenschaften und Methoden des Zeichenfolgen“objekt-Wrappers zugreifen und diese verwenden, ohne die von Ihnen erstellte Zeichenfolgenprimitive tatsächlich in ein Objekt zu ändern.

      Während dieses Konzepts zunächst etwas anspruchsvoll ist, sollten Sie sich der Unterscheidung zwischen Primitive und Objekt bewusst sein. Im Wesentlichen stehen allen Zeichenfolgen Methoden und Eigenschaften zur Verfügung. Im Hintergrund führt JavaScript bei jedem Aufruf einer Methode oder Eigenschaft eine Konvertierung in ein Objekt und zurück in eine Primitive durch.

      Wie Zeichenfolgen indiziert sind

      Jedes der Zeichen in einer Zeichenfolge entspricht einer Indexnummer, beginnend mit 0.

      Zur Demonstration erstellen wir eine Zeichenfolge mit dem Wert How are you?.

      H o w a r e y o u ?
      0 1 2 3 4 5 6 7 8 9 10 11

      Das erste Zeichen in der Zeichenfolge ist H, was dem Index 0 entspricht. Das letzte Zeichen ist ?, was 11 entspricht. Die Leerzeichen haben auch einen Index bei 3 und 7.

      Wenn wir auf jedes Zeichen in einer Zeichenfolge zugreifen können, haben wir verschiedene Möglichkeiten, mit Zeichenfolgen zu arbeiten und diese zu bearbeiten.

      Zugriff auf Zeichen

      Wir zeigen Ihnen, wie Sie auf Zeichen und Indizes mit der Zeichenfolge How are you? zugreifen können.

      'How are you?'
      
      

      Mit der quadratischen Klammernotation können wir auf jedes Zeichen in der Zeichenfolge zugreifen.

      'How are you?'[5]
      

      Output

      r

      Wir können auch die charAt()-Methode verwenden, um das Zeichen mit der Indexnummer als Parameter zurückzugeben.

      'How are you?'.charAt(5)
      

      Output

      r

      Alternativ können wir indexOf() verwenden, um die Indexnummer durch die erste Instanz eines Zeichens zurückzugeben.

      'How are you?'.indexOf('o')
      

      Output

      1

      Obwohl „o“ zweimal in der Zeichenfolge How are you? erscheint, erhält indexOf() die erste Instanz.

      lastIndexOf() wird verwendet, um die letzte Instanz zu finden.

      'How are you?'.lastIndexOf('o')
      

      Output

      9

      Für beide Methoden können Sie auch nach mehreren Zeichen in der Zeichenfolge suchen. Sie gibt die Indexnummer des ersten Zeichens in der Instanz zurück.

      'How are you?'.indexOf('are')
      

      Output

      4

      Die slice()-Methode hingegen gibt die Zeichen zwischen zwei Indexnummern zurück. Der erste Parameter ist die Startindexnummer und der zweite Parameter ist die Indexnummer, an der sie enden soll.

      'How are you?'.slice(8, 11)
      

      Output

      you

      Beachten Sie, dass 11 ? ist, aber ? ist nicht Teil der zurückgegebenen Ausgabe. slice() gibt zurück, was zwischen dem letzten Parameter liegt, schließt ihn jedoch nicht ein.

      Wenn ein zweiter Parameter nicht enthalten ist, gibt slice() alles vom Parameter bis zum Ende der Zeichenfolge zurück.

      'How are you?'.slice(8)
      

      Output

      you?

      Zusammenfassend helfen charAt() und slice() dabei, Zeichenfolgenwerte basierend auf Indexnummern zurückzugeben, und indexOf() und lastIndexOf() machen das Gegenteil und geben Indexnummern basierend auf den angegebenen Zeichenfolgen zurück.

      Die Länge einer Zeichenfolge finden

      Mit der Eigenschaft length können wir die Anzahl der Zeichen in einer Zeichenfolge zurückgeben.

      'How are you?'.length
      

      Output

      12

      Denken Sie daran, dass die Eigenschaft length die tatsächliche Anzahl von Zeichen zurückgibt, die mit 1 beginnen, was 12 ergibt, und nicht die endgültige Indexnummer, die bei 0 beginnt und bei 11 endet.

      Konvertieren in Groß- oder Kleinschreibung

      Die beiden integrierten Methoden toUpperCase() und toLowerCase() sind hilfreiche Möglichkeiten, um Text zu formatieren und Textvergleiche in JavaScript zu erstellen.

      toUpperCase() konvertiert alle Zeichen in Großbuchstaben.

      'How are you?'.toUpperCase()
      

      Output

      HOW ARE YOU?

      toLowerCase() konvertiert alle Zeichen in Kleinbuchstaben.

      'How are you?'.toLowerCase()
      

      Output

      how are you?

      Diese beiden Formatierungsmethoden nehmen keine zusätzlichen Parameter.

      Es lohnt sich, zu beachten, dass diese Methoden die ursprüngliche Zeichenfolge nicht ändern.

      Zeichenfolgen teilen

      JavaScript bietet eine sehr nützliche Methode, um eine Zeichenfolge durch ein Zeichen zu teilen und aus den Abschnitten eine neue Anordnung zu erstellen. Wir verwenden die split()-Methode, um die Anordnung durch ein Leerzeichen zu trennen, das durch „“ dargestellt ist.

      const originalString = 'How are you?'
      
      // Split string by whitespace character
      const splitString = originalString.split(' ')
      
      console.log(splitString)
      

      Output

      [ 'How', 'are', 'you?' ]

      Nachdem wir eine neue Anordnung in der splitString-Variablen haben, können wir auf jeden Abschnitt mit einer Indexnummer zugreifen.

      splitString[1]
      

      Output

      are

      Wenn ein leerer Parameter angegeben ist, erstellt split() eine durch Komma getrennte Anordnung mit jedem Zeichen in der Zeichenfolge.

      Durch die Trennung von Zeichenfolgen können Sie bestimmen, wie viele Wörter sich in einer Satz befinden und die Methode als Möglichkeit verwenden, um beispielsweise die Vornamen und die Nachnamen von Leuten zu bestimmen.

      Leerzeichen kürzen

      Die JavaScript-Methode trim() entfernt Leerzeichen an beiden Enden einer Zeichenfolge, jedoch nicht irgendwo dazwischen. Leerzeichen können Tabulatoren oder Leerzeichen sein.

      const tooMuchWhitespace="     How are you?     "
      
      const trimmed = tooMuchWhitespace.trim()
      
      console.log(trimmed)
      

      Output

      How are you?

      Die trim()-Methode ist eine einfache Möglichkeit, die gemeinsame Aufgabe auszuführen, um überschüssige Leerzeichen zu entfernen.

      Zeichenfolgenwerte suchen und ersetzen

      Wir können eine Zeichenfolge nach einem Wert durchsuchen und ihn mithilfe der replace() -Methode durch einen neuen Wert ersetzen. Der erste Parameter ist der zu findende Wert und der zweite Parameter ist der Wert, der ihn ersetzen kann.

      const originalString = 'How are you?'
      
      // Replace the first instance of "How" with "Where"
      const newString = originalString.replace('How', 'Where')
      
      console.log(newString)
      

      Output

      Where are you?

      Wir können nicht nur einen Wert durch einen anderen Zeichenfolgenwert ersetzen, sondern auch reguläre Ausdrücke verwenden, um replace() leistungsfähiger zu machen. Zum Beispiel wirkt sich replace() nur auf den ersten Wert aus, aber wir können das Flag g (global) verwenden, um alle Instanzen eines Werts abzufangen, und das Flag i (ohne Berücksichtigung der Groß- und Kleinschreibung), um Groß- und Kleinschreibung zu ignorieren.

      const originalString =
        "Javascript is a programming language. I'm learning javascript."
      
      // Search string for "javascript" and replace with "JavaScript"
      const newString = originalString.replace(/javascript/gi, 'JavaScript')
      
      console.log(newString)
      

      Output

      JavaScript is a programming language. I'm learning JavaScript.

      Dies ist eine sehr häufige Aufgabe, die reguläre Ausdrücke verwendet. Besuchen Sie Regexr, um weitere Beispiele für RegEx zu üben.

      Zusammenfassung

      Zeichenfolgen sind einer der am häufigsten verwendeten Datentypen, und es gibt eine Menge, was wir mit ihnen tun können.

      In diesem Tutorial haben wir den Unterschied zwischen der Zeichenfolgenprimitive und dem Zeichenfolgenobjekt kennengelernt, wie Zeichenfolgen indiziert werden und wie die integrierten Methoden und Eigenschaften von Zeichenfolgen verwendet werden, um auf Zeichen zuzugreifen, Text zu formatieren und Werte zu suchen und zu ersetzen.

      Eine allgemeinere Übersicht über Zeichenfolgen finden Sie im Lernprogramm „So arbeiten Sie mit Zeichenfolgen in JavaScript“.



      Source link