Structures in GoLang

Question

Ho appena iniziato con GoLang e sto guardando uno dei loro tutorial (https://golang.org/doc/code.html).

In uno dei loro esempi, impostano una variabile su una struttura, ma sono così confuso su come stanno accedendo agli elementi della struttura nel ciclo for di seguito? Qualche possibilità che qualcuno possa chiarire? Molte grazie!

Codice:

package stringutil 

import "testing" 

func TestReverse(t *testing.T) { 
    cases := []struct { 
     in, want string 
    }{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } 
    for _, c := range cases { 
     got := Reverse(c.in) 
     if got != c.want { 
      t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want) 
     } 
    } 
} 

Answer 1

Di seguito è riportato il codice con alcuni commenti per contribuire a chiarire ogni ruolo dichiarazioni in questo.

import "testing" 

func TestReverse(t *testing.T) { 
    cases := []struct { // declaration of anonymous type 
     in, want string // fields on that type called in and want, both strings 
    }{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } // composite literal initilization 
    // note the use of := in assigning to cases, that op combines declaration and assignment into one statement 
    for _, c := range cases { // range over cases, ignoring the index - the underscore means to discard that return value 
     got := Reverse(c.in) // c is the current instance, access in with the familiar dot notation 
     if got != c.want { // again, access operator on c, the current instance 
      t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want) // more access 
     } 
    } 
} 

Fammi sapere se questo aiuta. Posso provare a dare più di un sommario nella lingua parlata o aggiungere ulteriori dettagli se alcune delle affermazioni non hanno ancora senso. Inoltre, fyi se non ti è familiare gamma 'intervalli' su una raccolta, restituendo k, v dove k è l'indice o chiave e v il valore.

EDIT: dettagli sulla dichiarazione/initilization di cases

cases := []struct { 
     in, want string 
    } 

Questo bit all'interno della prima coppia di parentesi graffe è la definizione di una struttura. Questo è un tipo anonimo, una dichiarazione normale sarebbe simile a questa;

type case strcut { 
     in string 
     want string 
    } 

Se tu avessi qualcosa di simile, allora ci sarebbe un tipo chiamato case nel campo di applicazione di questo pacchetto (non esportati, se si voleva rendere 'pubblica' in modo che avrebbe bisogno di essere type Case invece). Invece la struttura degli esempi è anonima. Funziona allo stesso modo del tipo normale, tuttavia come sviluppatore, non avrai modo di fare riferimento a quel tipo in modo da poter lavorare praticamente solo con la raccolta inizializzata qui. Internamente questo tipo è uguale a qualsiasi altra struttura con 2 stringhe non esportate per i campi. I campi sono denominati in e want. Si noti che nell'assegnazione qui cases := []struct si ha [] prima dello struct ciò significa che si sta dichiarando una porzione di questo tipo anonimo.

Questo prossimo bit, viene chiamato inizializzazione statica. Questa è una sintassi per l'inizializzazione di raccolte e tipi. Ognuno di questi bit nidificati come {"", ""} è la dichiarazione e l'inizializzazione di una di queste strutture anonime, indicate nuovamente dalle parentesi graffe. In questo caso si assegnano due stringhe vuote rispettivamente a in e want (se non si utilizzano i nomi, l'ordine è lo stesso della definizione). La coppia esterna di parentesi graffe è per la fetta. Se la tua fetta fosse di "int" o "stringhe", allora avresti i valori giusti senza il livello aggiuntivo di nidificazione come myInts := []int{5,6,7}.

{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } 

Answer 2

Passare alla radice di cosa è una struttura.

si dichiarano le variabili in esso quindi quindi è possibile utilizzarlo da una funzione. Esempio:

package main 

import (
    "fmt" 

) 

func main() { 
    Get() 

} 

func Get(){ 
    out := new(Var) 

    out.name = "james" 

    fmt.Println(out.name) 
} 
type Var struct { 
    name string 
} 

Answer 3

Puoi trovare maggiori informazioni su Golang Struc

 
// GO language program with an example of Struc Type 

package main 

import (
"fmt" 
) 

func main() { 
    type Salary struct{ 
     Basic, HRA, TA float64  
    } 

    type Employee struct{ 
     FirstName, LastName, Email string 
     Age int 
     MonthlySalary []Salary 
    } 

    e := Employee{ 
     FirstName: "Mark", 
     LastName: "Jones", 
     Email: "mark@gmail.com", 
     Age: 25, 
     MonthlySalary: []Salary{ 
      Salary{ 
       Basic:15000.00, 
       HRA:5000.00, 
       TA:2000.00, 
      }, 
      Salary{ 
       Basic:16000.00, 
       HRA:5000.00, 
       TA:2100.00, 
      }, 
      Salary{ 
       Basic:17000.00, 
       HRA:5000.00, 
       TA:2200.00, 
      }, 
     }, 
    } 
    fmt.Println(e.FirstName,e.LastName) 
    fmt.Println(e.Age) 
    fmt.Println(e.Email) 
    fmt.Println(e.MonthlySalary[0]) 
    fmt.Println(e.MonthlySalary[1]) 
    fmt.Println(e.MonthlySalary[2]) 
}