客服电话
APP下载
迪恩网络APP
随时随地掌握行业动态
官方微信
扫描二维码
关注迪恩网络微信公众号
|
一.创建第一个go语言程序：打印hello world！ package main
import "fmt"
func main() {
fmt.Println("Hello World")
}
运行go语言： go run main.go 小结： 切换到main.go所在的目录, go run main.go运行main.go程序, 输出"Hello World". go run命令后面是要编译并运行的文件, 多个文件用空格分开, go run将go程序文件编译成可执行的程序, 并放在一个临时目录下面. 如果程序有错误, go的编译器会提示哪里出错. import关键字使包含在其他package的代码用在当前程序中, 如main.go的import "fmt", fmt包实现了格式化输入和输出, import在包括包时, 报名需要用""括起来. 在go中注释一行代码使用//, 被注释的代码go编译器忽略, 注释只是提高代码的可读性, 如果需要注释多行代码, go提供了另一种方式: /* ... */, 在/*和*/之间的代码都被go编译器忽略不计. 二：变量的声明与初始化： go语言中的变量引入var关键字，类型信息放到变量之后 eg1:声明并初始化一个变量 package main
import "fmt"
func main() {
var m int = 10
fmt.Println(m)
}
输出结果10 eg2.1：声明初始化多个变量： package main
import "fmt"
func main() {
var a,b,c = 1,3,8
fmt.Println(a,b,c)
}
输出结果：1 3 8 eg2.2匿名变量 package main
import "fmt"
func main() {
var a,_,c = 1,3,8
fmt.Println(a,c)
}
输出结果为1 8 解释：这种情况主要用在函数有多个返回值的时候，去除我们需要的一个或者多个值的时候使用，如果没有用_的话，直接fmt.Println(a,c)，会报错 eg3：var关键字的另一种用法是可以将若干个需要声明的变量放置在一起，免得程序员需要重复写var关键字，如下： package main
import "fmt"
var (
v1 int
v2 string
)
func main() {
v1 = 10
v2 = "subao"
fmt.Println(v1,v2)
}
输出信息：10 subao eg4:对于声明变量时需要进行初始化的场景，var关键字可以保留，但不再是必要的元素，如下： package main
import "fmt"
func main() {
var v1 int = 88
var v2 = 88
v3 := 88
fmt.Println(v1,v2,v3)
}
输出结果 88 88 88 以上三种用法的效果是完全一致的。 注意：出现在:=左侧的变量不应该是已经被声明过的，否则会导致错误。 常量：go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值的类型（包括整型、浮点型、布尔型、字符串型等）
二.values ：值类型 go语言内置以下这些基础类型 布尔型：bool 整型：int8，byte，int16，int，int16，uint，uintptr等 浮点类型：float32、float64 复数类型：complex64、complex128 字符串型：string 字符类型：rune 错误类型：error 此外，go语言支持的复数类型： 指针（pointer） 数组(array) 切片（slice） 字典（map） 通道（chan） 结构体（struct） 接口（interface） 布尔型： package main
import "fmt"
//布尔型
func main() {
var v1 bool
v1 = true
fmt.Println(v1)
}
布尔型不能接受其他类型的赋值，不支持自动或者强制的类型转换,一下写法是错误的
输出：true 下面错的会报错： ./hello.go:14: cannot use 1 (type int) as type bool in assignment 整型：整型是所有语言中最基础的数据类型，go支持下图所示的整型类型 i：类型的表示： 首先说一点是：int和int32在go语言里被认为是两种不同的类型，编译器也不会帮你自动做类型转换，举一个错误例子 package main
import "fmt"
func main() {
var value2 int32
value1 := 64
value2 = value1
fmt.Println(value2)
}
会出现: ./hello.go:24: cannot use value1 (type int) as type int32 in assignment 如果以后真的遇到这样的错误，需要强制转换类型，正确的方式是： package main
import "fmt"
//整型
func main() {
var value2 int32
value1 := 64
value2 = int32(value1)（强制转换）
fmt.Println(value2)
}
正确输出：64 ii：数值的运算：举一个例子加法： package main
import "fmt"
//数值运算
func main() {
var v1,v2,v3 int
v1 = 64
v2 = 32
v3 = v1 + v2
fmt.Println(v3)
}
输出结果：96 iii：比较运算，与大多数其他语言相同，几种比较常见的运算符：>、<、==、>=、<=、!= package main
import "fmt"
//比较运算
func main() {
var v1,v2 int
v1 = 64
v2 = 32
if v1 >= v2 {
fmt.Println("v1 大于 v2")
}
}
输出：v1 大于 v2 注意：两个不同类型的整型数不能直接比较，比如int8类型的数和int类型的数不能直接比较，但是各种类型的整型变量都可以直接与字面常量（literal）进行比较
iv：位运算 浮点型： i.浮点数的表示： package main
import "fmt"
func main() {
var f1 float32
f1 = 12
f2 :=12.0
if f1 == f2 {
fmt.Println("相等")
}
}
报错：./hello.go:9: invalid operation: f1 == f2 (mismatched types float32 and float64) 原因：以上例子中类型自动推到的f2，需要注意的是其类型被自动设置成float64，而不管给他的数字是否用32为长度表示的。因此我们必须要强制类型转换，进行比较： package main
import "fmt"
func main() {
var f1 float32
f1 = 12
f2 :=12.0
if f1 == float32(f2) {
fmt.Println("相等")
}
}
输出：相等 ii:浮点数比较 因为浮点数不是一种精确的表达方式，所以想整型那样直接用==来判断是不可行的，（上面的例子是特殊情况），会导致不稳定的结果。 复数类型： i.复数的表示： package main
import "fmt"
func main() {
var value1 complex64
value1 = 3.2 + 12i
value2 := 3.2 + 12i
value3 := complex(3.2,12)
value4 := real(value3)
value5 := imag(value3)
fmt.Println(value1,value2,value3,value4,value5)
}
输出：(3.2+12i) (3.2+12i) (3.2+12i) 3.2 12 ii.实部与虚部 对于一个复数value3 :=complex(3.2,12),可以通过go语言内置函数real（z）获得该复数的实数，也就是3.2，通过imag（z）获得该复数的虚数。 字符串： i：字符串操作： package main
import "fmt"
func main() {
var str string
str = "hello world"
ch := str[0]
fmt.Printf("The length of \"%s\" is %d \n", str, len(str))
fmt.Printf("The first character of \"%s\" is %c.\n", str,ch)
}
输出信息： The length of "hello world" is 11 字符串遍历： a.遍历字符串（字节） package main
import "fmt"
func main() {
var str2 = "hello"
str3 := "世界"
// 字符串合并
str4 := str2 + " " + str3
// 遍历字符串(字节)
for i:=0;i<len(str4);i++ {
fmt.Printf("%d : %d\n", i, str4[i])
}
}
输出结果： 0 : 104 可以看出一个汉字三个字节，并且字符串的拼接也有了。 b.遍历字符串的字符： package main
import "fmt"
func main() {
var str2 = "hello"
str3 := "世界"
// 字符串合并
str4 := str2 + " " + str3
// 遍历字符串(字符)
for k,v := range(str4) {
fmt.Printf("%d : %x : %c\n", k, v, v)
}
}
输出: 0 : 68 : h 数组：数组是go语言编程中常见的数据结构之一，顾名思义，数组就是指一系列数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度 数组必知：在go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者是一个常量表达式（常量表达式是指在编译期即可计算结果的表达式）。数组的长度是该数组类型的一个内置常量，可以用go语言的内置函数len()来获取。方法: arrLength :=len(arr) i: 数组的创建方式： package main
import "fmt"
func main() {
var a [10]int
var b = [10]int{0,1,2,3,4,5,6,7,8,9}
var c = [...]int{0,1,2,3,4,5,6,7,8,9}
var d = [2][2]int{[2]int{1,1},[2]int{2,2}}
var e = [2][2]int{{1,1},{2,2}}
arrLength :=len(a)
fmt.Println(a,b,c,d,e,arrLength)
}
输出信息：[0 0 0 0 0 0 0 0 0 0] [0 1 2 3 4 5 6 7 8 9] [0 1 2 3 4 5 6 7 8 9] [[1 1] [2 2]] [[1 1] [2 2]] 10 解释：a没有赋值，默认是0；b与c实现的功能是相同的，取除10以内的整数；d，e则是二维数组，表示的是两行两列的二维整型数组，总共存放了四个元素；arrLength是获取的函数的长度 ii:元素的访问： 可以用数组下标来访问数组中的元素，数组下标从0开始，len（array）-1，则表示最后一个元素的下标。下面是遍历整型数组并逐个打印元素内容： package main
import "fmt"
func main() {
var c = [...]int{0,1,2,3,4,5,6,7,9}
for i := 0; i < len(c); i++ {
fmt.Println("Element", i, "of c is", c[i])
}
}
/*
func main() {
var c = [...]int{0,1,2,3,4,5,6,7,9}
for i,v := range c {
fmt.Println("c element[", i , "]=", v)
}
}
*/
以上两个函数都可以遍历整型数组的，输出内容是： c element[ 0 ]= 0 Element 0 of c is 0 并且上面的例子可看出，c具有两个返回值，第一个返回值是数组下标，第二个返回值是元素的值。 iii值类型： 未完待续。。。 |
请发表评论