AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Go基础（包、变量和函数）：开启Go语言之旅

2018-05-16 1425
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 开启Go语言之旅Go编程语言是一个开源项目，可以让程序员提高工作效率。Go是富有表现力，简洁，干净和高效的。其并发机制使编写充分利用多核和联网机器的程序变得容易，而其新颖类型系统则可实现灵活的模块化程序构建。

开启Go语言之旅

Go编程语言是一个开源项目，可以让程序员提高工作效率。

Go是富有表现力，简洁，干净和高效的。其并发机制使编写充分利用多核和联网机器的程序变得容易，而其新颖类型系统则可实现灵活的模块化程序构建。快速编译为机器代码，但具有垃圾收集的便利性和运行时反射的能力。它是一种快速，静态类型的编译语言，感觉像是一种动态类型的解释型语言。

一、包

Go语言也是要从包开始学起来

package main

//使用import导包
import (
    _ "fmt"
    "fmt"
    "math/rand"
    "math"
)

func main()  {
    fmt.Println("你好，世界")
    fmt.Println("my faovrite number is", rand.Intn(100))
    fmt.Println(math.Pi)
}

二、函数

  • 函数的一些例子
package main

import (
    _ "fmt"
    "fmt"
)

/**
 *函数可以没有参数或接受多个参数。
 *在本例中，add 接受两个 int 类型的参数。
 *注意类型在变量名 之后。
 *计算x+y,返回一个int类型的值
 */
func add(x int, y int)  int{
    return x + y
}

/**
 * 当连续的两个或者多个函数的已命名形参类型相同时，除最后的一个类型外，其他的都可以省略掉
 *
 */
func add2(x, y int)  int{
    return x + y
}

/**
 * 多值返回
 * 函数可以返回多个任意数量的返回值
 * 将x、y交换位置
 */
func swap(x,y string)  (string, string){
    return y, x
}

/*命名返回值
 *Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。
 *返回值的名称应当具有一定的意义，它可以作为文档使用。
 *没有参数的 return 语句返回已命名的返回值。也就是 直接 返回。
 *直接返回语句应当仅用在下面这样的短函数中。在长的函数中它们会影响代码的可读性。
 *传入一个int类型的sum,计算后返回一个int类型x和一个int类型的y
 */
func split(sum int)(x, y int)  {
    x = sum * 4 / 9
    y = sum - x
    return
}

func main()  {
    fmt.Println(add(42,31))
    fmt.Println(add2(42,31))

    a, b := swap("hello", "world")
    fmt.Println(a, b)

    fmt.Println(split(17))
}
  • 输出结果
73
73
world hello
7 10

三、变量

变量这个和Java的变量没有多大的差别。

package main

import (
    _ "fmt"
    "fmt"
)
/**
 * 变量
 * var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。
 * 定义了几个变量
 * 它们的类型为boolean类型的
 * 默认初始化值为false
 */
var c, python, java bool

//--------------------------------------------------------
 /**
  * 变量的初始化
  * 变量声明可以包含初始值，每个变量对应一个
  * 如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型
  */
var g, j int  = 1, 2

//-------------------------------------------------------
/**
 * 短变量声明
 * 在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。
 * 函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。
 */
 //:=不能在函数外使用
 //k := 4

func main()  {
    //变量
    // int类型的i，默认值为0
    var i int
    fmt.Println(i, c, python, java)

    //变量的初始化
    // --------------------------------------------------
    var d, e, f = true, false, "helloworld"
    fmt.Println(g, j, d, e, f)

    //短变量声明
    // --------------------------------------------------
    var h, k int = 1, 2
    //声明一个短变量
    p := 3
    l, m, n := true,false,"no!"
    fmt.Println(h,k,p,l,m,n)

}
  • 输出结果：
GOROOT=/usr/local/go #gosetup
GOPATH=/Users/wangdong/go #gosetup
/usr/local/go/bin/go build -i -o /private/var/folders/w4/3z7svk7s6n7c85w6t6j7t4_80000gn/T/___go_build_variables_go /Users/wangdong/Block/go/godemo01/src/main/variables.go #gosetup
/private/var/folders/w4/3z7svk7s6n7c85w6t6j7t4_80000gn/T/___go_build_variables_go #gosetup
0 false false false
1 2 true false helloworld
1 2 3 true false no!

Process finished with exit code 0

四、Go的基本类型

Go的基本类型就比较特殊了，和Go相比还是有蛮大的差距的。

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
    // 表示一个 Unicode 码点

float32 float64

complex64 complex128
  • int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。
  • 下面看一个例子：
package main

