Mot Golang au pluriel

Dans le domaine de la programmation, il est parfois nécessaire de convertir un mot au pluriel. En golang, nous pouvons utiliser quelques astuces simples pour atteindre cet objectif. Dans cet article, nous présenterons comment utiliser Golang pour implémenter la fonction de conversion de mots en pluriels.

1. Règles de base

En golang, il existe quelques règles de base qui peuvent nous aider à convertir les mots au pluriel. Ces règles concernent principalement les points suivants :

• Pour les mots se terminant par une lettre consonne, ajoutez la terminaison -es.

Par exemple : le pluriel de box est boxes.

• Pour les mots se terminant par une consonne + y, remplacez y par -i et ajoutez -es à la fin.

Par exemple : la forme plurielle de bébé est bébés.

• Pour les mots se terminant par une voyelle ou -f ou -fe, ajoutez simplement -s à la fin.

Par exemple : la forme plurielle de livre est livres.

2. Code d'implémentation

Sur la base des règles ci-dessus, nous pouvons écrire un programme golang simple pour réaliser la fonction de conversion des mots en pluriels. Voici le code spécifique de ce programme :

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"))
}

Dans le code ci-dessus, nous utilisons une fonction pluralize() pour implémenter la fonction de conversion de mots en nombres pluriels. Cette fonction accepte un mot paramètre de type chaîne, qui représente le mot à convertir. Ensuite, sur la base des règles ci-dessus, nous utilisons une instruction switch-case pour déterminer le suffixe du mot et renvoyer sa forme plurielle correspondante.

Pour déterminer les deux dernières lettres du mot, nous utilisons la fonction len() et l'opération de découpage. Nous convertissons la chaîne de mots complète en une tranche et utilisons la fonction len() pour obtenir la longueur de la tranche. Ensuite, utilisez la syntaxe "[:len(word)-1]" pour obtenir tous les caractères sauf le dernier caractère. Nous pouvons également utiliser la syntaxe "[:len(word)-2]" pour obtenir le premier et le dernier caractères sauf. le dernier caractères autres que deux caractères.

Dans la fonction main(), nous avons utilisé quelques mots pour tester la fonction pluralize() et imprimer les résultats.

3. Conclusion

Dans cet article, nous avons présenté les règles de conversion des mots au pluriel en golang et écrit un programme simple pour implémenter cette fonction. Le programme utilise les techniques d'opérations de découpage et d'instructions de changement de casse, ainsi que la connaissance du suffixe et du jugement de suffixe et de la concaténation de chaînes. J'espère que les lecteurs pourront mieux maîtriser les compétences de base de la programmation Golang en étudiant cet article.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!