Hoe standaardwaarden toewijzen voor struct-velden in Golang?

Hoe Standaardwaarden Toewijzen Voor Struct Velden In Golang



Golang is een moderne programmeertaal die de laatste jaren aan populariteit heeft gewonnen. Een van de krachtige kenmerken van Golang is het vermogen om structuren te definiëren en te manipuleren. structuren zijn door de gebruiker gedefinieerde gegevenstypen waarmee ontwikkelaars gerelateerde gegevensvelden kunnen groeperen in één enkel object. op weg, structureert kan hebben standaard waarden toegewezen aan hun velden, wat het initialiseren ervan veel eenvoudiger maakt.

In dit essay zullen we onderzoeken hoe we a kunnen toewijzen standaardwaarde voor een struct-veld in Golang.

Wat zijn structuurvelden?

Ten eerste is het essentieel om het concept van te begrijpen velden structureren . De velden structureren zijn variabelen die gegroepeerd zijn om a te vormen structuur voorwerp. Elk struct veld heeft een naam en een gegevenstype. Een structuur die een persoon vertegenwoordigt, kan bijvoorbeeld velden hebben zoals naam, leeftijd en geslacht.







Hoe standaardwaarden toewijzen voor structurele velden in Golang?

Standaard waarden kan worden toegewezen voor struct-velden in Go met behulp van:



  • Standaard nulwaarden
  • Constructeurs
  • Structureer letterlijk
  • Standaard veldwaarden

1: Standaard nulwaarden

In Go kan het toewijzen van standaardwaarden aan struct-velden worden bereikt met de ' nul waarde ' functie. Deze functie kent automatisch een standaardwaarde toe van ' 0 ' of ' vals ' naar elk niet-geïnitialiseerd veld, afhankelijk van het gegevenstype. Dit betekent dat u niet expliciet standaardwaarden hoeft in te stellen voor elk veld in de struct, aangezien Go dit voor u doet.



Deze functie kan handig zijn bij het omgaan met grote structuren met veel velden, omdat het de tijd en moeite bespaart van het handmatig instellen van standaardwaarden voor elk veld.





Hier is een voorbeeld dat de nulwaarde gebruikt om standaardwaarden toe te wijzen aan struct-velden:

pakket belangrijkste

importeren 'fmt'

type Persoonsstructuur {
Naam tekenreeks
Leeftijd int
Hoogte vlotter64
IsMale bool
}

func hoofd ( ) {
p1 := Persoon { Naam: 'John' , Leeftijd: 30 }
fmt.Println ( p1.Naam )
fmt.Println ( p1.Leeftijd )
fmt.Println ( p1.Hoogte )
fmt.Println ( p1.IsMale )
}

De bovenstaande code definieert een Persoon structuur met vier velden: Naam, Leeftijd, Lengte en IsMale, die allemaal van het bool-gegevenstype zijn. Vervolgens maken we een nieuwe instantie van de klasse Person, p1, en initialiseren we een aantal van zijn velden door struct-literals te gebruiken om de veldnamen en waarden op te geven. De standaard nulwaarden voor de velden die niet expliciet zijn ingesteld tijdens de initialisatie, worden weergegeven wanneer u de waarden van de velden afdrukt met behulp van fmt.Println .



Uitgang

2: Constructeurs

Door een te schrijven constructeur functie voor de struct, kunt u ook standaardwaarden geven aan struct-velden in Golang. De constructeur functie maakt een nieuw exemplaar van de struct en stelt de standaardwaarden voor de velden in. Deze methode bespaart moeite en tijd, vooral bij interactie met enorme structuren met talloze velden.

Hier is een voorbeeld van hoe een te definiëren constructeur functie met standaard veldwaarden voor een struct:

pakket belangrijkste

importeren 'fmt'

type Persoonsstructuur {
Naam    tekenreeks
Leeftijd     int
Adresreeks
}
func NieuwePersoon ( ) * Persoon {
opbrengst & Persoon {
Naam: 'John Doe' ,
Leeftijd: 30 ,
Adres: Hoofdstraat 123 ,
}
}
func hoofd ( ) {
p := NieuwePersoon ( )
fmt.Println ( p.Naam, p.Leeftijd, p.Adres )
}

In de bovenstaande code, a Persoon struct is gedefinieerd, evenals de nieuw persoon() functie, die een nieuw exemplaar van de Persoon struct met vooraf bepaalde standaardwaarden. Wij bellen nieuw persoon() in voornaamst() om een ​​nieuwe Person-instantie mee te maken standaard veldwaarden , en we printen vervolgens de waarden van de velden van die instantie.

