GO语言特点

最新推荐文章于 2024-09-19 01:23:20 发布
最新推荐文章于 2024-09-19 01:23:20 发布
阅读量4.3k 收藏 1
点赞数
分类专栏： GOLANG
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/win_lin/article/details/18236737
版权

抽时间看看Google的GO语言到底有什么特点。Go说得是不错，自从C依赖，N年没有一个经典的编程语言了，计算机发展了几十年，语言还是C的那一套，是该有所作为了，做起来真的不容易啊。看看GO到底有哪些地方做的很好。

编译打包

python很好，只是依赖于python环境，譬如CentOS5.5上是Python2.5，还没有json。。。

如果在CentOS6上开发的.py，直接放到CentOS5.5，有可能是跑不起来的，这个对于商业化部署还是很头疼的。

一种方式是把Python2.6虚拟机编译出来，还可以用cxfreeze和pyinstaller打包成一个binary，不再依赖于python环境。

一般都是选择后一种了，一般编译出来的文件几兆左右，和用c/c++编译出来的程序没有什么区别。

额，来看看GO，GO其实不是解释性的语言，而是静态语言。所以是可以编译的：

// hello.go

package main

import "fmt"

func main() {
    fmt.Printf("hello, world!\n")
}

编译一下： 

[winlin@dev6 go-rtmp]$ go build hello.go 
[winlin@dev6 go-rtmp]$ ls -lh
-rwxrwxr-x 1 winlin winlin 2.2M Jan 13 22:31 hello

查看依赖，只依赖于libc： 

[winlin@dev6 bin]$ ldd gotour 
	linux-vdso.so.1 =>  (0x00007fff263ff000)
	libpthread.so.0 => /lib64/libpthread.so.0 (0x0000003856600000)
	libc.so.6 => /lib64/libc.so.6 (0x0000003855a00000)
	/lib64/ld-linux-x86-64.so.2 (0x0000003855200000)

关于GOPATH，其实类似于python的site-packages，譬如： 

go get code.google.com/p/go-tour/gotour

这条命令会在$GOPATH下载go-tour以及依赖的包，然后编译出gotour执行文件，直接$GOPATH/bin/gotour执行就可以。

go get相当于执行下面的命令：

这个命令会执行：
            mkdir -p $GOPATH/src && cd $GOPATH/src
            mkdir -p code.google.com/p && cd code.google.com/p
            hg clone https://code.google.com/p/go-tour
然后下载依赖的项目：
          cd $GOPATH/src/code.google.com/p
          hg clone https://code.google.com/p/go.tools
          hg clone https://code.google.com/p/go.net
然后开始编译：
          mkdir -p $GOPATH/bin && cd $GOPATH/bin 
          go build code.google.com/p/go-tour/gotour
其实go get最后一步调用的不是build，而是install：
          mkdir -p $GOPATH/bin && cd $GOPATH/bin 
          go install code.google.com/p/go-tour/gotour
install就会生成pkg。GOPATH就是用来指定这个dir的，可以在任何目录调用go install，会生成到GOPATH这个目录。

go install安装某个package时，要求package的目录结构有规则，可以查看go help gopath。

一般而言，可以用两个GOPATH，一个用来装哪些个依赖包，一个是自己的包。参考：https://code.google.com/p/go-wiki/wiki/GOPATH#Repository_Integration_and_Creating_

譬如，在/etc/profile中设置如下：

     # for google go.
      export GOROOT=/usr/local/go
      export GOPATH=/home/winlin/git/google-go:/home/winlin/git/go-rtmp
      export PATH=$PATH:$GOROOT/bin

执行：go get code.google.com/p/go-tour/gotour

会生成如下项目：

[winlin@centos6x86 ~]$ ls /home/winlin/git/google-go/src/code.google.com/p/
go.net  go.tools  go-tour

外部依赖库就安装到了第一个GOPATH所在的目录了。

在自己的目录下建立package，譬如：mkdir -p /home/winlin/git/go-rtmp/src/hello

然后：vim /home/winlin/git/go-rtmp/src/hello/hello.go

输入以下内容：

package main

import "fmt"
import "math"

func main() {
    fmt.Println(math.Pi)
}

在任意位置都都可以编译这个package： 

