Go语言基础语法

已于 2024-05-14 17:56:05 修改
阅读量611 收藏 5
点赞数 1
分类专栏： Golang 文章标签： 1024程序员节 golang
于 2022-10-24 10:17:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35669498/article/details/127486784
版权

Go语言基础语法

一、HelloWorld

package main
import "fmt"

// main函数，需要package main一个主包
/*
	fmt是一个包
	Println是print.go中的一个func
*/
func main() {
	fmt.Println("Hello World!")
}

go语言需要申明一个package main包，并且需要写一个func main()函数，来运行项目

二、注释

// 这是行注释

/*
这是块注释1
这是块注释2
*/

注释和一般语言的注释都一样

三、变量

package main
import "fmt"

func main() {
	var name string = "XianDan"
	name = "xd"
	fmt.Println(name)
}

变量是内存地址中存放了一个值

1、变量的定义

package main
import "fmt"

func main() {

	var name string = "XianDan"
	var age int = 18

	fmt.Println(name, age)
}

声明变量需要使用var关键字，并且显式的表明出变量的类型

var 变量名 type
  • var 是声明变量的关键字，是固定写法。
  • 变量名是任意取的名字，需要自己来定义
  • type是代表变量的类型
package main
import "fmt"

func main() {

	var (
		name string
		age int
		money float64
		status bool
	)
	/*
		string 默认值 空
		int 默认值 0
		float64 默认值 0
		bool 默认值 false
	*/
	fmt.Println(name, age, money, status)
}

2、变量的赋值

有两种变量的赋值

第一种

package main
import "fmt"

func main() {

	var (
		name string
		age int
	)
	name = "XianDan"
    age = 18
	fmt.Println(name, age, money, status)
}

第二种（go语言的语法糖）

package main
import "fmt"

func main() {
    // := 自动推导
	name := "XianDan"
	age := 20
	fmt.Println(name, age)
}

:=编译器会自动推导右边是什么类型

fmt.Printf("%T, %T", name, age)

%T可以打印出此变量的类型，其输出结果是string, int

var name string
name := "XianDan"
// 当显式的定义的变量类型，就不能使用 := 来定义变量了
// 会报错no new variables on left side of := (左侧没有新变量)

3、打印内存地址

package main
import "fmt"

func main() {
	var num int
	num = 100
	fmt.Printf("num:%d,内存地址：%p\n", num, &num)
	num = 200
	fmt.Printf("num:%d,内存地址：%p", num, &num)
}

其结果为

num:100,内存地址：0xc00001e098
num:200,内存地址：0xc00001e098

可以看出当改变变量的值的时候，不会改变其内存地址

4、变量交换

// 在其他语言里需要进行变量交换通常需要定义一个temp来进行交换
// 在go语言里不需要重新定义一个temp
package main
import "fmt"

func main() {

	var a int = 100
	var b int = 200
	fmt.Println(a, b)
	b, a = a, b
	fmt.Println(a, b)
}

其输出结果为

100 200
200 100

5、匿名变量_

package main
import "fmt"

func test() (int, int) {
	return 100, 200
}

func main() {

	a, b := test()
	fmt.Println(a, b)
	c, _ := test()
	fmt.Println(c)
	_, d := test()
	fmt.Println(d)
}

其输出结果为

100 200
100
200

匿名变量的特点是一个下划线“_”，是一个特殊的标识符，被称为空白标识符，任何赋给这个标识符的值都将被抛弃。

匿名变量不占用内存空间，不会分配内存。匿名变量雨匿名变量之间也不会因为多次声明而无法使用。

6、变量的作用域

局部变量

package main

import "fmt"
func main() {

	// 局部变量
	var a int = 3
	var b int = 4

	c := a + b
	fmt.Println(a, b, c)
    test()
}

func test() {
    // 报错，无法取到a和b的值
    d := a + b
}

全局变量

package main

import "fmt"


// 全局变量
var a int = 3
var b int = 4

func main() {

	c := a + b
	fmt.Println(a, b, c)
    test()
}

