Go 入門 > 0x1 の基本

Go 言語チュートリアル | 新人チュートリアル (runoob.com)を参照し、次のメモを作成しました。
package main

import (
   "fmt"
   "math"
   "strconv"
)

// Book 结构体
type Book struct {
   title string
   author string
   bookId  int
}

var (
   i int = 1
   s string = "2"
)

func main() {
   fmt.Println("fmt**************************************************")
   fmt.Println("Hello, Go!")
   var str string // 空字符串，即零值，即默认值
   fmt.Print(str)

   greeting := "Hello, " + "%s!" // ":="声明并赋值，不可var，不可全局
   fmt.Printf(greeting+"\n", "World")
   var n, err = fmt.Println(fmt.Sprintf(greeting, "World")) // 13 + 1(\n)
   fmt.Println(n, err)
   fmt.Print(string(65) + "\n")  // ASCII码的65对应A

   fmt.Println("变量赋值**************************************************")
   a, b, c := 5, 7, "abc" // 同时（并行）赋值
   b, a, _ = a, b, c      // 交换a, b; 丢弃c, "_"丢弃一般用于接收多返回值
   println(a, b)          // print不加空格,不按语句顺序打印？总是最后执行？
   fmt.Printf("a变量类型为%T\n", a)

   fmt.Println("数组与循环**************************************************")
   // 没有三目运算符（a?b:c），有 goto ，循环不用小括号
   // 在多重循环中，可以用标号 label 标出想 continue 的那层循环。
   //var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
   balance := [...]float32{1:2.0, 3:7.0}  // 自动取最少4个元素
   fmt.Println(balance)
   // range在数组([]type)和切片(长度可变的的动态数组)中返回元素的索引和索引对应的值，在集合(map)中返回 key-value 对。
   for _, v := range balance {   // 丢弃索引，留下值。
      fmt.Print(v)
      fmt.Print("\t")
   }
   fmt.Println()
   for i := 0; i < len(balance); i++ {
      fmt.Print(balance[i])
      fmt.Print("\t")
   }
   fmt.Println()
   //for  {
   //   fmt.Printf("这是无限循环。\n")
   //}

   fmt.Println("切片**************************************************")
   // 切片是动态数组
   s1 :=[] int {1,2,3 }
   fmt.Println(s1)
   //s := make([]int,len,cap) // 可扩大容量后copy旧的进来
   s2 := s1[1:2]
   fmt.Println(s2)   // [2]

   fmt.Println("函数**************************************************")
   str1 := "One"
   str2 := "Two"
   swap(str1, str2)  // 默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
   fmt.Println(str1, str2)
   str1, str2 = swap(str1, str2)
   fmt.Println(str1, str2)

   /* 函数变量 */
   fmt.Println("函数变量**************************************************")
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }
   flt := 123.21
   root := getSquareRoot(flt)
   fmt.Printf("%f的平方根是%f\n", flt, root)
   fmt.Println(paramFuncForInt(getSquareRoot, flt))
   // strconv互换数串
   fmt.Println(strconv.FormatFloat(root, 'e', -1, 64))   // 小数点e后留-1位？

   fmt.Println("指针**************************************************")
   var  ptr *int
   fmt.Printf("ptr 的值为 : %x\n", ptr  )
   fmt.Println("ptr == nil", ptr == nil)
   ptr = &a // * 号用于指定变量是作为一个指针
   fmt.Printf("a的值*ptr为%d，地址即指针ptr为%d\n", *ptr, ptr)
   // 指针数组*ptr[0], 指针指针**ptr（传递）
   //指针参数 swap(&a, &b) 与  func swap(x *int, y *int)

   fmt.Println("结构体**************************************************")
   // 结构体，可用k-v对构造，其指针也用"."访问成员
   // type Book struct{}   book.title  ptr = &book,ptr.title
   book := Book{title: "AI"}
   fmt.Println(book.title)
   ptrBook := &book
   fmt.Println(ptrBook.title)

   // 集合map
   fmt.Println("集合**************************************************")
   countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
   fmt.Println("原始地图", countryCapitalMap)
   //for country := range countryCapitalMap {
   //   fmt.Println(country, "首都是", countryCapitalMap[country])
   //}
   delete(countryCapitalMap, "France")
   capital, ok := countryCapitalMap["France"]   // "", false
   fmt.Println(capital, ok)
   for country, capital := range countryCapitalMap {
     fmt.Println(country, "首都是", capital)
   }
}

// 形参x、y是 string 型变量，返回值是两个 string 型变量
func swap(x, y string) (string, string) {
   return y, x
}

// 函数形参f的类型是 func(x float64) float64
// 对float64型形参 flt ，调用函数 f ，最终得到一个 int 型返回值
func paramFuncForInt(f func(x float64) float64, flt float64) int{
   return int( f(flt) )   // 精度丢失。
   // 基本的类型转换 typeTo(typeFromVar)，如int(flt)，flt是float64型变量
   // 不支持隐式转换（typeToVar = typeFromVar）
}
おすすめ
