Es gibt verschiedene Arten von lexikalischen Elementen in der Go-Sprache

Es gibt 5 Kategorien lexikalischer Elemente in der Go-Sprache: 1. Bezeichner, das sind Zeichenfolgen, die aus mehreren Buchstaben (codiert durch Unicode), Unterstrichen und Zahlen bestehen; 2. Schlüsselwörter, die von der Programmiersprache reserviert und nicht erlaubt sind Für Programmierer können Zeichenfolgen, die als Bezeichner verwendet werden, auch als reservierte Wörter bezeichnet werden. 3. Operatoren sind Symbole, die zum Ausführen bestimmter arithmetischer Operationen oder logischer Operationen verwendet werden. 5. Literale sind eine Notation für Werte.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Die Sprachsymbole der Go-Sprache werden auch als lexikalische Elemente bezeichnet und umfassen fünf Kategorien: Bezeichner, Schlüsselwort, Operator, Trennzeichen und Literal. Sie sind die grundlegendsten Einheiten, aus denen Codes und Programme der Go-Sprache bestehen.

Normalerweise werden Leerzeichen, horizontale Tabulatoren, Wagenrückläufe und Zeilenvorschübe ignoriert, es sei denn, sie sind Teil des Trennzeichens zwischen mehreren Sprachsymbolen. In der Go-Sprache ist es nicht erforderlich, Semikolons explizit einzufügen. Bei Bedarf fügt die Go-Sprache automatisch Semikolons in den Code ein, um Anweisungen zu trennen.

Der Go-Sprachcode besteht aus mehreren Unicode-Zeichen. Alle Quellcodes der Go-Sprache müssen im UTF-8-Kodierungsformat der Unicode-Kodierungsspezifikation kodiert sein (d. h. die Quellcodedateien der Go-Sprache müssen in geschrieben sein). das UTF-8-Codierungsformat).

Die Sprachsymbole der Go-Sprache werden auch lexikalische Elemente genannt, die 5 Kategorien umfassen: Bezeichner(Bezeichner), Schlüsselwort(Schlüsselwort), Operator(Operator), Trennzeichen(Trennzeichen) und Literal (wörtlich). Im Allgemeinen werden Leerzeichen, horizontale Tabulatoren, Wagenrückläufe und Zeilenvorschübe ignoriert, es sei denn, sie werden als Teil eines Trennzeichens zwischen mehreren Sprachsymbolen verwendet. In der Go-Sprache ist es nicht erforderlich, Semikolons explizit einzufügen. Bei Bedarf fügt die Go-Sprache automatisch Semikolons in den Code ein, um Anweisungen zu trennen.

Der Go-Sprachcode besteht aus mehreren Unicode-Zeichen. Alle Quellcodes der Go-Sprache müssen im UTF-8-Kodierungsformat der Unicode-Kodierungsspezifikation kodiert sein (d. h. die Quellcodedateien der Go-Sprache müssen in geschrieben sein). das UTF-8-Codierungsformat).

1. Bezeichner

Der Bezeichner der Go-Sprache ist eine Zeichenfolge, die aus mehreren Buchstaben (codiert durch Unicode) besteht, wobei das erste Zeichen der Zeichenfolge ein Buchstabe sein muss.

Hinweis:

• Im Go-Sprachcode muss jede Kennung vor der Verwendung deklariert werden.

• Eine Deklaration bindet einen nicht leeren Bezeichner an eine Konstante, einen Typ, eine Variable, eine Funktion oder ein Codepaket.

• Im selben Codeblock ist die wiederholte Deklaration desselben Bezeichners nicht zulässig (außer bei Zuweisungsanweisungen).

• Bezeichner in einer Quellcodedatei und einem Codepaket müssen dieser Regel folgen.

• Der Geltungsbereich eines deklarierten Bezeichners ist derselbe wie der Geltungsbereich des Codeblocks, zu dem er direkt gehört.

Streng genommen ist die Codepaket-Deklarationsanweisung keine Deklaration. Weil der Name des Codepakets in keinem Bereich erscheint. Der Zweck der Codepaket-Deklarationsanweisung besteht darin, festzustellen, ob mehrere Quellcodedateien zum selben Codepaket gehören, oder beim Importieren des Codepakets den Standard-Codepaket-Referenznamen anzugeben.