[winlin@centos6x86 ~]$ go build hello
[winlin@centos6x86 ~]$ pwd
/home/winlin
[winlin@centos6x86 ~]$ ls -lh hello 
-rwxrwxr-x. 1 winlin winlin 1.8M Jan 14 21:50 hello
[winlin@centos6x86 ~]$ ./hello 
3.141592653589793

实际上如果编译一个错误的package，会显示go查找的目录位置： 

 
[winlin@centos6x86 ~]$ go build hells
can't load package: package hells: cannot find package "hells" in any of:
	/usr/local/go/src/pkg/hells (from $GOROOT)
	/home/winlin/git/google-go/src/hells (from $GOPATH)
	/home/winlin/git/go-rtmp/src/hells

可见是先去GOROOT找，然后去所有的GOPATH找。

总之，GO在编译打包上没有问题。

Package依赖关系

GO的核心目标是大规模编程，所以在处理依赖方面必须要很强悍。即用户不需要处理任何编译的依赖关系，go自动处理，只需要遵守语言的package规范即可。
这一点还是真的很赞，要知道编译一个ffmpeg真的不容易，依赖巨多，版本居多，编译错误后可能得找出错的那个库的依赖，以此类推，确实是一件不容易的事情。
GO如何处理这个问题？看看如何编译SRS，分别是c++的和GO的两个版本。

参考：http://dev:6060/doc/code.html

C++版本，参考：https://github.com/winlinvip/simple-rtmp-server

git clone https://github.com/winlinvip/simple-rtmp-server 
cd simple-rtmp-server/trunk
./configure --with-ssl --with-hls --with-ffmpeg --with-http
make

其实还好？其实不然，如果在CentOS6下面编译，基本上没有问题，如果换个环境呢？肯定编译失败。原因是configrure做了很多事情，需要安装gcc/g++/make等工具，需要编译nginx/ffmpeg，编译nginx需要安装pcre，安装ffmpeg时需要libaacplus/liblame/libx264，以此类推，真的是不容易的一个脚本。

具体的依赖项目，得用一个wiki才能搞定：https://github.com/winlinvip/simple-rtmp-server/wiki/Build

GO版本，参考：https://github.com/winlinvip/go.srs

export GOPATH=~/mygo
go get github.com/winlinvip/go.srs/go_srs

这样就可以？是的，这样就可以了。

C++的srs编译在：./objs/srs
GO的srs编译在：$GOPATH/bin/go_srs

其实go做了很多事情，因为go.srs依赖的其他package都是按照go的规范写的，所以go get命令可以自动下载需要的依赖包，并且进行编译。
查看GOPATH就知道它做的事情：

[winlin@centos6x86 ~]$ tree $GOPATH
/home/winlin/mygo
├── bin
│   └── go_srs
├── pkg
│   └── linux_386
│       └── github.com
│           └── winlinvip
│               └── go.rtmp
│                   └── rtmp.a
└── src
    └── github.com
        └── winlinvip
            ├── go.rtmp
            │   ├── LICENSE
            │   ├── README.md
            │   └── rtmp
            │       └── version.go
            └── go.srs
                ├── go_srs
                │   └── srs.go
                ├── LICENSE
                ├── README.md
                └── research
                    └── demo-func
                        └── func_declare.go

除了go.srs，连go.srs依赖的go.rtmp也自动下载下来并且编译了。
go get等价于下载和安装： 

go get -d github.com/winlinvip/go.srs/go_srs
go install github.com/winlinvip/go.srs/go_srs

代价就是package会比较长，好处是一个命令，搞定所有的事情，这个很赞～


并发和并行计算

无疑go的设计目标就是大规模程序，并发和并行计算是很重要也是很大的一个特点。用时髦的词，go为云计算而生。从领域角度讲，go是为写服务器/服务而设计的。

不管用什么词语，云/服务都有一个重要的特点：系统为多人同时提供服务，也就是并发和并行计算。并发只同时支持多人的能力，并行计算指利用多CPU和多机器的计算系统。单进程也可以支持并发，利用linux的epoll和非阻塞异步socket就可以做到，nginx就是典型。只是服务器基本上都是多CPU，所以支持多进程也会有很大的优势，nginx也是典型。

