golang 基础语法

1.当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的 public);标识符如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected )。

注意要分清是否跨包

2.

package main
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
 a int
 b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
 g, h := 123, "hello"
 println(x, y, a, b, c, d, e, f, g, h)
}

3.全局变量是允许声明但不使用,局部变量不能重新声明而且声明了必须要使用
4.空白标识符 也被用于抛弃值,如值 5 在:, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量,你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量,但有时你并不需要使用从一个函数得到的所有返回值。

5.常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。常量表达式中,函数必须是内置函数,否则编译不过:

package main
import "unsafe"
const (
 a = "abc"
 b = len(a)
 c = unsafe.Sizeof(a)
)
func main(){
 println(a, b, c)
}

6.iota
iota,特殊常量,可以认为是一个可以被编译器修改的常量。
在每一个const关键字出现时,被重置为0,然后再下一个const出现之前,每出现一次iota,其所代表的数字会自动增加1。

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

7.指针变量与变量地址

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);
 a=5
 fmt.Printf("ptr 为 %d\n", ptr);//825741050416
 fmt.Printf("*ptr 为 %d\n", *ptr);//5
 *ptr=7
 fmt.Println(*ptr,a)//7 7
}

8 . if不强制加括号

package main
import "fmt"
func main() {
 var a int = 100;
 if a < 20 {
 fmt.Printf("a 小于 20\n" );
 } else if a>100{
 fmt.Printf("a > 100\n" );
 }else{
 fmt.Printf("其他" );
 }
}

9.for 循环

package main
import "fmt"
func main() {
 var b int = 15
 var a int
 numbers := [6]int{1, 2, 3, 5}
 /* for 循环 */
 for a := 0; a < 10; a++ {
 fmt.Printf("a 的值为: %d\n", a)
 }
 for a < b {
 a++
 fmt.Printf("a 的值为: %d\n", a)
 }
 //range可以对 slice、map、数组、字符串等进行迭代循环
 for i,x:= range numbers {
 fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
 }
 for{
 fmt.Printf("无限循环")
 }
}

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++ 
 } 
}

10 . 函数

package main
import "fmt"
func swap(x int, y string) (string, int) {
 return y, x
}
func swap1(x , y string) (string, string) {
 return y, x
}
func swap2(y string) string {
 return y
}
func main() {
 a, b := swap(1, "Kumar")
 fmt.Println(a, b)
}

11.闭包

package main
import "fmt"
func getSequence() func() int {
 i:=0
 return func() int {
 i+=1
 return i 
 }
}
func main(){
 /* nextNumber 为一个函数,函数 i 为 0 */
 nextNumber := getSequence() 
 /* 调用 nextNumber 函数,i 变量自增 1 并返回 */
 fmt.Println(nextNumber())
 fmt.Println(nextNumber())
 fmt.Println(nextNumber())
 /* 创建新的函数 nextNumber1,并查看结果 */
 nextNumber1 := getSequence() 
 fmt.Println(nextNumber1())
 fmt.Println(nextNumber1())
}

12.函数方法,是否可以理解成java对象内部方法

package main
import (
 "fmt" 
)
/* 定义函数 */
type Circle struct {
 radius float64
}
func main() {
 var c1 Circle
 c1.radius = 10.00
 fmt.Println("Area of Circle(c1) = ", c1.getArea())
}
//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
 //c.radius 即为 Circle 类型对象中的属性
 return 3.14 * c.radius * c.radius
}

13.全局变量,同一个包内不能重名,不然编译报错
pointer类型变量默认值为nil
14.数组

package main
import "fmt"
func main() {
 var n [10]int /* n 是一个长度为 10 的数组 */
 var i,j int
 /* 为数组 n 初始化元素 */ 
 for i = 0; i < 10; i++ {
 n[i] = i + 100 /* 设置元素为 i + 100 */
 }
 /* 输出每个数组元素的值 */
 for j = 0; j < 10; j++ {
 fmt.Printf("Element[%d] = %d\n", j, n[j] )
 }
}

15.再次强调指针

package main
import "fmt"
func main() {
 /* 定义局部变量 */
 var a int = 100
 var b int= 200
 fmt.Printf("交换前 a 的值 : %d\n", a )
 fmt.Printf("交换前 b 的值 : %d\n", b )
 /* 调用函数用于交换值
 * &a 指向 a 变量的地址
 * &b 指向 b 变量的地址
 */
 swap(&a, &b);
 fmt.Printf("交换后 a 的值 : %d\n", a )
 fmt.Printf("交换后 b 的值 : %d\n", b )
}
func swap(x *int, y *int) {
 var temp int
 temp = *x /* 保存 x 地址的值 */
 *x = *y /* 将 y 赋值给 x */
 *y = temp /* 将 temp 赋值给 y */
}

