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
Язык GraphQL Go
AI (машинное обучение) Go Language
Язык Go Легко писать Легко учиться даже для новичков Легко понять Грамматика проста и понятна
В языке Go нет классов, но есть альтернативы.
https://www.kwbtblog.com/entry/2020/04/07/055735
Ключевой момент.
Объедините несколько переменных в одну группу (переменные-члены).
Определите функции, которые могут работать над ними, на основе группировки (функции-члены).
-----
2020-04-07
Заметки о вещах, на которых я застрял в языке Go (классы и наследование)
Язык Go Golang Go Классы Указатели Наследование
Я начал работать с Golang.
Когда я начинал, я обнаружил, что Golang разработан так, чтобы иметь как можно более простой синтаксис и как можно более простой код.
В связи с этим синтаксис Golang немного сложный.
Однако, не зная их, я попадал в неприятные ситуации, потому что выносил суждения, основанные на моих предубеждениях и предположениях из других языков.
Здесь я хотел бы записать некоторые вещи, с которыми я лично столкнулся или которые неправильно понял, когда начинал работать с Golang, в качестве напоминания по каждой теме.
На этот раз это памятка о классах и наследовании в Golang.
В Golang нет классов
Люди говорят, что в Golang нет классов, и это действительно так.
Однако есть вещи, которые близки к занятиям.
Начнем с того, что основные вещи, которые вы хотите делать с помощью классов, обычно такие, как
Объедините несколько переменных в одну группу (переменные-члены)
Определите функции, которые связаны с группировкой и могут манипулировать ими (функции-члены).
В Golang "структура" используется для группировки нескольких переменных в одну группу, а функции, которые работают над сгруппированными элементами, могут быть определены как специальные функции, привязанные к структуре для достижения того, что вы хотели сделать выше.
Например, класс с переменными-членами 'x' и 'y' и функцией-членом 'test()' для получения их суммы может быть создан следующим образом.
основной пакет
импортировать "fmt"
// Поместите переменные вместе в структуру
тип myStruct struct {
x int
y int
}
// Функции для манипулирования структурой Вызываются по "." структуры. Вызывается оператором
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
}
Функция "test()" немного непривычна, но функции, написанные таким образом, являются функциями-членами, вызываемыми из оператора "." структуры. оператор структуры.
К элементам структуры может получить доступ любой человек извне, поэтому даже если вы не определяете функции-члены, вы можете добиться того же, написав функции, которые принимают структуру в качестве аргумента и манипулируют ею.
основной пакет
импортировать "fmt"
тип myStruct struct {
x int
y int
}
// Манипулировать структурой, принимая ее в качестве аргумента
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
}
Однако даже в структурах, таких как классы, вы можете записывать их рабочие функции с помощью ".". оператор, как в классе, так что эти операционные функции могут быть записаны с помощью ".". оператор, как и в классе.
В таком виде она выглядит, на первый взгляд, как функция-член класса.
В действительности, функция управляется путем передачи структуры (или указателя на структуру), но именно класс в Golang позволяет написать ее как функцию-член структуры.
Наследование
Как упоминалось выше, в Golang нет классов, а скорее "struct + struct-operated function = class pseudo-class".
Бывают случаи, когда вы хотите расширить уже определенную классоподобную структуру, добавив переменные или функции манипулирования позже. Это так называемое наследование в классе.
В Golang вы также можете делать подобные наследованию вещи.
Если вы регистрируете родительскую структуру как элемент дочерней структуры без имени элемента, а только имя родительской структуры, вы можете получить доступ к родительской структуре с помощью имени элемента имени родительской структуры.
Его трудно понять, когда он написан текстом, поэтому код выглядит следующим образом.
основной пакет
импортировать "fmt"
// Родительская структура
тип parentStruct struct {
x int
y int
}
// функция родительской структуры
func (p *parentStruct) testParent() {
fmt.Println("Родитель", p.x, p.y)
}
// childStruct
тип childStruct struct {
z int
parentStruct // родительская структура
}
// функция дочерней структуры
func (p *childStruct) testChild() {
// доступ к переменной в родительской структуре
fmt.Println("Ребенок", p.parentStruct.x, p.parentStruct.y, p.z)
}
func main() {
var a childStruct
a.parentStruct.x = 1 // Доступ к родительской переменной
a.parentStruct.y = 2 // доступ к родительской переменной
a.z = 3 // доступ к дочерней переменной
a.parentStruct.testParent() // Родитель 1 2 Доступ к родительской функции
a.testChild() // Child 1 2 3 Доступ к дочерним функциям.
}
Наследование
Если посмотреть на вышеупомянутый код, то дочерняя структура просто содержит элементы родительской структуры, а не наследуется от нее, поэтому кажется естественным, что так и должно быть.
Однако здесь есть ключ к разгадке.
Если вы напишете приведенную выше структуру, вы можете вызывать переменные-члены и функции родительской структуры, записывая переменные-члены и функции непосредственно под дочерней структурой.
Другими словами, вышеупомянутый код можно записать следующим образом, опустив имя родительской структуры
основной пакет
импортировать "fmt"
// Структура родителя
тип parentStruct struct {
x int
y int
}
// функция родительской структуры
func (p *parentStruct) testParent() {
fmt.Println("Родитель", p.x, p.y)
}
// childStruct
тип childStruct struct {
z int
parentStruct
}
// Функция дочерней структуры
func (p *childStruct) testChild() {
// Доступ к переменным родительской структуры
fmt.Println("Child", p.x, p.y, p.z) // можно опустить модификаторы родительской структуры
}
func main() {
var a childStruct
a.x = 1 // Доступ к родительской переменной Можно опустить модификатор parent struct
a.y = 2 // Доступ к родительской переменной Можно опустить модификатор parent struct
a.z = 3
a.testParent() // Родитель 1 2 Доступ к родительской функции Можно опустить модификатор родительской структуры
a.testChild() // Ребенок 1 2 3
}
Когда это написано таким образом, на первый взгляд это выглядит как наследование.
На самом деле, это не наследование, поскольку у вас есть только родительская структура как элемент, но именно наследование в Golang позволяет вам писать так, как будто оно наследуется.
Что делать, если имена элементов и функций закрыты?
Что произойдет, если дочерняя структура определит элемент или функцию с тем же именем, что и родительская структура?
В этом случае используется элемент/функция дочерней структуры. Доступ к элементам и функциям родительской структуры осуществляется путем указания имени родительской структуры, как описано в первом разделе.
основной пакет
импортировать "fmt"
тип parentStruct struct {
x int
y int
}
func (p *parentStruct) test() {
fmt.Println("Родитель", p.x, p.y)
}
тип childStruct struct {
x int
parentStruct
}
func (p *childStruct) test() {
// x является дубликатом, поэтому для доступа к x в родительской структуре укажите родительскую структуру
fmt.Println("Ребенок", p.parentStruct.x, p.y, p.x)
}
func main() {
var a childStruct.
// x является дубликатом, поэтому для доступа к x в родительской структуре укажите родительскую структуру
a.parentStruct.x = 1
a.y = 2
a.x = 3
// test() является дубликатом, поэтому для доступа к test() родительской структуры укажите родительскую структуру
a.parentStruct.test() // Родитель 1 2
a.test() // Ребенок 1 2 3
}
Другими словами, "вы можете вызывать переменные-члены и функции родительской структуры, записывая переменные-члены и функции непосредственно под дочерней структурой", потому что компилятор смотрит на код и дописывает имена родительских структур за кулисами ради блага.
Использование наследования
Бывают случаи, когда необходимо добавить элементы или функции в структуру, которая уже была создана как объект. В таких случаях наследование может быть использовано с пользой.
Например, допустим, вы хотите расширить структуру http.Clinet так, чтобы в ней хранились результаты поиска Google.
основной пакет
импорт (
"fmt".
"io/ioutil"
"net/http"
)
// Унаследовать структуру с новой функциональностью
тип googleSearch struct {
строка result // результат
*http.Client // указатель на наследуемую структуру
}
// Добавить функцию search() Результаты поиска сохраняются в result
func (p *googleSearch) search(q string) {
resp, err := p.Get(fmt.Sprintf("https://www.google.com?q=%s", q))
если err ! = nil {
возврат
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
если err ! = nil {
возврат
}
p.result = string(body).
}
func main() {
c := &http.Client{}
g := googleSearch{Client: c} // Наследуем http.Client и добавляем новые элементы/функции
g.search("test")
fmt.Println(g.result)
}
Существует множество случаев, когда структуры извлекаются по указателям, и в таких случаях важно убедиться, что родительская структура получена по указателям.
Когда вы создаете расширенную структуру, вы присваиваете указатель родительской структуры указателю, который уже был получен.
Затем вы можете получить доступ к элементам/функциям родительской структуры непосредственно из дочерней структуры.
Комментарии и т.д.
Поскольку структуры и их операционные функции определяются независимо в разных местах, сложнее выяснить, какие операционные функции имеет структура по сравнению с классом.
На самом деле, структуры независимы от структур, а функции независимы от функций, и компилятор связывает их вместе только при кодировании, без участия структуры в том, что представляют собой ее функции-члены.
Наследование - это не наследование, это просто структура с родительскими структурами в качестве элементов. Я неправильно понял это и застрял. Легко запутаться, если сначала опустить имя родительской структуры.
Синтаксис Golang примитивен, но он позволяет писать и опускать различными способами, что делает его эквивалентным высокопроизводительному языку.
Хммм... Golang - разумный и довольно интересный язык.
0 コメント:
コメントを投稿