/*
数组
数组切片
map
*/
import (
"fmt"
)
/*
[32]byte //长度32的数组,每个元素1个字节
[2*n] struct{x,y int32} //复杂类型数组
[1000]*float64 //指针数组
[3][5]int //2维数组
[2][2][2]float64 //等同[2]([2][2]float64)
*/
/*
a:=[10] int{1,2,3,4,5,6} 未提供初始化值的元素默认为0
b:=[...]int{1,2} 由初始化列表决定数组长度,不能省略"..."否则为slice
c:=[10]int{2:1,5:100} 按序号初始化元素
d:=[...]{19:1} 长度20第下标19(最后一个元素)为1,其余的数为0
*/
func ArrayBase() {
var a1 [1]int
var a2 [2]int
var a3 [2]int
// a1 = a2 不能相等,因为数组长度也是数组类型的一部分
a2 = a3 //可以赋值类型长度相同
fmt.Println("数组类型:", a1, a2, a3)
}
/*
数组指针,指针数组
*/
func PointerArray() {
x, y := 1, 2
var p1 *[2]int = &[2]int{x, y} //数组指针类型
var p2 [2]*int = [2]*int{&x, &y} //指针数组类型
fmt.Printf("%#v\n", p1)
fmt.Printf("%#v\n", p2)
a := [...]int{9: 9} //数组
var p *[10]int = &a //数组的指针
fmt.Println("数组的指针", p)
b := [...]*int{&x, &y} //保持的是指针,是指针数组
fmt.Println("指针数组", b)
ps := new([10]int) //返回指向数组的指针
fmt.Println("new数组:", ps)
}
//判断数组是否相等
func EqualsArray() {
a := [2]int{1, 2}
b := [2]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b) //true
fmt.Println(a == c) //false
}
//数组赋值
func SetValue() {
//2中方式对数组元素赋值
a := [2]int{}
a[1] = 2
fmt.Println(a)
p := new([2]int)
p[1] = 2
fmt.Println(p)
}
//多维数组
func Dimensions() {
a := [2][3]int{{1, 2, 3}, {4, 5, 67}}
fmt.Println("多维数组", a)
b := [2][3]int{{1: 2}, {2: 1}}
fmt.Println("多维数组下标赋值", b)
}
//冒泡排序
func BubbleSort(unsort [9]int) {
fmt.Println("排序前", unsort)
var size = len(unsort)
for i := size - 1; i > 0; i-- {
for j := 0; j < i; j++ {
if unsort[j] > unsort[j+1] {
unsort[j], unsort[j+1] = unsort[j+1], unsort[j]
}
}
}
fmt.Println("排序后", unsort)
}
/*
go中数组是一个值类型,在赋值或作为参数传递时将产生1次复制.
--函数体内操作的是所传入数组的副本
*/
func ArrayUseParam() {
array := [5]int{1, 2, 3, 4, 5}
setArray(array)
fmt.Println("原数组值是:", array)
}
func setArray(array [5]int) {
array[0] = 10
fmt.Println("修改中,数组值是:", array)
}
--------------------
package part2
/*
go类型:
布尔型：bool
- 长度：1字节
- 取值范围：true, false
- 注意事项：不可以用数字代表true或false
整型：int/uint
- 根据运行平台可能为32或64位
8位整型：int8/uint8
- 长度：1字节
- 取值范围：-128~127/0~255
字节型：byte（uint8别名）
16位整型：int16/uint16
- 长度：2字节
- 取值范围：-32768~32767/0~65535
32位整型：int32（rune）/uint32
- 长度：4字节
- 取值范围：-2^32/2~2^32/2-1/0~2^32-1
64位整型：int64/uint64
- 长度：8字节
- 取值范围：-2^64/2~2^64/2-1/0~2^64-1
浮点型：float32/float64
- 长度：4/8字节
- 小数位：精确到7/15小数位
复数：complex64/complex128
- 长度：8/16字节
足够保存指针的 32 位或 64 位整数型：uintptr
其它值类型：
- array、struct、string
引用类型：
- slice、map、chan
接口类型：inteface
函数类型：func
时间：2013-11-07 14:50:42
*/
/*
类型零值:
零值并不等于空值，而是当变量被声明为某种类型后的默认值，
通常情况下值类型的默认值为0，bool为false，string为空字符串
*/
import (
"fmt"
"math"
)
//类型别名
type (
bs int8
rune int32
文本 string
)
func Pri() {
/*
var a int
可省略变量类型,由系统推断
a = 123
var b int = 321
var c = 321
变量声明赋值的最简形式
d := 456
*/
var bb 文本
bb = "中文啊亲"
var a string = "aaaaaaaaaaaaa"
var num int = 123
num++
fmt.Println("文本b：" + bb)
fmt.Println(a)
fmt.Println(num)
}
/*
多个变量的声明与赋值
全局变量的声明可使用 var() 的方式进行简写
全局变量的声明不可以省略 var，但可使用并行方式
所有变量都可以使用类型推断
局部变量不可以使用 var() 的方式简写，只能使用并行方式
*/
var (
aaa = "hello"
//并行赋值与类型推断
sss, ccc = 1, 2
//不可省略var
//dd:=3
)
/*
变量的类型转换
Go中不存在隐式转换，所有类型转换必须显式声明
转换只能发生在两种相互兼容的类型之间
类型转换的格式：
<ValueA> [:]= <TypeOfValueA>(<ValueB>)
结果:1
*/
func TypeChange() {
var num float32 = 1.1
b := int(num)
fmt.Println(b)
//无法通过编译
//var cc bool = false
//d := int(cc)
}
/*
int转string
结果：A
*/
func ItS() {
var a int = 65
b := string(a)
fmt.Println(b)
}
//不同类型整数不能直接比较
func Type_Change() {
var i int32
var j int64
i, j = 1, 2
// if i == j {
// fmt.Println("变量类型不同编译不通过.")
// }
if i == 1 || j == 2 {
fmt.Println("变量和常数比较编译通过.")
}
}
//浮点不是精确表达方式,所以==不能判断2浮点是否相等
/**
* 判断2个float64数是否相等
* @param f1
* @param f2
* return：真true,假false
*/
func FloatEquals(f1, f2 float64) bool {
flag := math.Nextafter(f1, f2) == f1
return flag
}
/*
复数
*/
func Plural() {
var value1 complex64
value1 = 3.2 + 12i
value2 := 3.2 + 12i
value3 := complex(3.2, 12)
fmt.Println(value1)
fmt.Println(value2)
fmt.Println(value3)
fmt.Println(real(value1), imag(value1)) //复数的实数部分和虚数部分
}
//字符串
func Gstring() {
var str string = "abcdefghijklmn"
s1 := str[0]
fmt.Println(string(s1))
var size int = len(str)
//循环打印字符串
for i := 0; i < size; i++ {
fmt.Print(string(str[i]))
}
//range便捷遍历集合中元素,i,v 返回元素下标和值
fmt.Println("range遍历")
//for _, v := range str { 下划线表示不使用下标i这个值
for i, v := range str {
fmt.Print(i)
fmt.Println(string(v))
}
}
---------------------
package part1
/*
go基础
1.包别名
2.函数大小写
时间：2013-11-07 14:28:04
*/
import (
"fmt"
"time"
)
//常量定义
const PI = 3.14
//全局变量声明赋值
var name = "john"
//一般类型声明
type newType int
//结构声明
type gopher struct{}
//接口声明
type golang interface{}
//显示当前时间,函数名大写代表public,小写代表private
func GetTime() {
fmt.Println(time.Now())
}
func fontMin() {
fmt.Println("函数名小写,代表private")
}
func FontMax() {
fmt.Println("函数名大写,代表public1")
}
//变量转换
func ChangeValue() {
var i, j int = 1, 2
fmt.Println("变量值交换前：", i, j)
i, j = j, i //变量值交换
fmt.Println("变量值交换后：", i, j)
}
------------------------
package main
import (
"fmt"
//包使用别名
bs "part1"
types "part2"
)
func main() {
bs.ChangeValue()
bs.GetTime()
// con.fontMin() 因为是方法名小写,所以包外无法引用
bs.FontMax()
types.Pri()
types.TypeChange()
types.ItS()
// flag := types.FloatEquals(1.1,1.1)
fmt.Println(types.FloatEquals(1.1, 1.1))
types.Plural()
types.Gstring()
types.ArrayBase()
types.PointerArray()
types.EqualsArray()
types.SetValue()
types.Dimensions()
unsort := [...]int{9, 5, 1, 17, 26, 38, 0, 0, 3}
types.BubbleSort(unsort)
types.ArrayUseParam()
}
有疑问加站长微信联系（非本文作者）