多进程编程可以参考：http://blog.csdn.net/win_lin/article/details/7755773

异步非阻塞能带来最高性能，麻烦的地方就是状态机很复杂；因此对于复杂的状态机，譬如RTMP协议，状态变换巨多，用协程（协程/轻量级线程/用户态线程）等技术就能在异步的基础上使用同步，参考：http://blog.csdn.net/win_lin/article/details/8242653

C/C++并未提供语言级别的协程支持，而是有一些库提供支持（python提供了yield关键字，但支持的不是很完善，有eventlet库支持）；go重要的特点就是在语言级别提供支持。

C/C++的库一般只提供了协程的支持，对多进程的支持有限；go同时支持协程和多进程，go的运行时本身是多线程的。

在EffectiveGo中解释得很详细：http://dev:6060/doc/effective_go.html#concurrency

下面开启了两个协程goroutine，不断进行累加运算：

package main

import (
	"fmt"
	"time"
)

func main() {
	var fun = func (id int) {
		count := 0
		for {
			if (count % 1500000000) == 0 {
				fmt.Printf("[%v] id=%v, count=%v\n", time.Now().Format("2006-1-06 15:04:05"), id, count)
			}
			count++
		}
	}
	go fun(101)
	go fun(102)
	time.Sleep(300 * time.Second)
}

计算结果如下： 

C:/Go/bin/go.exe run R:/mygo/go.srs/research/demo/tour/go_concurrency.go
[2014-2-14 11:08:02] id=101, count=0
[2014-2-14 11:08:02] id=102, count=0
[2014-2-14 11:08:07] id=101, count=1500000000
[2014-2-14 11:08:09] id=102, count=1500000000
[2014-2-14 11:08:11] id=101, count=3000000000
[2014-2-14 11:08:14] id=102, count=3000000000
[2014-2-14 11:08:16] id=101, count=4500000000
[2014-2-14 11:08:19] id=102, count=4500000000
[2014-2-14 11:08:21] id=101, count=6000000000
[2014-2-14 11:08:23] id=102, count=6000000000
[2014-2-14 11:08:26] id=101, count=7500000000
[2014-2-14 11:08:28] id=102, count=7500000000
[2014-2-14 11:08:30] id=101, count=9000000000
[2014-2-14 11:08:33] id=102, count=9000000000
[2014-2-14 11:08:35] id=101, count=10500000000

可见这两个goroutine是交替执行的，go的运行时会调度它们。查看CPU，4CPU用到了25%也就是1CPU。

只需要设置一句，就可以利用多CPU多进程并行计算：

runtime.GOMAXPROCS(2)

将使用两个CPU计算，代码如下： 

package main

import (
	"fmt"
	"time"
	"runtime"
)

func main() {
	var fun = func (id int) {
		count := 0
		for {
			if (count % 1500000000) == 0 {
				fmt.Printf("[%v] id=%v, count=%v\n", time.Now().Format("2006-1-06 15:04:05"), id, count)
			}
			count++
		}
	}

	if runtime.NumCPU() > 1 {
		runtime.GOMAXPROCS(2)
	}

	go fun(101)
	go fun(102)
	time.Sleep(300 * time.Second)
}

运算结果如下： 

C:/Go/bin/go.exe run R:/mygo/go.srs/research/demo/tour/go_parallelization.go
[2014-2-14 11:12:22] id=101, count=0
[2014-2-14 11:12:22] id=102, count=0
[2014-2-14 11:12:25] id=102, count=1500000000
[2014-2-14 11:12:25] id=101, count=1500000000
[2014-2-14 11:12:28] id=102, count=3000000000
[2014-2-14 11:12:28] id=101, count=3000000000
[2014-2-14 11:12:31] id=102, count=4500000000
[2014-2-14 11:12:31] id=101, count=4500000000
[2014-2-14 11:12:34] id=102, count=6000000000
[2014-2-14 11:12:34] id=101, count=6000000000
[2014-2-14 11:12:38] id=102, count=7500000000
[2014-2-14 11:12:38] id=101, count=7500000000
[2014-2-14 11:12:41] id=102, count=9000000000
[2014-2-14 11:12:41] id=101, count=9000000000
[2014-2-14 11:12:44] id=102, count=10500000000
[2014-2-14 11:12:44] id=101, count=10500000000

