JAPANESE
https://neovisionconsulting.blogspot.com/2022/05/vwasmvvgographqlaiwebwebtool20220504.html
ー－－－－－－－－－－－
ENGLISH
https://neovisionconsulting.blogspot.com/2022/05/in-future-v-wasm-v-frameworks-etc-would.html
ー－－－－－－－－－－－－－－－－－
WASM V Sprache
GraphQL Go-Sprache
KI (maschinelles Lernen) Go Language
Go language Leicht zu schreiben Leicht zu erlernen auch für Anfänger Leicht verständlich Die Grammatik ist einfach und leicht verständlich
Die Sprache Go hat keine Klassen, aber es gibt Alternativen.
Wichtigster Punkt.
Kombinieren Sie mehrere Variablen zu einer Gruppe (Mitgliedsvariablen).
Definieren Sie Funktionen, die auf der Grundlage der Gruppierung auf sie einwirken können (Mitgliedsfunktionen).
-----
2020-04-07
Anmerkungen zu Dingen, bei denen ich in der Sprache Go stecken geblieben bin (Klassen und Vererbung)
Go Golang Go Sprache Klassen Zeiger Vererbung
Ich habe mit Golang angefangen.
Als ich anfing, stellte ich fest, dass Golang darauf ausgelegt ist, eine möglichst einfache Syntax und einen möglichst einfachen Code zu haben.
Aus diesem Grund hat Golang eine etwas komplizierte Syntax.
Aber ohne sie zu kennen, bin ich in Schwierigkeiten geraten, weil ich auf der Grundlage meiner Vorurteile und Annahmen aus anderen Sprachen geurteilt habe.
Hier möchte ich einige der Dinge aufschreiben, in die ich persönlich hineingeraten bin oder die ich missverstanden habe, als ich mit Golang angefangen habe, als Erinnerung für jedes Thema.
Diesmal ist es ein Memo über Klassen und Vererbung in Golang.
Golang hat keine Klassen
Die Leute sagen, dass Golang keine Klassen hat, und in der Tat hat es das.
Es gibt jedoch Dinge, die dem Unterricht nahe stehen.
Zu Beginn sind die wichtigsten Aufgaben, die Sie mit dem Unterricht erledigen wollen, in der Regel Dinge wie
Mehrere Variablen zu einer Gruppe zusammenfassen (Mitgliedsvariablen)
Definieren Sie Funktionen, die an die Gruppierung gebunden sind und diese manipulieren können (Mitgliedsfunktionen).
In Golang wird eine "Struktur" verwendet, um mehrere Variablen in einer Gruppe zu gruppieren, und Funktionen, die mit den gruppierten Elementen arbeiten, können als spezielle Funktionen definiert werden, die an die Struktur gebunden sind, um das zu erreichen, was Sie oben tun wollten.
Eine Klasse mit den Mitgliedsvariablen 'x' und 'y' und einer Mitgliedsfunktion 'test()', um deren Summe zu ermitteln, kann zum Beispiel wie folgt erstellt werden.
Paket Haupt
importieren "fmt"
// Zusammenfügen der Variablen in einer Struktur
Typ myStruct struct {
x int
y int
}
// Funktionen zur Manipulation der Struktur Aufgerufen durch das "." der Struktur Aufgerufen vom Betreiber
func (p *myStruct) test() int {
return p.x + p.y
}
func main() {
var a myStruct
a.x = 1
a.y = 2
fmt.Println(a.test()) // 3
}
Die Funktion "test()" ist ein wenig ungewohnt, aber so geschriebene Funktionen sind Mitgliedsfunktionen, die vom "."-Operator der Struktur aufgerufen werden. Operator der Struktur.
Auf die Elemente der Struktur kann jeder von außen zugreifen. Selbst wenn Sie keine Mitgliedsfunktionen definieren, können Sie das Gleiche erreichen, indem Sie Funktionen schreiben, die die Struktur als Argument nehmen und sie manipulieren.
Paket Haupt
importieren "fmt"
Typ myStruct struct {
x int
y int
}
// Manipulieren Sie eine Struktur, indem Sie sie als Argument nehmen
func test(p *myStruct) int {
return p.x + p.y
}
func main() {
var a myStruct
a.x = 1
a.y = 2
fmt.Println(test(&a)) // 3
}
Aber auch bei Strukturen, wie z.B. Klassen, können Sie deren Operationsfunktionen mit dem "." schreiben. Operator, genau wie in einer Klasse, so dass diese Betriebsfunktionen mit dem "." geschrieben werden können. Operator, genau wie in einer Klasse.
So geschrieben, sieht sie auf den ersten Blick wie eine Mitgliedsfunktion einer Klasse aus.
In Wirklichkeit wird die Funktion durch die Übergabe einer Struktur (oder eines Zeigers auf eine Struktur) manipuliert, aber es ist die Klasse in Golang, die es erlaubt, sie wie eine Mitgliedsfunktion der Struktur zu schreiben.
Vererbung
Wie bereits erwähnt, gibt es in Golang keine Klassen, sondern eher "struct + struct-operated function = class pseudo-class".
Es kann vorkommen, dass Sie eine bereits definierte klassenähnliche Struktur erweitern möchten, indem Sie später Variablen oder Manipulationsfunktionen hinzufügen. Dies ist die so genannte Vererbung in einer Klasse.
In Golang können Sie auch diese vererbungsähnlichen Dinge tun.
Wenn Sie eine übergeordnete Struktur als Element einer untergeordneten Struktur registrieren, die keinen Elementnamen, sondern nur den Namen der übergeordneten Struktur hat, können Sie auf die übergeordnete Struktur mit dem Elementnamen des Namens der übergeordneten Struktur zugreifen.
In Textform ist er schwer zu verstehen, daher lautet der Code wie folgt.
Paket Haupt
importieren "fmt"
// Übergeordnete Struktur
Typ parentStruct struct {
x int
y int
}
// Funktion der übergeordneten Struktur
func (p *parentStruct) testParent() {
fmt.Println("Elternteil", p.x, p.y)
}
// childStruct
Typ childStruct struct {
z int
parentStruct // übergeordnete Struktur
}
// Funktion der untergeordneten Struktur
func (p *childStruct) testChild() {
// Zugriff auf eine Variable in der übergeordneten Struktur
fmt.Println("Kind", p.parentStruct.x, p.parentStruct.y, p.z)
}
func main() {
var a childStruct
a.parentStruct.x = 1 // Zugriff auf übergeordnete Variable
a.parentStruct.y = 2 // Zugriff auf übergeordnete Variable
a.z = 3 // Zugriff auf die untergeordnete Variable
a.parentStruct.testParent() // Elternteil 1 2 Zugriff auf die Elternfunktion
a.testChild() // Child 1 2 3 Zugriff auf Child-Funktionen.
}
Vererbung
Wenn man sich den oben erwähnten Code ansieht, hat die untergeordnete Struktur nur Elemente der übergeordneten Struktur, anstatt von ihr zu erben, also scheint es natürlich, dass dies der Fall sein sollte.
Aber hier ist der Schlüssel.
Wenn Sie die obige Struktur schreiben, können Sie die Mitgliedsvariablen und Funktionen der übergeordneten Struktur aufrufen, indem Sie die Mitgliedsvariablen und Funktionen direkt unter die untergeordnete Struktur schreiben.
Mit anderen Worten, der vorgenannte Code kann auch wie folgt geschrieben werden, wobei der Name der übergeordneten Struktur weggelassen wird
Paket Haupt
importieren "fmt"
// Parent struct
Typ parentStruct struct {
x int
y int
}
// Funktion der übergeordneten Struktur
func (p *parentStruct) testParent() {
fmt.Println("Elternteil", p.x, p.y)
}
// childStruct
Typ childStruct struct {
z int
parentStruct
}
// Funktion der untergeordneten Struktur
func (p *childStruct) testChild() {
// Zugriff auf Variablen der übergeordneten Struktur
fmt.Println("Kind", p.x, p.y, p.z) // übergeordnete Strukturmodifikatoren können weggelassen werden
}
func main() {
var a childStruct
a.x = 1 // Zugriff auf übergeordnete Variable Kann übergeordneten Strukturmodifikator weglassen
a.y = 2 // Zugriff auf übergeordnete Variable Kann übergeordneten Strukturmodifikator weglassen
a.z = 3
a.testParent() // Elternteil 1 2 Zugriff auf die Elternfunktion Kann den Modifikator für die Elternstruktur weglassen
a.testChild() // Kind 1 2 3
}
So geschrieben, sieht es auf den ersten Blick wie eine Vererbung aus.
Eigentlich ist es keine Vererbung, da Sie nur die übergeordnete Struktur als Element haben, aber es ist die Vererbung in Golang, die es Ihnen erlaubt, es so zu schreiben, als ob es vererbt wird.
Was ist, wenn die Element- und Funktionsnamen abgedeckt sind?
Was geschieht, wenn eine untergeordnete Struktur ein Element oder eine Funktion mit demselben Namen wie die übergeordnete Struktur definiert?
In diesem Fall wird das Element/die Funktion der untergeordneten Struktur verwendet. Der Zugriff auf die Elemente und Funktionen der übergeordneten Struktur erfolgt durch Angabe des Namens der übergeordneten Struktur, wie im ersten Abschnitt beschrieben.
Paket Haupt
importieren "fmt"
Typ parentStruct struct {
x int
y int
}
func (p *parentStruct) test() {
fmt.Println("Elternteil", p.x, p.y)
}
Typ childStruct struct {
x int
parentStruct
}
func (p *childStruct) test() {
// x ist ein Duplikat; um auf x in der übergeordneten Struktur zuzugreifen, ist die übergeordnete Struktur anzugeben
fmt.Println("Kind", p.parentStruct.x, p.y, p.x)
}
func main() {
var a childStruct.
// x ist ein Duplikat; um auf x in der übergeordneten Struktur zuzugreifen, ist die übergeordnete Struktur anzugeben
a.parentStruct.x = 1
a.y = 2
a.x = 3
// test() ist ein Duplikat. Um auf test() der übergeordneten Struktur zuzugreifen, ist die übergeordnete Struktur anzugeben.
a.parentStruct.test() // Elternteil 1 2
a.test() // Kind 1 2 3
}
Mit anderen Worten: "Sie können Mitgliedsvariablen und Funktionen der übergeordneten Struktur aufrufen, indem Sie Mitgliedsvariablen und Funktionen direkt unter die untergeordnete Struktur schreiben", denn der Compiler sieht sich den Code an und vervollständigt die Namen der übergeordneten Struktur hinter den Kulissen, um Himmels willen.
Verwendung der Vererbung
Es gibt Fälle, in denen Sie einer bereits als Objekt angelegten Struktur Elemente oder Funktionen hinzufügen möchten. In solchen Fällen kann die Vererbung gut eingesetzt werden.
Nehmen wir zum Beispiel an, Sie möchten die http.Clinet-Struktur so erweitern, dass sie die Ergebnisse einer Google-Suche enthält.
Paket Haupt
importieren (
"fmt".
"io/ioutil"
"net/http"
)
// Vererben einer Struktur mit neuen Funktionen
type googleSearch struct {
result string // Ergebnis
*http.Client // Zeiger auf die geerbte Struktur
}
// Funktion search() hinzufügen Suchergebnisse werden in result gespeichert
func (p *googleSearch) search(q string) {
resp, err := p.Get(fmt.Sprintf("https://www.google.com?q=%s", q))
if err ! = nil {
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err ! = nil {
return
}
p.result = string(body).
}
func main() {
c := &http.Client{}
g := googleSearch{Client: c} // Erben von http.Client und Hinzufügen neuer Elemente/Funktionen
g.search("test")
fmt.Println(g.result)
}
Es gibt viele Fälle, in denen Strukturen mit einem Zeiger abgerufen werden, und in solchen Fällen ist es wichtig, sicherzustellen, dass die übergeordnete Struktur mit einem Zeiger empfangen wird.
Wenn Sie eine erweiterte Struktur anlegen, weisen Sie den Zeiger der übergeordneten Struktur dem bereits abgerufenen Zeiger zu.
Sie können dann von der untergeordneten Struktur aus direkt auf die Elemente/Funktionen der übergeordneten Struktur zugreifen.
Kommentare, etc.
Da Strukturen und ihre Operationsfunktionen unabhängig voneinander an verschiedenen Stellen definiert werden, ist es schwieriger, herauszufinden, welche Operationsfunktionen eine Struktur im Vergleich zu einer Klasse hat.
In der Tat sind Strukturen unabhängig von Strukturen und Funktionen unabhängig von Funktionen, und der Compiler verbindet sie nur in der Kodierung miteinander, ohne dass die Struktur an den Funktionen ihrer Mitglieder beteiligt ist.
Vererbung ist keine Vererbung, sondern einfach eine Struktur mit übergeordneten Strukturen als Elementen. Ich habe das missverstanden und bin stecken geblieben. Wenn Sie wissen, wie Sie den Namen der übergeordneten Struktur auslassen, können Sie sich leicht festfahren.
Die Syntax von Golang ist primitiv, aber sie erlaubt es Ihnen, auf verschiedene Arten zu schreiben und auszulassen, was sie zu einer Hochleistungssprache macht.
Hmmm... Golang ist eine vernünftige und recht interessante Sprache.
0 コメント:
コメントを投稿