深入解析golang编程中函数的用法
投稿：goldensun
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了golang编程中函数的用法,是Go语言入门学习中的基础知识,需要的朋友可以参考下
函数是一组一起执行任务的语句。每Go程序具有至少一个函数，它一般是main()，以及所有的最琐碎程序可以定义附加函数。
你可以将代码放到独立的功能。如何划分代码之间的不同功能，但逻辑上的划分通常是让每个函数执行特定的任务。
函数声明告诉编译器有关的函数的名称，返回类型和参数。一个函数定义提供了函数的实际主体。
Go语言标准库提供了大量的内置函数，在程序可以调用。例如，函数len()需要不同类型的参数和返回值的类型的长度。例如，如果一个字符串传递给它，它会返回字符串的长度以字节为单位，如果一个数组传递给它，它就会返回数组的长度为它所拥有元素的个数。
函数称为具有各种名字等的方法或子例程或程序等。
定义一个函数：
在Go编程语言的函数定义的一般形式如下：
func function_name( [parameter list] ) [return_types]
&& body of the function
在Go编程语言中的函数定义由函数头和函数体。这里是一个函数的所有部分：
func 开始函数的声明。
Function Name: 这是该函数的实际名称。函数名和参数列表一起构成了函数签名。
Parameters: 参数是像一个占位符。当调用一个函数，你传递一个值的参数。这个值被称为实际参数或参数。参数列表指的类型，顺序和数量的函数的参数。参数是可选的;也就是说，一个函数可包含任何参数。
Return Type: 函数可能返回值的列表。return_types是该函数返回值的数据类型的列表。有些函数执行所需的操作没有返回值。在这种情况下，return_type不是必需的。
Function Body: 函数体包含了定义函数操作语句的集合。
下面是一个函数的源代码称为max()。这个函数有两个参数num1与num2并返回两者之间的最大值：
/* function returning the max between two numbers */
func max(num1, num2 int) int
&& /* local variable declaration */
&& result int
&& if (num1 & num2) {
&&&&& result = num1
&& } else {
&&&&& result = num2
&& return result
调用一个函数：
创建一个Go编程的函数必须做一个定义。要使用函数，需要调用该函数来执行规定的任务。
当程序调用函数，程序控制被转移到所调用的函数。调用函数定义执行任务时，被执行的return语句或达到其功能结束的右括号，则返回程序控制返回到主程序。
要调用一个函数，只需要通过必要的参数以及函数的名称，如果函数返回一个值，那么可以存储返回值。例如：
package main
import "fmt"
func main() {
&& /* local variable definition */
&& var a int = 100
&& var b int = 200
&& var ret int
&& /* calling a function to get max value */
&& ret = max(a, b)
&& fmt.Printf( "Max value is : %d\n", ret )
/* function returning the max between two numbers */
func max(num1, num2 int) int {
&& /* local variable declaration */
&& var result int
&& if (num1 & num2) {
&&&&& result = num1
&& } else {
&&&&& result = num2
&& return result
保持max()函数与main()函数并编译源代码。在运行最后的可执行文件，它会产生如下结果：
Max value is : 200
从函数返回多个值
Go语言函数可以返回多个值。例如：
&package main
import "fmt"
func swap(x, y string) (string, string) {
&& return y, x
func main() {
&& a, b := swap("Mahesh", "Kumar")
&& fmt.Println(a, b)
让我们编译和运行上面的程序，这将产生以下结果：
Kumar Mahesh
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具GO语言练习：不定参数函数
- Go语言中文网 - Golang中文社区
<meta name="author" content="polaris ">
GO语言练习：不定参数函数
fengbohello
· 1267 次点击 ·
开始浏览 & &
package main
import "fmt"
func MyPrintf(args ...interface{}){
for _, arg := range args {
switch arg.(type) {
case int :
fmt.Println("\"", arg, "\"", "is an int value.")
case string :
fmt.Println("\"", arg, "\"", "is a string value.")
case int64 :
fmt.Println("\"", arg, "\"", "is an int64 value.")
fmt.Println("\"", arg, "\"", "is an unknown type.")
func main(){
var v1 int = 1
var v2 int64 = 234
var v3 string = "hello"
var v4 float32 = 1.123
MyPrintf(v1, v2, v3, v4)
$ go run myprintf.go
" 1 " is an int value.
" 234 " is an int64 value.
" hello " is a string value.
" 1.123 " is an unknown type.
1267 次点击 &
请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
记住登录状态
package main
import "fmt"
func MyPrintf(args ...interface{}){
for _, arg := range args {
switch arg.(type) {
case int :
fmt.Println("\"", arg, "\"", "is an int value.")
case string :
fmt.Println("\"", arg, "\"", "is a string value.")
case int64 :
fmt.Println("\"", arg, "\"", "is an int64 value.")
fmt.Println("\"", arg, "\"", "is an unknown type.")
func main(){
var v1 int = 1
var v2 int64 = 234
var v3 string = "hello"
var v4 float32 = 1.123
MyPrintf(v1, v2, v3, v4)
$ go run myprintf.go
" 1 " is an int value.
" 234 " is an int64 value.
" hello " is a string value.
" 1.123 " is an unknown type.
&最高记录 1364
&2012- Go语言中文网，中国 Golang 社区，致力于构建完善的 Golang 中文社区，Go语言爱好者的学习家园。
Powered by
&o&服务器由
赞助 &·&CDN 由
VERSION: V3.0.0&·&4.310403ms&·&为了更好的体验，本站推荐使用 Chrome 或 Firefox 浏览器
登录和大家一起探讨吧
记住登录状态
还不是会员golang内置数据类型作为函数参数
- Go语言中文网 - Golang中文社区
<meta name="author" content="polaris ">
golang内置数据类型作为函数参数
· 1460 次点击 ·
开始浏览 & &
golang的所有内置类型作为函数参数传递都是传值的方式（没有传递引用一说），需要注意的是：数组、slice和map作为函数参数时也是传值，但是如果对结构内元素进行的修改，修改的是原数据。如果是对其进行整体赋值，则不会修改原数据，相当于拷贝出一个新的临时变量。要想无论什么情况都修改原数据，可以通过传递指针参数实现。
来段实例代码
1 package main
3 import (
"bytes"
"fmt"
"strings"
9 func f_1(a int) {
13 func f_1_1(a *int) {
17 func f_2(s string) {
s = "cba"
21 func f_2_1(s *string) {
*s = "cba"
25 func f_3(v []string) {
v[0] = "haha"
29 func f_3_1(v []string) {
33 func f_3_2(v *[]string) {
37 func f_4(m map[int]int) {
42 func f_4_1(m map[int]int) {
46 func f_4_2(m *map[int]int) {
50 func f_5(b []byte) {
b[0] = 0x40
54 func f_5_1(b []byte) {
b = bytes.Replace(b, []byte("1"), []byte("a"), -1)
58 func f_5_2(b *[]byte) {
*b = bytes.Replace(*b, []byte("1"), []byte("a"), -1)
62 type why struct {
s []string
66 func (ss why) SetV(s []string) {
70 func (ss *why) SetP(s []string) {
74 func (ss why) String() string {
return strings.Join(ss.s, ",")
78 func main() {
s := "abc"
v := []string{"sd", "aa"}
m := map[int]int{1: 1, 2: 2, 3: 3}
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
b := []byte("")
fmt.Printf("%s\n", b)
fmt.Printf("%s\n", b)
fmt.Printf("%s\n", b)
ss := &why{}
ss.SetV([]string{"abc", "efg"})
fmt.Println(ss)
ss.SetP([]string{"abc", "efg"})
fmt.Println(ss)
1 1,abc,[haha aa],map[1:3 2:2 3:1] slice和map值传递是可以修改原数据的，但基本数据类型不行
2 1,abc,[haha aa],map[1:3 2:2 3:1] 整体赋值不会修改原数据，值得注意的是map是无序的
3 2,cba,[],map[] 传递指针始终会修改原数据
4 @2145178 同上
5 @2145178 使用bytes.Replace实际上还是赋值，所以不会修改原数据
6 @2a45a78 使用指针传参就可以了
类的成员函数定义为传值的方式，不会修改原数据（原数据为空）
类的成员函数定义为传指针的方式，可以修改原成员变量
10 成功: 进程退出代码 0.
现在弄明白了吗～
1460 次点击 &
请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
记住登录状态
golang的所有内置类型作为函数参数传递都是传值的方式（没有传递引用一说），需要注意的是：数组、slice和map作为函数参数时也是传值，但是如果对结构内元素进行的修改，修改的是原数据。如果是对其进行整体赋值，则不会修改原数据，相当于拷贝出一个新的临时变量。要想无论什么情况都修改原数据，可以通过传递指针参数实现。
来段实例代码
1 package main
3 import (
"bytes"
"fmt"
"strings"
9 func f_1(a int) {
13 func f_1_1(a *int) {
17 func f_2(s string) {
s = "cba"
21 func f_2_1(s *string) {
*s = "cba"
25 func f_3(v []string) {
v[0] = "haha"
29 func f_3_1(v []string) {
33 func f_3_2(v *[]string) {
37 func f_4(m map[int]int) {
42 func f_4_1(m map[int]int) {
46 func f_4_2(m *map[int]int) {
50 func f_5(b []byte) {
b[0] = 0x40
54 func f_5_1(b []byte) {
b = bytes.Replace(b, []byte("1"), []byte("a"), -1)
58 func f_5_2(b *[]byte) {
*b = bytes.Replace(*b, []byte("1"), []byte("a"), -1)
62 type why struct {
s []string
66 func (ss why) SetV(s []string) {
70 func (ss *why) SetP(s []string) {
74 func (ss why) String() string {
return strings.Join(ss.s, ",")
78 func main() {
s := "abc"
v := []string{"sd", "aa"}
m := map[int]int{1: 1, 2: 2, 3: 3}
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
b := []byte("")
fmt.Printf("%s\n", b)
fmt.Printf("%s\n", b)
fmt.Printf("%s\n", b)
ss := &why{}
ss.SetV([]string{"abc", "efg"})
fmt.Println(ss)
ss.SetP([]string{"abc", "efg"})
fmt.Println(ss)
1 1,abc,[haha aa],map[1:3 2:2 3:1] slice和map值传递是可以修改原数据的，但基本数据类型不行
2 1,abc,[haha aa],map[1:3 2:2 3:1] 整体赋值不会修改原数据，值得注意的是map是无序的
3 2,cba,[],map[] 传递指针始终会修改原数据
4 @2145178 同上
5 @2145178 使用bytes.Replace实际上还是赋值，所以不会修改原数据
6 @2a45a78 使用指针传参就可以了
类的成员函数定义为传值的方式，不会修改原数据（原数据为空）
类的成员函数定义为传指针的方式，可以修改原成员变量
10 成功: 进程退出代码 0.
现在弄明白了吗～
&最高记录 1364
&2012- Go语言中文网，中国 Golang 社区，致力于构建完善的 Golang 中文社区，Go语言爱好者的学习家园。
Powered by
&o&服务器由
赞助 &·&CDN 由
VERSION: V3.0.0&·&4.565206ms&·&为了更好的体验，本站推荐使用 Chrome 或 Firefox 浏览器
登录和大家一起探讨吧
记住登录状态
还不是会员Go中使用全新的关键字var来声明变量。var我们并不陌生，在Javascript 和C#中均有出现。不同的是Go和C#中变量属于强类型，在声明变量后就不允许改变其数据类型。
声明变量有多种形态:
var a int //声明一个int类型的变量
var b struct { //声明一个结构体
name string
var a = 8 //声明变量的同时赋值，编译器自动推导其数据类型
var a int = 8 //声明变量的同时赋值
var { //批量声明变量，简洁
变量初始化
变量的初始化工作可以在声明变量时进行初始化，也可以先声明后初始化。此时var关键字不再是必须的。
初始化变量有多种方式，每种方式有不同的使用场景：
在方法中声明一个临时变量并赋初值
& var tmpStr = &&
& var tmpStr string = &&
& tmpStr :=&&
全局中已声明变量直接赋值
& tmpStr = &&body&&
我们看到有此两种方式：
var name [type] = value
如果不书写 type ,则在编译时会根据value自动推导其类型。
name := value
这里省略了关键字var，我很喜欢这种方式（可以少写代码，而没有任何坏处）。 但这有需要注意的是& :=& 是在声明和初始化变量，因此该变量必须是第一次出现，如下初始化是错误的。但是要注意赋值时要确定你想要的类型，在Go中不支持隐式转换的。如果是定义个float64类型的变量，请写为 v1 :=8.0 而不是v1 :=8 。
//我刚开始时老出现这种错误，一直将 &:= & 当作 一般赋值语句处理
初始化语句，在编译器上是如何进行自动类型推导的。一些字面常量是如何归类的？
如 8 & int , 8.0 & float64
package main
func main(){
var v1 int = 8
var v2 byte = 8
fmt.Printf("v1 type
:%s\n",reflect.TypeOf(v1)) //int
fmt.Printf("v2 type
:%s\n",reflect.TypeOf(v2)) //uint8
fmt.Printf("v3 type
:%s\n",reflect.TypeOf(v3)) //int
fmt.Printf("v4 type
:%s\n",reflect.TypeOf(v4)) //float64
官方文档：
const a = 2 + 3.0
// a == 5.0
(untyped floating-point constant)
const b = 15 / 4
(untyped integer constant)
const c = 15 / 4.0
// c == 3.75
(untyped floating-point constant)
const &T float64 = 3/2
// &T == 1.0
(type float64, 3/2 is integer division)
const Π float64 = 3/2.
// Π == 1.5
(type float64, 3/2. is float division)
const d = 1 && 3.0
(untyped integer constant)
const e = 1.0 && 3
(untyped integer constant)
const f = int32(1) && 33
(type int32)
const g = float64(2) && 1
// illegal
(float64(2) is a typed floating-point constant)
const h = "foo" & "bar"
// h == true
(untyped boolean constant)
const j = true
// j == true
(untyped boolean constant)
const k = 'w' + 1
// k == 'x'
(untyped rune constant)
const l = "hi"
// l == "hi"
(untyped string constant)
const m = string(k)
// m == "x"
(type string)
const &S = 1 - 0.707i
(untyped complex constant)
const &D = &S + 2.0e-4
(untyped complex constant)
const &P = iota*1i - 1/1i
(untyped complex constant)
const ic = complex(0, c) // ic == 3.75i (untyped complex constant)
const i&T = complex(0, &T)
// i&T == 1.5i
(type complex128)
const Huge = 1 && 100
// Huge == 3205376 (untyped integer constant)
const Four int8 = Huge && 98
// Four == 4
(type int8)
^1 // untyped integer constant, equal to -2
// illegal: same as uint8(-2), -2 cannot be represented as a uint8
// typed uint8 constant, same as 0xFF ^ uint8(1) = uint8(0xFE)
// same as int8(-2)
// same as -1 ^ int8(1) = -2
------------------------补充----------------------------------------
func &main(){
& & & & v1 :=8
& & & & v1 =8.0 & & & // 编译可通过，运行无错误
& & & & fmt.Println(v1)
在C#中会编译不通过，而Go语言中却是可行的，这是为什么呢？我在golang-chang中向大家请教了该问题，谢谢帮助我的人。
将结果整理给大家
1. Go里面不损失精度的情况下会把8.0这类浮点数视作整数8
2. Go里面的常数是高精度数，分为几类：
1.有类型的：uint(8)，类型显式指定了，在表达式里面不会变化。
2.无类型的：分成无类型整数和无类型浮点两类。这两类在使用的时候会根据上下文需要的类型转化为实际类型，
比如uint8(0) + 1.0就是uint8(1)，但是uint8(0)+1.2就会由于1.2无法转化为uint8而报错。
如果上下文无法确定（比如 i, j := 1, 2.0这样的），那么整数无类型常数转化为int，浮点数无类型常数转化为float64.
具体规则参见：
---------------------------------&end------------------------------------------------
阅读(...) 评论()