这两个协程是并行运算的，4CP占用50%即2CPU在工作。

若使用C/C++呢？需要使用库，譬如state-threads，然后多进程需要fork，若需要通信的话，还需要用进程间通信技术，着实很麻烦。

go呢？一个go关键字，即可支持协程和多进程，通信用channel即可。简单～

Reflect反射

反射是元编程概念，参考"The Laws of Reflection"：http://dev:6060/blog/laws-of-reflection

简单来讲，reflect的基本类型是Type和Value，即变量的类型信息和值信息。

Type.Elem是获取元素类型，譬如Type为**MyClass，Type.Elem是*MyClass，Type.Elem().Elem()是MyClass。或者说，就是类似于C/C++中*的作用，取指针的值。

Value.Elem和Type.Elem是对应的，是对值进行操作。

Value.CanSet和Value.Set是对变量进行设置操作，和C/C++一样，只有指针才能被设置。

package main

import (
	"fmt"
	"reflect"
)

type BlackWinlin struct {
	id int
}
type RedWinlin struct {
	name string
}

func main() {
	bw := BlackWinlin{id:10}

	var rtmp_pkt *RedWinlin = nil
	fmt.Println("rtmp==========================")

	rtmp_pkt = nil
	if my_rtmp_expect(&bw, &rtmp_pkt) {
		fmt.Println("discoveryed pkt from black:", rtmp_pkt)
	}

	fmt.Println()
	rtmp_pkt = nil
	if my_rtmp_expect(&RedWinlin{}, &rtmp_pkt) {
		fmt.Println("discoveryed pkt from red:", rtmp_pkt)
	}

	fmt.Println()
	fmt.Println("rtmp==========================")
	var src_black_pkt *BlackWinlin = &bw
	var src_red_pkt *RedWinlin = &RedWinlin{name: "hello"}

	rtmp_pkt = nil
	if my_rtmp_expect(&src_black_pkt, &rtmp_pkt) {
		fmt.Println("discoveryed pkt from black:", rtmp_pkt)
	}

	fmt.Println()
	rtmp_pkt = nil
	if my_rtmp_expect(&src_red_pkt, &rtmp_pkt) {
		fmt.Println("discoveryed pkt from red:", rtmp_pkt)
	}

	fmt.Println()
	fmt.Println("rtmp==========================")
	// set the value which is ptr to ptr
	var prtmp_pkt **RedWinlin = nil
	if my_rtmp_expect(&src_red_pkt, prtmp_pkt) {
		fmt.Println("discoveryed pkt from red(ptr):", prtmp_pkt)
		fmt.Println("discoveryed pkt from red(value):", *prtmp_pkt)
	}
	prtmp_pkt = &rtmp_pkt
	if my_rtmp_expect(&src_red_pkt, prtmp_pkt) {
		fmt.Println("discoveryed pkt from red(ptr):", prtmp_pkt)
		fmt.Println("discoveryed pkt from red(value):", *prtmp_pkt)
	}
}

