GO语言基础

最新推荐文章于 2024-05-18 17:38:58 发布

zaiduozhuanliangquan

最新推荐文章于 2024-05-18 17:38:58 发布

阅读量545

点赞数

文章标签： golang

本文链接：https://blog.csdn.net/ZBDX2113/article/details/126674526

版权

GO

hello world

每一门编程语言的开始都是hello world，GO语言中示例如下

package main/*定义一个包名，所有的go都有*/
 
import "fmt"/*类似于python中的库*/
 
func main() {
	fmt.Println("Hello, World!")/*可以将字符串输出到控制台，并在最后自动增加换行字符 \n，相当于 fmt.Print("hello, world\n")*/
}

这就是我们的第一个hello，world程序，其中有几个注意的点：

1.开始的包名不能丢，每个go语言程序都需要用到它。

2.func main()后面的{}不能单独的写在一行，比如

func main()
{
.......
}

就是错误写法。

当我们写好.go文件之后，还有其它方式可以运行

首先可以在cmd里，输入

go run 文件名.go

即可运行这个文件，但是记得运行时一定要在其目录文件夹下，不然会显示找不到文件。

其次我们可以使用go build创建一个二进制文件，输入

go build as.go
 
as.exe

也可以运行hello world程序。
基础语法

它的基础语法和c非常相似：

1.注释

单行注释//，多行注释/* */

2.标识符

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A_Z和az)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

例如：mahesh _hash 反例：2ks case(关键字) a+b

3.字符串连接

“dog”+“cat”

4.关键字

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

5.格式化字符串

package main
 
import (
    "fmt"
)
 
func main() {
   
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}
 
#Code=123&endDate=2020-12-31

记得运行程序的时候，不要一个文件夹下放入两个go的源文件，否则会运行报错。

数据类型

1.布尔型

2.字符串型

3.派生型
包括：

(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构化类型(struct)
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型

4.整型
1 uint8
无符号 8 位整型 (0 到 255)
2 uint16
无符号 16 位整型 (0 到 65535)
3 uint32
无符号 32 位整型 (0 到 4294967295)
4 uint64
无符号 64 位整型 (0 到 18446744073709551615)
5 int8
有符号 8 位整型 (-128 到 127)
6 int16
有符号 16 位整型 (-32768 到 32767)
7 int32
有符号 32 位整型 (-2147483648 到 2147483647)
8 int64
有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

5.浮点型
1 float32
IEEE-754 32位浮点型数
2 float64
IEEE-754 64位浮点型数
3 complex64
32 位实数和虚数
4 complex128
64 位实数和虚数

6.其它数字类型
1 byte
类似 uint8
2 rune
类似 int32
3 uint
32 或 64 位
4 int
与 uint 一样大小
5 uintptr
无符号整型，用于存放一个指针。

语言变量

可以一次声明多个变量

package main

import "fmt"

func main() {
	var a string = "Runoob"
	fmt.Println(a)
	var b, c int = 1, 2
	fmt.Println(b, c)
}
//Runoob
//1 2

package main

import "fmt"

func main() {
	var a = "Runoob"
	fmt.Println(a)
	var b int//未赋值默认为0值
	fmt.Println(b)
	var c bool
	fmt.Println(c)
}

/* Runoob
0
false
*/

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

//0 0 false ""

package main

import "fmt"

func main() {
	var d = true
	fmt.Println(d)
}

//true

package main

import "fmt"

func main() {
	f := "Runoob" // var f string = "Runoob"

	fmt.Println(f)
}

//Runoob

package main

var x, y int
var (
	a int
	b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"

func main() {
	g, h := 123, "hello"
	println(x, y, a, b, c, e, f, g, h)
}

//0 0 0 false 1 123 hello 123 hello

语言常量

常量中的数据类型只可以是布尔型，数字型和字符串型

定义格式：
const identifier [type] = value

const b string ="abc"-----显示类型定义
const b ="abc"-----隐式类型定义

package main

import "fmt"

func main() {
	const LENGTH int = 10
	const WIDTH int = 5
	var area int
	const a, b, c = 1, false, "str"
	area = LENGTH * WIDTH
	fmt.Println("面积：", area)
	println()
	println(a, b, c)
}

/*面积： 50

1 false str
*/

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}
//0 1 2 ha ha 100 100 7 8

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k //3<<2
    l //3<<3 
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}
/*
i= 1
j= 6
k= 12
l= 24
*/

i=1：左移 0 位，不变仍为 1。
j=3：左移 1 位，变为二进制 110，即 6。
k=3：左移 2 位，变为二进制 1100，即 12。
l=3：左移 3 位，变为二进制 11000，即 24。

<<n==*(2^n)

运算符

与c语言相同

位运算符

p	q	p&q	p\|q	p^q
0	0	0	0	0
0	1	0	1	1
0	1	1	1	0
1	0	0	1	1

