Nietzsche réincarné en chat, un "outil" CLI réalisé avec GO

J'ai trois projets GO en tête, mais j'ai peur de les terminer. Je veux le faire et avoir le sentiment d'apprendre au fur et à mesure, au lieu de simplement copier et coller des codes de stackoverflow et chatgpt.

Je souhaite décortiquer les codes, concepts et idées des projets pour les expliquer dans un article, comme celui-ci. Je crois que de cette façon, je serais en mesure d'absorber les connaissances derrière la production de codes de projet.

Sur les trois projets, aucun ne s'avère très simple. J'ai donc pensé à construire un quatrième projet, plus simple, plus court et où je pourrais apprendre quelque chose.

Quelque chose vaut mieux que rien. Et rien n'est mieux que quelque chose d'inachevé.

Mais quand même, faisons-le !

FCAT?

Ah, le nom est vraiment drôle, mais j'ai pensé au concept de f-string, où l'on introduit une chaîne dans du code.

Quant au chat... eh bien, voilà. Les gens aiment les chats. En plus de cela, je pensais que Nietzsche serait un chat, au lieu d'un chien, d'un papillon, d'un éléphant, d'un dinosaure ou d'un paresseux. Alors c'est tout. C'est un chat, parce que OUI.

Quel est le problème ?

Nous commençons par le fait que nous avons déjà un fichier txt avec les citations de Nitzsche. Le programme doit en sélectionner un au hasard et le mettre à la disposition de l'utilisateur. De plus, vous devez imprimer le chat en ASCII et former une bulle autour de la citation affichée.

En bref :

Fichier avec guillemets : fichier .txt avec des citations de Nietzsche, où chaque citation est sur une ligne distincte.

Dessin de chat en ASCII : Définissons le dessin de chat qui sera imprimé dans le terminal.

J'ai aimé celui-ci. Il a des yeux fascinants.

 ,_     _
 |\_,-~/
 / _  _ |    ,--.
(  @  @ )   / ,-'
 \  _T_/-._( (
 /         `. \
|         _  \ |
 \ \ ,  /      |
  || |-_\__   /
 ((_/`(____,-'

Charger et sélectionner une citation aléatoire : Le programme lira les citations d'un fichier .txt et en sélectionnera une au hasard.

Imprimer la citation avec bulle : La citation sera affichée à l'intérieur d'une bulle au-dessus du chat.

Allons-y, bébé

Tout d'abord :

Créez un répertoire pour le projet et accédez-y :

mkdir fcat
cd fcat

Créez un fichier main.go :

touch main.go

Initialiser les modules go :

go mod init main.go

Votre répertoire devrait ressembler à ceci :

fcat
.
├── go.mod
├── main.go
└── quotes.txt

Maintenant, ouvrez main.go dans votre IDE préféré.

NVIM si c'est du battage médiatique XD

Explication du code :

Fonction LoadCitations

Cette fonction ouvre le fichier de citation (nietzsche.txt), lit chaque ligne et stocke toutes les citations dans une liste.

La fonction ne recevra pas d'arguments, elle renverra simplement une liste/tranche de chaînes et une erreur : string et error :

 ,_     _
 |\_,-~/
 / _  _ |    ,--.
(  @  @ )   / ,-'
 \  _T_/-._( (
 /         `. \
|         _  \ |
 \ \ ,  /      |
  || |-_\__   /
 ((_/`(____,-'

Au sein de la fonction nous initialiserons une tranche/liste pour recevoir tous les devis :

mkdir fcat
cd fcat

Maintenant, ouvrons le fichier txt :

touch main.go

Maintenant, nous devrons créer un "scanner" pour lire notre fichier de devis quotes.txt.

Il faudra également lire chaque ligne du fichier.

go mod init main.go

Maintenant, nous allons vérifier l'erreur lors de la lecture du fichier txt des citations et renvoyer notre liste avec les citations qui y ont été ajoutées.

fcat
.
├── go.mod
├── main.go
└── quotes.txt

Nous devons maintenant créer la fonction principale pour renvoyer les citations et vérifier si la fonction loadCitations est correcte :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations()([]string, error) {
}

Le code devrait ressembler à ceci :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

}

Maintenant, exécutons le code dans le terminal

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   
}

Vous devriez voir toutes les citations dans votre fichier quotes.txt dans votre terminal.

fonction getRandomCitation

Cette fonction utilise la bibliothèque math/rand pour sélectionner une citation aléatoire dans la liste.

À l'intérieur des parenthèses de la fonction (), vous définissez les paramètres que la fonction reçoit en entrée. Dans l'exemple :

• citations []string signifie que la fonction getRandomCitation attend un argument appelé citations, qui est une tranche de chaînes (c'est-à-dire une liste de chaînes).

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)


    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista/slice citas
    }
}

• []string est la syntaxe de Go pour "une tranche de chaînes", c'est-à-dire une collection ordonnée de chaînes.

Lorsque vous appelez la fonction, vous devez transmettre une liste de guillemets (par exemple chargés à partir du fichier quotes.txt), et cette liste sera utilisée au sein de la fonction.

Après les parenthèses de saisie, juste avant le corps de la fonction {}, vous spécifiez le type de valeur que la fonction renverra.

• chaîne juste après les parenthèses signifie que la fonction renverra une chaîne une fois son exécution terminée.

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)

    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista citas
    }

    // Verifica se houve erro na leitura do arq txt
    if err := scanner.Err(); err != nil {
        return nil, err
    }

    // Retornar nossa lista com citações
    return citas, nil // Retorna lista de citações
}