func my_rtmp_expect(pkt interface {}, v interface {}) (ok bool){
	/*
    func my_rtmp_expect(pkt interface {}, v interface {}){
        rt := reflect.TypeOf(v)
        rv := reflect.ValueOf(v)
        
        // check the convertible and convert to the value or ptr value.
        // for example, the v like the c++ code: Msg**v
        pkt_rt := reflect.TypeOf(pkt)
        if pkt_rt.ConvertibleTo(rt){
            // directly match, the pkt is like c++: Msg**pkt
            // set the v by: *v = *pkt
            rv.Elem().Set(reflect.ValueOf(pkt).Elem())
            return
        }

        if pkt_rt.ConvertibleTo(rt.Elem()) {
            // ptr match, the pkt is like c++: Msg*pkt
            // set the v by: *v = pkt
            rv.Elem().Set(reflect.ValueOf(pkt))
            return
        }
    }
	 */
	ok = false

	pkt_rt := reflect.TypeOf(pkt)
	pkt_rv := reflect.ValueOf(pkt)
	pkt_ptr_rt := reflect.PtrTo(pkt_rt)
	rt := reflect.TypeOf(v)
	rv := reflect.ValueOf(v)

	if rv.Kind() != reflect.Ptr || rv.IsNil() {
		fmt.Println("expect must be ptr and not nil")
		return
	}

	fmt.Println("type info, src:", pkt_rt, "ptr(src):", pkt_ptr_rt, ", expect:", rt)
	fmt.Println("value info, src:", pkt_rv, ", src.Elem():", pkt_rv.Elem(), ", expect:", rv, ", expect.Elem():", rv.Elem())
	fmt.Println("convertible src=>expect:", pkt_rt.ConvertibleTo(rt))
	fmt.Println("ptr convertible ptr(src)=>expect:", pkt_ptr_rt.ConvertibleTo(rt))
	fmt.Println("elem convertible src=>expect.Elem()", pkt_rt.ConvertibleTo(rt.Elem()))
	fmt.Println("settable src:", pkt_rv.CanSet(), ", expect:", rv.CanSet())
	fmt.Println("elem settable src:", pkt_rv.Elem().CanSet(), ", expect:", rv.Elem().CanSet())

	// check the convertible and convert to the value or ptr value.
	// for example, the v like the c++ code: Msg**v
	if rv.Elem().CanSet() {
		if pkt_rt.ConvertibleTo(rt){
			// directly match, the pkt is like c++: Msg**pkt
			// set the v by: *v = *pkt
			fmt.Println("directly match, src=>expect")
			rv.Elem().Set(pkt_rv.Elem())
			ok = true
			return
		}

		if pkt_rt.ConvertibleTo(rt.Elem()) {
			// ptr match, the pkt is like c++: Msg*pkt
			// set the v by: *v = pkt
			fmt.Println("pointer match, src=>*expect")
			rv.Elem().Set(pkt_rv)
			ok = true
			return
		}
		fmt.Println("not match, donot set expect")
	} else {
		fmt.Println("expect cannot set")
	}

	return
}

GO语言的问题

GO语言RTMP服务器：https://github.com/winlinvip/go.srs

C++语言RTMP服务器：https://github.com/winlinvip/simple-rtmp-server

GO只有C++性能的1/30，在50个连接时，GO占用CPU50%，C++只占用2%。当然，应该是代码写的有问题。至少目前还没有办法转向GO。