import (
    _ "fmt"
    "fmt"
)
/**
 * 变量
 * var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。
 * 定义了几个变量
 * 它们的类型为boolean类型的
 * 默认初始化值为false
 */
var c, python, java bool

//--------------------------------------------------------
 /**
  * 变量的初始化
  * 变量声明可以包含初始值，每个变量对应一个
  * 如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型
  */
var g, j int  = 1, 2

//-------------------------------------------------------
/**
 * 短变量声明
 * 在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。
 * 函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。
 */
 //:=不能在函数外使用
 //k := 4

func main()  {
    //变量
    // int类型的i，默认值为0
    var i int
    fmt.Println(i, c, python, java)

    //变量的初始化
    // --------------------------------------------------
    var d, e, f = true, false, "helloworld"
    fmt.Println(g, j, d, e, f)

    //短变量声明
    // --------------------------------------------------
    var h, k int = 1, 2
    //声明一个短变量
    p := 3
    l, m, n := true,false,"no!"
    fmt.Println(h,k,p,l,m,n)

}
  • 输出结果：
Type: bool Value: false
Type: uint64 Value: 18446744073709551615
Type: complex128 Value: (2+3i)

五、零值

没有明确初始值的变量声明会被赋予它们的 零值。
零值是：

  • 数值类型为 0，
  • 布尔类型为 false，
  • 字符串为 “”（空字符串）。
  • 下面看一个例子
package main

import (
    _ "fmt"
    "fmt"
)

