1.基本熟悉,了解组成
package main
import "fmt"
var Pi float32
var aname1= "你好"
var (
a11= 1
a22= "x"
)
func init ( ) {
Pi= 2 + 1
}
func main ( ) {
fmt. Println ( "Hello word" )
const name string = "你好"
const age int = 123
const name2 = "你好"
const age2 = 456
const name3 = "你" +
"好"
n := "hello"
l := len ( n)
fmt. Println ( l)
const (
Monday, Tuesday, Wednesday= 1 , 2 , 3
)
const (
a = iota ;
b
c
h= "h"
)
fmt. Println ( c)
DPi := Pi
fmt. Println ( Pi, DPi)
}
2.整型,浮点,字符串
package main
import (
"fmt"
"strings"
)
func main ( ) {
fmt. Println ( "你好" )
const value_int_1 int = 132
value_int := 4
fmt. Println ( value_int, value_int_1)
const value_float float32 = 123.123
value_float_1 := 123.1234
fmt. Println ( value_float, value_float_1)
str1:= "1234567"
fmt. Println ( "字符串长度为:" , len ( str1) )
for i:= 0 ; i< len ( str1) ; i++ {
fmt. Println ( "每个字符为" , str1[ i] )
fmt. Println ( "每个字符为" , string ( str1[ i] ) )
fmt. Printf ( "%d = %v\n" , i+ 1 , str1[ i] )
}
str2:= "你好\n圣姑"
fmt. Println ( str2)
str3:= `你好\n圣姑`
fmt. Println ( str3)
str_a1 := "hello word"
str_a2 := [ ] byte ( str_a1)
str_a2[ 5 ] = ','
fmt. Printf ( "%s\n" , str_a2)
str_a3:= [ ] rune ( str_a1)
str_a3[ 5 ] = ','
fmt. Println ( string ( str_a3) )
fmt. Println ( string ( str_a3[ 2 ] ) )
str_b1 := "There is dongxi 你好"
is_bool := strings. HasPrefix ( str_b1, "Th" )
fmt. Println ( is_bool)
is_bool_1 := strings. ContainsAny ( str_b1, "T" )
fmt. Println ( is_bool_1)
is_bool_2 := strings. ContainsAny ( str_b1, "T & e" )
fmt. Println ( is_bool_2)
is_bool_3 := strings. ContainsAny ( str_b1, "" )
fmt. Println ( is_bool_3)
is_bool_4 := strings. Contains ( str_b1, "T" )
fmt. Println ( is_bool_4)
is_bool_5 := strings. Contains ( str_b1, "T & e" )
fmt. Println ( is_bool_5)
is_bool_6 := strings. Contains ( str_b1, "" )
fmt. Println ( is_bool_6)
is_bool_7 := strings. Index ( str_b1, "ere" )
fmt. Println ( is_bool_7)
fmt. Println ( "最后一次索引" , strings. Index ( str_b1, "x" ) )
fmt. Println ( "最后一次索引" , strings. Index ( str_b1, "z" ) )
fmt. Println ( "最后一次索引" , strings. Index ( str_b1, "你" ) )
fmt. Println ( "最后一次索引" , strings. IndexRune ( str_b1, '你' ) )
str:= "你好世界,世界good"
println ( strings. Replace ( str, "你好" , "加油" , 1 ) )
fmt. Printf ( "%d\n" , strings. Count ( str, "o" ) )
fmt. Printf ( "%d\n" , len ( [ ] rune ( str) ) )
fmt. Println ( utf8. RuneCountInString ( str) )
str_e := "here is my"
fmt. Println ( strings. ToLower ( str_e) )
fmt. Println ( strings. ToUpper ( str_e) )
fmt. Println ( strings. Trim ( "!!! golang !!!" , "! " ) )
fmt. Println ( strings. Trim ( "!!! golang !!!" , " !" ) )
fmt. Println ( strings. Trim ( "!!! golang !!!" , "!" ) )
fmt. Println ( strings. TrimLeft ( "!!! golang !!!" , "! " ) )
fmt. Println ( strings. TrimRight ( "!!! golang !!!" , "! " ) )
results:= strings. Split ( "a,c,d" , "," )
fmt. Println ( results)
fmt. Println ( string ( results[ 0 ] ) )
strSli:= strings. Fields ( "a b c d" )
strSli_2:= strings. Fields ( "你 的 名 子" )
for _ , val:= range strSli{
fmt. Printf ( "%s" , val)
}
strStr2:= strings. Join ( strSli, ";" )
fmt. Println ( strStr2)
fmt. Println ( strSli_2)
}
3.字符串格式化
含义 格式化指令含义 %% %字面量 %b 一个二进制整数,将一个整数格式化为二进制的表达方式 %c 一个Unicode的字符 %d 十进制数值 %o 八进制数值 %x 小写的十六进制数值 %X 大写的十六进制数值 %U 一个Unicode表示法表示的整型码值,默认是4个数字字符 %s 输出以原生的UTF-8字节表示的字符,如果console不支持UTF-8编码,则会输出乱码 %t 以true或者false的方式输出布尔值 %v 使用默认格式输出值,或者如果方法存在,则使用类型的String()方法输出的自定义值 %T 输出值的类型
4.基础数据类型的扩展
package main
import "fmt"
type (
字符串 string
)
func main ( ) {
sum:= 11
count:= 3
mean:= float32 ( sum) / float32 ( count)
fmt. Printf ( "mean值为%f\n" , mean)
var b 字符串
b= "这是中文"
fmt. Println ( string ( b) )
a:= 10
fmt. Printf ( "%x\n" , & a)
a1:= 14
ap:= & a1
fmt. Printf ( "a1的地址%x\n" , & a1)
fmt. Printf ( "ap的地址%x\n" , ap)
fmt. Printf ( "*ap的值%d\n" , * ap)
var ptr * int
fmt. Printf ( "ptr的值是%x\n" , ptr)
a_n:= 10
aP:= & a_n
aPP:= & aP
fmt. Printf ( "aP: %x\n" , aP)
fmt. Printf ( "aPP: %x\n" , * aPP)
fmt. Printf ( "aPP: %d\n" , * * aPP)
a_list:= [ ] int { 10 , 100 , 200 }
var p_a [ 3 ] * int
for i:= 0 ; i< 3 ; i++ {
p_a[ i] = & a_list[ i]
fmt. Printf ( "p_a[%d]的内存地址:%x\n" , i, p_a[ i] )
}
for i:= 0 ; i< 3 ; i++ {
fmt. Printf ( "p_a[%d]的实际值:%d\n" , i, * p_a[ i] )
}
a3:= 100
b3:= 200
fmt. Printf ( "交换之前的a,b值为%d,%d\n" , a3, b3)
swap ( & a3, & b3)
fmt. Printf ( "交换之后的a,b值为%d,%d\n" , a3, b3)
}
func swap ( x * int , y * int ) {
var temp int
temp= * x
* x= * y
* y= temp
}
5.流程控制
package main
import (
"fmt"
"go/types"
"reflect"
)
var x interface { }
func main ( ) {
a:= 100
if a> 200 {
fmt. Println ( "大于200" )
} else if a< 200 {
fmt. Println ( "小于200" )
} else {
fmt. Println ( "等于200" )
}
if b:= 100 ; b< 200 {
fmt. Println ( "小于200" )
}
case_var:= 90
switch case_var {
case 90 :
fmt. Println ( "是90" )
case 100 :
fmt. Println ( "是100" )
default :
fmt. Println ( "啥也不是" )
}
switch {
case case_var> 100 :
fmt. Println ( "大于100" )
case case_var< 100 :
fmt. Println ( "小于100" )
default :
fmt. Println ( "啥也不是" )
}
switch_a:= "A"
switch_b:= "B"
switch {
case switch_a== "A" && switch_b== "C" :
fmt. Println ( "等于A" )
case switch_a== "A" && switch_b== "B" :
fmt. Println ( "等于A和B" )
default :
fmt. Println ( "啥也不是" )
}
x= 1
switch i := x. ( type ) {
case types. Nil:
fmt. Printf ( "这里是nif类型,值是%T" , i)
case int :
fmt. Printf ( "这里是int类型,值是%T" , i)
case float64 :
fmt. Printf ( "这里是float64类型,值是%T" , i)
case bool :
fmt. Printf ( "这里是bool类型,值是%T" , i)
case string :
fmt. Printf ( "这里是string类型,值是%T" , i)
default :
fmt. Printf ( "未知类型" )
}
fmt. Printf ( "\n" )
fmt. Printf ( "v1的数据类型为:%s\n" , reflect. TypeOf ( switch_a) )
switch case_var_1:= 120 ; case_var_1 {
case 90 :
fmt. Println ( "是90" )
case 120 :
fmt. Println ( "是120" )
default :
fmt. Println ( "啥也不是" )
}
switch switch_c:= "C" ; {
case switch_c== "A" :
fmt. Println ( "等于A" )
case switch_c== "C" :
fmt. Println ( "等于C" )
default :
fmt. Println ( "啥也不是" )
}
for a:= 0 ; a< 5 ; a++ {
fmt. Printf ( "当前数值为%d\n" , a)
}
a1:= 0
b1:= 5
for a1< b1 {
fmt. Printf ( "当前数值为%d\n" , a1)
a1++
}
str_a:= "abcd"
for i, char := range str_a{
fmt. Printf ( "第%d个值是,具体值是%s\n" , i, string ( char) )
}
for _ , char := range str_a{
fmt. Printf ( "具体值是%s\n" , string ( char) )
}
for i := range str_a{
fmt. Printf ( "第%d的下标\n" , i)
}
for range str_a{
fmt. Printf ( "遍历字符串,不做任何操作\n" )
}
map_a:= map [ string ] int { "a" : 1 , "b" : 2 }
for k, v:= range map_a {
fmt. Printf ( "k值为%s,v值为%d\n" , k, v)
}
number_list:= [ ] int { 1 , 2 , 3 , 4 }
for i, num:= range number_list {
fmt. Printf ( "下标值为%d,具体的值为%d\n" , i, num)
}
number_list2:= [ 5 ] int { 1 , 2 , 3 , 4 }
for i, num:= range number_list2 {
fmt. Printf ( "下标值为%d,具体的值为%d\n" , i, num)
}
defer fmt. Println ( "word" )
fmt. Println ( "hello" )
goto L1
L1:
for i:= 0 ; i< 5 ; i++ {
fmt. Println ( "输出内容" )
}
}
注,range的返回值的输出:
右边表达式返回的类型 第一个值 第二个值 sting index str[index],返回的类型rune array/slice index str[index] map key m[key] channel element
6.函数
package main
import (
"fmt"
"time"
)
func add ( a int , b int ) int {
return a+ b
}
func Max ( a int , b int ) ( maxNum int ) {
if a> b{
maxNum= a
} else {
maxNum= b
}
return maxNum
}
func SumResult_A_B ( a int , b int ) ( int , int ) {
return a, b
}
type FormatFunc func ( s string , x, y int ) string
func pipe ( ff func ( ) int ) int {
return ff ( )
}
func format ( ff FormatFunc, s string , x, y int ) string {
return ff ( s, x, y)
}
func isEven ( v int ) bool {
if v% 2 == 0 {
return true
} else {
return false
}
}
type boolFunc func ( int ) bool
func filter ( slice [ ] int , f boolFunc) [ ] int {
var result [ ] int
for _ , value:= range slice{
if f ( value) {
result= append ( result, value)
}
}
return result
}
func int_change ( args ... int ) {
for _ , i:= range args {
fmt. Printf ( "数是%d\n" , i)
}
}
func Adds ( ) func ( b int ) int {
return func ( b int ) int {
return b+ 2
}
}
func recursion ( parse int ) {
if parse> 1 {
parse--
recursion ( parse)
fmt. Println ( "当前获得的递归数值为" , parse)
}
}
func fullName ( firstName * string , lastName * string ) {
if firstName == nil {
panic ( "runtime error: first name cannot be nil" )
}
if lastName == nil {
panic ( "runtime error: last name cannot be nil" )
}
fmt. Printf ( "%s %s\n" , * firstName, * lastName)
fmt. Println ( "returned normally from fullName" )
}
func genErr ( ) {
fmt. Println ( time. Now ( ) , "正常的语句" )
defer func ( ) {
fmt. Println ( time. Now ( ) , "defer正常的语句" )
panic ( "第二个错误" )
} ( )
panic ( "第一个错误" )
}
func throwsPanic ( f func ( ) ) ( b bool ) {
defer func ( ) {
if r:= recover ( ) ; r!= nil {
fmt. Println ( time. Now ( ) , "捕获到的异常:" , r)
b= true
}
} ( )
f ( )
return b
}
func main ( ) {
result_num:= add ( 1 , 2 )
fmt. Println ( result_num)
result_max_num:= Max ( 1 , 3 )
fmt. Println ( result_max_num)
s1:= pipe ( func ( ) int {
return 100
} )
fmt. Println ( s1)
s2:= format ( func ( s string , x, y int ) string {
return fmt. Sprintf ( s, x, y)
} , "值1为%d,值2位%d" , 10 , 20 )
fmt. Println ( s2)
slice := [ ] int { 3 , 3 , 4 , 5 , 6 }
even:= filter ( slice, isEven)
fmt. Println ( "even:" , even)
int_change ( 1 , 2 , 3 , 4 , 5 , 6 )
return_x:= func ( x1, x2 int ) int { return x1+ x2} ( 3 , 4 )
fmt. Println ( return_x)
adds_return:= Adds ( ) ( 3 )
fmt. Println ( adds_return)
recursion ( 5 )
f, err := os. Open ( "/test.txt" )
if err != nil {
fmt. Println ( "error:" , err)
return
}
fmt. Println ( f. Name ( ) , "open successfully" ) * /
firstName := "foo"
lastName:= "zhang"
fullName ( & firstName, & lastName)
fmt. Println ( "returned normally from main" )
throwsPanic ( genErr)
}
内置函数
内置函数就是不需要进行导入操作就可以直接使用的函数,它们有些可以根据不包进行操作(例如len、cap和append),有些用于系统级的操作(例如panic)。常见内置函数如下所示。
内置函数 详解 close 用于管道通信。 len 用于返回某个类型的长度或数量(字符串、数组、切片、map和管道)。 cap 容量的意思,用于返回某个类型的最大容量(只能用于切片和map)。 new、make 均用于分配内存,不过new用于值类型和用户定义的类型,如自定义结构,make 用于内置引用类型(切片、map和管道)。它们的用法就像是函数。但是将类型作为参数: new(type)、 make(type)。 new(T)分配类型 T的零值并返回其地址,也就是指向类型T的指针,它也可以用于基本类型: v := new(int)。返回类型T的初始化之后的值,因此它比new做更多的工作。new()是一 个不要忘记它的括号。 copy、 append 用于复制和连接切片。 panic、recover 两者均用于错误处理机制。 print、println 底层打印函数(部署环境中建议使用fmt包) . complex、 real imag 用于创建和操作复数。
7.复合数据类型
package main
import "fmt"
func main ( ) {
arrays:= [ 5 ] int { 1 , 2 , 3 , 4 , 5 }
for _ , v:= range arrays {
fmt. Println ( v)
}
arrays_a1:= [ ] int { 1 , 2 , 3 , 4 , 5 , 6 }
for _ , v1:= range arrays_a1 {
fmt. Print ( v1)
}
fmt. Println ( "\n" )
array_str1:= [ 5 ] string { "a" , "b" , "c" , "d" , "e" }
for i:= 0 ; i< len ( array_str1) ; i++ {
fmt. Printf ( "值的下标为:%d,值是%s\n" , i, string ( array_str1[ i] ) )
}
array_str2:= [ 5 ] string { "a" , "b" , "c" , "d" , "e" }
array_str2[ 0 ] = "a1"
fmt. Println ( "值为" , array_str2[ 0 ] )
array_str3:= [ 5 ] * int { 0 : new ( int ) , 1 : new ( int ) }
* array_str3[ 0 ] = 10
* array_str3[ 1 ] = 20
fmt. Println ( "数组的值为:" , * array_str3[ 0 ] )
array_str4:= [ 3 ] * string { new ( string ) , new ( string ) , new ( string ) }
* array_str4[ 0 ] = "a1"
fmt. Println ( * array_str4[ 0 ] )
array_str1_a:= [ 4 ] [ 2 ] int { { 10 , 10 } , { 20 , 21 } , { 30 , 31 } , { 40 , 41 } }
for i:= 0 ; i< len ( array_str1_a) ; i++ {
for j:= 0 ; j< len ( array_str1_a[ i] ) ; j++ {
fmt. Printf ( "每个的二维数组的值是%d\n" , array_str1_a[ i] [ j] )
}
}
array_str1_a[ 0 ] [ 0 ] = 100
fmt. Println ( array_str1_a)
slice_array:= [ ] int { 10 , 20 , 30 , 40 , 50 }
new_slice:= slice_array[ 1 : 3 ]
for _ , v:= range new_slice {
fmt. Println ( v)
}
fmt. Println ( len ( new_slice) )
new_slice= append ( new_slice, 60 )
fmt. Println ( new_slice)
array_str1_b:= [ ] [ ] int { { 10 , 10 } , { 20 , 21 } , { 30 , 31 } , { 40 , 41 } , { 410 , 123 , 111 } }
array_c1:= [ ] int { 12 , 123 }
slice_array= append ( slice_array, array_c1... )
fmt. Println ( slice_array)
array_str1_b= append ( array_str1_b, array_c1)
fmt. Println ( array_str1_b)
dict:= map [ string ] string { "a" : "1" , "b" : "2" , "c" : "3" }
dict[ "a" ] = "123"
delete ( dict, "c" )
dict[ "d" ] = "4"
for k, v:= range dict {
fmt. Println ( k, v)
}
Goods := [ ] map [ string ] string { { "a" : "1" } , { "1" : "23" } }
fmt. Println ( Goods)
Goods_p:= map [ string ] [ ] string { "a" : { "1" , "2" , "3" } , "b" : { "4" , "5" , "6" } }
fmt. Println ( Goods_p)
Goods_p_dic:= map [ string ] [ ] map [ string ] string { "map" : { { "a" : "1" } , { "b" : "2" } } }
fmt. Println ( Goods_p_dic)
}