符文文字只是32位整数值(但是它们是无类型的常量，所以它们的类型可以改变)。它们代表unicode码点。例如，符文文字“a”实际上是数字97。

因此，您的程序基本上相当于:

package main

import "fmt"

func SwapRune(r rune) rune {
    switch {
    case 97 <= r && r <= 122:
        return r - 32
    case 65 <= r && r <= 90:
        return r + 32
    default:
        return r
    }
}

func main() {
    fmt.Println(SwapRune('a'))
}

如果您查看Unicode映射，这应该是很明显的，在这个范围内它与ASCII是相同的。此外，32实际上是字符的大写和小写码位之间的偏移量。所以A加32，就得到A，反之亦然。

来自Go lang发布说明:http://golang.org/doc/go1#rune

符文是一种类型。它占用32位，用于表示Unicode代码点。 作为一个类比，用“ASCII”编码的英语字符集有128个码位。这样就可以装进一个字节(8位)。根据这个(错误的)假设，C将字符视为'bytes' char，将'strings'视为'sequence of characters' char*。

但你猜怎么着。除了abcde，人类还发明了许多其他的符号。的符号。有太多了，我们需要32位来编码它们。

在golang中，字符串是一个字节序列。然而，由于多个字节可以表示一个符文代码点，字符串值也可以包含符文。所以，它可以转换为[]符文，反之亦然。

unicode包http://golang.org/pkg/unicode/可以让你体验到挑战的丰富程度。

我没有足够的声誉在fabrizioM的答案上发表评论，所以我只能在这里发表。

法布里齐奥的回答在很大程度上是正确的，他当然抓住了问题的本质——尽管必须加以区分。

字符串不一定是一系列符文。它是一个“字节切片”的包装器，切片是一个Go数组的包装器。这又有什么区别呢?

一个符文类型必须是一个32位的值，这意味着符文类型的值序列必须有一定数量的位x*32。字符串是一个字节序列，长度为x*8位。如果所有字符串实际上都是Unicode，那么这种差异将没有影响。然而，由于字符串是字节的切片，Go可以使用ASCII或任何其他任意字节编码。

然而，字符串字面量必须写入以UTF-8编码的源文件中。

信息来源:http://blog.golang.org/strings

我尽量使我的语言简单，这样外行也能理解符文。

符文是一个字符。就是这样。

它是一个单一的字符。它是来自世界上任何地方任何语言的任何字母表中的一个字符。

来获取我们使用的字符串

double-quotes ""

OR

back-ticks ``

字符串不同于符文。在我们使用的符文中

single-quotes ''

现在一个符文也是int32的别名…嗯什么?

rune是int32的别名的原因是我们在如下的编码方案中看到的

每个字符映射到一个数字，所以这就是我们要存储的数字。例如，a映射到97，当我们存储这个数字时，它只是一个数字，这就是rune是int32的别名的方式。但不是任何数字。它是一个有32个“0和1”或“4”字节的数字。(注意:UTF-8是一个4字节编码方案)

符文和字符串有什么关系?

字符串是符文的集合。在以下代码中:

    package main

    import (
        "fmt"
    )

    func main() {
        fmt.Println([]byte("Hello"))
    }

我们尝试将字符串转换为字节流。输出结果为:

[72 101 108 108 111]

我们可以看到，组成该字符串的每个字节都是一个符文。

其他所有人都已经介绍了与符文相关的部分，所以我不打算谈论这个。

然而，还有一个关于开关没有任何参数的问题。这只是因为在Golang中，没有表达式的switch是表达if/else逻辑的另一种方式。例如，这样写:

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

和写这个是一样的

t := time.Now()
if t.Hour() < 12 {
    fmt.Println("It's before noon")
} else {
    fmt.Println("It's after noon")
}

你可以在这里阅读更多。

(感觉上面的答案仍然没有很清楚地说明字符串和[]符文之间的区别和关系，所以我会尝试用一个例子来补充另一个答案。)

正如@Strangework的回答所说，字符串和[]符文是完全不同的。

