Ein Artikel, der Ihnen hilft, die grundlegenden Datentypen der Go-Sprache zu verstehen

iota

iota iota是Go中的一个常量计数器，只能在跟常量(const)一块使用。

我们先来理解这一段话。

iota在const关键字出现时将被重置为0const中每新增一行常量，iota将计数(+1)一次

示例1:

package main

import "fmt"

func main() {
    const (
        n1 = iota //在const关键字出现时将被重置为0
        n2        //没写相当于写了个n2=iota，每新增一行常量iota计数(+1)一次，n2 = 1
        n3        //同上 n3 = 2
        n4        // 同上 n4 = 3
)
    fmt.Println(n1， n2， n3， n4)
}

示例2:

遇到_会是什么情况。

package main

import "fmt"

func main() {
    const (
        n1 = iota //在const关键字出现时将被重置为0
        n2        // n2=1
        _         //匿名变量，相当于写了个 _=iota，所以此时iota=2
        n4        //n4=3
)
    fmt.Println(n1， n2， n4)
}

示例3:

一行多个iota ist eine Konstante

Zähler in Go, die nur zusammen mit einer Konstante (const) verwendet werden kann. 🎜🎜

package main import "fmt" func main() { const ( a， b = iota + 1， iota + 2 //在const关键字出现时，iota=0，并且两次赋值在同一行，iota没有做+1 c， d //同理，新增一行常量，常量个数为俩，仍然是一行，所以iota=1 //c， d = iota + 1， iota + 2 同上，此时iota=1，c=2，d=3 e， f // 同理，同上，e=3，f=4 ) fmt.Println(a， b， c， d， e， f) }

package main import "fmt" func main() { var a = 10 //定义一个十进制数 fmt.Printf("%T\n"， a) //功能:打印变量类型，结果:默认为int类型，也叫int64 fmt.Printf("%d \n"， a) //功能:十进制输出，结果:10 fmt.Printf("%b \n"， a) //功能:二进制输出，结果:1010 fmt.Printf("%o \n"， a) //功能:二进制输出，结果:12 var b = 0b1010011010 //定义一个二进制数1010011010，以0b开头 fmt.Printf("%d\n"， b) //结果:666 var c = 077 //定义一个八进制数77 fmt.Printf("%d\n"， c) //结果:63 var d = 0x42 //定义一个十六进制42 fmt.Printf("%d\n"， d) //结果:66 }🎜

_Was wird 🎜🎜 sein ? Zustand. 🎜🎜

package main

import "fmt"

func main() {
    var a = 1.21          //默认为float64
    fmt.Printf("%T\n"， a) //结果:float64
    fmt.Printf("%f\n"，a)//功能:输出浮点型数，结果:1.210000
    fmt.Printf("%.1f\n"，a)//功能:输出浮点型数，保留小数点一位，其他忽略，结果:1.2
    fmt.Printf("%.2f\n"，a)//功能:输出浮点型数，保留小数点二位，其他忽略，结果:1.21
}

🎜

🎜Beispiel 3:🎜
🎜

🎜Mehrfach in einer Zeile🎜🎜iota Code >🎜🎜. 🎜🎜<section class="code-snippet__fix code-snippet__js"><pre class="brush:php;toolbar:false;">package main import &quot;fmt&quot; func main() { const ( a， b = iota + 1， iota + 2 //在const关键字出现时，iota=0，并且两次赋值在同一行，iota没有做+1 c， d //同理，新增一行常量，常量个数为俩，仍然是一行，所以iota=1 //c， d = iota + 1， iota + 2 同上，此时iota=1，c=2，d=3 e， f // 同理，同上，e=3，f=4 ) fmt.Println(a， b， c， d， e， f) }</pre></section><h2 cid="n139" mdtype="heading"><br></h2> <h2 cid="n139" mdtype="heading" style='break-after: avoid-page;break-inside: avoid;orphans: 4;font-size: 1.75em;margin-top: 1rem;margin-bottom: 1rem;font-weight: bold;line-height: 1.225;cursor: text;border-bottom: 1px solid rgb(238, 238, 238);white-space: pre-wrap;font-family: "Open Sans", "Clear Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;text-align: start;'> <span md-inline="plain">整型</span><br> </h2> <p cid="n140" mdtype="paragraph" style='line-height: inherit;orphans: 4;margin-top: 0.8em;margin-bottom: 0.8em;white-space: pre-wrap;font-family: "Open Sans", "Clear Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;font-size: 16px;text-align: start;'><span md-inline="plain">整数，很简单了，就是像</span><span md-inline="code" spellcheck="false"><code style="font-family: var(--monospace);vertical-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237);background-color: rgb(243, 244, 244);border-radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">1，2，3，7，11，..这样的整型数字了。

但是在Go中，整数分为两大类，正整数和没有符号的整数。

u开头的不能存负数

🎜🎜uint32🎜🎜🎜🎜 🎜🎜无符号 32位整型 (0 到 4294967295)🎜🎜🎜int16🎜🎜🎜🎜🎜有符号 16位整型 (-32768 到 32767)🎜🎜🎜🎜 🎜🎜 int32🎜🎜🎜🎜🎜🎜有符号 32位整型 (-2147483648 到 2147483647)🎜🎜

类型	描述
var(--monospace);text -align: left;vertikal-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237);background-color: rgb(243, 244, 244);border -radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">uint8uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 8位整型 (0 到 255)🎜🎜uint16🎜🎜🎜🎜🎜无符号 16位整型 (0 到 65535)🎜🎜🎜🎜
uint64uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	int8🎜🎜有符号 8位整型 (- 128 到 127)🎜🎜🎜🎜
int64	64-Bit-Ganzzahl mit Vorzeichen (-9223372036854775808 bis 9223372036854775807)

Unterschiede auf verschiedenen Plattformen.

🎜🎜int🎜🎜🎜🎜🎜🎜32位操作系统上就是🎜int32int32，64位操作系统上就是int64int64uintptr

类型	描述
var(--monospace);text -align: left;vertikal-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237);background-color: rgb(243, 244, 244);border -radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">uintuint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是uint32🎜 ，64位操作系统上就是🎜🎜uint64🎜🎜🎜🎜
uintptr，64位操作系统上就是

🎜🎜🎜无符号整型，用于存放一个指针🎜🎜🎜🎜🎜🎜

示例:

package main

import "fmt"

func main() {
    var a = 10             //定义一个十进制数
    fmt.Printf("%T\n"， a)  //功能:打印变量类型，结果:默认为int类型，也叫int64
    fmt.Printf("%d \n"， a) //功能:十进制输出，结果:10
    fmt.Printf("%b \n"， a) //功能:二进制输出，结果:1010
    fmt.Printf("%o \n"， a) //功能:二进制输出，结果:12

    var b = 0b1010011010  //定义一个二进制数1010011010，以0b开头
    fmt.Printf("%d\n"， b) //结果:666

    var c = 077           //定义一个八进制数77
    fmt.Printf("%d\n"， c) //结果:63
    var d = 0x42          //定义一个十六进制42
    fmt.Printf("%d\n"， d) //结果:66
}

浮点型

在Go中，只有float32和float64，默认使用的是float64。

示例:

package main

import "fmt"

func main() {
    var a = 1.21          //默认为float64
    fmt.Printf("%T\n"， a) //结果:float64
    fmt.Printf("%f\n"，a)//功能:输出浮点型数，结果:1.210000
    fmt.Printf("%.1f\n"，a)//功能:输出浮点型数，保留小数点一位，其他忽略，结果:1.2
    fmt.Printf("%.2f\n"，a)//功能:输出浮点型数，保留小数点二位，其他忽略，结果:1.21
}

布尔值

在Go中，bool类型就俩值，true和false。

无示例。

注:

1. bool类型默认值为false。

2. true != 1，在Go中，bool类型和整型不能混用。

字符串

终于到字符串了，在Go中，字符串是基本数据类型，在栈中存储。

字符串的值为双引号("")中的内容。

示例:

package main

import "fmt"

func main() {
    var name = "hello"
    var name2 = "张三"
    fmt.Println(name，name2)
}

在Go中，字符串内存布局如下。

Tatsächlich besteht das Wesen einer Zeichenfolge in Go darin, Zeichen einzeln zu verbinden.

Mehrzeilige Zeichenfolge

Manchmal benötigen wir möglicherweise einen langen Artikel und eine lange Zeichenfolge, dann müssen wir die Nummer ` verwenden.

package main

import "fmt"

func main() {
    var lyric = `
        昨夜同门云集bai 推杯又换盏
        今朝du茶凉酒寒 豪言成笑谈
        半生累 尽徒然zhi 碑文完美有谁看dao
        隐居山水之间 誓与浮名散
        湖畔青石板上 一把油纸伞
    `
    fmt.Println(lyric)
}

字符串常用操作

🎜+或fmt.Sprintf🎜🎜🎜🎜🎜拼接字符串🎜🎜🎜🎜🎜🎜strings.Split🎜🎜🎜🎜🎜🎜分割🎜🎜strings.HasPrefix，strings.HasSuffix

方法	介绍
t-Familie: var(--monospace); Textausrichtung: links; vertikale Ausrichtung: initial; Rahmenbreite: 1 Pixel; Rahmenstil: einfarbig; Rahmenfarbe: RGB (231, 234, 237); Hintergrundfarbe: RGB (243, 244, 244); border-radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">len(str)len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	求长度
strings.containsstrings.contains	判断是否包含
strings.HasPrefix，strings.HasSuffix	前缀/后缀判断
strings.Index()，strings.LastIndex()	子串出现的位置
strings.Join(a[]string， sep string)	判断是否包含

🎜🎜🎜前缀/后缀判断🎜🎜🎜🎜🎜🎜strings.Index()，strings.LastIndex()🎜🎜🎜🎜🎜子串出现的位置🎜🎜🎜🎜🎜🎜strings.Join(a[]string， sep string )🎜🎜🎜🎜🎜🎜mitmachen操作🎜🎜🎜🎜🎜🎜

示例代码

package main

func main() {
  //len() 求字符串字节长度
  //var name = "你好，世界"
  //fmt.Println(len(name)) //因为中文是utf8，一个文字三个字节，再加一个，号，所以是13

  //fmt.Sprintf 或 + 拼接字符串
  //name1 := "张"
  //name2 := "三"
  //name :=name1 + name2 //拼接字符串
  //fmt.Println(name)
  //name := fmt.Sprintf("%s%s"， name1， name2)//同上，不过这种更灵活，推荐
  //name := fmt.Sprintf("我的姓名是:%s%s"， name1， name2)//自定义拼接
  //fmt.Println(name)

  //strings.Split 分割字符串
  //name := "张三|18|男|法外狂徒"
  //info := strings.Split(name， "|")
  //fmt.Println(info) //返回的是切片，[张三 18 男 法外狂徒]

  //strings.contains 是否包含
  //name := "张三666"
  //result := strings.Contains(name， "6")
  //fmt.Println(result) //返回的是bool类型，true

  //strings.HasPrefix 判断前缀(是不是以什么开头)
  //name := "web/student/xxx.html"
  //result := strings.HasPrefix(name， "web")
  //fmt.Println(result) //true

  //strings.HasSuffix 判断后缀(是不是以什么结尾)
  //name := "web/student/xxx.html"
  //result := strings.HasSuffix(name， "html")
  //fmt.Println(result)//true

  //strings.Index() 返回第一个字符串出现的位置
  //name := "hello world"
  //index := strings.Index(name， "o")
  //fmt.Println(index) //4

  //strings.LastIndex() // 正向数，返回最后一个字符串出现的位置
  //name := "hello world"
  //index := strings.LastIndex(name， "o")
  //fmt.Println(index) // 7

  //strings.Join(a[]string， sep string) 字符串拼接
  //info_list := []string{"张三"， "男"， "18"} //定义一个列表
  //name := strings.Join(info_list， "|")
  //fmt.Println(name) //张三|男|18
}

Das obige ist der detaillierte Inhalt vonEin Artikel, der Ihnen hilft, die grundlegenden Datentypen der Go-Sprache zu verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!