x = y只是值交换,为啥?因为它们指向的地址是a/b,不同的地址

"在Java里面参数传递都是按值传递"这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递
不同于java如果想达到引用传递的效果,go要加上指针符号*才可以
16.结构体

package main
import "fmt"
type Books struct {
 title string
 author string
 subject string
 book_id int
}
func main() {
 var Book1 Books /* Declare Book1 of type Book */
 var Book2 Books /* Declare Book2 of type Book */
 /* book 1 描述 */
 Book1.title = "Go 语言"
 Book1.author = "www.runoob.com"
 Book1.subject = "Go 语言教程"
 Book1.book_id = 6495407
 /* book 2 描述 */
 Book2.title = "Python 教程"
 Book2.author = "www.runoob.com"
 Book2.subject = "Python 语言教程"
 Book2.book_id = 6495700
 /* 打印 Book1 信息 */
 printBook(&Book1)
 /* 打印 Book2 信息 */
 printBook(&Book2)
}
func printBook( book *Books ) {
 fmt.Printf( "Book title : %s\n", book.title);
 fmt.Printf( "Book author : %s\n", book.author);
 fmt.Printf( "Book subject : %s\n", book.subject);
 fmt.Printf( "Book book_id : %d\n", book.book_id);
}

17 切片
像java的list

package main
import "fmt"
func main() {
 var numbers = make([]int,3,5)
 printSlice(numbers)
 s :=[] int {1,2,3 }
 printSlice(s)
 var numbers1 []int
 printSlice(numbers1)
 if(numbers1== nil){
 fmt.Println("切片是空的")
 }
 /* 打印子切片从索引1(包含) 到索引3(不包含)*/
 fmt.Println("s[1:3] ==", s[1:3])
 /* 默认下限为 0*/
 fmt.Println("s[:3] ==", s[:3])
 /* 默认上限为 len(s)*/
 fmt.Println("s[2:] ==", s[2:])
 numbers=append(numbers, 0,1,2,3,4,5,6)
 fmt.Println(numbers,cap(numbers))
 /* 创建切片 numbersc 是之前切片的两倍容量*/
 numbersc := make([]int, len(numbers), (cap(numbers))*2)
 /* 拷贝 numbers 的内容到 numbersc */
 copy(numbersc,numbers)
 fmt.Println(numbersc)
}
func printSlice(x []int){
 fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)//len=3 cap=5 slice=[0 0 0]
}

18 map

package main
import "fmt"
func main() {
 var countryCapitalMap map[string]int
 /* 创建集合 */
 countryCapitalMap = make(map[string]int)
 /* map 插入 key-value 对,各个国家对应的首都 */
 countryCapitalMap["France"] = 1
 countryCapitalMap["Italy"] = 2
 countryCapitalMap["Japan"] = 3
 countryCapitalMap["India"] = 4
 delete(countryCapitalMap,"India");
 /* 使用 key 输出 map 值 */
 for country := range countryCapitalMap {
 fmt.Println("Capital of",country,"is",countryCapitalMap[country])
 }
 /* 查看元素在集合中是否存在 */
 captial, ok := countryCapitalMap["United States"]
 /* 如果 ok 是 true, 则存在,否则不存在 */
 if(ok){
 fmt.Println("Capital of United States is", captial)
 }else {
 fmt.Println("Capital of United States is not present")
 }
}

19 接口

package main
import (
 "fmt"
)
type Phone interface {
 call()
}
type NokiaPhone struct {
}
func (nokiaPhone NokiaPhone) call() {
 fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct {
}
func (iPhone IPhone) call() {
 fmt.Println("I am iPhone, I can call you!")
}
func main() {
 var phone Phone
 phone = new(NokiaPhone)
 phone.call()
 phone = new(IPhone)
 phone.call()
}

20 异常

package main
import (
 "fmt"
 "errors"
)
func main() {
 var err error = errors.New("this is a new error")
 //由于已经实现了error接口的方法 因此可以直接调用对应的方法
 fmt.Println(err.Error())
}

21 包内其他文件的变量和方法随便用,跨包则要通过"packageName."方式引用了
22 工程文件下要有main包,且main包下文件不能包含重复main方法

本文来自:简书

感谢作者:球球之家

查看原文:golang 基础语法

• 编辑
• 预览