winlinvip
关注
专栏目录
GO语言开山篇（三）：Go语言特点
weixin_40713980的博客
09-06 444
Go语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率，使用一个表达式来形容Go语言:Go=C+Pvthon，说明Go语言既有c静态语言程序的运行速度，又能达到Python动态语言的快速开发。
Go语言最主要的特性
zengchen73的专栏
07-14 322
自动垃圾回收更丰富的内置类型函数多返回值错误处理匿名函数和闭包类型和接口并发编程反射语言交互性更丰富的内置类型数组，字符串，字典（Map），数组切片（Slice）因为是语言内置特性,开发者根本不用费事去添加依赖的包,既可以少一些输入工作量,也 可以让代码看起来尽量简洁。函数多返回值目前的主流语言中除Python外基本都不支持函数的多返回值功能 Go语言革命性地在静态开发语言阵营中率先提供了多返回值...
Go的语言特性总结
挑灯看剑的专栏
05-01 4407
写在前面： 近来关于对Golang的讨论有很多，七牛的几个大牛们也断定Go语言在未来将会快速发展，并且很可能会取代Java成为互联网时代最受欢迎的编程语言。Go语言是google推出的编程语言，在已经成功的给世人创造了改变人们生活的操作系统之后，google似乎感觉有必要再为世人带来一款强大的编程语言，而Go语言依靠自己众多友好的特性也不负众望正在被开发者接触，我有幸在学习高性能并发编程的时候认识
Golang在Web应用程序开发中的优势和适用性_为什么用go来开发web
最新发布
2401_87197981的博客
09-19 386
Golang（又称为Go）是一种开源的编程语言，由谷歌开发。它专注于简洁、高效和可靠的Web应用程序开发。这篇文章将深入探讨Golang在Web应用程序开发中的优势和适用性，并分析为什么越来越多的开发者选择使用Golang来构建他们的Web应用程序。
go语言特性
MyCode学习笔记
10-17 1432
作者：Rio 链接：http://www.zhihu.com/question/21409296/answer/18145585 来源：知乎 著作权归作者所有，转载请联系作者获得授权。 说说对 Go 的优点的体会吧（从python的对比角度）： 部署简单。Go 编译生成的是一个静态可执行文件，除了 glibc 外没有其他外部依赖。这让部署变得异常方便：目标机器上只需要一个基础的系
Go语言特点
键盘敲烂，工资过万，多多实践，丰富经验
03-25 136
Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。
Go语言实战.pdf_go语言_Go_go_Go语言实战_
10-03
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的编程语言。自2009年发布以来，Go语言因其简洁、高效的语法和强大的并发处理能力，逐渐在云计算、微服务、容器等领域获得了广泛...
go语言中文教程及手册.pdf
05-06
Go语言，也称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。Go语言的设计目标是提高程序员的工作效率，它具有高表达力、简洁、清晰和高效的特性。Go语言的一个显著特点...
GO 语言学习辅导共220页.pdf
04-13
Go语言，又称为Golang，是由Google开发的一种静态类型的、编译型的、并发型且垃圾回收的编程语言。它设计简洁、效率高，特别适合于编写服务器端和网络应用。Go语言的语法接近C语言，但同时也引入了诸如goroutine（轻...
学习 Go 语言(Golang)
01-26
Go 语言的主要特点包括： 1. **简洁的语法**：Go 语言的语法设计清晰，易于理解和学习。它的关键字数量较少，没有像 C++ 或 Java 那样的复杂的继承和模板机制，使得代码更易于阅读和维护。 2. **并发原语**：Go ...
学习 Go 语言(Golang)_go语言_Go_
09-29
本文将深入探讨 Go 语言的关键特性、语法特点以及如何开始学习 Go 语言。 1. **基础语法** Go 语言的语法简洁明了，易于学习。它借鉴了 C 语言的很多元素，但同时也引入了一些新的概念，如类型推断（type ...
go语言有哪些特点？
weixin_56242987的博客
12-06 1035
　　随着互联网的不断发展，程序员能够掌握的编程语言也在不断的增加，而今天我们就通过案例分析来了解一下，go语言编程的特点都有哪些。 　　一、go语言概述 　　Go在语法上类似于C语言，但它具有C语言没有的优势，如内存安全、垃圾回收、结构化的类型和CSP风格的并发性。 　　二、go语言特点 　　Go的设计受C语言的影响，但更加简单和安全。该语言包括如下特点： 　　采用动态语言中比较常见的语法和环境模式： 　　可选的简明变量声明和通过类型推理进行初始化(如果使用x:=0而不是intx=0;或varx=0;)。
go语言的特性是什么？
weixin_42598278的博客
02-07 438
Go语言有很多特性，其中一些最重要的包括：1. 简单易学：Go语言的语法非常简单，容易学习。2. 高效：Go语言的运行速度非常快，比其他语言快得多。3. 并发：Go语言支持并发编程，可以轻松实现高效的多线程应用。4. 垃圾回收：Go语言内置了垃圾回收机制，可以自动回收内存，减少内存泄漏的风险。5. 跨平台：Go语言可以在多个平台上运行，包括Windows、Linux和Mac OS等。 ...
go语言特点
weixin_30663391的博客
10-29 518
特点： 1. 静态类型，编译开源语言。 静态类型就是说，必须要指定每一个变量的类型。 编译型的意思就是说，go语言程序运行之前，先要把它编译成机器代码。 2. 脚本化的语法，支持多种编程范式（函数式，面向对象） 3. 原生，给力的并发支持并发编程 View Code 转载于:https://www.cnblog...
GO语言部分特点
Xiang_lhh的博客
08-11 3199
go语言支持多个返回值，例如 package main import ( "fmt" ) func main() { fn, sn := test()//按照顺序返回值 fmt.Println(fn) fmt.Println(sn) } func test() (firsname, secondname string) {//第二个括号内定义返回值的变量名及变量类型 firsname = "may" secondname = "m" return } //如果一些返回的变量不使用，可以.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

winlinvip

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

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

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

打赏作者

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

抵扣说明：

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

余额充值