&	按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。	(A & B) 结果为 12, 二进制为 0000 1100
\|	按位或运算符"\|"是双目运算符。其功能是参与运算的两数各对应的二进位相或	(A \| B) 结果为 61, 二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。	(A ^ B) 结果为 49, 二进制为 0011 0001
<<	左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。	A << 2 结果为 240 ，二进制为 1111 0000
>>	右移运算符">>“是双目运算符。右移n位就是除以2的n次方。其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。	A >> 2 结果为 15 ，二进制为 0000

其它运算符

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

/*
第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4
*/

运算符优先级

优先级	运算符
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

条件语句

if

if a <20{
*******
}

if+else

if a<20{
****
}else{
*****
}

switch

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var grade string = "B"
	var marks int = 90

	switch marks {
	case 90:
		grade = "A"
	case 80:
		grade = "B"
	case 50, 60, 70:
		grade = "C"
	default:
		grade = "D"
	}

	switch {
	case grade == "A":
		fmt.Printf("优秀!\n")
	case grade == "B", grade == "C":
		fmt.Printf("良好\n")
	case grade == "D":
		fmt.Printf("及格\n")
	case grade == "F":
		fmt.Printf("不及格\n")
	default:
		fmt.Printf("差\n")
	}
	fmt.Printf("你的等级是 %s\n", grade)
}
/*
优秀!
你的等级是 A
*/

TYPE switch

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:  
         fmt.Printf(" x 的类型 :%T",i)                
      case int:  
         fmt.Printf("x 是 int 型")                      
      case float64:
         fmt.Printf("x 是 float64 型")          
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )      
      default:
         fmt.Printf("未知型")    
   }  
}

fallthrough

会强制执行后面的select语句。

package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

循环语句

for循环

func main() {
   sum := 0
      for i := 0; i <= 10; i++ {
         sum += i
      }

 for sum <= 10{
      sum += sum
   }

//通过循环来迭代输出元素
package main
import "fmt"

func main() {
   strings := []string{"google", "runoob"}
   for i, s := range strings {
      fmt.Println(i, s)
   }


   numbers := [6]int{1, 2, 3, 5}
   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }  
}
/*
0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0
*/

#通过range格式省略key和value
package main
import "fmt"

func main() {
    map1 := make(map[int]float32)
    map1[1] = 1.0
    map1[2] = 2.0
    map1[3] = 3.0
    map1[4] = 4.0
   
    // 读取 key 和 value
    for key, value := range map1 {
      fmt.Printf("key is: %d - value is: %f\n", key, value)
    }

    // 读取 key
    for key := range map1 {
      fmt.Printf("key is: %d\n", key)
    }

    // 读取 value
    for _, value := range map1 {
      fmt.Printf("value is: %f\n", value)
    }
}

/*
key is: 4 - value is: 4.000000
key is: 1 - value is: 1.000000
key is: 2 - value is: 2.000000
key is: 3 - value is: 3.000000
key is: 1
key is: 2
key is: 3
key is: 4
value is: 1.000000
value is: 2.000000
value is: 3.000000
value is: 4.000000
*/

break

//标记与不标记的区别
package main

import "fmt"

func main() {

   // 不使用标记
   fmt.Println("---- break ----")
   for i := 1; i <= 3; i++ {
      fmt.Printf("i: %d\n", i)
      for i2 := 11; i2 <= 13; i2++ {
         fmt.Printf("i2: %d\n", i2)
         break
      }
   }

   // 使用标记
   fmt.Println("---- break label ----")
   re:
      for i := 1; i <= 3; i++ {
         fmt.Printf("i: %d\n", i)
         for i2 := 11; i2 <= 13; i2++ {
         fmt.Printf("i2: %d\n", i2)
         break re
      }
   }
}

/*
---- break ----
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
---- break label ----
i: 1
i2: 11  
*/

continue

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* for 循环 */
   for a < 20 {
      if a == 15 {
         /* 跳过此次循环 */
         a = a + 1;
         continue;
      }
      fmt.Printf("a 的值为 : %d\n", a);
      a++;    
   }  
}
//当a等于15时直接跳过输出过程
/*
a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19
*/

其中也有标记选项，与上述类型相同。

goto

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++    
   }  
}

zaiduozhuanliangquan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
GO语言基础

每一门编程语言的开始都是hello world，GO语言中示例如下这就是我们的第一个hello，world程序，其中有几个注意的点：1.开始的包名不能丢，每个go语言程序都需要用到它。2.func main()后面的{}不能单独的写在一行，比如就是错误写法。当我们写好.go文件之后，还有其它方式可以运行首先可以在cmd里，输入即可运行这个文件，但是记得运行时一定要在其目录文件夹下，不然会显示找不到文件。其次我们可以使用go build创建一个二进制文件，输入也可以运行hello world程序。
复制链接

扫一扫