Uitgang

3: Letterlijke constructies

In Golang kunt u standaardwaarden voor struct-velden instellen met behulp van letterlijke teksten structureren ook. Maak gewoon een nieuwe instantie van de struct en stel de waarden in voor elk veld dat moet worden geïnitialiseerd. Als u standaardwaarden wilt instellen voor velden die u niet expliciet initialiseert, kunt u de nulwaardefunctie gebruiken.

Hier is een voorbeeld van hoe te gebruiken letterlijke teksten structureren om standaard veldwaarden voor een struct in te stellen:

pakket belangrijkste

importeren 'fmt'

type Persoonsstructuur {
Naam    tekenreeks
Leeftijd     int
Adresreeks
}
func hoofd ( ) {
p := Persoon {
Naam: 'John Doe' ,
Leeftijd: 30 ,
}
fmt.Println ( p.Naam, p.Leeftijd, p.Adres )
}

In de bovenstaande code definiëren we a Persoon struct in dit voorbeeld en maak er een nieuw exemplaar van met behulp van een letterlijke struct en standaardwaarden voor de velden. Een nieuwe Persoon instantie wordt gemaakt in main() waarbij sommige veldwaarden zijn ingevuld en andere leeg zijn gelaten. Sinds de Adres veld niet wordt geïnitialiseerd, ontvangt het de lege tekenreeks die de standaardwaarde voor dit veld is. Ten slotte drukken we de veldwaarden van de persoonsinstantie af.

Uitgang

4: Standaard veldwaarden

Toewijzen standaard waarden naar velden structureren in Go is een eenvoudig proces. De standaardwaarde voor een struct-veld kan worden ingesteld met behulp van de syntaxis veldnaam:standaardwaarde . Beschouw bijvoorbeeld de volgende structuurdefinitie:

type Persoonsstructuur {
Naamreeks
leeftijd int
Geslachtsreeks
}

Toewijzen standaard waarden naar de velden van deze structuur, kunnen we de volgende syntaxis gebruiken:

p := Persoon {
Naam: 'John Doe' ,
Leeftijd: 30 ,
Geslacht: 'Mannelijk' ,
}

In het bovenstaande voorbeeld hebben we toegewezen standaard waarden naar de velden van de Person-structuur. Als we tijdens de initialisatie een van de waarden weglaten, wordt het standaardwaarde zal in plaats daarvan worden gebruikt. Als we bijvoorbeeld een Person-object als volgt initialiseren:

p := Persoon {
Naam: 'Jane Doe' ,
}

Het resulterende Person-object heeft de standaard waarden voor de velden Leeftijd en Geslacht, die respectievelijk 0 en een lege tekenreeks zijn.

Hier is een volledige code die het bovenstaande proces illustreert:

pakket belangrijkste
importeren 'fmt'

type Persoonsstructuur {
Naam tekenreeks
Leeftijd int
Geslachtsreeks
}
func hoofd ( ) {
p1 := Persoon {
Naam: 'John Doe' ,
Leeftijd: 30 ,
Geslacht: 'Mannelijk' ,
}
fmt.Println ( p1 )

p2 := Persoon {
Naam: 'Jeremy' ,
}
fmt.Println ( p2 )
}

In het bovenstaande voorbeeld bouwen we een Person-structuur die drie velden heeft: Naam, een int die leeftijd vertegenwoordigt, en Gender, een tekenreeks die geslacht vertegenwoordigt. De struct-initialisatiesyntaxis wordt vervolgens gebruikt om twee persoonsinstanties te construeren, p1 en p2. p1 wordt geïnitialiseerd met de waarden 'John Doe' voor naam, '30' voor leeftijd en 'man' voor geslacht, allemaal waarden die uitdrukkelijk zijn opgegeven. Aangezien we geen waarden hebben gegeven voor Leeftijd en Geslacht, zullen de standaardwaarden van respectievelijk 0 en een lege tekenreeks eraan worden toegewezen. p2 wordt aanvankelijk geïnitialiseerd met alleen het verstrekte veld Naam.

Uitgang

Conclusie

Toewijzen standaard waarden in Go is een essentieel aspect van programmeren met deze taal. Het helpt ervoor te zorgen dat aan elke gemaakte struct-instantie standaardgegevens zijn toegewezen. Door een van de hierboven beschreven methoden te gebruiken, kunnen ontwikkelaars de standaard waarden van struct velden efficiënt.