Qualifizierte Bezeichner werden verwendet, um auf Variablen oder Typen in anderen Codepaketen zuzugreifen. Wenn ich beispielsweise auf eine Konstante namens O_RDONLY im Codepaket os zugreifen muss, muss ich os.O_RDONLY so schreiben.

Qualifizierte Bezeichner können verwendet werden, und es müssen zwei Voraussetzungen erfüllt sein:

• Das Codepaket, auf das zugegriffen werden soll, muss im Voraus importiert werden;

• Der Bezeichner in diesem Codepaket muss exportierbar sein.

Ein exportierbarer Bezeichner muss außerdem zwei Voraussetzungen erfüllen:

• Das erste Zeichen im Bezeichnernamen muss ein Großbuchstabe sein (Go-Sprache basiert auf der Groß- und Kleinschreibung des ersten Zeichens im Bezeichnernamen, um die Zugriffsberechtigungen dafür zu bestimmen Bezeichner: Wenn das erste Zeichen des Bezeichnernamens ein Großbuchstabe ist, sind seine Zugriffsberechtigungen „öffentlich“, das heißt, der Bezeichner kann von jedem Code in jedem Codepaket verwendet werden, indem der Bezeichnerzugriff qualifiziert wird In Kleinbuchstaben ist seine Zugriffsberechtigung „privat auf Paketebene“, d. h. nur Code im selben Codepaket wie der Bezeichner kann darauf zugreifen). Paket oder der Name eines Felds oder einer Methode, die zu einem Strukturtyp gehört.

