Go - Kurzanleitung
Go ist eine Allzwecksprache, die für die Systemprogrammierung entwickelt wurde. Es wurde ursprünglich bei Google im Jahr 2007 von Robert Griesemer, Rob Pike und Ken Thompson entwickelt. Es ist stark und statisch typisiert, bietet integrierte Unterstützung für die Speicherbereinigung und unterstützt die gleichzeitige Programmierung.
Programme werden mithilfe von Paketen erstellt, um Abhängigkeiten effizient zu verwalten. Go-Programmierimplementierungen verwenden ein traditionelles Kompilierungs- und Verknüpfungsmodell, um ausführbare Binärdateien zu generieren. Die Programmiersprache Go wurde im November 2009 angekündigt und wird in einigen Produktionssystemen von Google verwendet.
Funktionen der Go-Programmierung
Die wichtigsten Funktionen der Go-Programmierung sind unten aufgeführt -
Unterstützung für Umgebungen, die ähnliche Muster wie dynamische Sprachen verwenden. Beispiel: Typinferenz (x: = 0 ist eine gültige Deklaration einer Variablen x vom Typ int)
Die Kompilierungszeit ist schnell.
Eingebaute Parallelitätsunterstützung: einfache Prozesse (über Go-Routinen), Kanäle, Select-Anweisung.
Go-Programme sind einfach, präzise und sicher.
Unterstützung für Schnittstellen und Typeinbettung.
Erstellung statisch verknüpfter nativer Binärdateien ohne externe Abhängigkeiten.
Funktionen absichtlich ausgeschlossen
Um die Sprache einfach und prägnant zu halten, werden die folgenden Funktionen, die in anderen ähnlichen Sprachen allgemein verfügbar sind, in Go - weggelassen.
Unterstützung für Typvererbung
Unterstützung für Methoden- oder Bedienerüberladung
Unterstützung für zirkuläre Abhängigkeiten zwischen Paketen
Unterstützung für Zeigerarithmetik
Unterstützung für Behauptungen
Unterstützung für generische Programmierung
Gehen Sie Programme
Ein Go-Programm kann in der Länge von 3 bis Millionen Zeilen variieren und sollte in eine oder mehrere Textdateien mit der Erweiterung ".go" geschrieben werden. Zum Beispiel hallo.go.
Sie können "vi", "vim" oder einen anderen Texteditor verwenden, um Ihr Go-Programm in eine Datei zu schreiben.
Einrichtung der lokalen Umgebung
Wenn Sie weiterhin bereit sind, Ihre Umgebung für die Programmiersprache Go einzurichten, benötigen Sie die folgenden zwei auf Ihrem Computer verfügbaren Softwareprogramme:
- Ein Texteditor
- Gehen Sie zum Compiler
Texteditor
Sie benötigen einen Texteditor, um Ihre Programme einzugeben. Beispiele für Texteditoren sind Windows Notepad, OS Edit-Befehl, Brief, Epsilon, EMACS und vim oder vi.
Der Name und die Version der Texteditoren können auf verschiedenen Betriebssystemen variieren. Beispielsweise wird Notepad unter Windows und vim oder vi unter Windows sowie Linux oder UNIX verwendet.
Die Dateien, die Sie mit dem Texteditor erstellen, werden aufgerufen source files. Sie enthalten Programmquellcode. Die Quelldateien für Go-Programme werden normalerweise mit der Erweiterung benannt".go".
Stellen Sie vor Beginn der Programmierung sicher, dass Sie über einen Texteditor verfügen und über genügend Erfahrung verfügen, um ein Computerprogramm zu schreiben, in einer Datei zu speichern, zu kompilieren und schließlich auszuführen.
Der Go Compiler
Der in die Quelldatei geschriebene Quellcode ist die vom Menschen lesbare Quelle für Ihr Programm. Es muss kompiliert und in Maschinensprache umgewandelt werden, damit Ihre CPU das Programm gemäß den Anweisungen ausführen kann. Der Compiler der Programmiersprache Go kompiliert den Quellcode in sein endgültiges ausführbares Programm.
Die Go-Distribution kann binär für FreeBSD (Version 8 und höher), Linux, Mac OS X (Snow Leopard und höher) und Windows-Betriebssysteme mit 32-Bit- (386) und 64-Bit- (amd64) x86-Prozessorarchitekturen installiert werden.
Im folgenden Abschnitt wird erläutert, wie Sie die Go-Binärdistribution auf verschiedenen Betriebssystemen installieren.
Laden Sie Go Archive herunter
Laden Sie die neueste Version der installierbaren Go-Archivdatei von Go Downloads herunter . In diesem Tutorial wird die folgende Version verwendet: go1.4.windows-amd64.msi .
Es wird in den Ordner C: \> go kopiert.
Betriebssystem | Archivname |
---|---|
Windows | go1.4.windows-amd64.msi |
Linux | go1.4.linux-amd64.tar.gz |
Mac | go1.4.darwin-amd64-osx10.8.pkg |
FreeBSD | go1.4.freebsd-amd64.tar.gz |
Installation unter UNIX / Linux / Mac OS X und FreeBSD
Extrahieren Sie das Download-Archiv in den Ordner / usr / local und erstellen Sie einen Go-Baum in / usr / local / go. Zum Beispiel -
tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz
Fügen Sie der Umgebungsvariablen PATH / usr / local / go / bin hinzu.
Betriebssystem | Ausgabe |
---|---|
Linux | export PATH = $ PATH: / usr / local / go / bin |
Mac | export PATH = $ PATH: / usr / local / go / bin |
FreeBSD | export PATH = $ PATH: / usr / local / go / bin |
Installation unter Windows
Verwenden Sie die MSI-Datei und befolgen Sie die Anweisungen, um die Go-Tools zu installieren. Standardmäßig verwendet das Installationsprogramm die Go-Distribution in c: \ Go. Das Installationsprogramm sollte das Verzeichnis c: \ Go \ bin in der Umgebungsvariablen PATH von Windows festlegen. Starten Sie alle geöffneten Befehlsaufforderungen neu, damit die Änderung wirksam wird.
Überprüfen der Installation
Erstellen Sie eine Go-Datei mit dem Namen test.go in C:\>Go_WorkSpace.
Datei: test.go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Führen Sie nun test.go aus, um das Ergebnis zu sehen -
C:\Go_WorkSpace>go run test.go
Ausgabe
Hello, World!
Bevor wir uns mit den Grundbausteinen der Go-Programmiersprache befassen, wollen wir zunächst die Mindeststruktur von Go-Programmen erörtern, damit wir sie in den folgenden Kapiteln als Referenz verwenden können.
Hallo Welt Beispiel
Ein Go-Programm besteht im Wesentlichen aus folgenden Teilen:
- Paketerklärung
- Pakete importieren
- Functions
- Variables
- Aussagen und Ausdrücke
- Comments
Schauen wir uns einen einfachen Code an, der die Wörter "Hello World" druckt -
package main
import "fmt"
func main() {
/* This is my first sample program. */
fmt.Println("Hello, World!")
}
Werfen wir einen Blick auf die verschiedenen Teile des obigen Programms -
Die erste Zeile des Programmpakets main definiert den Paketnamen, in dem dieses Programm liegen soll. Dies ist eine obligatorische Anweisung, da Go-Programme in Paketen ausgeführt werden. Das Hauptpaket ist der Ausgangspunkt für die Ausführung des Programms. Jedem Paket sind ein Pfad und ein Name zugeordnet.
Der nächste Zeilenimport "fmt" ist ein Präprozessorbefehl, der den Go-Compiler anweist, die im Paket fmt liegenden Dateien einzuschließen.
Die nächste Zeile func main () ist die Hauptfunktion, in der die Programmausführung beginnt.
Die nächste Zeile /*...*/ wird vom Compiler ignoriert und dient zum Hinzufügen von Kommentaren zum Programm. Kommentare werden auch mit // ähnlich wie Java- oder C ++ - Kommentare dargestellt.
Die nächste Zeile fmt.Println (...) ist eine weitere in Go verfügbare Funktion, die die Meldung "Hallo Welt!" auf dem Bildschirm angezeigt werden. Hier hat das fmt-Paket die Println-Methode exportiert, mit der die Nachricht auf dem Bildschirm angezeigt wird.
Beachten Sie das Großbuchstaben P der Println-Methode. In der Sprache Go wird ein Name exportiert, wenn er mit einem Großbuchstaben beginnt. Exportiert bedeutet, dass die Funktion oder Variable / Konstante dem Importeur des jeweiligen Pakets zugänglich ist.
Ausführen eines Go-Programms
Lassen Sie uns diskutieren, wie der Quellcode in einer Datei gespeichert, kompiliert und schließlich das Programm ausgeführt wird. Bitte befolgen Sie die unten angegebenen Schritte -
Öffnen Sie einen Texteditor und fügen Sie den oben genannten Code hinzu.
Speichern Sie die Datei als hello.go
Öffnen Sie die Eingabeaufforderung.
Wechseln Sie in das Verzeichnis, in dem Sie die Datei gespeichert haben.
Geben Sie go run hello.go ein und drücken Sie die Eingabetaste, um Ihren Code auszuführen.
Wenn Ihr Code keine Fehler enthält, wird "Hallo Welt!" auf dem Bildschirm gedruckt.
$ go run hello.go
Hello, World!
Stellen Sie sicher, dass sich der Go-Compiler in Ihrem Pfad befindet und dass Sie ihn in dem Verzeichnis ausführen, das die Quelldatei hello.go enthält.
Wir haben die Grundstruktur eines Go-Programms im vorherigen Kapitel besprochen. Jetzt werden die anderen Grundbausteine der Programmiersprache Go leicht zu verstehen sein.
Token in Go
Ein Go-Programm besteht aus verschiedenen Token. Ein Token ist entweder ein Schlüsselwort, ein Bezeichner, eine Konstante, ein Zeichenfolgenliteral oder ein Symbol. Die folgende Go-Anweisung besteht beispielsweise aus sechs Token:
fmt.Println("Hello, World!")
Die einzelnen Token sind -
fmt
.
Println
(
"Hello, World!"
)
Leitungstrennzeichen
In einem Go-Programm ist der Zeilentrennschlüssel ein Anweisungsabschluss. Das heißt, einzelne Anweisungen benötigen kein spezielles Trennzeichen wie ";" in C. Der Go-Compiler platziert intern ";" als Anweisungsterminator, um das Ende einer logischen Entität anzugeben.
Schauen Sie sich zum Beispiel die folgenden Aussagen an:
fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")
Bemerkungen
Kommentare sind wie Hilfetexte in Ihrem Go-Programm und werden vom Compiler ignoriert. Sie beginnen mit / * und enden mit den Zeichen * / wie unten gezeigt -
/* my first program in Go */
Sie können keine Kommentare in Kommentaren haben und sie kommen nicht in Zeichenfolgen- oder Zeichenliteralen vor.
Kennungen
Ein Go-Bezeichner ist ein Name, mit dem eine Variable, eine Funktion oder ein anderes benutzerdefiniertes Element identifiziert wird. Ein Bezeichner beginnt mit einem Buchstaben A bis Z oder a bis z oder einem Unterstrich _, gefolgt von null oder mehr Buchstaben, Unterstrichen und Ziffern (0 bis 9).
Kennung = Buchstabe {Buchstabe | unicode_digit}.
Go erlaubt keine Interpunktionszeichen wie @, $ und% in Bezeichnern. Go ist eincase-sensitiveProgrammiersprache. So Manpower und Manpower sind zwei verschiedene Kennungen in Go. Hier sind einige Beispiele für akzeptable Bezeichner -
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal
Schlüsselwörter
Die folgende Liste zeigt die reservierten Wörter in Go. Diese reservierten Wörter dürfen nicht als Konstante, Variable oder andere Bezeichnernamen verwendet werden.
Unterbrechung | Standard | func | Schnittstelle | wählen |
Fall | verschieben | Gehen | Karte | Struct |
Chan | sonst | Gehe zu | Paket | Schalter |
const | durchfallen | wenn | Angebot | Art |
fortsetzen | zum | importieren | Rückkehr | Var |
Leerzeichen in Go
Whitespace ist der Begriff, der in Go verwendet wird, um Leerzeichen, Tabulatoren, Zeilenumbrüche und Kommentare zu beschreiben. Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und ein Go-Compiler ignoriert sie vollständig.
Whitespaces trennen einen Teil einer Anweisung von einem anderen und ermöglichen es dem Compiler zu identifizieren, wo ein Element in einer Anweisung, wie z. B. int, endet und das nächste Element beginnt. Daher in der folgenden Aussage -
var age int;
Es muss mindestens ein Leerzeichen (normalerweise ein Leerzeichen) zwischen int und age vorhanden sein, damit der Compiler sie unterscheiden kann. Auf der anderen Seite in der folgenden Aussage -
fruit = apples + oranges; // get the total fruit
Zwischen Obst und = oder zwischen = und Äpfeln sind keine Leerzeichen erforderlich, obwohl Sie einige hinzufügen können, wenn Sie dies aus Gründen der Lesbarkeit wünschen.
In der Programmiersprache Go beziehen sich Datentypen auf ein umfangreiches System, das zum Deklarieren von Variablen oder Funktionen verschiedener Typen verwendet wird. Der Typ einer Variablen bestimmt, wie viel Speicherplatz sie einnimmt und wie das gespeicherte Bitmuster interpretiert wird.
Die Typen in Go können wie folgt klassifiziert werden:
Sr.Nr. | Typen und Beschreibung |
---|---|
1 | Boolean types Sie sind boolesche Typen und bestehen aus den beiden vordefinierten Konstanten: (a) wahr (b) falsch |
2 | Numeric types Sie sind wieder arithmetische Typen und repräsentieren a) ganzzahlige Typen oder b) Gleitkommawerte im gesamten Programm. |
3 | String types Ein Zeichenfolgentyp repräsentiert die Menge der Zeichenfolgenwerte. Sein Wert ist eine Folge von Bytes. Zeichenfolgen sind unveränderliche Typen, die einmal erstellt wurden. Es ist nicht möglich, den Inhalt einer Zeichenfolge zu ändern. Der vorab deklarierte Zeichenfolgentyp ist Zeichenfolge. |
4 | Derived types Dazu gehören (a) Zeigertypen, (b) Array-Typen, (c) Strukturtypen, (d) Union-Typen und (e) Funktionstypen f) Slice-Typen g) Schnittstellentypen h) Map-Typen i) Kanaltypen |
Array-Typen und Strukturtypen werden zusammenfassend als bezeichnet aggregate types. Der Typ einer Funktion gibt die Menge aller Funktionen mit demselben Parameter und denselben Ergebnistypen an. Wir werden die Grundtypen im folgenden Abschnitt diskutieren, während andere Typen in den kommenden Kapiteln behandelt werden.
Ganzzahlige Typen
Die vordefinierten architekturunabhängigen Ganzzahltypen sind -
Sr.Nr. | Typen und Beschreibung |
---|---|
1 | uint8 8-Bit-Ganzzahlen ohne Vorzeichen (0 bis 255) |
2 | uint16 Vorzeichenlose 16-Bit-Ganzzahlen (0 bis 65535) |
3 | uint32 32-Bit-Ganzzahlen ohne Vorzeichen (0 bis 4294967295) |
4 | uint64 64-Bit-Ganzzahlen ohne Vorzeichen (0 bis 18446744073709551615) |
5 | int8 Vorzeichenbehaftete 8-Bit-Ganzzahlen (-128 bis 127) |
6 | int16 Vorzeichenbehaftete 16-Bit-Ganzzahlen (-32768 bis 32767) |
7 | int32 Vorzeichenbehaftete 32-Bit-Ganzzahlen (-2147483648 bis 2147483647) |
8 | int64 Vorzeichenbehaftete 64-Bit-Ganzzahlen (-9223372036854775808 bis 9223372036854775807) |
Schwimmende Typen
Die vordefinierten architekturunabhängigen Float-Typen sind -
Sr.Nr. | Typen und Beschreibung |
---|---|
1 | float32 IEEE-754 32-Bit-Gleitkommazahlen |
2 | float64 IEEE-754 64-Bit-Gleitkommazahlen |
3 | complex64 Komplexe Zahlen mit float32 Real- und Imaginärteilen |
4 | complex128 Komplexe Zahlen mit float64 Real- und Imaginärteilen |
Der Wert einer n-Bit-Ganzzahl beträgt n Bits und wird unter Verwendung von Zweierkomplement-Arithmetikoperationen dargestellt.
Andere numerische Typen
Es gibt auch eine Reihe von numerischen Typen mit implementierungsspezifischen Größen -
Sr.Nr. | Typen und Beschreibung |
---|---|
1 | byte das gleiche wie uint8 |
2 | rune das gleiche wie int32 |
3 | uint 32 oder 64 Bit |
4 | int gleiche Größe wie uint |
5 | uintptr eine vorzeichenlose Ganzzahl zum Speichern der nicht interpretierten Bits eines Zeigerwerts |
Eine Variable ist nichts anderes als ein Name für einen Speicherbereich, den die Programme bearbeiten können. Jede Variable in Go hat einen bestimmten Typ, der die Größe und das Layout des Speichers der Variablen, den Wertebereich, der in diesem Speicher gespeichert werden kann, und die Operationen festlegt, die auf die Variable angewendet werden können.
Der Name einer Variablen kann aus Buchstaben, Ziffern und dem Unterstrich bestehen. Es muss entweder mit einem Buchstaben oder einem Unterstrich beginnen. Groß- und Kleinbuchstaben unterscheiden sich, da bei Go zwischen Groß- und Kleinschreibung unterschieden wird. Basierend auf den im vorherigen Kapitel erläuterten Grundtypen gibt es die folgenden Grundvariablentypen:
Sr.Nr. | Typ & Beschreibung |
---|---|
1 | byte Normalerweise ein einzelnes Oktett (ein Byte). Dies ist ein Bytetyp. |
2 | int Die natürlichste Ganzzahlgröße für die Maschine. |
3 | float32 Ein Gleitkommawert mit einfacher Genauigkeit. |
Mit der Programmiersprache Go können Sie auch verschiedene andere Variablentypen wie Aufzählung, Zeiger, Array, Struktur und Union definieren, die in den folgenden Kapiteln erläutert werden. In diesem Kapitel konzentrieren wir uns nur auf grundlegende Variablentypen.
Variablendefinition in Go
Eine Variablendefinition teilt dem Compiler mit, wo und wie viel Speicher für die Variable erstellt werden soll. Eine Variablendefinition gibt einen Datentyp an und enthält eine Liste einer oder mehrerer Variablen dieses Typs wie folgt:
var variable_list optional_data_type;
Hier, optional_data_type ist ein gültiger Go-Datentyp, einschließlich Byte, Int, Float32, Complex64, Boolean oder eines benutzerdefinierten Objekts usw., und variable_listkann aus einem oder mehreren durch Kommas getrennten Bezeichnernamen bestehen. Einige gültige Erklärungen werden hier angezeigt -
var i, j, k int;
var c, ch byte;
var f, salary float32;
d = 42;
Die Aussage “var i, j, k;”deklariert und definiert die Variablen i, j und k; Dies weist den Compiler an, Variablen mit den Namen i, j und k vom Typ int zu erstellen.
Variablen können in ihrer Deklaration initialisiert (mit einem Anfangswert versehen) werden. Der Variablentyp wird vom Compiler automatisch anhand des an ihn übergebenen Werts beurteilt. Der Initialisierer besteht aus einem Gleichheitszeichen, gefolgt von einem konstanten Ausdruck wie folgt:
variable_name = value;
Zum Beispiel,
d = 3, f = 5; // declaration of d and f. Here d and f are int
Für die Definition ohne Initialisierer: Variablen mit statischer Speicherdauer werden implizit mit nil initialisiert (alle Bytes haben den Wert 0). Der Anfangswert aller anderen Variablen ist der Nullwert ihres Datentyps.
Statische Typdeklaration in Go
Eine statische Typvariablendeklaration gibt dem Compiler die Gewissheit, dass eine Variable mit dem angegebenen Typ und Namen verfügbar ist, sodass der Compiler mit der weiteren Kompilierung fortfahren kann, ohne die vollständigen Details der Variablen zu benötigen. Eine Variablendeklaration hat nur zum Zeitpunkt der Kompilierung ihre Bedeutung, der Compiler benötigt die eigentliche Variablendeklaration zum Zeitpunkt der Verknüpfung des Programms.
Beispiel
Versuchen Sie das folgende Beispiel, in dem die Variable mit einem Typ deklariert und innerhalb der Hauptfunktion initialisiert wurde:
package main
import "fmt"
func main() {
var x float64
x = 20.0
fmt.Println(x)
fmt.Printf("x is of type %T\n", x)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
20
x is of type float64
Dynamische Typdeklaration / Typinferenz in Go
Bei einer dynamischen Typvariablendeklaration muss der Compiler den Typ der Variablen basierend auf dem an sie übergebenen Wert interpretieren. Der Compiler benötigt keine Variable, um einen statischen Typ als notwendige Anforderung zu haben.
Beispiel
Versuchen Sie das folgende Beispiel, in dem die Variablen ohne Typ deklariert wurden. Beachten Sie, dass wir im Falle einer Typinferenz die Variable initialisiert habeny mit: = Operator, während x wird mit dem Operator = initialisiert.
package main
import "fmt"
func main() {
var x float64 = 20.0
y := 42
fmt.Println(x)
fmt.Println(y)
fmt.Printf("x is of type %T\n", x)
fmt.Printf("y is of type %T\n", y)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
20
42
x is of type float64
y is of type int
Gemischte Variablendeklaration in Go
Variablen verschiedener Typen können mithilfe der Typinferenz auf einmal deklariert werden.
Beispiel
package main
import "fmt"
func main() {
var a, b, c = 3, 4, "foo"
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Printf("a is of type %T\n", a)
fmt.Printf("b is of type %T\n", b)
fmt.Printf("c is of type %T\n", c)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
3
4
foo
a is of type int
b is of type int
c is of type string
Die lWerte und die rWerte in Go
Es gibt zwei Arten von Ausdrücken in Go -
lvalue- Ausdrücke, die sich auf einen Speicherort beziehen, werden als "lvalue" -Ausdruck bezeichnet. Ein Wert kann entweder als linke oder rechte Seite einer Zuweisung angezeigt werden.
rvalue- Der Begriff rWert bezieht sich auf einen Datenwert, der an einer bestimmten Adresse im Speicher gespeichert ist. Ein r-Wert ist ein Ausdruck, dem kein Wert zugewiesen werden kann. Dies bedeutet, dass ein r-Wert möglicherweise auf der rechten, aber nicht auf der linken Seite einer Zuweisung angezeigt wird.
Variablen sind l-Werte und können daher auf der linken Seite einer Zuweisung angezeigt werden. Numerische Literale sind r-Werte und können daher nicht zugewiesen werden und nicht auf der linken Seite angezeigt werden.
Die folgende Aussage ist gültig -
x = 20.0
Die folgende Aussage ist ungültig. Es würde einen Fehler bei der Kompilierung erzeugen -
10 = 20
Konstanten beziehen sich auf feste Werte, die das Programm während seiner Ausführung möglicherweise nicht ändert. Diese festen Werte werden auch genanntliterals.
Konstanten können von einem der grundlegenden Datentypen sein, z. B. eine Ganzzahlkonstante, eine Floating-Konstante, eine Zeichenkonstante oder ein Zeichenfolgenliteral . Es gibt auch Aufzählungskonstanten.
Konstanten werden wie reguläre Variablen behandelt, außer dass ihre Werte nach ihrer Definition nicht mehr geändert werden können.
Ganzzahlige Literale
Ein ganzzahliges Literal kann eine Dezimal-, Oktal- oder Hexadezimalkonstante sein. Ein Präfix gibt die Basis oder den Radix an: 0x oder 0X für Hexadezimal, 0 für Oktal und nichts für Dezimal.
Ein ganzzahliges Literal kann auch ein Suffix haben, das eine Kombination aus U und L für unsigned bzw. long ist. Das Suffix kann in Groß- oder Kleinbuchstaben und in beliebiger Reihenfolge angegeben werden.
Hier sind einige Beispiele für ganzzahlige Literale -
212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal digit */
032UU /* Illegal: cannot repeat a suffix */
Im Folgenden finden Sie weitere Beispiele für verschiedene Arten von Integer-Literalen:
85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
Gleitkomma-Literale
Ein Gleitkomma-Literal besteht aus einem ganzzahligen Teil, einem Dezimalpunkt, einem Bruchteil und einem Exponententeil. Sie können Gleitkomma-Literale entweder in Dezimalform oder in Exponentialform darstellen.
Bei der Darstellung in Dezimalform müssen Sie den Dezimalpunkt, den Exponenten oder beides angeben. Bei der Darstellung in Exponentialform müssen Sie den ganzzahligen Teil, den Bruchteil oder beides einschließen. Der vorzeichenbehaftete Exponent wird durch e oder E eingeführt.
Hier einige Beispiele für Gleitkomma-Literale -
3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction */
Fluchtabfolge
Wenn bestimmten Zeichen ein Backslash vorangestellt wird, haben sie in Go eine besondere Bedeutung. Diese werden als Escape-Sequenzcodes bezeichnet, die zur Darstellung von Zeilenumbruch (\ n), Tabulator (\ t), Rücktaste usw. verwendet werden. Hier finden Sie eine Liste einiger solcher Escape-Sequenzcodes.
Fluchtabfolge | Bedeutung |
---|---|
\\ | \ Zeichen |
\ ' | 'Charakter |
"" | "Charakter |
\? | ? Charakter |
\ein | Alarm oder Glocke |
\ b | Rücktaste |
\ f | Formularvorschub |
\ n | Neue Zeile |
\ r | Wagenrücklauf |
\ t | Horizontale Registerkarte |
\ v | Vertikale Registerkarte |
\ ooo | Oktalzahl von ein bis drei Ziffern |
\ xhh. . . | Hexadezimalzahl aus einer oder mehreren Ziffern |
Das folgende Beispiel zeigt die Verwendung \t in einem Programm -
package main
import "fmt"
func main() {
fmt.Printf("Hello\tWorld!")
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Hello World!
String Literals in Go
String-Literale oder Konstanten werden in doppelte Anführungszeichen "" eingeschlossen. Eine Zeichenfolge enthält Zeichen, die Zeichenliteralen ähnlich sind: einfache Zeichen, Escape-Sequenzen und universelle Zeichen.
Sie können eine lange Zeile mithilfe von Zeichenfolgenliteralen in mehrere Zeilen aufteilen und diese durch Leerzeichen trennen.
Hier sind einige Beispiele für String-Literale. Alle drei Formen sind identische Zeichenfolgen.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
Das const- Schlüsselwort
Sie können verwenden const Präfix zum Deklarieren von Konstanten mit einem bestimmten Typ wie folgt:
const variable type = value;
Das folgende Beispiel zeigt die Verwendung von const Schlüsselwort -
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
area = LENGTH * WIDTH
fmt.Printf("value of area : %d", area)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
value of area : 50
Beachten Sie, dass es eine gute Programmierpraxis ist, Konstanten in GROSSBUCHSTABEN zu definieren.
Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Die Go-Sprache ist reich an integrierten Operatoren und bietet die folgenden Arten von Operatoren:
- Rechenzeichen
- Vergleichsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungsoperatoren
- Verschiedene Betreiber
In diesem Lernprogramm werden nacheinander arithmetische, relationale, logische, bitweise, Zuweisungs- und andere Operatoren erläutert.
Rechenzeichen
Die folgende Tabelle zeigt alle von der Go-Sprache unterstützten arithmetischen Operatoren. Variable annehmenA hält 10 und variabel B hält dann 20 -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
+ | Fügt zwei Operanden hinzu | A + B ergibt 30 |
- - | Subtrahiert den zweiten Operanden vom ersten | A - B ergibt -10 |
* * | Multipliziert beide Operanden | A * B ergibt 200 |
/. | Dividiert den Zähler durch den Nenner. | B / A ergibt 2 |
%. | Moduloperator; gibt den Rest nach einer ganzzahligen Division an. | B% A ergibt 0 |
++ | Inkrementoperator. Es erhöht den ganzzahligen Wert um eins. | A ++ gibt 11 |
- - | Operator dekrementieren. Es verringert den ganzzahligen Wert um eins. | A-- gibt 9 |
Vergleichsoperatoren
In der folgenden Tabelle sind alle von der Sprache Go unterstützten Vergleichsoperatoren aufgeführt. Variable annehmenA hält 10 und variabel B hält 20, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
== | Es wird geprüft, ob die Werte zweier Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. | (A == B) ist nicht wahr. |
! = | Es wird geprüft, ob die Werte zweier Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. | (A! = B) ist wahr. |
> | Es wird geprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> B) ist nicht wahr. |
< | Es wird geprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <B) ist wahr. |
> = | Es wird geprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> = B) ist nicht wahr. |
<= | Es wird geprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <= B) ist wahr. |
Logische Operatoren
In der folgenden Tabelle sind alle logischen Operatoren aufgeführt, die von der Sprache Go unterstützt werden. Variable annehmenA hält 1 und variabel B hält 0, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
&& | Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden ungleich Null sind, wird die Bedingung wahr. | (A && B) ist falsch. |
|| | Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden ungleich Null ist, wird die Bedingung wahr. | (A || B) ist wahr. |
! | Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false. | ! (A && B) ist wahr. |
Die folgende Tabelle zeigt alle logischen Operatoren, die von der Go-Sprache unterstützt werden. Variable annehmenA gilt wahr und variabel B hält falsch, dann -
Operator | Beschreibung | Beispiel |
---|---|---|
&& | Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden falsch sind, wird die Bedingung falsch. | (A && B) ist falsch. |
|| | Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden wahr ist, wird die Bedingung wahr. | (A || B) ist wahr. |
! | Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT sie falsch. | ! (A && B) ist wahr. |
Bitweise Operatoren
Bitweise Operatoren arbeiten an Bits und führen eine bitweise Operation durch. Die Wahrheitstabellen für &, | und ^ lauten wie folgt:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Angenommen, A = 60; und B = 13. Im Binärformat sind sie wie folgt:
A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Die von der Sprache C unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Angenommen, Variable A hält 60 und Variable B hält 13, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
& | Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. | (A & B) ergibt 12, was 0000 1100 ist |
| | Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. | (A | B) ergibt 61, was 0011 1101 ist |
^ | Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. | (A ^ B) ergibt 49, was 0011 0001 ist |
<< | Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben. | Ein << 2 ergibt 240, was 1111 0000 ist |
>> | Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben. | Eine >> 2 ergibt 15, was 0000 1111 ist |
Zuweisungsoperatoren
In der folgenden Tabelle sind alle Zuweisungsoperatoren aufgeführt, die von der Sprache Go unterstützt werden.
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
= | Einfacher Zuweisungsoperator, Weist Werte von Operanden auf der rechten Seite dem Operanden auf der linken Seite zu | C = A + B weist C den Wert von A + B zu |
+ = | UND-Zuweisungsoperator hinzufügen. Er fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu | C + = A entspricht C = C + A. |
- = | Subtrahieren UND Zuweisungsoperator, subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu | C - = A entspricht C = C - A. |
* = | Multiplizieren Sie den UND-Zuweisungsoperator. Er multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu | C * = A entspricht C = C * A. |
/ = | UND-Zuweisungsoperator teilen. Er teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu | C / = A entspricht C = C / A. |
% = | Modul- UND Zuweisungsoperator. Der Modul wird mit zwei Operanden verwendet und das Ergebnis dem linken Operanden zugewiesen | C% = A entspricht C = C% A. |
<< = | Linksverschiebung UND Zuweisungsoperator | C << = 2 ist dasselbe wie C = C << 2 |
>> = | Rechtsverschiebung UND Zuweisungsoperator | C >> = 2 ist dasselbe wie C = C >> 2 |
& = | Bitweiser UND-Zuweisungsoperator | C & = 2 ist dasselbe wie C = C & 2 |
^ = | bitweises exklusives ODER und Zuweisungsoperator | C ^ = 2 ist dasselbe wie C = C ^ 2 |
| = | bitweises Inklusiv-ODER und Zuweisungsoperator | C | = 2 ist dasselbe wie C = C | 2 |
Verschiedene Betreiber
Es gibt einige andere wichtige Operatoren, die von Go Language unterstützt werden, einschließlich sizeof und ?:.
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
& | Gibt die Adresse einer Variablen zurück. | &ein; liefert die tatsächliche Adresse der Variablen. |
* * | Zeiger auf eine Variable. | *ein; liefert einen Zeiger auf eine Variable. |
Vorrang der Operatoren in Go
Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator.
Zum Beispiel x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.
Hier werden Operatoren mit der höchsten Priorität oben in der Tabelle angezeigt, Operatoren mit der niedrigsten Priorität unten. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.
Beispiele anzeigen
Kategorie | Operator | Assoziativität |
---|---|---|
Postfix | () [] ->. ++ - - | Links nach rechts |
Einstellig | + -! ~ ++ - - (Typ) * & sizeof | Rechts nach links |
Multiplikativ | * /% | Links nach rechts |
Zusatzstoff | + - | Links nach rechts |
Verschiebung | << >> | Links nach rechts |
Relational | << = >> = | Links nach rechts |
Gleichberechtigung | ==! = | Links nach rechts |
Bitweises UND | & | Links nach rechts |
Bitweises XOR | ^ | Links nach rechts |
Bitweises ODER | | | Links nach rechts |
Logisches UND | && | Links nach rechts |
Logisches ODER | || | Links nach rechts |
Zuordnung | = + = - = * = / =% = >> = << = & = ^ = | = | Rechts nach links |
Komma | , | Links nach rechts |
Entscheidungsstrukturen erfordern, dass der Programmierer eine oder mehrere Bedingungen angibt, die vom Programm bewertet oder getestet werden sollen, zusammen mit einer Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr bestimmt wird, und optional anderen Anweisungen, die ausgeführt werden sollen, wenn die Bedingung ausgeführt wird wird als falsch bestimmt.
Es folgt die allgemeine Form einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:
Die Programmiersprache Go bietet die folgenden Arten von Entscheidungsbefehlen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.
Sr.Nr. | Aussage & Beschreibung |
---|---|
1 | if-Anweisung Ein if statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen. |
2 | if ... else-Anweisung Ein if statement kann von einem optionalen gefolgt werden else statement, wird ausgeführt, wenn der boolesche Ausdruck false ist. |
3 | verschachtelte if-Anweisungen Sie können eine verwenden if oder else if Aussage in einem anderen if oder else if Aussage (n). |
4 | switch-Anweisung EIN switch Mit der Anweisung kann eine Variable auf Gleichheit mit einer Liste von Werten getestet werden. |
5 | select-Anweisung EIN select Aussage ist ähnlich wie switch Anweisung mit dem Unterschied, dass case-Anweisungen sich auf die Kanalkommunikation beziehen. |
Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.
Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.
Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:
Die Programmiersprache Go bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen.
Sr.Nr. | Schleifentyp & Beschreibung |
---|---|
1 | für Schleife Es führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet. |
2 | verschachtelte Schleifen Dies sind eine oder mehrere Schleifen innerhalb einer for-Schleife. |
Schleifensteuerungsanweisungen
Schleifensteueranweisungen ändern eine Ausführung von ihrer normalen Reihenfolge. Wenn eine Ausführung ihren Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.
Go unterstützt die folgenden Steueranweisungen:
Sr.Nr. | Steueranweisung & Beschreibung |
---|---|
1 | break-Anweisung Es beendet a for loop oder switch Anweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der for-Schleife oder dem Schalter. |
2 | Aussage fortsetzen Es bewirkt, dass die Schleife den Rest ihres Körpers überspringt und ihren Zustand sofort erneut testet, bevor sie wiederholt wird. |
3 | gehe zu Aussage Es überträgt die Kontrolle auf die beschriftete Anweisung. |
Die Endlosschleife
Eine Schleife wird zu einer Endlosschleife, wenn ihr Zustand niemals falsch wird. Zu diesem Zweck wird traditionell die for-Schleife verwendet. Da keiner der drei Ausdrücke, die die for-Schleife bilden, erforderlich ist, können Sie eine Endlosschleife erstellen, indem Sie den bedingten Ausdruck leer lassen oder true an ihn übergeben.
package main
import "fmt"
func main() {
for true {
fmt.Printf("This loop will run forever.\n");
}
}
Wenn der bedingte Ausdruck fehlt, wird angenommen, dass er wahr ist. Möglicherweise haben Sie einen Initialisierungs- und Inkrementausdruck, aber C-Programmierer verwenden häufiger das for (;;) - Konstrukt, um eine Endlosschleife zu kennzeichnen.
Note - Sie können eine Endlosschleife beenden, indem Sie Strg + C drücken.
Eine Funktion ist eine Gruppe von Anweisungen, die zusammen eine Aufgabe ausführen. Jedes Go-Programm hat mindestens eine Funktion:main(). Sie können Ihren Code in separate Funktionen unterteilen. Wie Sie Ihren Code auf verschiedene Funktionen aufteilen, liegt bei Ihnen. Logischerweise sollte die Aufteilung jedoch so erfolgen, dass jede Funktion eine bestimmte Aufgabe ausführt.
Eine Funktion declarationinformiert den Compiler über einen Funktionsnamen, einen Rückgabetyp und Parameter. Eine Funktiondefinition liefert den eigentlichen Körper der Funktion.
Die Go-Standardbibliothek bietet zahlreiche integrierte Funktionen, die Ihr Programm aufrufen kann. Zum Beispiel die Funktionlen()Nimmt Argumente verschiedener Typen und gibt die Länge des Typs zurück. Wenn eine Zeichenfolge an diese übergeben wird, gibt die Funktion die Länge der Zeichenfolge in Byte zurück. Wenn ein Array an das Array übergeben wird, gibt die Funktion die Länge des Arrays zurück.
Funktionen sind auch bekannt als method, sub-routine, oder procedure.
Funktion definieren
Die allgemeine Form einer Funktionsdefinition in der Programmiersprache Go lautet wie folgt:
func function_name( [parameter list] ) [return_types]
{
body of the function
}
Eine Funktionsdefinition in der Programmiersprache Go besteht aus einem Funktionsheader und einem Funktionskörper . Hier sind alle Teile einer Funktion -
Func - Es startet die Deklaration einer Funktion.
Function Name- Es ist der tatsächliche Name der Funktion. Der Funktionsname und die Parameterliste bilden zusammen die Funktionssignatur.
Parameters- Ein Parameter ist wie ein Platzhalter. Wenn eine Funktion aufgerufen wird, übergeben Sie einen Wert an den Parameter. Dieser Wert wird als tatsächlicher Parameter oder Argument bezeichnet. Die Parameterliste bezieht sich auf den Typ, die Reihenfolge und die Anzahl der Parameter einer Funktion. Parameter sind optional; Das heißt, eine Funktion darf keine Parameter enthalten.
Return Type- Eine Funktion kann eine Liste von Werten zurückgeben. Der return_types ist die Liste der Datentypen der Werte, die die Funktion zurückgibt. Einige Funktionen führen die gewünschten Operationen aus, ohne einen Wert zurückzugeben. In diesem Fall ist der return_type nicht erforderlich.
Function Body - Es enthält eine Sammlung von Anweisungen, die definieren, was die Funktion tut.
Beispiel
Der folgende Quellcode zeigt eine aufgerufene Funktion max(). Diese Funktion verwendet zwei Parameter num1 und num2 und gibt das Maximum zwischen den beiden zurück -
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
Eine Funktion aufrufen
Beim Erstellen einer Go-Funktion definieren Sie, was die Funktion zu tun hat. Um eine Funktion zu verwenden, müssen Sie diese Funktion aufrufen, um die definierte Aufgabe auszuführen.
Wenn ein Programm eine Funktion aufruft, wird die Programmsteuerung auf die aufgerufene Funktion übertragen. Eine aufgerufene Funktion führt eine definierte Aufgabe aus. Wenn ihre return-Anweisung ausgeführt wird oder wenn ihre schließende Klammer zum Beenden der Funktion erreicht ist, gibt sie die Programmsteuerung an das Hauptprogramm zurück.
Um eine Funktion aufzurufen, müssen Sie lediglich die erforderlichen Parameter zusammen mit ihrem Funktionsnamen übergeben. Wenn die Funktion einen Wert zurückgibt, können Sie den zurückgegebenen Wert speichern. Zum Beispiel -
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
var ret int
/* calling a function to get max value */
ret = max(a, b)
fmt.Printf( "Max value is : %d\n", ret )
}
/* function returning the max between two numbers */
func max(num1, num2 int) int {
/* local variable declaration */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
Wir haben die Funktion max () zusammen mit der Funktion main () beibehalten und den Quellcode kompiliert. Beim Ausführen der endgültigen ausführbaren Datei wird das folgende Ergebnis erzielt:
Max value is : 200
Rückgabe mehrerer Werte von Function
Eine Go-Funktion kann mehrere Werte zurückgeben. Zum Beispiel -
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Kumar Mahesh
Funktionsargumente
Wenn eine Funktion Argumente verwenden soll, muss sie Variablen deklarieren, die die Werte der Argumente akzeptieren. Diese Variablen werden als bezeichnetformal parameters der Funktion.
Die formalen Parameter verhalten sich wie andere lokale Variablen innerhalb der Funktion und werden beim Eintritt in die Funktion erstellt und beim Beenden zerstört.
Beim Aufrufen einer Funktion gibt es zwei Möglichkeiten, wie Argumente an eine Funktion übergeben werden können:
Sr.Nr. | Anruftyp & Beschreibung |
---|---|
1 | Call by value Diese Methode kopiert den tatsächlichen Wert eines Arguments in den formalen Parameter der Funktion. In diesem Fall haben Änderungen am Parameter innerhalb der Funktion keine Auswirkung auf das Argument. |
2 | Rufen Sie als Referenz an Diese Methode kopiert die Adresse eines Arguments in den formalen Parameter. Innerhalb der Funktion wird die Adresse verwendet, um auf das tatsächliche Argument zuzugreifen, das im Aufruf verwendet wird. Dies bedeutet, dass Änderungen am Parameter das Argument beeinflussen. |
Standardmäßig verwendet Go Call-by-Value, um Argumente zu übergeben. Im Allgemeinen bedeutet dies, dass der Code innerhalb einer Funktion die zum Aufrufen der Funktion verwendeten Argumente nicht ändern kann. Das obige Programm verwendete beim Aufrufen der Funktion max () dieselbe Methode.
Funktionsnutzung
Eine Funktion kann auf folgende Arten verwendet werden:
Sr.Nr. | Funktionsnutzung & Beschreibung |
---|---|
1 | Funktion als Wert Funktionen können im laufenden Betrieb erstellt und als Werte verwendet werden. |
2 | Funktionsabschlüsse Funktionsschließungen sind anonyme Funktionen und können in der dynamischen Programmierung verwendet werden. |
3 | Methode Methoden sind spezielle Funktionen mit einem Empfänger. |
Ein Bereich in jeder Programmierung ist ein Bereich des Programms, in dem eine definierte Variable existieren kann und darüber hinaus nicht auf die Variable zugegriffen werden kann. Es gibt drei Stellen, an denen Variablen in der Programmiersprache Go deklariert werden können:
Innerhalb einer Funktion oder eines Blocks (local Variablen)
Außerhalb aller Funktionen (global Variablen)
Bei der Definition von Funktionsparametern (formal Parameter)
Lassen Sie uns herausfinden, was sind local und global Variablen und was sind formal Parameter.
Lokale Variablen
Variablen, die innerhalb einer Funktion oder eines Blocks deklariert sind, werden als lokale Variablen bezeichnet. Sie können nur von Anweisungen verwendet werden, die sich in dieser Funktion oder diesem Codeblock befinden. Es ist nicht bekannt, dass lokale Variablen außerhalb ihrer eigenen Funktionen funktionieren. Im folgenden Beispiel werden lokale Variablen verwendet. Hier sind alle Variablen a, b und c lokal für die Funktion main ().
package main
import "fmt"
func main() {
/* local variable declaration */
var a, b, c int
/* actual initialization */
a = 10
b = 20
c = a + b
fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
value of a = 10, b = 20 and c = 30
Globale Variablen
Globale Variablen werden außerhalb einer Funktion definiert, normalerweise über dem Programm. Globale Variablen behalten ihren Wert während der gesamten Lebensdauer des Programms und können in allen für das Programm definierten Funktionen aufgerufen werden.
Auf eine globale Variable kann von jeder Funktion zugegriffen werden. Das heißt, eine globale Variable kann nach ihrer Deklaration im gesamten Programm verwendet werden. Im folgenden Beispiel werden sowohl globale als auch lokale Variablen verwendet.
package main
import "fmt"
/* global variable declaration */
var g int
func main() {
/* local variable declaration */
var a, b int
/* actual initialization */
a = 10
b = 20
g = a + b
fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
value of a = 10, b = 20 and g = 30
Ein Programm kann für lokale und globale Variablen denselben Namen haben, der Wert der lokalen Variablen in einer Funktion wird jedoch bevorzugt. Zum Beispiel -
package main
import "fmt"
/* global variable declaration */
var g int = 20
func main() {
/* local variable declaration */
var g int = 10
fmt.Printf ("value of g = %d\n", g)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
value of g = 10
Formale Parameter
Formale Parameter werden in dieser Funktion als lokale Variablen behandelt und haben Vorrang vor den globalen Variablen. Zum Beispiel -
package main
import "fmt"
/* global variable declaration */
var a int = 20;
func main() {
/* local variable declaration in main function */
var a int = 10
var b int = 20
var c int = 0
fmt.Printf("value of a in main() = %d\n", a);
c = sum( a, b);
fmt.Printf("value of c in main() = %d\n", c);
}
/* function to add two integers */
func sum(a, b int) int {
fmt.Printf("value of a in sum() = %d\n", a);
fmt.Printf("value of b in sum() = %d\n", b);
return a + b;
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30
Initialisieren lokaler und globaler Variablen
Lokale und globale Variablen werden auf ihren Standardwert 0 initialisiert. während Zeiger auf Null initialisiert werden.
Datentyp | Anfänglicher Standardwert |
---|---|
int | 0 |
float32 | 0 |
Zeiger | Null |
Strings, die in der Go-Programmierung weit verbreitet sind, sind schreibgeschützte Bytes. In der Programmiersprache Go sind Zeichenfolgenslices. Die Go-Plattform bietet verschiedene Bibliotheken zum Bearbeiten von Zeichenfolgen.
- unicode
- regexp
- strings
Strings erstellen
Der direkteste Weg, einen String zu erstellen, ist das Schreiben von -
var greeting = "Hello world!"
Immer wenn ein String-Literal in Ihrem Code auftritt, erstellt der Compiler ein String-Objekt mit dem Wert "Hallo Welt!".
Ein String-Literal enthält gültige UTF-8-Sequenzen, die als Runen bezeichnet werden. Ein String enthält beliebige Bytes.
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("normal string: ")
fmt.Printf("%s", greeting)
fmt.Printf("\n")
fmt.Printf("hex bytes: ")
for i := 0; i < len(greeting); i++ {
fmt.Printf("%x ", greeting[i])
}
fmt.Printf("\n")
const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98"
/*q flag escapes unprintable characters, with + flag it escapses non-ascii
characters as well to make output unambigous
*/
fmt.Printf("quoted string: ")
fmt.Printf("%+q", sampleText)
fmt.Printf("\n")
}
Dies würde das folgende Ergebnis erzeugen -
normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21
quoted string: "\xbd\xb2=\xbc \u2318"
Note - Das String-Literal ist unveränderlich, sodass ein String-Literal nach seiner Erstellung nicht mehr geändert werden kann.
String-Länge
Die Methode len (str) gibt die Anzahl der im Zeichenfolgenliteral enthaltenen Bytes zurück.
package main
import "fmt"
func main() {
var greeting = "Hello world!"
fmt.Printf("String Length is: ")
fmt.Println(len(greeting))
}
Dies würde das folgende Ergebnis erzeugen -
String Length is : 12
Verketten von Strings
Das Strings-Paket enthält eine Methode join zum Verketten mehrerer Zeichenfolgen -
strings.Join(sample, " ")
Join verkettet die Elemente eines Arrays, um eine einzelne Zeichenfolge zu erstellen. Der zweite Parameter ist der Separator, der zwischen den Elementen des Arrays platziert wird.
Schauen wir uns das folgende Beispiel an:
package main
import ("fmt" "math" )"fmt" "strings")
func main() {
greetings := []string{"Hello","world!"}
fmt.Println(strings.Join(greetings, " "))
}
Dies würde das folgende Ergebnis erzeugen -
Hello world!
Die Programmiersprache Go bietet eine Datenstruktur namens the array, die eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe speichern kann. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Oft ist es jedoch sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.
Anstatt einzelne Variablen wie Nummer 0, Nummer 1, ... und Nummer 99 zu deklarieren, deklarieren Sie eine Array-Variable wie Zahlen und verwenden Zahlen [0], Zahlen [1] und ..., Zahlen [99] zur Darstellung einzelne Variablen. Auf ein bestimmtes Element in einem Array wird über einen Index zugegriffen.
Alle Arrays bestehen aus zusammenhängenden Speicherstellen. Die niedrigste Adresse entspricht dem ersten Element und die höchste Adresse dem letzten Element.
Arrays deklarieren
Um ein Array in Go zu deklarieren, gibt ein Programmierer den Typ der Elemente und die Anzahl der für ein Array erforderlichen Elemente wie folgt an:
var variable_name [SIZE] variable_type
Dies wird als eindimensionales Array bezeichnet. DasarraySize muss eine ganzzahlige Konstante größer als Null sein und typekann ein beliebiger gültiger Go-Datentyp sein. Zum Beispiel, um ein Array mit 10 Elementen zu deklarieren, das aufgerufen wirdbalance Verwenden Sie diese Anweisung vom Typ float32 -
var balance [10] float32
Hier, balance ist ein variables Array, das bis zu 10 Gleitkommazahlen enthalten kann.
Arrays initialisieren
Sie können das Array in Go entweder einzeln oder mithilfe einer einzelnen Anweisung wie folgt initialisieren:
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Die Anzahl der Werte zwischen geschweiften Klammern {} darf nicht größer sein als die Anzahl der Elemente, die wir für das Array zwischen eckigen Klammern [] deklarieren.
Wenn Sie die Größe des Arrays weglassen, wird ein Array erstellt, das gerade groß genug ist, um die Initialisierung aufzunehmen. Deshalb, wenn Sie schreiben -
var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
Sie erstellen genau das gleiche Array wie im vorherigen Beispiel. Es folgt ein Beispiel zum Zuweisen eines einzelnen Elements des Arrays:
balance[4] = 50.0
Die obige Anweisung weist Elementnummer 5 th in dem Array mit einem Wert von 50,0. Alle Arrays haben 0 als Index ihres ersten Elements, das auch als Basisindex bezeichnet wird, und der letzte Index eines Arrays entspricht der Gesamtgröße des Arrays minus 1. Es folgt die bildliche Darstellung desselben Arrays, das wir oben besprochen haben -
Zugriff auf Array-Elemente
Auf ein Element wird zugegriffen, indem der Arrayname indiziert wird. Dazu wird der Index des Elements in eckige Klammern nach dem Namen des Arrays gesetzt. Zum Beispiel -
float32 salary = balance[9]
Die obige Erklärung nimmt 10 - te Element aus dem Array und den Wert auf Gehalt Variablen zuweisen. Das Folgende ist ein Beispiel, das alle oben genannten drei Konzepte verwendet, nämlich. Deklaration, Zuweisung und Zugriff auf Arrays -
package main
import "fmt"
func main() {
var n [10]int /* n is an array of 10 integers */
var i,j int
/* initialize elements of array n to 0 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* set element at location i to i + 100 */
}
/* output each array element's value */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Gehen Sie Arrays im Detail
Es gibt wichtige Konzepte in Bezug auf das Array, die einem Go-Programmierer klar sein sollten -
Sr.Nr. | Konzept & Beschreibung |
---|---|
1 | Mehrdimensionale Arrays Go unterstützt mehrdimensionale Arrays. Die einfachste Form eines mehrdimensionalen Arrays ist das zweidimensionale Array. |
2 | Übergeben von Arrays an Funktionen Sie können der Funktion einen Zeiger auf ein Array übergeben, indem Sie den Namen des Arrays ohne Index angeben. |
Zeiger in Go sind einfach und machen Spaß zu lernen. Einige Go-Programmieraufgaben lassen sich einfacher mit Zeigern ausführen, und andere Aufgaben, z. B. Aufruf per Referenz, können nicht ohne Verwendung von Zeigern ausgeführt werden. Es wird also notwendig, Zeiger zu lernen, um ein perfekter Go-Programmierer zu werden.
Wie Sie wissen, ist jede Variable ein Speicherort, und für jeden Speicherort ist eine Adresse definiert, auf die mit dem kaufmännischen Und (&) -Operator zugegriffen werden kann, der eine Adresse im Speicher angibt. Betrachten Sie das folgende Beispiel, in dem die Adresse der definierten Variablen gedruckt wird:
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("Address of a variable: %x\n", &a )
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Address of a variable: 10328000
Sie haben also verstanden, was Speicheradresse ist und wie Sie darauf zugreifen können. Lassen Sie uns nun sehen, was Zeiger sind.
Was sind Zeiger?
EIN pointerist eine Variable, deren Wert die Adresse einer anderen Variablen ist, dh die direkte Adresse des Speicherorts. Wie bei jeder Variablen oder Konstante müssen Sie einen Zeiger deklarieren, bevor Sie ihn zum Speichern einer Variablenadresse verwenden können. Die allgemeine Form einer Zeigervariablendeklaration lautet -
var var_name *var-type
Hier, typeist der Basistyp des Zeigers; Es muss ein gültiger C-Datentyp sein undvar-nameist der Name der Zeigervariable. Das Sternchen *, mit dem Sie einen Zeiger deklariert haben, ist das gleiche Sternchen, das Sie für die Multiplikation verwenden. In dieser Anweisung wird das Sternchen jedoch verwendet, um eine Variable als Zeiger zu kennzeichnen. Es folgen die gültigen Zeigerdeklarationen -
var ip *int /* pointer to an integer */
var fp *float32 /* pointer to a float */
Der tatsächliche Datentyp des Werts aller Zeiger, ob Ganzzahl, Gleitkomma oder auf andere Weise, ist derselbe, eine lange Hexadezimalzahl, die eine Speicheradresse darstellt. Der einzige Unterschied zwischen Zeigern verschiedener Datentypen ist der Datentyp der Variablen oder Konstante, auf die der Zeiger zeigt.
Wie verwende ich Zeiger?
Es gibt einige wichtige Operationen, die wir häufig mit Zeigern ausführen: (a) Wir definieren Zeigervariablen, (b) weisen einem Zeiger die Adresse einer Variablen zu und (c) greifen auf den Wert an der in der Zeigervariablen gespeicherten Adresse zu .
Alle diese Operationen werden mit dem unären Operator * ausgeführt, der den Wert der Variablen zurückgibt, die sich an der durch ihren Operanden angegebenen Adresse befindet. Das folgende Beispiel zeigt, wie diese Vorgänge ausgeführt werden:
package main
import "fmt"
func main() {
var a int = 20 /* actual variable declaration */
var ip *int /* pointer variable declaration */
ip = &a /* store address of a in pointer variable*/
fmt.Printf("Address of a variable: %x\n", &a )
/* address stored in pointer variable */
fmt.Printf("Address stored in ip variable: %x\n", ip )
/* access the value using the pointer */
fmt.Printf("Value of *ip variable: %d\n", *ip )
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20
Keine Zeiger in Go
Der Go-Compiler weist einer Zeigervariablen einen Nullwert zu, falls Sie keine genaue Adresse haben, die zugewiesen werden soll. Dies erfolgt zum Zeitpunkt der Variablendeklaration. Ein Zeiger, dem null zugewiesen ist, heißt anil Zeiger.
Der Nullzeiger ist eine Konstante mit dem Wert Null, die in mehreren Standardbibliotheken definiert ist. Betrachten Sie das folgende Programm -
package main
import "fmt"
func main() {
var ptr *int
fmt.Printf("The value of ptr is : %x\n", ptr )
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
The value of ptr is 0
Auf den meisten Betriebssystemen dürfen Programme unter der Adresse 0 nicht auf den Speicher zugreifen, da dieser Speicher vom Betriebssystem reserviert wird. Die Speicheradresse 0 hat jedoch eine besondere Bedeutung; es signalisiert, dass der Zeiger nicht auf einen zugänglichen Speicherort zeigen soll. Wenn ein Zeiger jedoch den Wert Null (Null) enthält, wird angenommen, dass er auf nichts zeigt.
Um nach einem Nullzeiger zu suchen, können Sie eine if-Anweisung wie folgt verwenden:
if(ptr != nil) /* succeeds if p is not nil */
if(ptr == nil) /* succeeds if p is null */
Zeiger im Detail
Zeiger haben viele, aber einfache Konzepte und sie sind sehr wichtig für die Go-Programmierung. Die folgenden Konzepte von Zeigern sollten einem Go-Programmierer klar sein:
Sr.Nr. | Konzept & Beschreibung |
---|---|
1 | Go - Array von Zeigern Sie können Arrays definieren, die eine Reihe von Zeigern enthalten. |
2 | Go - Zeiger auf Zeiger Mit Go können Sie einen Zeiger auf einen Zeiger usw. setzen. |
3 | Übergeben von Zeigern auf Funktionen in Go Durch Übergeben eines Arguments als Referenz oder als Adresse kann das übergebene Argument in der aufrufenden Funktion von der aufgerufenen Funktion geändert werden. |
Mit Go-Arrays können Sie Variablen definieren, die mehrere Datenelemente derselben Art enthalten können. Structure ist ein weiterer benutzerdefinierter Datentyp, der in der Go-Programmierung verfügbar ist und es Ihnen ermöglicht, Datenelemente verschiedener Art zu kombinieren.
Strukturen werden verwendet, um einen Datensatz darzustellen. Angenommen, Sie möchten die Bücher in einer Bibliothek verfolgen. Möglicherweise möchten Sie die folgenden Attribute jedes Buches verfolgen:
- Title
- Author
- Subject
- Buch-ID
In einem solchen Szenario sind Strukturen sehr nützlich.
Struktur definieren
Um eine Struktur zu definieren, müssen Sie verwenden type und structAussagen. Die struct-Anweisung definiert einen neuen Datentyp mit mehreren Mitgliedern für Ihr Programm. Die type-Anweisung bindet einen Namen mit dem Typ, der in unserem Fall struct ist. Das Format der struct-Anweisung lautet wie folgt:
type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}
Sobald ein Strukturtyp definiert ist, kann er verwendet werden, um Variablen dieses Typs mithilfe der folgenden Syntax zu deklarieren.
variable_name := structure_variable_type {value1, value2...valuen}
Zugriff auf Strukturmitglieder
Um auf ein Mitglied einer Struktur zuzugreifen, verwenden wir die member access operator (.).Der Elementzugriffsoperator wird als Punkt zwischen dem Namen der Strukturvariablen und dem Strukturelement codiert, auf das wir zugreifen möchten. Sie würden verwendenstructSchlüsselwort zum Definieren von Variablen des Strukturtyps. Im folgenden Beispiel wird die Verwendung einer Struktur erläutert.
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
fmt.Printf( "Book 1 title : %s\n", Book1.title)
fmt.Printf( "Book 1 author : %s\n", Book1.author)
fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)
/* print Book2 info */
fmt.Printf( "Book 2 title : %s\n", Book2.title)
fmt.Printf( "Book 2 author : %s\n", Book2.author)
fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Book 1 title : Go Programming
Book 1 author : Mahesh Kumar
Book 1 subject : Go Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700
Strukturen als Funktionsargumente
Sie können eine Struktur als Funktionsargument auf sehr ähnliche Weise übergeben wie jede andere Variable oder jeden anderen Zeiger. Sie würden auf Strukturvariablen genauso zugreifen wie im obigen Beispiel -
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(Book1)
/* print Book2 info */
printBook(Book2)
}
func printBook( book Books ) {
fmt.Printf( "Book title : %s\n", book.title);
fmt.Printf( "Book author : %s\n", book.author);
fmt.Printf( "Book subject : %s\n", book.subject);
fmt.Printf( "Book book_id : %d\n", book.book_id);
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Book title : Go Programming
Book author : Mahesh Kumar
Book subject : Go Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700
Zeiger auf Strukturen
Sie können Zeiger auf Strukturen auf dieselbe Weise definieren, wie Sie Zeiger auf eine andere Variable wie folgt definieren:
var struct_pointer *Books
Jetzt können Sie die Adresse einer Strukturvariablen in der oben definierten Zeigervariablen speichern. Um die Adresse einer Strukturvariablen zu ermitteln, platzieren Sie den Operator & wie folgt vor dem Namen der Struktur:
struct_pointer = &Book1;
Um mit einem Zeiger auf diese Struktur auf die Elemente einer Struktur zuzugreifen, müssen Sie das "." Betreiber wie folgt -
struct_pointer.title;
Lassen Sie uns das obige Beispiel mit dem Strukturzeiger neu schreiben -
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = "Go Programming"
Book1.author = "Mahesh Kumar"
Book1.subject = "Go Programming Tutorial"
Book1.book_id = 6495407
/* book 2 specification */
Book2.title = "Telecom Billing"
Book2.author = "Zara Ali"
Book2.subject = "Telecom Billing Tutorial"
Book2.book_id = 6495700
/* print Book1 info */
printBook(&Book1)
/* print Book2 info */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s\n", book.title);
fmt.Printf( "Book author : %s\n", book.author);
fmt.Printf( "Book subject : %s\n", book.subject);
fmt.Printf( "Book book_id : %d\n", book.book_id);
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Book title : Go Programming
Book author : Mahesh Kumar
Book subject : Go Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700
Go Slice ist eine Abstraktion über Go Array. Mit Go Array können Sie Variablen definieren, die mehrere Datenelemente derselben Art enthalten können. Es wird jedoch keine integrierte Methode bereitgestellt, um die Größe dynamisch zu erhöhen oder ein eigenes Subarray abzurufen. Slices überwinden diese Einschränkung. Es bietet viele Dienstprogrammfunktionen, die für das Array erforderlich sind, und wird häufig in der Go-Programmierung verwendet.
Ein Slice definieren
Um ein Slice zu definieren, können Sie es als Array deklarieren, ohne seine Größe anzugeben. Alternativ können Sie verwendenmake Funktion zum Erstellen eines Slice.
var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/
len () und cap () Funktionen
Ein Slice ist eine Abstraktion über Array. Es verwendet tatsächlich Arrays als zugrunde liegende Struktur. Daslen() Funktion gibt die Elemente zurück, die in dem Slice vorhanden sind, in dem cap()Die Funktion gibt die Kapazität des Slice zurück (dh wie viele Elemente es aufnehmen kann). Das folgende Beispiel erläutert die Verwendung von Slice -
package main
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSlice(numbers)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
len = 3 cap = 5 slice = [0 0 0]
Keine Scheibe
Wenn ein Slice ohne Eingaben deklariert wird, wird es standardmäßig als Null initialisiert. Seine Länge und Kapazität sind Null. Zum Beispiel -
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
if(numbers == nil){
fmt.Printf("slice is nil")
}
}
func printSlice(x []int){
fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
len = 0 cap = 0 slice = []
slice is nil
Subslicing
Mit Slice können die Untergrenze und die Obergrenze angegeben werden, um die Unterscheibe davon zu erhalten[lower-bound:upper-bound]. Zum Beispiel -
package main
import "fmt"
func main() {
/* create a slice */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* print the original slice */
fmt.Println("numbers ==", numbers)
/* print the sub slice starting from index 1(included) to index 4(excluded)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* missing lower bound implies 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
/* missing upper bound implies len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* print the sub slice starting from index 0(included) to index 2(excluded) */
number2 := numbers[:2]
printSlice(number2)
/* print the sub slice starting from index 2(included) to index 5(excluded) */
number3 := numbers[2:5]
printSlice(number3)
}
func printSlice(x []int){
fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9 slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]
Funktionen append () und copy ()
Man kann die Kapazität eines Slice mit dem erhöhen append()Funktion. Verwenden voncopy()Funktion wird der Inhalt eines Quell-Slice in ein Ziel-Slice kopiert. Zum Beispiel -
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
/* append allows nil slice */
numbers = append(numbers, 0)
printSlice(numbers)
/* add one element to slice*/
numbers = append(numbers, 1)
printSlice(numbers)
/* add more than one element at a time*/
numbers = append(numbers, 2,3,4)
printSlice(numbers)
/* create a slice numbers1 with double the capacity of earlier slice*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* copy content of numbers to numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]
Das range Schlüsselwort wird in verwendet forSchleife zum Durchlaufen von Elementen eines Arrays, Slice, Kanals oder einer Karte. Mit Array und Slices wird der Index des Elements als Ganzzahl zurückgegeben. Bei Maps wird der Schlüssel des nächsten Schlüssel-Wert-Paares zurückgegeben. Der Bereich gibt entweder einen oder zwei Werte zurück. Wenn links von einem Bereichsausdruck nur ein Wert verwendet wird, ist dies der erste Wert in der folgenden Tabelle.
Bereichsausdruck | 1. Wert | 2. Wert (optional) |
---|---|---|
Array oder Slice a [n] E. | index i int | a [i] E. |
String s String-Typ | index i int | Rune int |
Karte m Karte [K] V. | Schlüssel k K. | Wert m [k] V. |
Kanal c Kanal E. | Element e E. | keiner |
Beispiel
Der folgende Absatz zeigt, wie der Bereich verwendet wird -
package main
import "fmt"
func main() {
/* create a slice */
numbers := []int{0,1,2,3,4,5,6,7,8}
/* print the numbers */
for i:= range numbers {
fmt.Println("Slice item",i,"is",numbers[i])
}
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* print map using key-value*/
for country,capital := range countryCapitalMap {
fmt.Println("Capital of",country,"is",capital)
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Go bietet einen weiteren wichtigen Datentyp namens map, der eindeutigen Schlüsseln Werte zuordnet. Ein Schlüssel ist ein Objekt, mit dem Sie einen Wert zu einem späteren Zeitpunkt abrufen. Mit einem Schlüssel und einem Wert können Sie den Wert in einem Map-Objekt speichern. Nachdem der Wert gespeichert wurde, können Sie ihn mit seinem Schlüssel abrufen.
Karte definieren
Sie müssen verwenden make Funktion zum Erstellen einer Karte.
/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type
/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)
Beispiel
Das folgende Beispiel zeigt, wie Sie eine Karte erstellen und verwenden.
package main
import "fmt"
func main() {
var countryCapitalMap map[string]string
/* create a map*/
countryCapitalMap = make(map[string]string)
/* insert key-value pairs in the map*/
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "New Delhi"
/* print map using keys*/
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* test if entry is present in the map or not*/
capital, ok := countryCapitalMap["United States"]
/* if ok is true, entry is present otherwise entry is absent*/
if(ok){
fmt.Println("Capital of United States is", capital)
} else {
fmt.Println("Capital of United States is not present")
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present
delete () Funktion
Mit der Funktion delete () wird ein Eintrag aus einer Karte gelöscht. Es erfordert die Karte und den entsprechenden Schlüssel, der gelöscht werden soll. Zum Beispiel -
package main
import "fmt"
func main() {
/* create a map*/
countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
fmt.Println("Original map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* delete an entry */
delete(countryCapitalMap,"France");
fmt.Println("Entry for France is deleted")
fmt.Println("Updated map")
/* print map */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo
Rekursion ist der Prozess des Wiederholens von Elementen auf selbstähnliche Weise. Das gleiche Konzept gilt auch für Programmiersprachen. Wenn ein Programm das Aufrufen einer Funktion innerhalb derselben Funktion zulässt, wird es als rekursiver Funktionsaufruf bezeichnet. Schauen Sie sich das folgende Beispiel an -
func recursion() {
recursion() /* function calls itself */
}
func main() {
recursion()
}
Die Programmiersprache Go unterstützt die Rekursion. Das heißt, es ermöglicht einer Funktion, sich selbst aufzurufen. Bei der Verwendung der Rekursion müssen Programmierer jedoch darauf achten, eine Austrittsbedingung für die Funktion zu definieren, da sie sonst zu einer Endlosschleife wird.
Beispiele für die Rekursion in Go
Rekursive Funktionen sind sehr nützlich, um viele mathematische Probleme zu lösen, z. B. die Berechnung der Fakultät einer Zahl, die Erzeugung einer Fibonacci-Reihe usw.
Beispiel 1: Berechnen des Faktors mithilfe der Rekursion in Go
Das folgende Beispiel berechnet die Fakultät einer bestimmten Zahl mithilfe einer rekursiven Funktion:
package main
import "fmt"
func factorial(i int)int {
if(i <= 1) {
return 1
}
return i * factorial(i - 1)
}
func main() {
var i int = 15
fmt.Printf("Factorial of %d is %d", i, factorial(i))
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Factorial of 15 is 1307674368000
Beispiel 2: Fibonacci-Reihe mit Rekursion in Go
Das folgende Beispiel zeigt, wie eine Fibonacci-Reihe einer bestimmten Zahl mit einer rekursiven Funktion generiert wird.
package main
import "fmt"
func fibonaci(i int) (ret int) {
if i == 0 {
return 0
}
if i == 1 {
return 1
}
return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
var i int
for i = 0; i < 10; i++ {
fmt.Printf("%d ", fibonaci(i))
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
0 1 1 2 3 5 8 13 21 34
Typumwandlung ist eine Möglichkeit, eine Variable von einem Datentyp in einen anderen Datentyp zu konvertieren. Wenn Sie beispielsweise einen langen Wert in einer einfachen Ganzzahl speichern möchten, können Sie cast long in int eingeben. Sie können Werte von einem Typ in einen anderen konvertieren, indem Sie diecast operator. Die Syntax lautet wie folgt:
type_name(expression)
Beispiel
Betrachten Sie das folgende Beispiel, in dem der Cast-Operator bewirkt, dass die Division einer Ganzzahlvariablen durch eine andere als Gleitkommaoperation ausgeführt wird.
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("Value of mean : %f\n",mean)
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Value of mean : 3.400000
Die Go-Programmierung bietet einen anderen Datentyp namens interfacesDies stellt eine Reihe von Methodensignaturen dar. Der Datentyp struct implementiert diese Schnittstellen mit Methodendefinitionen für die Methodensignatur der Schnittstellen.
Syntax
/* define an interface */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* define a struct */
type struct_name struct {
/* variables */
}
/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
/* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* method implementation */
}
Beispiel
package main
import (
"fmt"
"math"
)
/* define an interface */
type Shape interface {
area() float64
}
/* define a circle */
type Circle struct {
x,y,radius float64
}
/* define a rectangle */
type Rectangle struct {
width, height float64
}
/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
return math.Pi * circle.radius * circle.radius
}
/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
return rect.width * rect.height
}
/* define a method for shape */
func getArea(shape Shape) float64 {
return shape.area()
}
func main() {
circle := Circle{x:0,y:0,radius:5}
rectangle := Rectangle {width:10, height:5}
fmt.Printf("Circle area: %f\n",getArea(circle))
fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Circle area: 78.539816
Rectangle area: 50.000000
Die Go-Programmierung bietet ein ziemlich einfaches Framework zur Fehlerbehandlung mit dem eingebauten Fehlerschnittstellentyp der folgenden Deklaration:
type error interface {
Error() string
}
Funktionen geben normalerweise Fehler als letzten Rückgabewert zurück. Verwendenerrors.New um eine grundlegende Fehlermeldung wie folgt zu erstellen:
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
Rückgabewert und Fehlermeldung verwenden.
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}
Beispiel
package main
import "errors"
import "fmt"
import "math"
func Sqrt(value float64)(float64, error) {
if(value < 0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
return math.Sqrt(value), nil
}
func main() {
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
result, err = Sqrt(9)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(result)
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Math: negative number passed to Sqrt
3