Dans ce cas, la fonction renverra une citation aléatoire, qui est une seule chaîne.

Cependant, nous devons générer une valeur aléatoire, mais VRAIMENT aléatoire. Si nous utilisons uniquement rand.Seed(), la graine par défaut sera toujours la même. C'est pourquoi nous devons passer deux autres fonctions en paramètres :

• time.Now(), qui renvoie l'heure actuelle

• UnixNano(), qui se convertira cette fois en un entier, représentant le nombre de nanosecondes depuis le 1er janvier 1970. La haute granularité qui fait le grand saut XD

Et puis nous avons besoin de la fonction pour renvoyer un index aléatoire de citations en fonction de la taille de la liste de citations (longueur)

func main() {
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações", err)
        return
    }

    for _, citation := range citations {
        fmt.Println(citation)
    }
}

• len(citations) renvoie le nombre de citations dans la tranche.

• rand.Intn(n) génère un nombre aléatoire compris entre 0 et n-1.

• rand.Intn(len(citations)) sélectionne un index aléatoire valide pour accéder à une citation dans la liste.

Et maintenant modifions la fonction principale pour imprimer la citation aléatoire :

 ,_     _
 |\_,-~/
 / _  _ |    ,--.
(  @  @ )   / ,-'
 \  _T_/-._( (
 /         `. \
|         _  \ |
 \ \ ,  /      |
  || |-_\__   /
 ((_/`(____,-'

Notre code devrait ressembler à ceci :

mkdir fcat
cd fcat

Maintenant, lancez main.go dans votre terminal pour vérifier si nous pouvons obtenir un devis aléatoire :

touch main.go

Fonction d'impressionCat

Cette fonction affiche un dessin d'un chat en ASCII et imprime la citation dans une bulle.

go mod init main.go

fonction principale

Dans la fonction main(), le programme charge les citations, en sélectionne une au hasard et imprime le chat avec la citation dans un ballon.

fcat
.
├── go.mod
├── main.go
└── quotes.txt

Notre code final devrait ressembler à ceci :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations()([]string, error) {
}

Finition

Il ne nous reste plus qu'à compiler notre programme et à l'exécuter.

Compilez votre fichier main.go en tant que fcat :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

}

Et enfin, exécutez :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   
}

Voici le résultat :

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)


    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista/slice citas
    }
}

J'ai trouvé intéressant de voir comment quelque chose d'aussi simple peut devenir si compliqué à exécuter.

Mais ce qui m'a impressionné, c'est la phrase d'ouverture du programme : "Celui qui a un pourquoi vivre peut supporter presque n'importe quel comment"

Que la phrase ci-dessus vous inspire à continuer à apprendre.

---

ions,

Un autre jour sur terre

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!