您好,登录后才能下订单哦!
[toc]
package main
import "fmt"
func main(){
const v = 20
var a byte = 10
b := v + a
fmt.Printf("%T,%v\n",b,b) //此时b的类型为int8
const c float32 = 3.14
d := c + v
fmt.Printf("%T,%v",d,d) //此时d的类型是float32
}
不能将内存地址与指针混为一谈,内存地址是内存中的每个字节单元的唯一编号;指针是一个实体;指针会分配内存空间,相当于一个专门用来 保存地址的整型变量
&
用于获取对象地址*
用于间接引用目标对象**T
,如果包含包名的话则写成*package.T
package main
import "fmt"
func main(){
x := 10
var p *int = &x
fmt.Printf("%v\n%v",*p,p)
}
指针类型支持相等运算符,但不能做加减法运算或者类型转换。两个指针执行同一个地址,或者都为nil。那他们相等。
对于复合类型(数组,切片,字典,结构体)变量进行初始化时,有一些语法限制,如下:
允许多行,但是每行必须用逗号或者花括号结束
正确的初始化栗子如下:
package main
import "fmt"
func test1() {
type data struct {
x int
y string
}
var a data = data{123, "abc"} //初始化
b := data{
234,
"bcd",
}
c := []int{
1,
2,
}
d := []int{1, 23, 4,
233, 5,
12,
22,
}
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
}
func main() {
test1()
}
package main
import "fmt"
func xinit(){
fmt.Println("heheheh")
}
func If_else(){
x := 10
if xinit();x == 0{
fmt.Println("hehehe")
}
if a,b := x+1,x+10;a < b{
fmt.Println("a < b")
}else {
fmt.Println("error!")
}
}
func main() {
If_else()
}
package main
import (
"fmt"
"errors"
"log"
)
func check(x int) error {
if x <=0 {
return errors.New("x <= 0")
}
return nil
}
func main() {
//If_else()
//If_else2()
x := 10
if err := check(x);err == nil{
x++
fmt.Println(x)
}else {
log.Fatal(err) //如果x<0的话会输出错误日志
}
}
main可以改造成如下的样子,以便查看
func main() {
x := 100
if err := check(x);err !=nil{
log.Fatal(err)
}
x++
fmt.Println(x)
}
package main
import (
"strconv"
"log"
"fmt"
)
func main(){
s := "9"
n,err := strconv.ParseInt(s,10,64) //将字符串转换成数字
if err != nil{
log.Fatal(err)
}else if n < 0 || n > 10{
log.Fatalln("invalid number!!")
}
fmt.Println(n)
fmt.Println(err)
}
package main
import (
"strconv"
"log"
"fmt"
)
func main(){
s := "9"
if n,err := strconv.ParseInt(s,10,64);err != nil || n <0 || n > 10{
log.Fatalln("invalid num!!")
}
fmt.Println("ok") //条件判断外层,不能引用条件参数
}
通过函数调用改进的版本:
package main
import (
"strconv"
"errors"
"log"
"fmt"
)
func check(s string) error {
n ,err := strconv.ParseInt(s,10,64)
if err != nil || n <0 || n > 10{
return errors.New("invalid number!")
}
return nil
}
func main(){
s := "8"
if err := check(s);err != nil{
log.Fatalln(err)
}
fmt.Println("ok")
}
package main
import "fmt"
func main(){
switch x := 5;x {
default:
x+=100
fmt.Println(x)
case 5:
x+=50
fmt.Println(x)
}
}
package main
import "fmt"
func main(){
switch x:=5;x{
default:
fmt.Println(x)
case 5:
x += 10
fmt.Println(x)
fallthrough //继续执行下一个case,但是不匹配条件
/*if x >= 15 {
break //直接跳出循环
}
fallthrough*/
case 6:
x += 20
fmt.Println(x)
}
}
package main
import (
"fmt"
)
func test1(){
switch x:=5;x{
default:
fmt.Println(x)
case 5:
x += 10
fmt.Println(x)
fallthrough //继续执行下一个case,但是不匹配条件
case 6:
x += 20
fmt.Println(x)
}
}
func test2(){
switch x:=5;x {
case 5:
x += 10
fmt.Println(x)
if x >= 15 {
break
}
fallthrough
case 6:
x += 20
fmt.Println(x)
}
}
func test3(){
switch x:=5; {
case x > 5:
fmt.Println("a")
case x > 0 && x <= 5:
fmt.Println("b")
default:
fmt.Println("z")
}
}
func main(){
test1()
test2()
test3()
}
### 循环
#### for
只有一种循环语句,支持常用的方式:
``` go
package main
import "fmt"
func count() int{
fmt.Println("count.")
return 3
}
func main(){
for i,c :=0,count();i < c;i++{
fmt.Println("a",i)
}
c := 0
for c < count(){
fmt.Println("b",c)
c++
}
}
package main
func main(){
data := [3]string{"a","b","c"}
for i,s := range data{
println(i,s)
}
for i,_ range data{
println(i) //返回单值
}
}
package main
func main(){
data := [3]string{"a","b","c"}
for i,s := range data{
println(&i,&s)
}
}
range会复制目标数据,直接受影响的是数组;可以改用切片或者数组指针类型
package main
import (
"fmt"
)
func main(){
data := [3]int{10,20,30}
for i,x := range data{
if i == 0 {
data[0] += 100
data[1] += 200
data[2] += 300
}
fmt.Printf("x: %d\tdata: %d\n",x,data[i]) //经过复制的x,值不变
}
for i,x := range data[:]{
if i == 0 {
data[0] += 100
data[1] += 200
data[2] += 300
}
fmt.Printf("x: %d\tdata: %d\n",x,data[i]) //循环的切片,x发生了变化
}
}
相关数据类型中,字符串,切片基本结构是很小的结构体;而字典,管道本身是指针封装,复制成本都比较低,无需专门做优化。
package main
import "fmt"
func data() []int {
fmt.Println("original data....")
return []int{10,20,30}
}
func main(){
for i,x := range data(){
fmt.Println(i,x)
}
}
建议嵌套不要超过两层,否则会难以维护。必要时可以剥离,重构函数
package main
func test1(){
for i :=0;i < 10 ;i++{
if i > 7{
break
}
println(i)
}
}
func test2(){
outer: //定义标签,break和continue可在多层嵌套中指定标签
for x := 0;x < 5 ;x++{
for y := 0; y < 10 ; y++{
if y > 2 {
println()
continue outer
}
if x > 2{
break outer
}
print(x,":",y,":")
}
}
}
func main(){
test1()
test2()
}
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。