func test() {
    // 不会报错，可以取到值
    d := a + b
    fmt.Println(a, b, d)
}

7、常量

package main
import "fmt"

func main() {

	const URL string = "www.xiandan123.cn"
    // URL = "123" // 会报错，常量不能给它重新赋值
	fmt.Println(URL)
}

8、iota

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

iota在const关键字出现的时候会被重置为0，const每新增一行常量声明将是iota计数一次

package main
import "fmt"

func main() {

	const (
		a = iota	// iota 0
		b			// iota 1
		c			// iota 2
		d = "XianDan" // iota 3
		e			// iota 4
		f			// iota 5
		g = iota	// iota 6
		h			// iota 7
		i			// iota 8
	)
	const (
		j = iota	// iota 0
		k			// iota 1
	)
	fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}

其输出结果为

0 1 2 XianDan XianDan XianDan 6 7 8 0 1

四、基本数据类型

1、布尔类型

布尔类型主要有两种bool：true或者false

package main
import "fmt"

func main() {

	var isFlag bool
	fmt.Println(isFlag)
}

其输出结果是false，说明bool默认值是false

2、数字类型

整型

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

浮点型

序号类型和描述
1float32 IEEE-754 32位浮点型数
2float64 IEEE-754 64位浮点型数
3complex64 32 位实数和虚数
4complex128 64 位实数和虚数
package main
import "fmt"

func main() {

	var f1 float32 = 3.14
	var f2 float64 = 3.17
	fmt.Println(f1, f2)
	fmt.Printf("%f\n", f1)
	fmt.Printf("%f\n", f2)
	fmt.Printf("%.1f\n", f1)
	fmt.Printf("%.1f\n", f2)
	fmt.Println("================================")
	var f3 float32 = -123.0000901
	var f4 float64 = -123.0000901
	fmt.Println("f3 = ", f3, "f4 = ", f4)
}

其输出结果为

3.14 3.17
3.140000                           
3.170000                           
3.1                                
3.2                                
================================   
f3 =  -123.00009 f4 =  -123.0000901
// 默认保留六位小数，尾数部分可能会丢失造成精度损失。其保留小数点结果是四舍五入
// 尽量使用float64来定义浮点类型的小数

其他数字类型

序号类型和描述
1byte 类似 uint8
2rune 类似 int32
3uint 32 或 64 位
4int 与 uint 一样大小
5uintptr 无符号整型，用于存放一个指针

3、字符与字符串

package main
import "fmt"

func main() {

	var name string
	name = "XianDan"
	fmt.Printf("%T, %s\n", name, name)
	fmt.Println("=================================")
	v1 := 'A'
	v2 := '蛋'
	v3 := "A"
	fmt.Printf("%T, %d\n", v1, v1)
	fmt.Printf("%T, %d\n", v2, v2)
	fmt.Printf("%T, %s\n", v3, v3)
}

其输出结果为

string, XianDan
=================================
int32, 65                        
int32, 34507                     
string, A  
// 可以看出''对应的是编码值
// 基础数字字母对应的编码表 ASCII字符码
// 所有的中国字的编码表：GBK
// 全世界的编码表：Unicode编码表

还要一些特殊运用

package main
import "fmt"

func main() {

	// 字符串连接 +
	fmt.Println("Xian" + "Dan")

	// 转义字符 \
	fmt.Println("Xian\"Dan")
	fmt.Println("Xian\nDan") // n换行
    fmt.Println("Xian\tDan") // t制表符 (四个空格)
}

其输出结果为

XianDan                          
Xian"Dan                         
Xian                             
Dan                              
Xian    Dan

4、数据类型的转换

由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明

package main
import "fmt"

func main() {

	a := 5   // int
	b := 5.0 // float64

	c := float64(a)
	d := int(b)

	fmt.Printf("%T\n", a)
	fmt.Printf("%T\n", b)
	fmt.Printf("%T\n", c)
	fmt.Printf("%T\n", d)

}

其输出结果为

int
float64
float64
int

五、运算符

1、算术运算符

下表列出了所有Go语言的算术运算符。假定 A 值为 10，B 值为 20。