• Vordefinierte Bezeichner für die Go-Sprache:

  • Die Namen aller grundlegenden Datentypen.
  • Fehler beim Schnittstellentyp
  • Konstante true, false und iota
  • Die Namen aller integrierten Funktionen, nämlich append, cap, close, complex, copy, delete, imag, len, make, new, panic, print, println , real und erholen.

  In der Go-Sprache gibt es einen leeren Bezeichner, der durch einen Unterstrich dargestellt wird und im Allgemeinen in einer Deklaration verwendet wird, die keine Einführung einer neuen Bindung erfordert. Wenn wir beispielsweise die Initialisierungsfunktion nur in einem bestimmten Codepaket ausführen möchten, ohne Programmentitäten in diesem Codepaket zu verwenden, können wir die folgende Importanweisung schreiben:

  import _ "runtime/cgo"1.

  wobei „ runtime/cgo " stellt die Kennung eines Standardbibliothekscodepakets dar.

  2. Schlüsselwörter

  Schlüsselwörter (auch reservierte Wörter genannt) sind Zeichenfolgen, die von Programmiersprachen reserviert sind und von Programmierern nicht als Bezeichner verwendet werden.

  Kategorie	Schlüsselwörter
  Programmdeklaration	Import, Paket
  Programmentitätsdeklaration und -definition	chan, const, func, interface, map, struct, type, var
  Programmkontrollfluss	go, select, break, case, continue, default, defer, else, fallthrough, for, goto, if, range, return, switch

  ---

  在Go语言中，程序实体的声明和定义是建立在其数据类型的体系之上的。例如关键字chan、func、interface、map和struct，分别于Go语言的复合数据类型Channel（通道）、Function（函数）、Interface（接口）、Map（字典）和Struct（结构体）相对应。

  程序控制流程的关键字，一共15个。其中go和select，这两个主要用于Go语言并发编程。

  3、字面量

  简单来说，字面量就是值的一种标记法。但是，在Go中，字面量的含义要更加广泛一些。

  Go语言代码中用到的字面量有以下3类：

  1、表示基础数据类型值的各种字面量。例如，表示浮点数类型值的12E-3。

  2、构造各种自定义的复合数据类型的类型字面量。例如，下面表示一个名称为Person的自定义结构体类型：

  type Person struct {
  	Name 	string
  	Age	uint8
  	Address	string
  }

  3、表示复合数据类型的值的复合字面量

  被用来构造类型Struct（结构体）、Array（数组）、Slice（切片）和Map（字典）的值。例如，下面的字面量用于表示上面名称为Person的结构体类型的值：
  

  Person {
  	Name："Huazie",
  	Age: "21",
  	Address: "Nanjing, China"
  }

  注意：
  对复合字面量的每次求值都会导致一个新的值被创建。因此，如上该复合字面量每被求值一次就会创建一个新的Person类型的值。

  Go语言不允许在一个此类的复合字面变量中，出现重复的键。如下都是错误，无法通过编译，因为键都有重复。

  //表示结构体类型值,有重复的键 Name
  Person {Name: "Huazie",Age: "21", Name: "Unknown"}
  //表示字典类型值，有重复的键 Age
  map[string]string{ Name: "Huazie",Age: "21", Age: "21"}
  //表示切片类型值，有重复的键 0
  []string{0: "0", 1: "1", 0: "-1"}

  4、类型

  一个类型确定了一类值的集合，以及可以在这些值上施加的操作。类型可以由类型名称或者类型字面量指定，分为基本类型和复合类型，基本类型的名称可以代表其自身。

  var bookName string1.

  如上声明了一个类型为string（基本类型中的一个）、名称为bookName的变量。

  其他基本类型（预定义类型）有bool、byte、rune、int/uint、int8/uint8、int16/uint16、int32/uint32、int64/uint64、float32、float64、complex64和complex128。除了bool和string之外的其他基本类型也叫做数值类型。

  复合类型一般由若干（也包括零）个其他已被定义的类型组合而成。复合类型有Channel（通道）、Function（函数）、Interface（接口）、Map（字典）、Struct（结构体）、Slice（切片）、Array（数组）和Pointer（指针）。

  Go语言中的类型又可以分为静态类型和动态类型。一个变量的静态类型是指在变量声明中给出的那个类型。绝大多数类型的变量都只有静态类型。唯独接口类型的变量例外，它除了拥有静态类型之外，还拥有动态类型（接口类型在后面会讲到）。

  每一个类型都会有一个潜在类型。如果这个类型是一个预定义类型（也就是基本类型），或者是一个由类型字面量构造的复合类型，那么它的潜在类型就是它自身。如string类型的潜在类型就是string类型，上面自定义的Person类型的潜在类型就是Person。如果一个类型并不属于上述情况，那么这个类型的潜在类型就是类型声明中的那个类型的潜在类型。

  如下声明一个自定义类型

  type MyString string1.

  如上可以把类型MyString看作string类型的一个别名类型，那么MyString类型的潜在类型就是string类型。Go语言基本数据类型中的rune类型可以看作是uint32类型的一个别名类型，其潜在类型就是uint32。

  注意：

  • 类型MyString和类型string是两个不相同的类型。不能将其中一个类型的值赋给另一个类型的变量。
  • 别名类型与它的源类型的不同仅仅体现在名称上，它们的内部结构是一致的;下面的类型转换的表达式都是合法的：MyString(“ABC”) 和string(MyString(“ABC”))。这种类型转换并不会创建新的值。

  一个类型的潜在类型具有可传递性，如下：

  type iString MyString1.

  则类型isString的潜在类型就是string类型。

  这里声明一个类型，如下：

  type MyStrings [3]string1.

  **Hinweis:**Der zugrunde liegende Typ vom Typ MyStrings ist kein [3]String. [3] string ist weder ein vordefinierter Typ noch ein aus Typliteralen zusammengesetzter Typ, sondern ein Array-Typ, dessen Elementtyp string ist.

  Gemäß der obigen Definition ist ersichtlich, dass der potenzielle Typ von MyStrings der potenzielle Typ string von [3] string ist.

  Die Go-Sprache legt fest, dass der potenzielle Typ eines Array-Typs bestimmt, welche Art von Elementen in einer Variablen dieses Typs gespeichert werden können.

  5. Operatoren

  Operatoren sind Symbole, mit denen bestimmte arithmetische Operationen oder logische Operationen ausgeführt werden. (Ich werde es hier nicht im Detail erklären, es ähnelt den Operatoren in der C-Sprache), aber in der Go-Sprache gibt es keinen ternären Operator. Daher müssen alle Operatoren mit Ausnahme der unären Operatoren binäre Operatoren sein. Die Go-Sprache verfügt über insgesamt 21 Operatoren, darunter arithmetische Operatoren, Vergleichsoperatoren, logische Operatoren, Adressoperatoren und Empfangsoperatoren.

  2 Binär, arithmetisch, Adresse Bitweise Löschoperation, binärer, arithmetischer Operator Logische NICHT-Operation, unärer, logischer Operator

  Symbol

  Erklärung

  Beispiel

  &&

  Logische UND-Verknüpfung . Binärer, logischer Operator

  true && false //Das Ausdrucksergebnis ist falsch

  ==

  Gleichheitsbeurteilungsoperation. Binär, Vergleichsoperator

  "abc" == "abc" //Das Ergebnis ist wahr

  !=

  Ungleiche Beurteilungsoperation. Binär, Vergleichsoperator

  "abc" != "Abc" //Das Ergebnis ist wahr

  weniger als die Beurteilungsoperation. Binär, Vergleichsoperator

  1

  kleiner oder gleich. Binär, Vergleichsoperator

  1

  >

  ist größer als die Beurteilungsoperation. Binär, Vergleichsoperator

  3 > 2 //Das Ausdrucksergebnis ist wahr

  >=

  ist größer oder gleich. Binär, Vergleichsoperator

  3 >= 2 //Das Ergebnis des Ausdrucks ist wahr

  +

  bedeutet Summation, unär ist wieder binär, arithmetischer Operator

  +1 //Das Ergebnis ist 1 ( 1+ 2) //Das Ergebnis ist 3

  -

  bedeutet, die Differenz zu finden, ein Yuan ist zwei Yuan, arithmetischer Operator

  -1 //Das Ergebnis ist -1 (1 – 2) //Das Ergebnis ist - 1

  Bitweise ODER-Verknüpfung, binärer, arithmetischer Operator

  5 11 // Das Ergebnis des Ausdrucks ist 15

  ^

  Bitweises XOR, ein Element ist binär, arithmetischer Operator

  5^{11 //Das Ergebnis ist 14 (}5)//Das Ergebnis ist -6

  *

  Produkt oder Wert, unär, binär, arithmetisch, Adresse

  *p //Wertoperation

  /

  Quotientenoperation, binär, arithmetischer Operator

  10 / 5 //Das Ergebnis des Ausdrucks ist 2

  %

  Restoperation, binär, arithmetischer Operator

  12 % 5 //Das Ergebnis des Ausdrucks ist 2

  Bitweise Linksverschiebungsoperation, binär, arithmetischer Operator

  4

  &v //Adressoperation

  &^

  5 &^ 11 //Das Ergebnis des Ausdrucks ist 4

  !

  !b //Wenn b wahr ist, ist das Ergebnis falsch

  注意：假设上面的ch 代表了元素类型为 byte的通道类型值,则

  重点讲解3个操作符：

  1、&^ 实现了按位清除操作，按位清除就是根据第二个操作数的二进制值对第一个操作数的二进制值进行相应的清零操作，如果第二个操作数的某个二进制位上的数组为1，就把第一个操作数的对应二进制位上的数值设置为0。否则，第一个操作数的对应二进制位上的数值不变。这样的操作并不会改变第一个操作数的原值，只会根据两个操作数的二进制值计算出结果值。这样就可以理解上面的5 &^ 11的结果为4了。

  2、^ 作为一元操作符，分两种情况：

  (1). 操作数是无符号的整数类型，使用这一个操作就相当于对这个操作数和其整数类型的最大值进行二元的按位异或操作，如下：

  ^uint8(1)           = 254     
  //无符号整数的一元按位异或操作00000001 ^ 11111111 = 11111110//对应的二进制数运算1.2.3.

  如上，内置函数uint8会将一个整数字面量转换为一个uint8类型的值，这保证了一元操作符^的唯一操作数一定是一个无符号整数类型的值。

  (2). 操作是有符号的整数类型，这一操作就相当于对这个操作数和-1进行二元按位异或操作。例如：

  ^1                  = -2 
  //有符号整数的一元按位异或操作00000001 ^ 11111111 = 11111110//对应的二进制运算1.2.

  **注意：**以上的操作数的二进制值都是以补码形式表示；默认情况下整数字面量是有符号的,所以(2)中操作数1不需要显示使用内置函数int8 。

  3、 接收操作符，只作用于通道类型的值。使用时，需要注意两点：

  (1).  从一个通道类型的空值（即nil）接收值的表达式将会永远被阻塞。
  (2).  从一个已被关闭的通道类型值接收值会永远成功并立即返回一个其元素类型的零值。

  一个由接收操作符和通道类型的操作数所组成的表达式可以直接被用于变量赋值或初始化，如下所示(在赋值语句讲解时，再细说)

  v1 := <-ch
  v2 = <-ch1.2.

  特殊标记 = 用于将一个值赋给一个已被声明的变量或常量。
  特殊标记 := 则用于在声明一个变量的同时对这个变量进行赋值，且只能在函数体内使用。

  又如下：

  v, ok = <-ch
  v, ok := <-ch1.2.

  当同时对两个变量进行赋值或初始化时，第二个变量将会是一个布尔类型的值。这个值代表了接收操作的成功与否。如果这个值为false，就说明这个通道已经被关闭了。（之后讲解通道类型会详细介绍）。

  操作符优先级

  优先级	操作符
  5	*     /    %    >    &    &^
  4	+     -     \     ^
  3	==     !=         >=
  2	&&
  1

  扩展知识：表达式

  基本表达式

  (1) 使用操作数来表示;

  (2) 使用类型转换来表示;

  (3) 使用内建函数调用来表示;

  (4) 一个基本表达式和一个选择符号组成选择表达式;

  例如，如果在一个结构体类型中存在字段f，我们就可以在这个结构体类型的变量x上应用一个选择符号来访问这个字段f，即x.f。其中，.f就是一个选择符号。注意：前提是这个变量x的值不能是nil。在Go语言中，nil用来表示空值。

  (5) 一个基本表达式和一个索引符号组成索引表达式;

  索引符号由狭义的表达式（仅由操作符和操作数组成）和外层的方括号组成，例如[]int{1,2,3,4,5}[2]就是索引表达式。
  Go语言允许如下的赋值语句：

  v, ok := a[x]1.

  如上a为字典类型，x为字典的键。该索引表达式的结果是一对值，而不是单一值。第一个值的类型就是该字典类型的元素类型，而第二个值则是布尔类型。与变量ok绑定的布尔值代表了在字典类型a中是否包含了以x为键的键值对。如果在a中包含这样的键值对，那么赋给变量ok的值就是true，否则就为false。

  **注意：**虽然当字典类型的变量a的值为nil时，求值表达式a[x]并不会发生任何错误，但是在这种情况下对a[x]进行赋值却会引起一个运行时恐慌（ Go语言异常）。

  (6) 一个基本表达式和一个切片符号组成切片表达式;

  切片符号由2个或3个狭义的表达式和外层的方括号组成，这些表达式之间由冒号分隔。切片符号作用与索引符号类似，只不过索引符号针对的是一个点，切片符号针对的是一个范围。例如，要取出一个切片[]int{1,2,3,4,5}的第二个到第四个元素，那么可以使用切片符号的表达式[]int{1,2,3,4,5}[1:4]，该结果还是一个切片。

  切片表达式a[x:y:z]，a是切片符号[x:y]的操作对象。其中，x代表了切片元素下界索引，y代表了切片的元素上界索引，而z则代表了切片的容量上界索引。约束如下：

  0

  设a的值为[]int{1,2,3,4,5}，则切片表达式a[:3]等同于a[0:3],这是因为切片符号的元素下界索引的默认值为0，相应的元素上界的索引的默认值为操作对象的长度值或容量值，即切片表达式a[3:]等同于a[3:5]。同样，切片表达式a[:]等同于复制a所代表的值并将这个复制品作为表达式的求值结果。

  注意: UTF-8 编码格式会以3个字节来表示一个中文字符，而切片操作是针对字节进行的。

  如果有“Go并发编程实战”的字符串类型的变量a，那么切片表达式a[1:3]的结果不是“o并”，而a[1:5]的结果才是“o并”。

  (7) 一个基本表达式和一个类型断言符号组成;

  类型断言符号以一个英文句号为前缀，并后跟一个被圆括号括起来的类型名称或类型字面量。类型断言符号用于判断一个变量或常量是否为一个预期的类型，并根据判断结果采取不同的响应。例如，如果要判断一个int8类型的变量num是否是int类型，可以这样编写表达式：interface{}(num).(int)。

  对于一个求值结果为接口类型值的表达式x和一个类型T，对应的类型断言为：

  x.(T)1.

  该表达式的作用是判断“x不为nil且存储在其中的值是T类型的”是否成立。

  如果T不是一个接口类型，那么x.(T)会判断类型T是否为x的动态类型（一个变量的动态类型就是在运行期间存储在其中的值的实际类型）；而这个实际类型必须是该变量声明的那个类型的一个实现类型，否则就根本不可能在该变量中存储这一类型的值。所以类型T必须为x的类型的一个实现类型，而在Go语言中只有接口类型可以被其他类型实现，所以x的求值结果必须是一个接口类型的值。

  所以上面表达式interface{}(num).(int)中表达式interface{}(num)的含义就是将变量num转换为interface{}类型的值（即它的结果值是接口类型的），而这刚好符合前面的定义。

  知识点： interface{}是一个特殊的接口类型，代表空接口。所有类型都是它的实现类型。

  在对变量的赋值或初始化的时候，也可以使用类型断言，如下：

  v, ok := x.(T)1.

  当使用类型断言表达式同时对两个变量进行赋值时，如果类型断言成功，那么赋给第一个变量的将会是已经被转换为T类型的表达式x的求值结果，否则赋给第一个变量的就是类型T的零值。布尔类型会被赋给变量ok，它体现了类型断言的成功（true）与否（false）。

  注意： 在这种场景下，即使类型断言失败也不会引发运行时恐慌。

  (8) 一个基本表达式和一个调用符号组成。

  调用符号只针对于函数或者方法。与调用符号组合的基本表达式不是一个代表代码包名称（或者其别名）的标识符就是一个代表结构体类型的方法的名称的标识符。调用符号由一个英文句号为前缀和一个被圆括号括起来的参数列表组成，多个参数列表之间用逗号分隔。例如，基本表达式os.Open(“/etc/profile”)表示对代码包os中的函数Open的调用。

  可变长参数

  如果函数f可以接受的参数的数量是不固定的，那么函数f就是一个能够接受可变长参数的函数，简称可变参函数。在Go语言中，在可变参函数的参数列表的最后总会出现一个可变长参数，这个可变长参数的类型声明形如…T。Go语言会在每次调用函数f的时候创建一个切片类型值，并用它来存放这些实际函数。这个切片类型值的长度就是当前调用表达式中与可变长参数绑定的实际参数的数量。

  可变参函数appendIfAbsent声明如下(函数体省略)：

  func appendIfAbsent(s []string, t ...string) []string1.

  针对此函数的调用表达式如下：

  appendIfAbsent([]string(“A”,”B”,”C”),”C”,”B”,”A”)1.

  其中，与可变参数t绑定的切片类型值为[]string{”C”,”B”,”A”},包含了实际参数”C”,”B”和”A”。

  也可以直接把一个元素类型为T的切片类型值赋给…T类型的可变长参数，如下调用：

  appendIfAbsent([]string(“A”,”B”,”C”), []string(”C”,”B”,”A”)...)1.

  或者如果有一个元素类型为stirng的切片类型的变量s的话，如下调用：

  appendIfAbsent([]string(“A”,”B”,”C”), s...)1.

  对于将切片类型的变量赋给可变长参数的情况，Go语言不会专门创建一个切片类型值来存储其中的实际参数。因为，这样的切片类型值已经存在了，可变长参数t的值就是变量s的值。

  【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonEs gibt verschiedene Arten von lexikalischen Elementen in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!