在GO语言中可以使用%+特定字母形成转义字符，这个表示特定含义的组合成为转义字符
在GO语言中又称为verb
转义字符在GO语言中以下两种情况使用频率较高
fmt.Print("verb",内容)//输出
fmt.Scanf("verb",接受变量)//输入
| Verb | 含义 |
|---|---|
使用Scanln(&变量名，&变量名)的方式接收
package main
import "fmt"
func main() {
var name, age string
fmt.Print("请输入用户姓名和年龄：")
fmt.Scanln(&name, &age)
fmt.Println("接收到内容为：", name, age)
}
也可以使用fmt.Scanf(verb,&变量)按照特定的格式进行输入
package main
import "fmt"
func main() {
var a, b string
fmt.Println("请输入姓名和年龄:")
fmt.Scanf("%s\n%s", &a, &b)
fmt.Printf("%s\n%s", a, b)
}
// Fprintln formats using the default formats for its operands and writes to w.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
p := newPrinter()
p.doPrintln(a)
n, err = w.Write(p.buf)
p.free()
return
}
函数参数中第一个参数是输出流，后面参数是内容，表示把内容写入到输出流中
第一个返回值表示输出内容长度（字节数），第二个返回值表示错误，如果没有错误取nil
// doPrintln is like doPrint but always adds a space between arguments
// and a newline after the last argument.
func (p *pp) doPrintln(a []interface{}) {
for argNum, arg := range a {
if argNum > 0 {
p.buf.writeByte(' ')
}
p.printArg(arg, 'v')
}
p.buf.writeByte('\n')
}
FprintXX()支持下面三种方式
func main() {
fmt.Fprint(os.Stdout, "内容1")//向流中写入内容
fmt.Fprintln(os.Stdout, "内容2")//向流中写入内容后额外写入换行符
fmt.Fprintf(os.Stdout, "%s", "内容3")//根据verb格式向流中写入内容
}
func main(){
fmt.Println("内容1")//输出内容后换行
fmt.Print("内容2")//输出内容后不换行
fmt.Printf("verb","内容")//根据verb输出指定格式内容
}
// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Println(a ...interface{}) (n int, err error) {
return Fprintln(os.Stdout, a...)
}
// Sprint formats using the default formats for its operands and returns the resulting string.
// Spaces are added between operands when neither is a string.
func Sprint(a ...interface{}) string {
p := newPrinter()
p.doPrint(a)
s := string(p.buf)
p.free()
return s
}
fmt.Sprint("内容1", "内容2")
fmt.Sprintf()
fmt.Sprintln("1", "2")
| 关键字如下 | ||||
|---|---|---|---|---|
| 保留字如下 | ||||
|---|---|---|---|---|
//语法
//1.声明
var 变量名 类型
//2.赋值
变量名=值
//语法
var 变量名 类型 = 值
//实例
var smallming string = "英文名"
//语法
var 变量名 = 值
//语法
变量名 := 值
func main(){
var a,b,c int
a,b,c = 1,2,3
fmt.Println(a,b,c)
}
func main(){
var a,b,c,d = 1,2,3,false
fmt.Println(a,b,c,d)
}
func main(){
var (
a = 1
b = true
c = "测试"
)
fmt.Println(a,b,c)
}
func main(){
var (
a = 1
b = true
c = "测试"
)
b,c,d := false, "smallming", 3
fmt.Println(a,b,c,d)
}
在GO语言中可以进行数据运算的类型分为整型和浮点型
所有的整数数字存储到整型中就可以进行数学运算
整型分为有符合整型和无符号整型
无符号整型只能取大于等于0的整数，其二进制最高位表示真实数字，unit和unitx为无符号整型
整型取值范围和作用
无符号整数统一公式为
| 类型 | 取值范围 |
|---|---|
package main
import "fmt"
func main() {
//声明3个类型变量
var a int = 1
var b int32 = 2
var c int64 = 3
fmt.Println(a, b, c)
//把int32转换为int64
a = int(b)
fmt.Println(a, b)
a = 1
//把int64转换为int32
b = int32(c)
fmt.Println(b, c)
b = 2
//把int转换为int64
c = int64(a)
fmt.Println(a, c)
c = 3
}
package main
import "fmt"
func main() {
//默认表示十进制
d := 17
//0开头表示八进制
o := 021
//0x开头表示十六进制
x := 0x11
//e2表示10的2次方
e := 11e2
//输出
fmt.Println(d, o, x, e)
//把变量d中内容转为二进制
b := fmt.Sprintf("%b", d)
fmt.Println(b)
}
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。