运算符描述实例
+相加A + B 输出结果 30
-相减A - B 输出结果 -10
*相乘A * B 输出结果 200
/相除B / A 输出结果 2
%求余B % A 输出结果 0
++自增A++ 输出结果 11
–自减A-- 输出结果 9
package main
import "fmt"

func main() {

	var a int = 21
	var b int = 10
	var c int

	c = a + b
	fmt.Printf("c 的值为 %d\n", c)	// 31
	c = a - b
	fmt.Printf("c 的值为 %d\n", c)	// 11
	c = a * b
	fmt.Printf("c 的值为 %d\n", c)	// 210
	c = a / b
	fmt.Printf("c 的值为 %d\n", c)	// 2
	c = a % b
	fmt.Printf("c 的值为 %d\n", c)	// 1
	a++
	fmt.Printf("a 的值为 %d\n", a)	// 22
	a = 21
	a--
	fmt.Printf("a 的值为 %d\n", a)	// 20
}

其输出结果为

c 的值为 31
c 的值为 11 
c 的值为 210
c 的值为 2  
c 的值为 1  
a 的值为 22 
a 的值为 20

2、关系运算符

下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。

运算符描述实例
==检查两个值是否相等，如果相等返回 True 否则返回 False。(A == B) 为 False
!=检查两个值是否不相等，如果不相等返回 True 否则返回 False。(A != B) 为 True
>检查左边值是否大于右边值，如果是返回 True 否则返回 False。(A > B) 为 False
<检查左边值是否小于右边值，如果是返回 True 否则返回 False。(A < B) 为 True
>=检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。(A >= B) 为 False
<=检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。(A <= B) 为 True
package main
import "fmt"

func main() {
	var a int = 21
	var b int = 10

	if a == b {
		fmt.Printf("a 等于 b\n")
	} else {
		fmt.Printf("a 不等于 b\n")
	}
	if a < b {
		fmt.Printf("a 小于 b\n")
	} else {
		fmt.Printf("a 不小于 b\n")
	}

	if a > b {
		fmt.Printf("a 大于 b\n")
	} else {
		fmt.Printf("a 不大于 b\n")
	}

	a = 5
	b = 20
	if a <= b {
		fmt.Printf("a 小于等于 b\n")
	}
	if b >= a {
		fmt.Printf("b 大于等于 a\n")
	}
}

其输出结果为

a 不等于 b
a 不小于 b   
a 大于 b     
a 小于等于 b 
b 大于等于 a

3、逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。

运算符描述实例
&&逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。(A && B) 为 False
||逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。(A || B) 为 True
!逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。!(A && B) 为 True
package main
import "fmt"

func main() {
	var a bool = true
	var b bool = false
	if a && b {
		fmt.Printf("条件为 true\n")
	}
	if a || b {
		fmt.Printf("条件为 true\n")
	}
	a = false
	b = true
	if a && b {
		fmt.Printf("条件为 true\n")
	} else {
		fmt.Printf("条件为 false\n")
	}
	if !(a && b) {
		fmt.Printf("条件为 true\n")
	}
}

其输出结果为

条件为 true 
条件为 false
条件为 true

4、位运算符

位运算符对整数在内存中的二进制位进行操作。下表列出了位运算符 &, |, 和 ^ 的计算：

pqp & qp | qp ^ q
00000
01011
11110
10011

Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

