Gos Konstanten: Jenseits der Grundlagen

Als ich zum ersten Mal mit Go anfing, dachte ich, Konstanten seien einfach und begrenzt – nur feste Werte, nichts Ausgefallenes. Aber wenn ich tiefer in die Materie eintauche, stelle ich fest, dass sie recht vielseitig sind. Ja, es handelt sich um feste Werte, aber Go handhabt sie auf eine Weise, die sowohl flexibel als auch effizient ist. Es ist ziemlich cool. Sehen wir uns anhand einiger praktischer Beispiele an, was das bedeutet.

Konstanten als typfreie Werte (bis sie verwendet werden)

In Go bleiben Konstanten oft untypisiert, bis Sie sie tatsächlich verwenden. Sie haben einen Standardtyp, können aber Variablen unterschiedlichen Typs zugewiesen werden, sofern der Wert passt. Dadurch sind sie auf eine Weise anpassungsfähig, die für eine statisch typisierte Sprache ungewöhnlich ist.

So sieht das aus:

const x = 10
var i int = x
var f float64 = x
var b byte = x

Etwas analog zu Schrödingers Paradoxon kann x ein int, ein float64 oder sogar ein Byte sein, bis Sie es zuweisen. Durch diese vorübergehende Flexibilität kann x problemlos mit verschiedenen Typen in Ihrem Code arbeiten. Kein Guss nötig, das sorgt für Ordnung.

Sie können sogar Konstanten verschiedener Typen im Ausdruck mischen und Go ermittelt den besten Typ für das Ergebnis:

const a = 1.5
const b = 2
const result = a * b // result is float64

Da a eine Gleitkommazahl ist, stuft Go den gesamten Ausdruck auf float64 hoch. Sie müssen sich also keine Sorgen über Präzisionsverluste machen – Go kümmert sich darum. Aber seien Sie vorsichtig: Wenn Sie versuchen, das Ergebnis einem Int zuzuweisen, erhalten Sie eine Fehlermeldung. Go erlaubt keine impliziten Konvertierungen, die zu Datenverlust führen könnten.

Einschränkungen

Diese Flexibilität geht nur weit. Sobald Sie einer Variablen eine Konstante zuweisen, wird der Typ dieser Variablen festgelegt:

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Aber wenn Sie Folgendes versuchen:

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Go gibt einen Fehler aus, da eine Gleitkommakonstante ohne explizite Umwandlung nicht automatisch in eine Ganzzahl konvertiert wird. Obwohl Konstanten flexibel sind, ändern sie ihren Typ nicht, um inkompatible Variablen zu passen.

Typstandards verstehen

Wenn Sie untypisierte Konstanten ohne Angabe eines Typs verwenden, gehen diese von einem Standardtyp aus:

• Untypisierte Ganzzahlkonstanten standardmäßig int.

• Untypisierte Gleitkommakonstanten sind standardmäßig float64.

• Untypisierte Runenkonstanten ist standardmäßig rune (int32).

• Untypisierte komplexe Konstanten sind standardmäßig complex128.

• Untypisierte String-Konstanten sind standardmäßig string.

• Untypisierte boolesche Konstanten sind standardmäßig bool.

Hier ist eine kurze Tabelle:

Constant Kind	Can Adapt To
Untyped Integer	int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128
Untyped Float	float32, float64, complex64, complex128
Untyped Complex	complex64, complex128
Untyped Rune	rune, int32, any integer type that can hold the value
Untyped String	string
Untyped Boolean	bool

Auswertung und Leistung zur Kompilierungszeit

Go wertet nicht nur Konstanten zur Kompilierungszeit aus, sondern optimiert auch konstante Ausdrücke. Das bedeutet, dass Sie Konstanten in Berechnungen verwenden können und Go das Ergebnis während der Kompilierung berechnet:

const x = 10
var i int = x
var f float64 = x
var b byte = x

C wird also zur Laufzeit nicht neu berechnet; Go hat zur Kompilierungszeit bereits herausgefunden, dass es 520 ist. Dies kann die Leistung steigern, insbesondere bei Code, bei dem es auf Geschwindigkeit ankommt. Durch die Verwendung von Konstanten führt Go die Berechnungen einmal durch, anstatt sie jedes Mal durchzuführen, wenn Ihr Programm ausgeführt wird.

Konstanten in der bedingten Kompilierung

Go verfügt nicht über einen Präprozessor wie einige andere Sprachen, aber Sie können Konstanten in if-Anweisungen verwenden, um Code zur Kompilierungszeit einzuschließen oder auszuschließen.

const a = 1.5
const b = 2
const result = a * b // result is float64

Wenn debug „false“ ist, weiß der Compiler, dass die if-Bedingung niemals wahr sein wird und lässt möglicherweise den Code im Block weg. Dadurch kann Ihre endgültige Binärdatei kleiner werden. Ziemlich praktisch, oder?

Arbeiten mit großen Zahlen

Eine leistungsstarke Eigenschaft der Go-Konstanten ist, dass sie sehr große Zahlen unterstützen. Nicht typisierte numerische Konstanten in Go haben eine „unendliche“ Genauigkeit, die nur durch den Speicher und den Compiler begrenzt ist.

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Obwohl bigNum viel größer ist als jeder integrierte numerische Typ wie float64 oder int, können Sie es in Go als Konstante definieren. Mit diesen großen Zahlen können Sie zur Kompilierzeit Berechnungen durchführen:

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Typisierte Konstanten mit Iota

