Artikel und Codes wurden im [Github-Warehouse: https://github.com/timerring/backend-tutorial ] archiviert, oder das öffentliche Konto [AIShareLab] kann auch durch Antworten auf go abgerufen werden .
Artikelverzeichnis
- Einführung
- Erste Schritte mit Go
-
- Gehen Sie zur Installation
- Gehen Sie zur Entwicklungsumgebung
- Grundgrammatik
- Variable
- ansonsten
- Zyklus
- schalten
- Array
- Scheibe
- Karte
- Bereich
- Funktion
- Zeiger
- Struktur
- Strukturmethode
- Fehlerbehandlung
- String-Manipulation
- String-Formatierung
- JSON-Verarbeitung
- Zeitverarbeitung
- digitale Analyse
- Prozessinformationen
Einführung
Was ist die Go-Sprache?
- Hohe Leistung und hohe Parallelität
- Einfache Syntax und sanfte Lernkurve
- Umfangreiche Standardbibliothek (in vielen Fällen kann die Entwicklung grundlegender Funktionen ohne die Hilfe von Bibliotheken Dritter durchgeführt werden)
- Perfekte Toolkette (ob Kompilierung, Codeprüfung, zusätzliche Eingabeaufforderungen usw., es gibt entsprechende Tools und ein vollständiges Unit-Test-Framework, Leistungstests usw. sind integriert)
- Statische Verknüpfung (alle Kompilierungsergebnisse sind statisch verknüpft. Sie müssen nur die kompilierte ausführbare Datei kopieren. Sie können sie direkt ausführen, ohne etwas hinzuzufügen. Die Bereitstellung ist bequem und schnell. Im Vergleich zu Java ist zum Ausführen eine große JRE erforderlich.)
- sehr schnelle Zusammenstellung
- Plattformübergreifend (kann auf einer Vielzahl von Geräten ausgeführt werden und verfügt über Cross-Compilation-Funktionen, es ist keine Konfiguration einer Cross-Compilation-Umgebung erforderlich)
- Garbage Collection (Fokus auf Geschäftslogik, Speicherzuweisung und -freigabe müssen nicht berücksichtigt werden)
Welche Unternehmen verwenden die Go-Sprache?
Erstens hat ByteDance die Go-Sprache vollständig angenommen. Es gibt Zehntausende von Microservices im Unternehmen, die in Golang geschrieben sind. Vor nicht allzu langer Zeit war auch das GORPC-Framework KiteX Open Source. Tencent, Baidu, Meituan, Didi, Sangfor, Ping An, OPPO, Zhihu, Qunar, 360, Jinshan, Weibo, bilibili, Qiniu, PingCAP und andere Unternehmen nutzen die Go-Sprache ebenfalls in großem Umfang.
Auch ausländische Unternehmen wie Google und Facebook nutzen die Go-Sprache in großem Umfang.
Aus geschäftlicher Sicht blüht die Sprache in den Bereichen Cloud Computing, Microservices, Big Data, Blockchain, Internet der Dinge und anderen Bereichen auf. In den Bereichen Cloud Computing und Microservices
haben Docker, Kubernetes, Istio usw. und Prometheus bereits einen sehr hohen Marktanteil. Fast alle Cloud-native-Komponenten sind in Go implementiert.
Warum Go-Sprache transformieren?
- Zu Beginn bestand das Back-End-Geschäft des Unternehmens hauptsächlich aus Web-Back-End. Das frühe Team hatte keinen Java-Hintergrund und C++ war nicht für das Online-Web-Geschäft geeignet.
- Der ursprüngliche Dienst war Python. Seit 2014, mit dem Wachstum des Geschäftsvolumens, sind bei Python einige Leistungsprobleme aufgetreten.
- Einige Teams versuchten zunächst, Go zu verwenden, und stellten fest, dass der Einstieg einfach, die Entwicklungseffizienz hoch und die Leistung relativ gut ist.
- Die Entwicklung und Bereitstellung der Go-Sprache ist sehr einfach und löst übrigens das problematische Problem der Abhängigkeitsbibliotheksversion, das zuvor von Python verursacht wurde.
- - Nachdem einige Unternehmen die Süße geschmeckt hatten, begannen sie, sie auf Unternehmensebene energisch zu fördern, und die unternehmensinternen Golang-basierten RPC- und HTTP-Frameworks waren geboren.
Erste Schritte mit Go
Gehen Sie zur Installation
Besuchen Sie go.dev/ oder Studygolang.com/dl
Gehen Sie zur Entwicklungsumgebung
- Cloudbasierte Entwicklungsumgebung: Online-Programmierumgebung gitpods.IO, erfordert GitHub-Konto
- Integrierte Entwicklungsumgebung: Vs Code (kostenlos) oder Goland (kostenpflichtig)
Grundgrammatik
// package main 代表这个文件属于main包的一部分, main包也就是程序的入口包。
package main
// 导入了标准库里面的 FMT 包。这个包主要是用来往屏幕输入输出字符串、格式化字符串。
import (
"fmt"
)
// import 下面是 main 函数，main 函数的话里面调用了 fmt.Println 输出 helloworld要运行这个程序的话，我们就直接 go run heloworld.go。
func main() {
fmt.Println("hello world")
}
Wenn Sie es in eine Binärdatei kompilieren möchten, können Sie go buildes in kompilieren. Nachdem die Kompilierung abgeschlossen ist, ./hellowordkönnen Sie es direkt in FMT ausführen. Das Paket enthält viele Funktionen für verschiedene Eingabe- und Ausgabeformatierungsaufgaben. Sie können im Editor mit der Maus über Ihren Code fahren, um die Dokumentation für jede Funktion anzuzeigen.
Sie können auch eingeben pkg.Go.Dev, Ihren Paketnamen hinzufügen, z. B. FMT, und dann die Online-Dokumentation dieses Pakets anzeigen, aus der Sie die Funktionen auswählen können, die Sie verwenden müssen.
Variable
package main
import (
"fmt"
"math"
)
func main() {
var a = "initial"
var b, c int = 1, 2
var d = true
var e float64
f := float32(e)
g := a + "foo"
fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g) // initialapple
const s string = "constant"
const h = 500000000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
Schauen wir uns das zweite Beispiel über Variablentypen an.
Die Go-Sprache ist eine stark typisierte Sprache und jede Variable hat ihren eigenen Variablentyp. Zu den gängigen Variablentypen gehören Zeichenfolgen, Ganzzahlen, Gleitkommatypen, boolesche Typen usw. Zeichenfolgen in der Go-Sprache sind integrierte Typen, die direkt mit einem Pluszeichen verkettet oder direkt zum Vergleich zweier Zeichenfolgen mit einem Gleichheitszeichen verwendet werden können .
Deklaration von Variablen in der Go-Sprache. Es gibt zwei Möglichkeiten, Variablen in der Go-Sprache zu deklarieren
- Eine besteht darin
var name string=" ", Variablen auf diese Weise zu deklarieren. Bei der Deklaration einer Variablen wird der Typ der Variablen im Allgemeinen automatisch abgeleitet. Bei Bedarf kann der Variablentyp auch explizit ausgeschrieben werden. - Eine andere Möglichkeit, Variablen zu deklarieren, ist die Verwendung von
变量 := 等于值.
Für Konstanten ändern Sie var in const. Der genannte Wert ist eine Konstante in der Go-Sprache. Sie hat keinen bestimmten Typ und der Typ wird automatisch entsprechend dem Verwendungskontext bestimmt.
ansonsten
package main
import "fmt"
func main() {
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}
Die Schreibmethode von if else in der Go-Sprache ähnelt C oder C++. Der Unterschied besteht darin, dass nach „if“ keine Klammern stehen und „if“ in Golang von geschweiften Klammern gefolgt werden muss und Sie die Anweisungen „if“ nicht direkt in derselben Zeile wie in C oder C++ einfügen können.
Zyklus
package main
import "fmt"
func main() {
i := 1
for {
fmt.Println("loop")
break
}
for j := 7; j < 9; j++ {
fmt.Println(j)
}
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
for i <= 3 {
fmt.Println(i)
i = i + 1
}
}
In go gibt es keine while- und do-while-Schleifen, sondern nur eine Art for-Schleife. Die einfachste for-Schleife besteht darin, nach for nichts zu schreiben, was eine Endlosschleife bedeutet. Sie können break oder continue verwenden, um die Schleife auszubrechen oder fortzusetzen.
schalten
package main
import (
"fmt"
"time"
)
func main() {
a := 2
switch a {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
case 4, 5:
fmt.Println("four or five")
default:
fmt.Println("other")
}
t := time.Now()
switch {
// case 里面写条件分支
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
Der Variablenname hinter dem Schalter benötigt keine Klammern. Hier gibt es einen großen Unterschied. Wenn in C++ der Switch-Case keine Pause anzeigt, werden weiterhin alle Cases durchlaufen. In der Go-Sprache besteht keine Notwendigkeit, eine Pause hinzuzufügen.
Im Vergleich zu C oder C++ ist die Switch-Funktion in der Go-Sprache leistungsfähiger. Beliebige Variablentypen können verwendet werden und können sogar zum Ersetzen beliebiger if else-Anweisungen verwendet werden. Sie können hinter dem Schalter keine Variablen hinzufügen und dann bedingte Verzweigungen in den Fall schreiben. Auf diese Weise wird die Codelogik klarer, als wenn Sie mehrere if else-Codes verwenden.
Array
package main
import "fmt"
func main() {
// 这里的话是一个可以存放 5 个 int 元素的数组 A
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
b := [5]int{
1, 2, 3, 4, 5}
fmt.Println(b)
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
Ein Array ist eine nummerierte Folge von Elementen fester Länge. Für ein Array ist es sehr praktisch, den Wert eines bestimmten Index abzurufen oder einen Wert an einem bestimmten Index zu speichern und dann direkt ein Array zu drucken. In echtem Geschäftscode verwenden wir Arrays jedoch selten direkt, da ihre Länge fest ist und wir mehr Slices verwenden.
Scheibe
package main
import "fmt"
func main() {
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2]) // c
fmt.Println("len:", len(s)) // 3
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]
fmt.Println(s[2:5]) // [c d e]
fmt.Println(s[:5]) // [a b c d e]
fmt.Println(s[2:]) // [c d e f]
good := []string{
"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]
}
Im Gegensatz zu Arrays können Slices ihre Länge beliebig ändern und mehr Operationen ausführen. Sie können make verwenden, um ein Slice zu erstellen, Sie können Werte wie ein Array abrufen und append verwenden, um Elemente hinzuzufügen.
Achten Sie auf die Verwendung von Append. Sie müssen das Ergebnis des Appends dem ursprünglichen Array zuweisen.
Da das Prinzip des Slice tatsächlich darin besteht, dass es eine Länge und eine Kapazität sowie einen Zeiger auf ein Array hat, wird es beim Ausführen des Anhängevorgangs erweitert, wenn die Kapazität nicht ausreicht, und gibt ein neues Slice zurück.
Slice kann bei der Initialisierung auch die Länge angeben.
Slice hat die gleiche Slicing-Operation wie Python, das heißt, die Elemente von der zweiten bis zur fünften Position werden herausgenommen, mit Ausnahme des fünften Elements. Im Gegensatz zu Python werden hier jedoch keine negativen Indizes unterstützt .
Karte
package main
import "fmt"
func main() {
// 用 make 来创建一个空 map，这里会需要两个类型。
// 第一个是那个 key 的类型，这里是 string 另一个是 value 的类型，这里是 int。
m := make(map[string]int)
// 可以从里面去存储或者取出键值对。
m["one"] = 1
m["two"] = 2
fmt.Println(m) // map[one:1 two:2]
fmt.Println(len(m)) // 2
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
// 可以用 delete 从里面删除键值对。
delete(m, "one")
m2 := map[string]int{
"one": 1, "two": 2}
var m3 = map[string]int{
"one": 1, "two": 2}
fmt.Println(m2, m3)
}
Karte ist die im tatsächlichen Gebrauch am häufigsten verwendete Datenstruktur.
Golangs Karte ist völlig ungeordnet. Beim Durchlaufen erfolgt die Ausgabe nicht in alphabetischer Reihenfolge und auch nicht in der Reihenfolge des Einfügens, sondern in zufälliger Reihenfolge.
Bereich
package main
import "fmt"
func main() {
nums := []int{
2, 3, 4}
sum := 0
for i, num := range nums {
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num) // index: 0 num: 2
}
}
fmt.Println(sum) // 9
m := map[string]string{
"a": "A", "b": "B"}
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
}
Für ein Segment oder eine Karte können wir den Bereich zum schnellen Durchqueren verwenden, sodass der Code prägnanter ist. Beim Durchlaufen des Bereichs werden zwei Werte für das Array zurückgegeben, der erste ist der Index und der zweite ist der Wert der entsprechenden Position. Wenn wir keinen Index benötigen, können wir ihn mit einem Unterstrich weglassen.
Funktion
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func add2(a, b int) int {
return a + b
}
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
func main() {
res := add(1, 2)
fmt.Println(res) // 3
// 第一个是真正的返回结果，第二个值是一个错误信息
v, ok := exists(map[string]string{
"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
Dies ist eine einfache Funktion in Golang zum Hinzufügen von zwei Variablen. Der Unterschied zwischen Golang und vielen anderen Sprachen besteht darin, dass der Variablentyp ein Postfix ist.
Funktionen in Golang unterstützen nativ die Rückgabe mehrerer Werte. Im eigentlichen Geschäftslogikcode geben fast alle Funktionen zwei Werte zurück, der erste ist das tatsächliche Rückgabeergebnis und der zweite Wert ist eine Fehlermeldung.
Zeiger
package main
import "fmt"
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
Zeiger werden auch in Go unterstützt. Natürlich sind die unterstützten Operationen im Vergleich zu Zeigern in C und C++ sehr begrenzt. Eine der Hauptanwendungen von Zeigern besteht darin, eingehende Parameter zu ändern.
Die obige Funktion versucht beispielsweise, 2 zu einer Variablen hinzuzufügen. Aber einfach so zu schreiben ist eigentlich ungültig. Da es sich bei dem an die Funktion übergebenen Parameter tatsächlich um eine Shell handelt, wird auch gesagt, dass +2 +2 für die Kopie ist, was nicht funktioniert. Wenn wir arbeiten müssen, müssen wir diesen Typ als Zeigertyp schreiben. Zur Typübereinstimmung wird beim Aufruf ein &-Symbol hinzugefügt.
Struktur
package main
import "fmt"
type user struct {
name string
password string
}
func main() {
a := user{
name: "wang", password: "1024"}
b := user{
"wang", "1024"}
c := user{
name: "wang"}
c.password = "1024"
var d user
d.name = "wang"
d.password = "1024"
fmt.Println(a, b, c, d) // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
}
func checkPassword(u user, password string) bool {
return u.password == password
}
// 同样的结构体我们也能支持指针，这样能够实现对于结构体的修改，也可以在某些情况下避免一些大结构体的拷贝开销。
func checkPassword2(u *user, password string) bool {
return u.password == password
}
Eine Struktur ist eine Sammlung typisierter Felder.
Die Benutzerstruktur enthält beispielsweise zwei Felder, Name und Passwort. Wir können den Namen der Struktur verwenden, um eine Strukturvariable zu initialisieren. Beim Erstellen müssen wir den Anfangswert jedes Felds übergeben. Sie können dieses Schlüssel-Wert-Paar auch verwenden, um den Anfangswert anzugeben, sodass nur ein Teil der Felder initialisiert werden kann.
Strukturmethode
package main
import "fmt"
type user struct {
name string
password string
}
func (u user) checkPassword(password string) bool {
return u.password == password
}
func (u *user) resetPassword(password string) {
u.password = password
}
func main() {
a := user{
name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
In Golang können einige Methoden für die Struktur definiert werden. Es ähnelt ein wenig den Klassenmitgliederfunktionen in anderen Sprachen. Hier haben wir beispielsweise checkPassworddie Implementierung von im obigen Beispiel von einer gewöhnlichen Funktion in eine Strukturmethode geändert. Auf diese Weise kann der Benutzer es wie a.checkPassword ("x") aufrufen. D Die spezifische Codeänderung besteht darin, den ersten Parameter hinzuzufügen, Klammern hinzuzufügen und ihn vor den Funktionsnamen zu schreiben.
Bei der Implementierung der Methode der Struktur gibt es auch zwei Schreibweisen: eine mit einem Zeiger und die andere ohne Zeiger. Wenn Sie einen Zeiger haben, können Sie diese Struktur ändern. Wenn kein Zeiger vorhanden ist, handelt es sich bei der Operation tatsächlich um eine Kopie, und Sie können die Struktur nicht ändern.
Fehlerbehandlung
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
// 在函数里面，我们可以在那个函数的返回值类型里面，后面加一个 error，就代表这个函数可能会返回错误。
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
func main() {
u, err := findUser([]user{
{
"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name) // wang
if u, err := findUser([]user{
{
"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
}
Die Fehlerbehandlung in der Go-Sprache entspricht dem idiomatischen Ansatz, einen separaten Rückgabewert zur Übermittlung von Fehlerinformationen zu verwenden.
Es unterscheidet sich von den von Java selbst verwendeten Ausnahmen. Die Verarbeitungsmethode der Go-Sprache kann eindeutig erkennen, welche Funktion einen Fehler zurückgibt, und kann den Fehler mit einem einfachen „If else“ behandeln.
In einer Funktion können wir einen Fehler zum Rückgabewerttyp dieser Funktion hinzufügen, was bedeutet, dass die Funktion möglicherweise einen Fehler zurückgibt.
Wenn die Funktion dann implementiert ist, muss return zwei Werte gleichzeitig zurückgeben, oder wenn ein Fehler auftritt, kann er return nilmit einem kombiniert werden error. Wenn nicht, geben Sie das ursprüngliche Ergebnis und Null zurück.
String-Manipulation
package main
import (
"fmt"
"strings"
)
func main() {
a := "hello"
fmt.Println(strings.Contains(a, "ll")) // true
fmt.Println(strings.Count(a, "l")) // 2
fmt.Println(strings.HasPrefix(a, "he")) // true
fmt.Println(strings.HasSuffix(a, "llo")) // true
fmt.Println(strings.Index(a, "ll")) // 2
fmt.Println(strings.Join([]string{
"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6
}
Im Strings-Paket der Standardbibliothek gibt es viele häufig verwendete String-Tool-Funktionen, z. B. „Contains“, um zu bestimmen, ob ein String einen anderen String enthält, „Count“, um Strings zu zählen, und „Index“, um die Position eines bestimmten Strings zu ermitteln. „Join“ verbindet mehrere Zeichenfolgen. „Repeat“ wiederholt mehrere Zeichenfolgen. „Replace“ ersetzt Zeichenfolgen.
String-Formatierung
package main
import "fmt"
type point struct {
x, y int
}
func main() {
s := "hello"
n := 123
p := point{
1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
fmt.Printf("p=%v\n", p) // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
}
In der Go-Sprache können Sie damit problemlos %vjede Art von Variable drucken, ohne zwischen numerischen Zeichenfolgen zu unterscheiden. Sie können %+vausführlichere Ergebnisse auch mit ausdrucken, %#vwas ausführlicher ist.
JSON-Verarbeitung
package main
import (
"encoding/json"
"fmt"
)
type userInfo struct {
Name string
Age int `json:"age"`
Hobby []string
}
func main() {
a := userInfo{
Name: "wang", Age: 18, Hobby: []string{
"Golang", "TypeScript"}}
buf, err := json.Marshal(a)
if err != nil {
panic(err)
}
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
var b userInfo
err = json.Unmarshal(buf, &b)
if err != nil {
panic(err)
}
fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}
Die JSON-Operation in der Go-Sprache ist sehr einfach. Für eine vorhandene Struktur können wir nichts tun, solange der erste Buchstabe jedes Felds ein Großbuchstabe ist, dh es sich um ein öffentliches Feld handelt. Anschließend kann diese Struktur mit JSON.Marshaler deserialisiert und in einen JSON-String umgewandelt werden.
Der serialisierte String kann mit JSON.Unmarshaler auch in eine leere Variable deserialisiert werden.
Wenn die Zeichenfolge standardmäßig auf diese Weise serialisiert wird, beginnt ihr Stil mit einem Großbuchstaben anstelle eines Unterstrichs. Wir können Syntax wie das JSON-Tag verwenden, um den Feldnamen im ausgegebenen JSON-Ergebnis später zu ändern.
Zeitverarbeitung
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t) // 2022-03-27 01:25:36 +0000 UTC
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
fmt.Println(t.Format("2006-01-02 15:04:05")) // 2022-03-27 01:25:36
diff := t2.Sub(t)
fmt.Println(diff) // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
panic(err)
}
fmt.Println(t3 == t) // true
fmt.Println(now.Unix()) // 1648738080
}
Das Folgende ist die Zeitverarbeitung. Die in der Go-Sprache am häufigsten verwendete Sprache besteht darin, time.Now ()die aktuelle Zeit zu ermitteln. Anschließend können Sie sie auch verwenden, time.Dateum eine Zeit mit einer Zeitzone zu konstruieren und die konstruierte Zeit zu erstellen. Es gibt viele der oben genannten Methoden, um Jahr, Monat, Tag, Stunde, Minute und Sekunde zu diesem Zeitpunkt zu erhalten. Anschließend können Sie auch sub verwenden, um die beiden Zeiten zu subtrahieren, um einen Zeitraum zu erhalten. Im Zeitraum können Sie ermitteln, wie viele Stunden, wie viele Minuten und wie viele Sekunden er hat.
Bei der Interaktion mit bestimmten Systemen verwenden wir häufig Zeitstempel. Dann können Sie verwenden .UNIX(), um den Zeitstempel abzurufen. time.format, time.parsewird zum Analysieren der Zeit verwendet. Weitere Informationen finden Sie in der Dokumentation.
digitale Analyse
package main
import (
"fmt"
"strconv"
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
Lassen Sie uns lernen, wie man zwischen Zeichenfolgen und Zahlen umwandelt. In der Go-Sprache befinden sich alle Konvertierungen zwischen Zeichenfolgen und Zahlen in strconvdiesem Paket, das die Abkürzung für die Zeichenfolgenkonvertierung aus zwei Wörtern darstellt.
Wir können parselnt oder parseFloat verwenden, um einen String zu analysieren. Parseint-Parameter
Wir können Atoi verwenden, um eine Dezimalzeichenfolge in eine Zahl umzuwandeln. Sie können itoA verwenden, um Zahlen in Zeichenfolgen umzuwandeln. Wenn die Eingabe ungültig ist, geben diese Funktionen einen Fehler zurück.
Prozessinformationen
package main
import (
"fmt"
"os"
"os/exec"
)
func main() {
// 比如我们编译的一个二进制文件，command。后面接 abcd 来启动，输出就是os.argv会是一个长度为5的 slice ,第一个成员代表:进制自身的名字。
// go run example/20-env/main.go a b c d
fmt.Println(os.Args) // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
fmt.Println(os.Setenv("AA", "BB"))
buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
if err != nil {
panic(err)
}
fmt.Println(string(buf)) // 127.0.0.1 localhost
}
In go können wir es os.argvverwenden um die angegebenen Befehlszeilenparameter abzurufen, wenn das Programm ausgeführt wird.
Wir können os.getenves verwenden, um Umgebungsvariablen zu lesen.