运算符描述实例
&按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。(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 1111
package main
import "fmt"

func main() {

	var a uint = 60 /* 60 = 0011 1100 */
	var b uint = 13 /* 13 = 0000 1101 */
	var c uint = 0

	c = a & b /* 12 = 0000 1100 */
	fmt.Printf("c 的值为 %d,二进制的值为 %b\n", c, c)

	c = a | b /* 61 = 0011 1101 */
	fmt.Printf("c 的值为 %d,二进制的值为 %b\n", c, c)

	c = a ^ b /* 49 = 0011 0001 */
	fmt.Printf("c 的值为 %d,二进制的值为 %b\n", c, c)

	c = a << 2 /* 240 = 1111 0000 */
	fmt.Printf("c 的值为 %d,二进制的值为 %b\n", c, c)

	c = a >> 2 /* 15 = 0000 1111 */
	fmt.Printf("c 的值为 %d,二进制的值为 %b\n", c, c)
}

其输出结果为

c 的值为 12,二进制的值为 1100
c 的值为 61,二进制的值为 111101   
c 的值为 49,二进制的值为 110001   
c 的值为 240,二进制的值为 11110000
c 的值为 15,二进制的值为 1111

5、赋值运算符

下表列出了所有Go语言的赋值运算符。

运算符描述实例
=简单的赋值运算符，将一个表达式的值赋给一个左值C = A + B 将 A + B 表达式结果赋值给 C
+=相加后再赋值C += A 等于 C = C + A
-=相减后再赋值C -= A 等于 C = C - A
*=相乘后再赋值C *= A 等于 C = C * A
/=相除后再赋值C /= A 等于 C = C / A
%=求余后再赋值C %= A 等于 C = C % A
<<=左移后赋值C <<= 2 等于 C = C << 2
>>=右移后赋值C >>= 2 等于 C = C >> 2
&=按位与后赋值C &= 2 等于 C = C & 2
^=按位异或后赋值C ^= 2 等于 C = C ^ 2
|=按位或后赋值C |= 2 等于 C = C | 2
package main
import "fmt"

func main() {
	var a int = 21
	var c int

	c = a
	fmt.Printf("=  运算符实例，c 值为 = %d\n", c)

	c += a
	fmt.Printf("+= 运算符实例，c 值为 = %d\n", c)

	c -= a
	fmt.Printf("-= 运算符实例，c 值为 = %d\n", c)

	c *= a
	fmt.Printf("*= 运算符实例，c 值为 = %d\n", c)

	c /= a
	fmt.Printf("/= 运算符实例，c 值为 = %d\n", c)

	c %= a
	fmt.Printf("%%= 运算符实例，c 值为 = %d\n", c)

	c = 200

	c <<= 2
	fmt.Printf("<<= 运算符实例，c 值为 = %d\n", c)

	c >>= 2
	fmt.Printf(">>= 运算符实例，c 值为 = %d\n", c)

	c &= 2
	fmt.Printf("&= 运算符实例，c 值为 = %d\n", c)

	c ^= 2
	fmt.Printf("^= 运算符实例，c 值为 = %d\n", c)

	c |= 2
	fmt.Printf("|= 运算符实例，c 值为 = %d\n", c)

}

其运算结果为

=  运算符实例，c 值为 = 21
+= 运算符实例，c 值为 = 42  
-= 运算符实例，c 值为 = 21  
*= 运算符实例，c 值为 = 441 
/= 运算符实例，c 值为 = 21  
%= 运算符实例，c 值为 = 0   
<<= 运算符实例，c 值为 = 800
>>= 运算符实例，c 值为 = 200
&= 运算符实例，c 值为 = 0   
^= 运算符实例，c 值为 = 2   
|= 运算符实例，c 值为 = 2

6、其他运算符

下表列出了Go语言的其他运算符。

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

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

	/* 运算符实例 */
	fmt.Printf("a 变量类型为 = %T\n", a)
	fmt.Printf("b 变量类型为 = %T\n", b)
	fmt.Printf("c 变量类型为 = %T\n", c)
	fmt.Printf("ptr 变量类型为 = %T\n", ptr)

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

其输出结果为

a 变量类型为 = int
b 变量类型为 = int32  
c 变量类型为 = float32
ptr 变量类型为 = *int 
a 的值为  4
*ptr 为 4

六、键盘输入输出

package main

import "fmt"

func main() {

	var x int
	var y float64

	// 定义两个变量，想用键盘来获取这两个变量
	// fmt.Println()	// 打印并换行
	// fmt.Printf()	// 格式化输出
	// fmt.Print()		// 打印输出
	fmt.Println("请输入两个数：1、整数，2、浮点数：")

	// 变量取地址 &变量
	fmt.Scanln(&x, &y)
	fmt.Println("x: ", x)
	fmt.Println("y: ", y)

	//fmt.Scanln() 		// 接收输入（若有两值要输入，只输入一个值回车后也可完成）
	//fmt.Scanf()		// 接收格式化输入
	//fmt.Scan()		// 接收输入（若有两个值要输入，就必须输入两个值）
}

七、if语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。
在这里插入图片描述

package main
import "fmt"

func main() {

	var score int = 15

	if score >= 60 && score < 70 {
		fmt.Println("及格")
	} else if score >= 70 && score < 80 {
		fmt.Println("良好")
	} else if score >= 80 && score < 90 {
		fmt.Println("优")
	} else if score >= 90 && score <= 100 {
		fmt.Println("非常优")
	} else {
		fmt.Println("不及格")
	}
}

其输出结果为

不及格

八、switch语句

Go 编程语言中 switch 语句的语法如下：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

package main
import "fmt"

func main() {

	var season int = 1

	switch season {
	case 1:
		fmt.Println("春天")
	case 2:
		fmt.Println("夏天")
	case 3:
		fmt.Println("秋天")
	case 4:
		fmt.Println("冬天")
	default:
		fmt.Println("请输入1-4中间的数")
	}
}

其输出结果为

春天

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

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")
    }
}