Wenn Sie Go verwendet haben, haben Sie wahrscheinlich Iota zum Erstellen von Aufzählungskonstanten gesehen. Dies ist nützlich, da es automatisch inkrementelle Werte zuweist.

Sie können Ausdrücke auch in Konstantendeklarationen mit iota verwenden, um verwandte Konstanten zu erstellen.

const a = 100
const b = 5
const c = a * b + 20 // c is computed at compile time

Dieser Code definiert Konstanten für Kilobyte, Megabyte, Gigabyte und Terabyte unter Verwendung von Bitverschiebung. Es wird zur Kompilierungszeit berechnet. Es ist eine praktische Möglichkeit, eine Reihe verwandter Konstanten zu generieren.

Ich finde Iota für solche Dinge wirklich hilfreich. Da Go über keinen integrierten Enum-Typ verfügt, können Sie Enums mithilfe der Iota-ID und benutzerdefinierten Typen effektiv simulieren.

Konstanten mit bitweisen Operationen und Verschiebungen

Konstanten können bitweise Operationen und Verschiebungen verwenden, was sogar zu Werten führt, die größer sind als jeder integrierte Typ.

const debug = false

func main() {
    if debug {
        fmt.Println("Debugging enabled")
    }
    // The above block might be removed by the compiler if debug is false
}

Hier wird „shiftedValue“ aufgrund des großen Verschiebungsbetrags zu einer sehr großen Zahl. Dieser Wert ist zu groß für Standard-Integer-Typen, bleibt aber als Konstante gültig, bis Sie versuchen, ihn zuzuweisen:

const bigNum = 1e1000 // This is a valid constant

Dies zeigt, dass Konstanten Werte darstellen können, die Sie nicht in Variablen speichern können, was Berechnungen zur Kompilierungszeit mit sehr großen Zahlen ermöglicht.

---

Einschränkungen bei Konstanten

Obwohl die Konstanten von Go flexibel sind, gibt es einige Dinge, die sie nicht können.

Konstanten können nicht durch Zeiger referenziert werden

Konstanten haben zur Laufzeit keine Speicheradresse. Sie können also nicht die Adresse einer Konstante übernehmen oder einen Zeiger darauf verwenden.

const x = 10
var i int = x
var f float64 = x
var b byte = x

Konstanten mit typisierten Nullzeigern

Während Null Variablen vom Typ Zeiger, Slice, Karte, Kanal und Funktion zugewiesen werden kann, können Sie keine Konstante erstellen, die einen typisierten Nullzeiger enthält.

const a = 1.5
const b = 2
const result = a * b // result is float64

Dies trägt zur Unveränderlichkeit und Kompilierungszeit von Konstanten in Go bei.

Funktionsaufrufe in Konstantendeklarationen

Nur ​​bestimmte integrierte Funktionen können in konstanten Ausdrücken verwendet werden, wie z. B. len, cap, real, imag und complex.

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Das liegt daran, dass diese integrierten Funktionen genutzt werden können

Zusammengesetzte Typen und Konstanten

Konstanten können zusammengesetzte Typen wie Slices, Karten oder Strukturen nicht direkt darstellen. Sie können sie jedoch mit Konstanten initialisieren.

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Der obige Code funktioniert nicht, da Sie ein Slice nicht als Konstante deklarieren können. Sie können jedoch Konstanten innerhalb eines Variablensegments verwenden:

const a = 100
const b = 5
const c = a * b + 20 // c is computed at compile time

Denken Sie daran, dass Typen wie Slice selbst keine Konstante sind – Sie können sie nicht als solche deklarieren. Die darin enthaltenen Elemente können jedoch Konstanten sein.

Explizite Konvertierung bei Bedarf

Wenn eine nicht typisierte Konstante aufgrund einer Typinkongruenz oder eines möglichen Genauigkeitsverlusts nicht direkt zugewiesen werden kann, müssen Sie eine explizite Typkonvertierung verwenden.

const debug = false

func main() {
    if debug {
        fmt.Println("Debugging enabled")
    }
    // The above block might be removed by the compiler if debug is false
}

Zusammenfassung

Ich hoffe, das gibt Ihnen eine bessere Vorstellung von Konstanten. Es handelt sich nicht nur um einfache feste Werte; sondern auch eine flexible Funktion, die Ihren Code ausdrucksvoller und effizienter machen kann.

Ich bin noch relativ neu darin, meine Erfahrungen in Go zu teilen und bin gespannt darauf, zu lernen und mich zu verbessern. Wenn Sie diesen Beitrag wertvoll fanden oder Vorschläge haben, wie ich ihn verbessern kann, posten Sie ihn bitte in den Kommentaren.

Mein allererster Reddit-Beitrag zum Thema „Gos UTF-8-Unterstützung: Eine interessante Einschränkung“ (erfordert kein Login)der große Aufmerksamkeit erregte.

Wir freuen uns auf Ihr Feedback.

Das obige ist der detaillierte Inhalt vonGos Konstanten: Jenseits der Grundlagen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!