区别-字符串和[]符文:

字符串值是只读字节片。并且，字符串文字用utf-8编码。字符串中的每个字符实际占用1 ~ 3个字节，而每个符文占用4个字节 对于string, len()和index都基于字节。 对于[]符文，len()和index都基于符文(或int32)。

关系-字符串和[]符文:

当您将字符串转换为[]符文时，该字符串中的每个utf-8字符都成为一个符文。 类似地，在反向转换中，当从[]符文转换为字符串时，每个符文都变成字符串中的utf-8字符。

小贴士:

你可以在字符串和[]符文之间转换，但它们在类型和整体大小上仍然是不同的。

(我将添加一个例子来更清楚地说明这一点。)

Code

string_rune_compare.go:

// string & rune compare,
package main

import "fmt"

// string & rune compare,
func stringAndRuneCompare() {
    // string,
    s := "hello你好"

    fmt.Printf("%s, type: %T, len: %d\n", s, s, len(s))
    fmt.Printf("s[%d]: %v, type: %T\n", 0, s[0], s[0])
    li := len(s) - 1 // last index,
    fmt.Printf("s[%d]: %v, type: %T\n\n", li, s[li], s[li])

    // []rune
    rs := []rune(s)
    fmt.Printf("%v, type: %T, len: %d\n", rs, rs, len(rs))
}

func main() {
    stringAndRuneCompare()
}

执行:

运行string_rune_compare.go

输出:

hello你好, type: string, len: 11
s[0]: 104, type: uint8
s[10]: 189, type: uint8

[104 101 108 108 111 20320 22909], type: []int32, len: 7

解释:

The string hello你好 has length 11, because the first 5 chars each take 1 byte only, while the last 2 Chinese chars each take 3 bytes. Thus, total bytes = 5 * 1 + 2 * 3 = 11 Since len() on string is based on bytes, thus the first line printed len: 11 Since index on string is also based on bytes, thus the following 2 lines print values of type uint8 (since byte is an alias type of uint8, in go). When converting the string to []rune, it found 7 utf8 chars, thus 7 runes. Since len() on []rune is based on rune, thus the last line printed len: 7. If you operate []rune via index, it will access base on rune. Since each rune is from a utf8 char in the original string, thus you can also say both len() and index operation on []rune are based on utf8 chars.

符文是一个int32值，因此它是一种Go类型，用于表示Unicode码位。Unicode码位是通常用于表示单个Unicode字符的数值;

程序

package main

import (
    "fmt"
)

func main() {
    words := "€25 or less"
    fmt.Println("as string slice")
    fmt.Println(words, len(words))

    runes := []rune(words)
    fmt.Println("\nas []rune slice")
    fmt.Printf("%v, len:%d\n", runes, len(runes))

    bytes := []byte(words)
    fmt.Println("\nas []byte slice")
    fmt.Printf("%v, len:%d\n", bytes, len(bytes))
}

输出

as string slice
€25 or less 13

as []rune slice
[8364 50 53 32 111 114 32 108 101 115 115], len:11

as []byte slice
[226 130 172 50 53 32 111 114 32 108 101 115 115], len:13

如您所见，欧元符号“€”由3个字节表示——226、130和172。 符文代表一个字符-任何字符，它是象形文字。一个符文的32位足以代表当今世界上所有的字符。因此，欧元符号“€”的符文表示是8364。

对于128个ASCII字符，一个字节(8位)就足够了。因此，符文和数字或字母的字节表示是相同的。例:2用50表示。

字符串的字节表示总是大于或等于其符文表示的长度，因为某些字符用超过一个字节表示，但不超过32位，这是一个符文。

https://play.golang.org/p/y93woDLs4Qe

Rune是int32的别名，在所有方面都等价于int32。它是 用于区分字符值和整数值。

L = 108, o = 111

Rune是int32类型的别名。它表示一个单一的Unicode码位。 统一码联盟(Unicode Consortium)为超过100万个独特的字符分配数字值，称为码点。例如，65是字母A的码位，66 -> B (来源:Get Programming with Go)