Nietzsche wurde in einer Katze wiedergeboren, einem mit GO erstellten „Werkzeug'-CLI

Ich habe drei GO-Projekte im Kopf, aber ich habe Angst, sie fertigzustellen. Ich möchte es tun und habe das Gefühl, dass ich dabei lerne, anstatt nur Codes aus Stackoverflow und Chatgpt zu kopieren und einzufügen.

Ich möchte die Codes, Konzepte und Ideen der Projekte analysieren, um sie in einem Artikel wie diesem zu erklären. Ich glaube, dass ich mir auf diese Weise das Wissen aneignen kann, das hinter der Erstellung von Projektcodes steckt.

Von den drei Projekten erweist sich keines als sehr einfach. Also habe ich darüber nachgedacht, ein viertes Projekt zu erstellen, einfacher, kürzer und bei dem ich etwas lernen kann.

Etwas ist besser als nichts. Und nichts ist besser als alles Unvollendete.

Aber trotzdem, lass es uns tun!

FCAT?

Ah, der Name ist wirklich lustig, aber ich habe über das Konzept von F-String nachgedacht, bei dem man einen String in einen Code einfügt.

Was die Katze betrifft... nun, da habe ich es. Menschen mögen Katzen. Außerdem dachte ich, Nietzsche wäre eine Katze statt eines Hundes, eines Schmetterlings, eines Elefanten, eines Dinosauriers oder eines Faultiers. Das ist es also. Es ist eine Katze, denn JA.

Was ist das Problem?

Wir beginnen damit, dass wir bereits eine TXT-Datei mit Nitzsches Zitaten haben. Das Programm muss eine davon zufällig auswählen und dem Benutzer zur Verfügung stellen. Zusätzlich müssen Sie die Katze in ASCII drucken und eine Sprechblase um das angezeigte Zitat bilden.

Kurz gesagt:

Datei mit Zitaten: .txt-Datei mit Zitaten von Nietzsche, wobei jedes Zitat in einer separaten Zeile steht.

Katzenzeichnung in ASCII: Definieren wir die Katzenzeichnung, die im Terminal gedruckt wird.

Dieses hat mir gefallen. Er hat faszinierende Augen.

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

Ein zufälliges Zitat laden und auswählen: Das Programm liest die Zitate aus einer TXT-Datei und wählt zufällig eines aus.

Zitat mit Sprechblase drucken: Das Zitat wird in einer Sprechblase über der Katze angezeigt.

Lass uns gehen, Baby

Zuallererst:

Erstellen Sie ein Verzeichnis für das Projekt und navigieren Sie dorthin:

mkdir fcat
cd fcat

Erstellen Sie eine main.go-Datei:

touch main.go

Go-Module initialisieren:

go mod init main.go

Ihr Verzeichnis sollte so aussehen:

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

Öffnen Sie jetzt main.go in Ihrer bevorzugten IDE.

NVIM, wenn es ein Hype ist XD

Code-Erklärung:

LoadCitations-Funktion

Diese Funktion öffnet die Zitatdatei (nietzsche.txt), liest jede Zeile und speichert alle Zitate in einer Liste.

Die Funktion empfängt keine Argumente, sondern gibt lediglich eine Liste/einen Abschnitt von Zeichenfolgen und Fehler: string und Fehler:
zurück

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

Innerhalb der Funktion initialisieren wir einen Slice/eine Liste, um alle Anführungszeichen zu empfangen:

mkdir fcat
cd fcat

Jetzt öffnen wir die TXT-Datei:

touch main.go

Jetzt müssen wir einen „Scanner“ erstellen, um unsere Angebotsdatei quotes.txt zu lesen.

Außerdem muss jede Zeile der Datei gelesen werden.

go mod init main.go

Jetzt überprüfen wir den Fehler beim Lesen der txt-Datei mit Zitaten und geben unsere Liste mit den hinzugefügten Zitaten zurück.

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

Jetzt müssen wir die Hauptfunktion erstellen, um die Zitate zurückzugeben und prüfen, ob die Funktion „loadCitations“ korrekt ist:

package main

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

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

