来源：京东技术

导读

本篇文章适用于学习过其他面向对象语言(Java、Php)，但没有学过Go语言的初学者。文章主要从Go与Java功能上的对比来阐述Go语言的基础语法、面向对象编程、并发与错误四个方面，能够让读者快速认识Go的相关语法与特性。

//学习一个语言应该从Hello World开始！package main
import "fmt"
func main() {  fmt.Println("Hello World!")// Hello World!    fmt.Println(add(3, 5)) //8    var sum = add(3, 5)}
func add(a int, b int) int{    return a+b;}

//返回值只定义了类型 没有定义返回参数func add(a, b int) (int, error) {    if a < 0 || b < 0 {        err := errors.New("只支持非负整数相加")        return 0, err    }    a *= 2    b *= 3    return a + b, nil}
//返回值还定义了参数 这样可以直接return 并且定义的参数可以直接使用 return时只会返回这两个参数func add1(a, b int) (z int, err error) {    if a < 0 || b < 0 {        err := errors.New("只支持非负整数相加")        return   //实际返回0 err 因为z只定义没有赋值 则nil值为0    }    a *= 2    b *= 3    z = a + b    return //返回 z err}
func main()  {    x, y := -1, 2    z, err := add(x, y)    if err != nil {        fmt.Println(err.Error())        return    }    fmt.Printf("add(%d, %d) = %d\n", x, y, z)}

func myfunc(numbers ...int) {    for _, number := range numbers {        fmt.Println(number)    }}
slice := []int{1, 2, 3, 4, 5}//使用...将slice打碎传入myfunc(slice...)

//定义了此文件属于 main 包package main
//通过import导入标注库中包import "fmt"
func main() {  fmt.Println("Hello World!")// Hello World!    fmt.Println(add(3, 5)) //8    var sum = add(3, 5)}
func add(a int, b int) int{    return a+b;}

func main() {    i := 0    //使用&来传入地址    fmt.Println(&i) //0xc00000c054
    var a, b int = 3 ,4    //传入 0xc00000a089 0xc00000a090    fmt.Println(add(&a, &b)) }
//使用*来声明一个指针类型的参数与使用指针func add(a *int, b *int)int{    //接收到 0xc00000a089 0xc00000a090    //前往 0xc00000a089位置查找具体数据 并取赋给x    x := *a    //前往 0xc00000a090位置查找具体数据 并取赋给y    y := *b  return x+y}

// ifif condition {     // do something }
// if...else...if condition {     // do something } else {    // do something }
// if...else if...else...if condition1 {     // do something } else if condition2 {    // do something else } else {    // catch-all or default }

sum := 0 
//普通for循环for i := 1; i <= 100; i++ {     sum += i }
//无限循环for{    sum++    if sum = 100{        break;    }}
//带条件的循环for res := sum+1; sum < 15{    sum++    res++}
//使用kv循环一个map或一个数组  k为索引或键值 v为值 k、v不需要时可以用_带替for k, v := range a {    fmt.Println(k, v)}

score := 100switch score {case 90, 100:    fmt.Println("Grade: A")case 80:    fmt.Println("Grade: B")case 70:    fmt.Println("Grade: C")case 65:    fmt.Println("Grade: D")default:    fmt.Println("Grade: F")}

//声明var nums [3]int //声明并初始化var nums = [3]int{1,2,3} <==> nums:=[3]int{1,2,3}
//使用for sum := 0, i := 0;i<10{  sum += nums[i]  i++}//修改值num[0] = -1

//声明一个数组var nums =[3]int{1, 2, 3}//0.直接声明var slice =[]int{0, 1, 2}
//1.从数组中引用切片 其中a:b是指包括a但不包括bvar slice1 = nums[0:2] //{1,2}//如果不写的则默认为0（左边）或最大值（右边）var slice2 = slice1[:2] <==> var slice2 = slice1[0:] <==>var slice2 = slice1[:]
//2.使用make创建Slice 其中int为切片类型，4为其长度，5为容量slice3 := make([]int, 5)slice4 := make([]int, 4, 5)

//使用append向切片中动态的添加元素func append(s []T, vs ...T) []T
slice5 := make([]int, 4, 5) //{0, 0, 0, 0}slice5 = append(slice5, 1) //{0,0,0,0,1}
//删除第一个0sliece5 = slice5[1:]

//声明切片var userIds = []int{}//模拟获取所有用户IDfor i := 0; i< 100{    userIds = append(userIdS, i);    i++;}//对用户信息进行处理for k,v := range userIds{    userIds[k] = v++}

//string为键类型，int为值类型maps := map[string]int{  "java" : 1,  "go" : 2,  "python" : 3,}
//还可以通过make来创建字典 100为其初始容量 超出可扩容maps = make(map[string]int, 100)

//直接使用fmt.Println(maps["java"]) //1
//赋值maps["go"] = 4
//取值 同时判断map中是否存在该键 ok为bool型value, ok := maps["one"] if ok { // 找到了  // 处理找到的value }
//删除delete(testMap, "four")

type Student struct {    id int    name string    male bool    score float64}//定义了一个学生类，属性有id name等，每个属性的类型都在其后面
//定义学生类的构造方法func NewStudent(id uint, name string, male bool, score float64) *Student {    return &Student{id, name, male, score}}
//实例化一个类对象student := NewStudent(1, "学院君", 100)fmt.Println(student)

//在方法名前，添加对应的类，即可认为改方法为该类的成员方法。func (s Student) GetName() string  {    return s.name}
//注意这里的Student是带了*的 这是因为在方法传值过程中 存在着值传递与引用传递 即指针的概念 当使用值传递时 编译器会为该参数创建一个副本传入 因此如果对副本进行修改其实是不生效的 因为在执行完此方法后该副本会被销毁 所以此处应该是用*Student 将要修改的对象指针传入 修改值才能起作用func (s *Student) SetName(name string) {    //这里其实是应该使用(*s).name = name，因为对于一个地址来说 其属性是没意义的 不过这样使用也是可以的 因为编译器会帮我们自动转换    s.name = name}

// 声明一个'iTemplate'接口interface iTemplate{    public function setVariable($name, $var);    public function getHtml($template);}

// 实现接口// 下面的写法是正确的class Template implements iTemplate{    private $vars = array();
    public function setVariable($name, $var){        $this->vars[$name] = $var;    }
    public function getHtml($template){        foreach($this->vars as $name => $value) {            $template = str_replace('{' . $name . '}', $value, $template);        }
        return $template;    }}

SessionHandlerInterface {    /* 方法 */    abstract public close ( void ) : bool    abstract public destroy ( string $session_id ) : bool    abstract public gc ( int $maxlifetime ) : int    abstract public open ( string $save_path , string $session_name ) : bool    abstract public read ( string $session_id ) : string    abstract public write ( string $session_id , string $session_data ) : bool}

type File struct {     // ...}
func (f *File) Read(buf []byte) (n int, err error) func (f *File) Write(buf []byte) (n int, err error) func (f *File) Seek(off int64, whence int) (pos int64, err error) func (f *File) Close() error

type IFile interface {     Read(buf []byte) (n int, err error)     Write(buf []byte) (n int, err error)     Seek(off int64, whence int) (pos int64, err error)     Close() error }
type IReader interface {     Read(buf []byte) (n int, err error) }
type IWriter interface {     Write(buf []byte) (n int, err error) }
type ICloser interface {     Close() error }

func say(s string) {  fmt.Println(s)}
func main() {    //通过 go 关键字新开一个协程  go say("world")  say("hello")}

//给类SafeCounter添加锁type SafeCounter struct {  v   map[string]int  mux sync.Mutex}
// Inc 增加给定 key 的计数器的值。func (c *SafeCounter) Inc(key string) {    //给该对象上锁  c.mux.Lock()  // Lock 之后同一时刻只有一个 goroutine 能访问 c.v  c.v[key]++    //解锁  c.mux.Unlock()}

ch <- v    // 将 v 发送至信道 ch。v := <-ch  // 从 ch 接收值并赋予 v。

package main
import "fmt"
func sum(s []int, c chan int) {  sum := 0  for _, v := range s {    sum += v  }  c <- sum // 将和送入 c}
//对于main方法来说 相当于就是开启了一个协程func main() {  s := []int{7, 2, 8, -9, 4, 0}
  c := make(chan int)    //通过go关键字开启两个协程 将chaneel当做参数传入  go sum(s[:len(s)/2], c)  go sum(s[len(s)/2:], c)    //通过箭头方向获取或传入信息  x, y := <-c, <-c // 从 c 中接收
  fmt.Println(x, y, x+y)}

type error interface {     Error() string }

func Foo(param int) (n int, err error) {     // ...}

n, err := Foo(0)
if err != nil {     // 错误处理 } else{    // 使用返回值 n }

func ReadFile(filename string) ([]byte, error) {    f, err := os.Open(filename)    if err != nil {        return nil, err    }    //无论结果如何 都要关闭文件流    defer f.Close()
    var n int64 = bytes.MinRead
    if fi, err := f.Stat(); err == nil {        if size := fi.Size() + bytes.MinRead; size > n {            n = size        }    }    return readAll(f, n)}

package main
import (    "fmt")
func divide() {    //通过defer，确保该方法只要执行完毕都要执行该匿名方法    defer func() {        //进行异常捕获        if err := recover(); err != nil {            fmt.Printf("Runtime panic caught: %v\n", err)        }    }()
    var i = 1    var j = 0    k := i / j    fmt.Printf("%d / %d = %d\n", i, j, k)}
func main() {    divide()    fmt.Println("divide 方法调用完毕，回到 main 函数")}