Der logische Wert wird durch den Bool-Typ dargestellt. Wie unten gezeigt, ist der Wert ** wahr ** wenn wahr und ** falsch ** wenn falsch. Sie können es auch durch Typinferenz definieren.
var a bool //Definieren Sie die Variable a als Bool-Typ
a = true //Weisen Sie der Variablen a true zu
a := true
Ganzzahltypen sind als numerische Typen verfügbar, und es gibt zwei Typen: ** Ganzzahlentyp mit Vorzeichen ** und Ganzzahlentyp ohne Vorzeichen **.
Vorzeichenbehaftete Ganzzahltypen umfassen `int8```,` int16, `` int32 und int64```, und die Zahlen geben die Größe an. Es gibt uint8 (Byte) , uint16```, uint32``` und uint64``` Typen von vorzeichenlosen Ganzzahltypen, und der numerische Wert ist auch die Größe. Repräsentiert. Im Gegensatz zu signiert kann `` uint8 auch mit einem Alias vom Typ` `` byte definiert werden und verhält sich genauso wie uint8.
In Go mit 64-Bit-Implementierung verhält sich der Typ `int``` genauso wie` int64```, aber wie unten gezeigt, ist es eine Variable, die eine 64-Bit-Ganzzahl mit demselben Vorzeichen darstellt. Da die Typen jedoch unterschiedlich sind, führt die implizite Typkonvertierung zu einem Kompilierungsfehler.
a := int(10)
b := int64(5)
b = a //Kompilierungsfehler
fmt.Printf("%v\n", b)
Auf diese Weise wird ein Kompilierungsfehler angezeigt, wenn Sie versuchen, implizit eine Typkonvertierung durchzuführen. Wenn Sie den Typ jedoch wie unten gezeigt fest angeben und die Typkonvertierung explizit durchführen, können Sie ihn ausführen, ohne einen Kompilierungsfehler zu verursachen.
a := int(10)
b := int64(a)
fmt.Printf("%v\n", b)
Mit dieser Methode können Zahlen verarbeitet werden, die die maximale Schriftgröße überschreiten.
a := int8(128) //Kompilierungsfehler
fmt.Printf("%v\n", a)
a := 128
b := int8(a)
fmt.Printf("%v\n", b)
Es ist jetzt möglich, bei 128 zu verarbeiten, was den Maximalwert von ** int8, 127 ** überschreitet. Wenn Sie dies explizit tun, tritt in der Binärdarstellung ein ** Überlauf ** auf, wenn 1 zum Maximalwert 127, ** Umlauf ** addiert wird und der Wert der Minimalwert ist. Weil es zurückkehren wird. In diesem Fall ist der Ausgabewert also -128 **, was dem Mindestwert von ** int8 entspricht.
Als Gegenmaßnahme für Up-Around können Sie durch Importieren und Verwenden des ** Mathe-Pakets ** Code schreiben, während Sie sich des Überlaufs von Ziffern bewusst sind.
Es gibt zwei Arten von Gleitkommatypen: `float32: Gleitkomma mit einfacher Genauigkeit und float64: Gleitkomma mit doppelter Genauigkeit`. Übrigens ist float32 weniger genau als float64, und wenn Sie den Aspekt der Effizienz der Speichernutzung nicht berücksichtigen, scheint es wenig sinnvoll zu sein, es zu verwenden, es sei denn, es gibt einen besonderen Grund.
a := 1.0 //float64
b := float32(1.0) //float32
Gleitkommatypen haben auch Konstanten, die einen Zahlenbereich im Mathematikpaket darstellen, und Sie müssen eine explizite Typkonvertierung durchführen, wenn Sie Gleitkommaliterale verwenden möchten, um verschiedene Wertetypen zu verwenden. Der Dezimalteil wird jedoch abgeschnitten.
Als nächstes folgt der spezielle Wert, der eine Berechnung unmöglich macht. Die Ausgabeergebnisse der folgenden Operationen haben die Bedeutungen + Int (** positive Unendlichkeit ), -Int ( negative Unendlichkeit ) bzw. NaN ( Nichtzahl **).
1.0 / 0.0 //+Int
-1.0 / 0.0 //-Int
0.0 / 0.0 //NaN
A ist der Realteil, b ist der Imaginärteil und i ist die Imaginäreinheit, die durch das Literal ** a + bi ** dargestellt wird und zwei Typen hat, `complex64``` und` `complex128```. Ist vorbereitet. Float32``` wird für den Realteil bzw. den Imaginärteil vom Typ complex64 verwendet, und `` float64``` wird für den Realteil und den Imaginärteil vom Typ complex128 verwendet.
Das Folgende ist eine Zuweisungsmethode unter Verwendung komplexer Literale. Das + -Zeichen ist übrigens nur ein Teil des Literal, kein Operator. Sie können die komplexe Funktion auch verwenden, um jeden Wert zurückzugeben und zu generieren, indem Sie die Argumente des Realteils und des Imaginärteils verwenden.
a := 1.0 + 2i
a := complex(1.0, 2)
Es gibt auch eine Funktion zum Abrufen der realen und imaginären Werte dieses Literals.
a := 1.0 + 2i
real(a) //1.0
imag(a) //2
Dies ist ein Typ, der ein Zeichen darstellt, und das in einfache Anführungszeichen eingeschlossene Zeichen wird durch Unicode-Codepunkte und -Ausgaben dargestellt. Sie können Unicode-Zeichen auch darstellen, indem Sie ein Präfix hinzufügen, das mit einem Backslash beginnt. Es gibt auch eine Escape-Sequenz für Zeichenfolgendarstellungen. Es ist als ein anderer Name int32 definiert und funktioniert genauso.
a := 'Beispiel'
fmt.Printf("%v", a) //20363
a := '\U00101234'
fmt.Printf("%v", a) //1053236
Es ist als Zeichenfolgentyp definiert und enthält ein Zeichenfolgenliteral in doppelten Anführungszeichen.
a := "Beispiel"
fmt.Printf("%v", a) //Beispiel
a := "\u65e 5 Stück\U00008a9e"
fmt.Printf("%v", a) //japanisch
Es gibt ein anderes Format für String-Literale, ** RAW-String-Literale **. Es hat die Eigenschaft, Backquotes zu verwenden, um mehrzeilige Zeichenfolgen zu unterstützen und diese Zeichen nicht zu verarbeiten.
a := '
Beispiel
Beispiel
Beispiel
'
fmt.Printf("%v", a) //Beispiel
Beispiel
Beispiel
Dieses Mal haben wir die Grundtypen von Go! Ich denke, Sie konnten nicht nur die Oberfläche des Grundtyps selbst verstehen, sondern auch die Bedeutung und den Mechanismus in gewissem Maße.
Ich werde weiterhin mit dieser Rate ausgeben!
Recommended Posts