lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add German translation of chapter 2

Browse Source
This commit is contained in:
digitalcraftsman
2015-08-07 22:53:30 +02:00
parent c60c38103e
commit 4da3f25821
9 changed files with 1429 additions and 1412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

326
de/02.4.md
View File

@@ -1,214 +1,214 @@
# 2.4 struct
# 2.4 Struct
## struct
## Struct
We can define new types of containers of other properties or fields in Go just like in other programming languages. For example, we can create a type called `person` to represent a person, with fields name and age. We call this kind of type a `struct`.
Wie in anderen Programmiersprachen können wir auch in Go neue Datentypen erstellen, die als eine "Struktur" verknüpfte Eigenschaften oder Felder zusammenfasst. So können wir Beipielsweise einen neuen Datentyp `person` erschaffen, dessen Eingenschaften der Name und das Alter einer Person sind. Wir nennen diesen Datentyp `struct`.
type person struct {
name string
age int
}
Look how easy it is to define a `struct`!
type person struct {
name string
alter int
}
Es sieht ziemlich einfach aus, ein `struct` zu definieren, nicht?
There are two fields.
Es gibt insgesamt zwei Eigenschaften.
- `name` is a `string` used to store a person's name.
- `age` is a `int` used to store a person's age.
- `name` ist ein `string` und wird genutzt, um den Namen einer Person zu speichern.
- `alter` is vom Typ `int` und beinhaltet das Alter einer Person.
Let's see how to use it.
Schauen wir uns das einmal praktisch an.
type person struct {
name string
age int
}
type person struct {
name string
alter int
}
var P person // p is person type
var P person // p ist vom Typ person
P.name = "Astaxie" // assign "Astaxie" to the field 'name' of p
P.age = 25 // assign 25 to field 'age' of p
fmt.Printf("The person's name is %s\n", P.name) // access field 'name' of p
P.name = "Astaxie" // Weise "Astaxie" der Eigenschaft 'name' von p zu
P.alter = 25 // Weise 25 der Eigenschaft 'alter' von p zu
fmt.Printf("Der Name der Person lautet %s\n", P.name) // Rufe die Eigenschaft 'name' von p auf
There are three more ways to define a struct.
Es gibt noch drei weitere Wege, ein Struct zu definieren.
- Assign initial values by order
- Weise Startwerte in der Reihenfolge der Eigenschaften zu.
P := person{"Tom", 25}
- Use the format `field:value` to initialize the struct without order
P := person{"Tom", 25}
- Oder nutze das Schema `Eigenschaft:Wert`, um ein Struct zu erstellen, ohne dabei auf die Reihenfolge achten zu müssen.
P := person{age:24, name:"Bob"}
P := person{alter:24, name:"Bob"}
- Define an anonymous struct, then initialize it
- Definiere ein "anonymes" Struct und vergebe Startwerte
P := struct{name string; age int}{"Amy",18}
Let's see a complete example.
P := struct{name string; alter int}{"Amy",18}
Schauen wir uns das vollständige Beispiel an.
package main
import "fmt"
package main
import "fmt"
// define a new type
type person struct {
name string
age int
}
// Definiere einen neuen Datentyp
type person struct {
name string
alter int
}
// compare the age of two people, then return the older person and differences of age
// struct is passed by value
func Older(p1, p2 person) (person, int) {
if p1.age>p2.age {
return p1, p1.age-p2.age
}
return p2, p2.age-p1.age
}
// Vergleiche das Alter von zwei Personen. Dann gibt die ältere Person und den Altersunterschied zurück
// Structs werden als normaler Wert übergeben
func Älter(p1, p2 person) (person, int) {
if p1.alter>p2.alter {
return p1, p1.alter-p2.alter
}
return p2, p2.alter-p1.alter
}
func main() {
var tom person
func main() {
var tom person
// initialization
tom.name, tom.age = "Tom", 18
// Initialisierung
tom.name, tom.alter = "Tom", 18
// initialize two values by format "field:value"
bob := person{age:25, name:"Bob"}
// Initialisiere zwei Werte nach dem Schema "Eigenschaft:Wert"
bob := person{alter:25, name:"Bob"}
// initialize two values with order
paul := person{"Paul", 43}
// Initialisiere die Eigenschaft nach der Reihenfolge
paul := person{"Paul", 43}
tb_Older, tb_diff := Older(tom, bob)
tp_Older, tp_diff := Older(tom, paul)
bp_Older, bp_diff := Older(bob, paul)
tb_Älter, tb_diff := Älter(tom, bob)
tp_Älter, tp_diff := Älter(tom, paul)
bp_Älter, bp_diff := Älter(bob, paul)
fmt.Printf("Of %s and %s, %s is older by %d years\n", tom.name, bob.name, tb_Older.name, tb_diff)
fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", tom.name, bob.name, tb_Älter.name, tb_diff)
fmt.Printf("Of %s and %s, %s is older by %d years\n", tom.name, paul.name, tp_Older.name, tp_diff)
fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", tom.name, paul.name, tp_Älter.name, tp_diff)
fmt.Printf("Of %s and %s, %s is older by %d years\n", bob.name, paul.name, bp_Older.name, bp_diff)
}
### embedded fields in struct
fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", bob.name, paul.name, bp_Älter.name, bp_diff)
}
### Eigenschaften in Structs einbetten
I've just introduced to you how to define a struct with field names and type. In fact, Go supports fields without names, but with types. We call these embedded fields.
Soeben habe ich Dir gezeigt, wie Du ein Struct mit Eigenschaften und Datentypen definieren kannst. Aber Go unterstützt auch Eigenschaften, die keinen Namen besitzen und nur dessen Datentyp angegeben wird. Wir bezeichnen diese als eingebettete Eigenschaften.
When the embedded field is a struct, all the fields in that struct will implicitly be the fields in the struct in which it has been embdedded.
Wenn die eingebette Eigenschaft ein weiteres Struct ist, dann all seine Eigenschaften in den Struct übertragen, in dem es eingebettet wurde.
Let's see one example.
Betrachten wir ein Beispiel.
package main
import "fmt"
package main
import "fmt"
type Human struct {
name string
age int
weight int
}
type Mensch struct {
name string
alter int
gewicht int
}
type Student struct {
Human // embedded field, it means Student struct includes all fields that Human has.
specialty string
}
type Student struct {
Mensch // Eingebettete Eigenschaft, d.h. Student besitzt alle Eigenschaften von Mensch.
fachgebiet string
}
func main() {
// initialize a student
mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
func main() {
// Initialisierng eines Studenten
mark := Student{Mensch{"Mark", 25, 120}, "Informatik"}
// access fields
fmt.Println("His name is ", mark.name)
fmt.Println("His age is ", mark.age)
fmt.Println("His weight is ", mark.weight)
fmt.Println("His specialty is ", mark.specialty)
// modify notes
mark.specialty = "AI"
fmt.Println("Mark changed his specialty")
fmt.Println("His specialty is ", mark.specialty)
// modify age
fmt.Println("Mark become old")
mark.age = 46
fmt.Println("His age is", mark.age)
// modify weight
fmt.Println("Mark is not an athlet anymore")
mark.weight += 60
fmt.Println("His weight is", mark.weight)
}
// Eigenschaften aufrufen
fmt.Println("Sein Name lautet ", mark.name)
fmt.Println("Sein Alter ist ", mark.alter)
fmt.Println("Er wiegt ", mark.gewicht)
fmt.Println("Sein Fachgebiet ist ", mark.fachgebiet)
// Eigenschaften verändern
mark.fachgebiet = "Künstliche Intelligenz"
fmt.Println("Mark hat sein Fachgebiet gewechselt")
fmt.Println("Sein Fachgebiet lautet ", mark.fachgebiet)
// Alter ändern
fmt.Println("Mark wurde alt")
mark.alter = 46
fmt.Println("Sein Alter beträgt ", mark.alter, " Jahre")
// Gewicht ändern
fmt.Println("Mark ist kein Athlet mehr")
mark.gewicht += 60
fmt.Println("Er wiegt nun", mark.gewicht)
}
![](images/2.4.student_struct.png?raw=true)
Figure 2.7 Inheritance in Student and Human
Abbildung 2.7 Einbettung von Mensch in Student
We see that we can access the age and name fields in Student just like we can in Human. This is how embedded fields work. It's very cool, isn't it? Hold on, there's something cooler! You can even use Student to access Human in this embedded field!
Wie Du siehst, können wir die Eigenschaften `alter` und `name` vom Typ Student genauso aufrufen, wie jene vom Typ Mensch. Genau so funktioniert das Einbetten. Ziemlich einfach, nicht wahr? Aber es gibt noch Kleinigkeit, die ich Dir zeigen möchte. Du kannst auch den Typ Mensch verwenden, um auf Eigenschaften von Student zurückzugreifen.
mark.Human = Human{"Marcus", 55, 220}
mark.Human.age -= 1
All the types in Go can be used as embedded fields.
mark.Mensch = Mensch{"Marcus", 55, 220}
mark.Mensch.alter -= 1
In Go können alle Datenttypen eingebettet werden.
package main
import "fmt"
package main
import "fmt"
type Skills []string
type Fähigkeiten []string
type Human struct {
name string
age int
weight int
}
type Mensch struct {
name string
alter int
gewicht int
}
type Student struct {
Human // struct as embedded field
Skills // string slice as embedded field
int // built-in type as embedded field
specialty string
}
type Student struct {
Mensch // Struct als eingebettete Eigenschaft
Fähigkeiten // Slice vom Typ string als eingebettete Eigenschaft
int // Standard Datentyp als eingebettete Eigenschaft
fachgebiet string
}
func main() {
// initialize Student Jane
jane := Student{Human:Human{"Jane", 35, 100}, specialty:"Biology"}
// access fields
fmt.Println("Her name is ", jane.name)
fmt.Println("Her age is ", jane.age)
fmt.Println("Her weight is ", jane.weight)
fmt.Println("Her specialty is ", jane.specialty)
// modify value of skill field
jane.Skills = []string{"anatomy"}
fmt.Println("Her skills are ", jane.Skills)
fmt.Println("She acquired two new ones ")
jane.Skills = append(jane.Skills, "physics", "golang")
fmt.Println("Her skills now are ", jane.Skills)
// modify embedded field
jane.int = 3
fmt.Println("Her preferred number is", jane.int)
}
In the above example, we can see that all types can be embedded fields and we can use functions to operate on them.
func main() {
// Initialisiere Studentin Jane
jane := Student{Mensch:Mensch{"Jane", 35, 100}, fachgebiet:"Biologie"}
// Eigenschaften aufrufen
fmt.Println("Ihr Name lautet ", jane.name)
fmt.Println("Ihr Alter ist ", jane.alter)
fmt.Println("Sie wiegt ", jane.gewicht)
fmt.Println("Ihr Fachgebiet ist ", jane.fachgebiet)
// Änderung des Wertes der Eigenschaft fähigkeit
jane.Fähigkeiten = []string{"Anatomie"}
fmt.Println("Sie besitzt folgende Fähigkeiten: ", jane.Fähigkeiten)
fmt.Println("Sie hat zwei neue Fähigkeiten erworben ")
jane.Fähigkeiten = append(jane.Fähigkeiten, "Physik", "Golang")
fmt.Println("Sie besitzt nun folgende Fähigkeiten ", jane.Fähigkeiten)
// Veränderung einer eingebetteten Eigenschaft
jane.int = 3
fmt.Println("Ihre bevorzugte Nummer lautet", jane.int)
}
Im oberen Beispiel ist erkenntlich, dass alle Datentypen eingebettet werden und Funktion auf ihre Werte zugreifen können.
There is one more problem however. If Human has a field called `phone` and Student has a field with same name, what should we do?
Aber es gibt noch ein kleines Problem. Was geschieht, wenn Mensch die Eigenschaft `telefon` besitzt und Student eine Eigenschaft mit dem gleichen Namen besitzt?
Go use a very simple way to solve it. The outer fields get upper access levels, which means when you access `student.phone`, we will get the field called phone in student, not the one in the Human struct. This feature can be simply seen as field `overload`ing.
Go nutzt einen einfachen Weg zur Unterscheidung. Um die Eigenschaft `telefon` von Student zu erhalten, nutzt Du weiterhein `Student.telefon`. Die gleichnahmige Eigenschaft von Mensch kannst Du erhalten, indem Du `Student.Mensch.telefon` verwendest. Wie Du siehst, muss einfach der eingebette Datentyp vorangestellt werden. Diese Fähigkeiten wird "überladen" genannt (im Englischen `overloading`).
package main
import "fmt"
package main
import "fmt"
type Human struct {
name string
age int
phone string // Human has phone field
}
type Mensch struct {
name string
alter int
telefon string // Mensch hat die Eigenschaft telefon
}
type Employee struct {
Human // embedded field Human
specialty string
phone string // phone in employee
}
type Mitarbeiter struct {
Mensch // Eingebetter Datentyp Mensch
spezialisierung string
telefon string // Eigenschaft telefon in Mitarbeiter
}
func main() {
Bob := Employee{Human{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
fmt.Println("Bob's work phone is:", Bob.phone)
// access phone field in Human
fmt.Println("Bob's personal phone is:", Bob.Human.phone)
}
func main() {
Bob := Mitarbeiter{Mensch{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
fmt.Println("Bobs berufliche Telefonnummer lautet ", Bob.telefon)
// Greife auf Eigenschaft telefon in Mensch zu
fmt.Println("Bobs private Telefonnummer lauet ", Bob.Mensch.telefon)
}
## Links
- [Directory](preface.md)
- Previous section: [Control statements and functions](02.3.md)
- Next section: [Object-oriented](02.5.md)
- [Inhaltsverzeichnis](preface.md)
- Vorheriger Abschnitt: [Kontrollstrukturen und Funktionen](02.3.md)
- Nächster Abschnitt: [Objektorientiertes Programmieren](02.5.md)