其输出结果为

2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true

如果要加穿透，又不想所有的穿透，可以在需要结束的那行加break。

九、for循环

在这里插入图片描述

package main
import "fmt"

// 计算1 到 10的数字之和
func main() {

	sum := 0
    // for 条件的起始值; 循环条件; 控制变量的值
	for i := 1; i <= 10; i++ {
		sum = sum + i
	}
	fmt.Println(sum)
}

其输出结果为

55

break 结束当前整个循环

package main
import "fmt"

func main() {

	sum := 0
	for i := 1; i <= 10; i++ {
		if i == 5 {
			break
		}
		sum = sum + i
	}
	fmt.Println(sum)
}

其输出结果为

10

continue 结束单次循环，继续执行后面的循环

package main
import "fmt"

func main() {

	sum := 0
	for i := 1; i <= 10; i++ {
		if i == 5 {
			continue
		}
		sum = sum + i
	}
	fmt.Println(sum)
}

其输出结果为

50

goto

goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。

package main
import "fmt"

func main() {

	sum := 0
	for i := 1; i <= 10; i++ {
		if i == 5 {
			goto LOOP
		}
		sum = sum + i
	}
LOOP:
	for i := 1; i <= 10; i++ {

		sum = sum + i
	}
	fmt.Println(sum)
}

其输出结果为

65

十、string

package main
import "fmt"

func main() {

	str := "hello,XianDan"
	fmt.Println(str)

	// 获取字符串的长度
	fmt.Println("字符串的长度:", len(str))

	// 获取指定的字节
	fmt.Println("字节打印:", str[0])
	fmt.Printf("字节打印: %c\n", str[0])

	// 遍历输出
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c ", str[i])
	}

}

其输出结果为