Der Code sollte so aussehen:

package main

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

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

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

}

Jetzt führen wir den Code im Terminal aus

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

Sie sollten alle Zitate in Ihrer quotes.txt-Datei in Ihrem Terminal sehen.

getRandomCitation-Funktion

Diese Funktion verwendet die Mathematik-/Rand-Bibliothek, um ein zufälliges Zitat aus der Liste auszuwählen.

In den Klammern () der Funktion definieren Sie die Parameter, die die Funktion als Eingabe erhält. Im Beispiel:

• citations []string bedeutet, dass die getRandomCitation-Funktion ein Argument namens citations erwartet, bei dem es sich um ein Segment von Strings (also eine Liste von Strings) handelt.

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 ist Gos Syntax für „ein Stück Strings“, also eine geordnete Sammlung von Strings.

Wenn Sie die Funktion aufrufen, müssen Sie eine Liste von Anführungszeichen übergeben (z. B. geladen aus der Datei quotes.txt), und diese Liste wird innerhalb der Funktion verwendet.

Nach den Eingabeklammern, direkt vor dem Funktionskörper {}, geben Sie den Werttyp an, den die Funktion zurückgeben soll.

• Eine Zeichenfolge direkt nach den Klammern bedeutet, dass die Funktion nach Abschluss der Ausführung eine Zeichenfolge zurückgibt.

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
}

In diesem Fall gibt die Funktion ein zufälliges Anführungszeichen zurück, bei dem es sich um eine einzelne Zeichenfolge handelt.

Wir müssen jedoch einen Zufallswert generieren, aber WIRKLICH zufällig. Wenn wir nur rand.Seed() verwenden, ist der Standard-Seed immer derselbe. Deshalb müssen wir zwei weitere Funktionen als Parameter übergeben:

• time.Now(), das die aktuelle Uhrzeit zurückgibt

• UnixNano(), das diese Zeit in eine Ganzzahl umwandelt, die die Anzahl der Nanosekunden seit dem 1. Januar 1970 darstellt. Die hohe Granularität ist der Katzensprung XD

Und dann brauchen wir die Funktion, um einen zufälligen Index von Zitaten entsprechend der Größe der Zitationsliste (Länge) zurückzugeben

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) gibt die Anzahl der Zitate im Slice zurück.

• rand.Intn(n) generiert eine Zufallszahl zwischen 0 und n-1.

• rand.Intn(len(citations)) wählt einen gültigen Zufallsindex aus, um auf ein Zitat aus der Liste zuzugreifen.

Und jetzt ändern wir die Hauptfunktion, um das zufällige Zitat zu drucken:

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

Unser Code sollte so aussehen:

mkdir fcat
cd fcat

Führen Sie nun main.go in Ihrem Terminal aus, um zu prüfen, ob wir ein zufälliges Angebot erhalten können:

touch main.go

DruckfunktionKat

Diese Funktion zeigt eine Zeichnung einer Katze in ASCII an und druckt das Zitat in eine Sprechblase.

go mod init main.go

Hauptfunktion

In der main()-Funktion lädt das Programm die Zitate, wählt ein zufälliges aus und druckt die Katze mit dem Zitat in einer Sprechblase.

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

Unser endgültiger Code sollte so aussehen:

package main

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

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

Abschluss

Jetzt müssen wir nur noch unser Programm kompilieren und ausführen.

Kompilieren Sie Ihre main.go-Datei als fcat:

package main

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

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

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

}

Und schließlich führen Sie Folgendes aus:

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

Das war das Ergebnis:

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

Ich fand es interessant, wie etwas so Einfaches in der Ausführung so kompliziert werden kann.

Aber was mich beeindruckte, war der Eröffnungssatz der Sendung: „Wer ein Warum zum Leben hat, kann fast jedes Wie ertragen“

Möge der obige Satz Sie dazu inspirieren, weiter zu lernen.

---

Ionen,

Ein weiterer Tag auf Erden

Das obige ist der detaillierte Inhalt vonNietzsche wurde in einer Katze wiedergeboren, einem mit GO erstellten „Werkzeug'-CLI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!