Golang-Wort zu Plural

Im Bereich der Programmierung ist es manchmal notwendig, ein Wort in seine Pluralform umzuwandeln. In Golang können wir einige einfache Tricks anwenden, um dieses Ziel zu erreichen. In diesem Artikel stellen wir vor, wie man mit Golang die Funktion der Konvertierung von Wörtern in Pluralformen implementiert.

1. Grundregeln

In Golang gibt es einige Grundregeln, die uns helfen können, Wörter in Pluralformen umzuwandeln. Diese Regeln betreffen im Wesentlichen die folgenden Punkte:

• Bei Wörtern, die mit einem Konsonanten enden, fügen Sie die Endung -es hinzu.

Zum Beispiel: Die Pluralform von Box ist Boxen.

• Bei Wörtern, die mit einem Konsonanten +y enden, ändern Sie y in -i und fügen Sie am Ende -es hinzu.

Zum Beispiel: Die Pluralform von Baby ist Babies.

• Für Wörter, die mit einem Vokal oder -f oder -fe enden, fügen Sie einfach -s danach hinzu.

Zum Beispiel: Die Pluralform von Buch ist Bücher.

2. Implementierungscode

Basierend auf den oben genannten Regeln können wir ein einfaches Golang-Programm schreiben, um Wörter in Pluralformen umzuwandeln. Das Folgende ist der spezifische Code dieses Programms:

package main

import "fmt"

func pluralize(word string) string {
  lastLetter := word[len(word)-1:]
  beforeLastLetter := word[len(word)-2 : len(word)-1]
  switch lastLetter {
  case "y":
    if beforeLastLetter == "a" || beforeLastLetter == "e" || beforeLastLetter == "i" || beforeLastLetter == "o" || beforeLastLetter == "u" {
      return word + "s"
    } else {
      return word[:len(word)-1] + "ies"
    }
  case "x", "s", "z", "o":
    return word + "es"
  case "h":
    if beforeLastLetter == "s" || beforeLastLetter == "c" {
      return word + "es"
    } else {
      return word + "s"
    }
  case "f":
    if beforeLastLetter == "f" {
      return word[:len(word)-2] + "ves"
    } else {
      return word[:len(word)-1] + "ves"
    }
  default:
    return word + "s"
  }
}

func main() {
  fmt.Println(pluralize("box"))
  fmt.Println(pluralize("baby"))
  fmt.Println(pluralize("book"))
  fmt.Println(pluralize("tomato"))
  fmt.Println(pluralize("life"))
  fmt.Println(pluralize("wife"))
}

Im obigen Code verwenden wir eine Funktion pluralize(), um die Funktion der Konvertierung von Wörtern in Pluralzahlen zu realisieren. Diese Funktion akzeptiert ein Parameterwort vom Typ String, das das umzuwandelnde Wort darstellt. Als nächstes verwenden wir basierend auf den oben genannten Regeln eine Anweisung zum Wechseln der Groß- und Kleinschreibung, um das Suffix des Worts zu bestimmen und die entsprechende Pluralform zurückzugeben.

Um die letzten beiden Buchstaben des Wortes zu bestimmen, verwenden wir die Funktion len() und die Slicing-Operation. Wir wandeln die komplette Wortzeichenfolge in ein Slice um und verwenden die Funktion len(), um die Länge des Slice zu ermitteln. Als nächstes verwenden Sie die Syntax „[:len(word)-1]“, um alle Zeichen außer dem letzten Zeichen abzurufen. Wir können auch die Syntax „[:len(word)-2]“ verwenden, um das erste und letzte Zeichen außer zu erhalten das letzte Zeichen außer zwei Zeichen.

In der Funktion main() haben wir einige Wörter verwendet, um die Funktion pluralize() zu testen und die Ergebnisse auszudrucken.

3. Fazit

In diesem Artikel haben wir die Regeln für die Konvertierung von Wörtern in Pluralformen in Golang vorgestellt und ein einfaches Programm geschrieben, um diese Funktion zu implementieren. Das Programm nutzt die Techniken von Slicing-Operationen und Switch-Case-Anweisungen sowie das Wissen über Suffix- und Suffixbeurteilung und String-Verkettung. Ich hoffe, dass die Leser durch das Studium dieses Artikels die grundlegenden Fähigkeiten der Golang-Programmierung besser beherrschen können.

Das obige ist der detaillierte Inhalt vonGolang-Wort zu Plural. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!