func main()  {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
  • 输出结果：
0 0 false ""

六、类型转换

表达式 T(v) 将值 v 转换为类型 T。

一些关于数值的转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

或者，更加简单的形式：

i := 42
f := float64(i)
u := uint(f)

与 C 不同的是，Go 在不同类型的项之间赋值时需要显式转换。试着移除例子中 float64 或 uint 的转换看看会发生什么。

下面来看一个例子：

package main

import (
    "math"
    "fmt"
)

func main()  {
    var x, y int  = 3, 4
    var f float64  = math.Sqrt(float64(x*x + y*y))
    var z uint  = uint(f)
    fmt.Println(x, y ,z)
}

输出结果：

3 4 5

七、类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

var i int
j := i // j 也是一个 int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度：

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

尝试修改示例代码中 v 的初始值，并观察它是如何影响类型的。
- 下面写一个例子：

package main

import (
    "fmt"
)

func main()  {
    v := 42 // 修改这里！
    v2 := 42.4323 // 修改这里！
    v3 := 42.323423423 + 34234i // 修改这里！
    v4 := 42.00 // 修改这里！
    v5 := 0.42434342342 // 修改这里！
    v6 := 4000.42 // 修改这里！
    fmt.Printf("v is of type %T\n", v)
    fmt.Printf("v is of type %T\n", v2)
    fmt.Printf("v is of type %T\n", v3)
    fmt.Printf("v is of type %T\n", v4)
    fmt.Printf("v is of type %T\n", v5)
    fmt.Printf("v is of type %T\n", v6)
}
  • 输出的结果是：
v is of type int
v is of type float64
v is of type complex128
v is of type float64
v is of type float64
v is of type float64

八、常量

常量的声明与变量类似，只不过是使用 const 关键字。
常量可以是字符、字符串、布尔值或数值。
常量不能用 := 语法声明。

package main

import (
    _ "fmt"
    "fmt"
)

/**
 * 声明变量
 * 变量一般首字母小写
 * 常量一般首字母大写
 * 不光Pi和Truth是定义的常量
 * Hello、Happy、Go rules是常量
 */
const Pi  = 3.14

func main() {
    const World  = "世界"
    fmt.Println("Hello",World)
    fmt.Println("Happy", Pi, "Day")

    const Truth  = true;
    fmt.Println("Go rules?", Truth)
}

九、数值常量

数值常量是高精度的 值。
一个未指定类型的常量由上下文来决定其类型。
再尝试一下输出 needInt(Big) 吧。

（int 类型最大可以存储一个 64 位的整数，有时会更小。）
（int 可以存放最大64位的整数，根据平台不同有时会更少。）

  • 下面看一个例子
package main

import "fmt"

const (
    // Create a huge number by shifting a 1 bit left 100 places.
    // In other words, the binary number that is 1 followed by 100 zeroes.
    //定义一个数值常量，前面一个1后面跟着100个0
    Big = 1 << 100
    // Shift it right again 99 places, so we end up with 1<<1, or 2.
    //将
    Small = Big >> 99
)

func needInt(x int) int  {
    return x * 10 + 1
}

func needFloat(x float64) float64 {
    return x * 0.1
}

func main() {
    fmt.Println(needInt(Small))
    fmt.Println(needFloat(Small))
    fmt.Println(needFloat(Big))
    fmt.Println(Small)
    fmt.Println(Big*0.1)
}
  • 输出结果
21
0.2
//表示1.2676506002282295 * （10）^ 29次方
1.2676506002282295e+29
2
1.2676506002282295e+29

好啦，基础知识已经学习完了！

文章标签：
Go
Python
Java
关键词：
Go语言
Go包
Go函数
Go变量
Go Go语言
hello熊本
目录
相关文章
叫个什么名字
|
2天前
|
JavaScript Java Go
探索Go语言在微服务架构中的优势
在微服务架构的浪潮中，Go语言以其简洁、高效和并发处理能力脱颖而出。本文将深入探讨Go语言在构建微服务时的性能优势，包括其在内存管理、网络编程、并发模型以及工具链支持方面的特点。通过对比其他流行语言，我们将揭示Go语言如何成为微服务架构中的一股清流。
叫个什么名字
73 53
听风de歌
|
2天前
|
SQL 关系型数据库 MySQL
go语言中安装数据库驱动
【11月更文挑战第1天】
听风de歌
15 5
听风de歌
|
2天前
|
编译器 Go 开发者
go语言中导入相关包
【11月更文挑战第1天】
听风de歌
10 3
听风de歌
|
3天前
|
测试技术 Go
go语言中测试工具
【10月更文挑战第22天】
听风de歌
13 4
听风de歌
|
3天前
|
SQL 关系型数据库 MySQL
go语言中数据库操作
【10月更文挑战第22天】
听风de歌
14 4
听风de歌
|
3天前
|
缓存 前端开发 中间件
go语言中Web框架
【10月更文挑战第22天】
听风de歌
14 4
听风de歌
|
2天前
|
关系型数据库 MySQL 数据库连接
go语言中打开数据库连接
【11月更文挑战第1天】
听风de歌
12 2
听风de歌
|
6天前
|
Go
go语言的复数常量
【10月更文挑战第21天】
听风de歌
24 6
叫个什么名字
|
6天前
|
Serverless Go
Go语言中的并发编程：从入门到精通
本文将深入探讨Go语言中并发编程的核心概念和实践，包括goroutine、channel以及sync包等。通过实例演示如何利用这些工具实现高效的并发处理，同时避免常见的陷阱和错误。
叫个什么名字
22 1
游客sjjs6jgz4gp7m1
|
3天前
|
安全 测试技术 Go
Go语言中的并发编程模型解析####
在当今的软件开发领域，高效的并发处理能力是提升系统性能的关键。本文深入探讨了Go语言独特的并发编程模型——goroutines和channels，通过实例解析其工作原理、优势及最佳实践，旨在为开发者提供实用的Go语言并发编程指南。 ####
游客sjjs6jgz4gp7m1
7 0

热门文章

最新文章

  • 1
    Go语言学习索引
  • 2
    《Go语言入门》第一个Go语言Web程序——简单的Web服务器
  • 3
    GO语言练习：map基本用法
  • 4
    《Go语言入门》第一个Go语言程序——HelloWorld
  • 5
    《Go语言编程》【3.6 完整示例】代码错误和文件目录结构
  • 6
    Go语言标准包之json编码
  • 7
    02-Go语言数据类型与变量
  • 8
    在go语言中通过Post的方法提交json的数据
  • 9
    Go语言之嵌入类型
  • 10
    Go语言，用原子函数atomic避免资源竞争
  • 1
    Go语言map并发安全，互斥锁和读写锁谁更优？
    55
  • 2
    Go语言map并发安全使用的正确姿势
    56
  • 3
    Go语言中的map为什么默认不是并发安全的？
    51
  • 4
    go语言中fmt格式化包和内置函数汇总
    73
  • 5
    go语言中格式化输出的占位符
    56
  • 6
    零值在go语言和初始化数据
    94
  • 7
    Go语言设计模式：使用Option模式简化类的初始化
    71
  • 8
    Go 语言性能优化技巧
    88
  • 9
    2019江行智能 后端开发工程师Go 面试题
    55
  • 10
    在go程序中的交叉编译
    189

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Python语言基础 - 语法入门
  • 【Python入门】Python数据处理编程基础

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 函数计算入门-HelloWorld应用开发
  • 语言入门-1：环境构建
  • 阿里云平台上进行Java程序的编译与运行
  • 云端Python及基本操作
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
    • 下一篇
    DataWorks售前咨询