hello,XianDan
字符串的长度: 13                     
字节打印: 104                        
字节打印: h
h e l l o , X i a n D a n
_咸蛋.
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言基础一
LAM1006_csdn的博客
02-28 566
Go语言基础 Go基础 1.变量定义：var 变量名 类型 = 表达式 var a int = 8 a 在函数内部，可以使用更简略的 := 方式声明并初始化变量。 **注意：**短变量只能用于声明局部变量，不能用于全局变量的声明 声明变量：快速 := 方式声明并初始化变量 // 变量名 := 表达式 n := 10 var a = 18 //一次变量多个声明 var a,b,c int a=1 b=2 c=3 //多变量声明 var( a int b string ) a=1 b="sad"
云计算之go语言——基础语法(下)
01-08
17 Go 语言范围(Range) 1, 概念 Go 语言中 range 关键字用于 for 循环中迭代数组(array)/切片(slice)/通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。 2，实例 range01.go package main import fmt func main() { /* 这是我们使用 range 去求一个 slice 的和。
Go语言-语法基础-全面
weixin_51991615的博客
10-24 5718
一.Go基础 1.1. init函数 go语言中init函数用于包(package)的初始化，该函数是go语言的一个重要特性。 有下面的特征： 1 init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等 ​ 2 每个包可以拥有多个init函数 ​ 3 包的每个源文件也可以拥有多个init函数 ​ 4 同一个包中多个init函数的执行顺序go语言没有明确的定义(说明) ​ 5 不同包的init函数按照包导入的依赖关系决定该初始化...
最全Go语言语法总结_go语法总结，Golang开发零基础教学
最新发布
2401_84910919的博客
05-13 593
定义struct面向对象特性: 封装初始化// structid intage int// 先声明// 再赋值dog.id = 1// 声明并赋值id: 2,age: 1,// new, 返回指针地址pig.id = 3作用域, 首字母大写表示公共的, 包外可调用, 首字母小写表示私有的, 包内可见, 包外无法调用// 结构体属性id intage int// newdog.id = 1// 调用方法。
【Go语言入门教程】Go语言基本语法
热门推荐
qq_41854911的博客
02-08 1万+
文章目录Go语言变量的声明（使用var关键字）标准格式批量格式简短格式Go语言变量的初始化回顾C语言变量初始化的标准格式编译器推导类型的格式短变量声明并初始化Go语言多个变量同时赋值Go语言匿名变量（没有名字的变量）Go语言变量的作用域局部变量全局变量形式参数Go语言整型（整数类型）哪些情况下使用 int 和 uintGo语言浮点类型（小数类型）Go语言复数Go语言输出正弦函数（Sin）图像设置图片背景色绘制正弦函数轨迹写入图片文件Go语言bool类型（布尔类型）Go语言字符串定义字符串字符串拼接符“+”字
Go语言基础语法（快速学习）
weixin_44801254的博客
07-09 718
Go语言知识分享 文章目录Go语言知识分享前言Go语言定义适用范围一、基础语法1.1 变量、常量、nil与零值、方法、包、可见性、指针1.1.1 变量声明1.1.2 常量声明1.1.3 nil与零值1.1.4 方法、包Go中方法的定义多个返回值变长参数包与可见性1.1.5 指针1.2 条件、循环、分支1.2.1 条件1.2.2 循环1.2.3 分支1.3 数组、切片、字典1.3.1 数组1.3.2 切片长度、容量创建切片动态操作切片切片的常用场景1.3.3 字典字典的声明与初始化字典的使用场景二、面向对象编
Go语言入门：基础语法解析
weixin_57849570的博客
07-26 174
什么是 Go 语言？Go语言（也称为Golang）是一种开源的静态类型编程语言，由Google于2007年开始开发，并于2009年首次公开发布。它的设计目标是将程序员的生产力和计算机的性能相结合，以提供高效、可靠和简洁的软件开发体验。Go 语言的优点简洁易学：Go语言的语法简单清晰，具有较少的关键字和语法结构，易于学习和阅读。它强调代码的可读性和简洁性，减少样板代码的编写。并发支持：Go语言原生支持并发编程，它通过轻量级的Go协程（goroutine）和通信顺序进程（CSP）模型来实现。
GoLang笔记—基础语法篇
[爪洼ing]的博客
07-03 2293
我们从计算机系统的角度来讲，变量就是一段或者多段内存，用于存储数据 注意：变量声明以关键字var开头，变量类型后置，行尾无须分号如果你学过C语言，就会体会到这样声明的好处，比如C语言这样声明：int* a, b ，那么只有a是指针，b不是，这样会使人迷惑，如果想要两个变量都为指针，需要这样定义：。 在go语言中，我们使用这样的声明方式：，就可以轻松的将a，b都声明为指针。变量的命名规则遵循驼峰命名法，即首个单词小写，每个新单词的首字母大写，例如： startDate当一个变量被声明之后，系统自动赋予它该类型
Go语言基本语法
wgchen
01-02 1248
Go语言基本语法
Go基础语法
weixin_64255084的博客
03-07 522
Go语言基础语法，适合小白阅读，也是我的学习历程！！！
Go语言基础（一篇上手go语言基本语法）
个人学习笔记库，一篇一篇记录成长的足迹
03-15 1078
一年多Java开发经验转Go，实际学习笔记，3天掌握Go的基本语法，实际心得讲解，值得一看！
go语言基础语法示例
09-21
Go语言的基础语法简洁而强大，适合初学者快速上手。 在Go语言中，`Hello World`程序的编写非常直观。首先，每个Go程序都由一个或多个包组成，`package main`声明了该文件属于主包，这是程序的入口。`import "fmt"`...
Go 语言基础语法
01-03
Go 语言基础语法 上一章节我们已经了解了 Go 语言的基本组成结构，本章节我们将学习 Go 语言的基础语法。 Go 标记 Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。如以下 GO 语句由 6 个...
Go 语言基础语法 .zip
03-06
在 Go 语言中，空格通常用于分隔标识符、关键字、运算符和表达式，以提高代码的可读性。 Go 语言中变量的声明必须使用空格隔开，如： var x int const Pi float64 = 3.14159265358979323846 在运算符和操作数之间要...
go语言基础语法代码整合
03-22
适合于刚学go语言或者对go语言0基础的小伙伴去学习代码。每个语法的代码都是一个单独的go文件，使大家能够更好更清晰的去学习或巩固go语言的基础语法篇。解压导入项目即可运行。
go语言基本语法
pin-csdn的博客
06-22 2370
1、使用go语言变量 2、定义常量 3、方法定义 4、测试数组 5、测试切片 6、测试map 7、测试通道 8、new 使用 9、range使用 10、并发 11、接口 12、错误处理 13、【defer、panic、recover】
返回go语言的基础语法知识
03-31
1. 变量和常量声明 Go语言中，使用var关键字声明变量，常量使用const关键字声明。 ``` var name string = "Tom" var age int = 18 const pi = 3.14 ``` 2. 数据类型 Go语言中，基本数据类型包括整型、浮点型、布尔型、字符串型等。 ``` var num int = 10 var f float64 = 3.14 var flag bool = true var str string = "hello world" ``` 3. 控制语句 Go语言中，支持if、for、switch等控制语句。 ``` if num > 0 { fmt.Println("positive") } else { fmt.Println("negative") } for i := 0; i < 10; i++ { fmt.Println(i) } switch num { case 1: fmt.Println("one") case 2: fmt.Println("two") default: fmt.Println("others") } ``` 4. 函数 Go语言中，使用func关键字定义函数。 ``` func add(a, b int) int { return a + b } result := add(1, 2) fmt.Println(result) ``` 5. 包和导入 Go语言中，使用package关键字定义包，使用import关键字导入包。 ``` package main import "fmt" func main() { fmt.Println("hello world") } ``` 6. 结构体和方法 Go语言中，使用type关键字定义自定义结构体，可以给结构体定义方法。 ``` type Person struct { name string age int } func (p Person) sayHello() { fmt.Println("hello, my name is", p.name) } p1 := Person{name: "Tom", age: 18} p1.sayHello() ``` 7. 指针 Go语言中，使用&符号获取变量的地址，使用*符号获取指针指向的值。 ``` num := 10 ptr := &num fmt.Println(*ptr) ``` 8. 数组和切片 Go语言中，使用[]定义数组和切片，数组长度固定，切片长度可变。 ``` arr := [3]int{1, 2, 3} slice := []int{1, 2, 3} ``` 9. map Go语言中，使用map关键字定义map。 ``` m := make(map[string]int) m["one"] = 1 m["two"] = 2 fmt.Println(m["one"]) ``` 10. 接口 Go语言中，使用interface关键字定义接口，一个类型只要实现了接口中定义的所有方法，就可以被认为是实现了该接口。 ``` type Shape interface { area() float64 } type Rectangle struct { width float64 height float64 } func (r Rectangle) area() float64 { return r.width * r.height } r := Rectangle{width: 10, height: 5} var s Shape = r fmt.Println(s.area()) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_咸蛋.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值