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方法
有疑问加站长微信联系（非本文作者）
