每天5分钟入门Go语言：基础概念与控制结构_每天五分钟学习go-优快云博客

每天5分钟入门Go语言：基础概念与控制结构

第一个Go程序

在Go语言中，每个程序都从main包和main函数开始执行。

例子：

package main

import "fmt"

func main() {
  fmt.Println("Hello, world")
}

应用场景：打印欢迎信息

package main

import "fmt"

func main() {
  fmt.Println("Welcome to the Go programming workshop!")
}

在这个应用场景中，程序会在控制台输出欢迎信息，适用于教学环境或工作坊的开始。

变量声明

在Go中，变量在使用前必须声明，并指定类型。

例子：

package main

import "fmt"

var a int
var (
  b bool
  c float32
  d string
)

func main() {
  a = 42
  b, c = true, 32.0
  d = "string"
  fmt.Println(a, b, c, d)
}

应用场景：员工信息管理

package main

import "fmt"

func main() {
  var employeeID int = 1001
  var isFullTime bool = true
  var salary float32 = 75000.00
  var employeeName string = "John Doe"
  
  fmt.Printf("Employee ID: %d, Full-Time: %t, Salary: %.2f, Name: %s\n", 
             employeeID, isFullTime, salary, employeeName)
}

在这个应用场景中，我们声明并初始化了与员工相关的变量，然后打印出员工的详细信息。

类型

Go提供了多种内置类型，包括整型、浮点型、布尔型、字符串等。

例子：

package main

import "fmt"

func main() {
  const a int32 = 12
  const b float32 = 20.5
  var c complex128 = 1 + 4i
  var d uint16 = 14
  
  n := 42
  pi := 3.14
  x, y := true, false
  z := "Go is awesome"
  
  fmt.Printf("user-specified types:\n %T %T %T %T\n", a, b, c, d)
  fmt.Printf("default types:\n %T %T %T %T %T\n", n, pi, x, y, z)
}

应用场景：处理用户输入

package main

import "fmt"

func main() {
  var age int
  var isMember bool
  var membershipFee float32
  var username string
  
  fmt.Println("Enter your age:")
  fmt.Scan(&age)
  
  fmt.Println("Are you a member? (true/false)")
  fmt.Scan(&isMember)
  
  fmt.Println("Enter your membership fee:")
  fmt.Scan(&membershipFee)
  
  fmt.Println("Enter your username:")
  fmt.Scan(&username)
  
  fmt.Printf("Thank you, %s! You are %d years old. Member: %t, Membership Fee: %.2f\n", 
             username, age, isMember, membershipFee)
}

在这个应用场景中，我们声明了几个变量来存储用户的信息，并通过fmt.Scan从用户那里获取输入。

数组

数组是相同数据类型元素的集合，具有固定长度。

例子：

package main

import "fmt"

func main() {
  var DeploymentOptions [4]string = [4]string{"R-pi", "AWS", "GCP", "Azure"}
  
  for i := 0; i < len(DeploymentOptions); i++ {
    option := DeploymentOptions[i]
    fmt.Println(i, option)
  }
}

应用场景：处理考试成绩

package main

import "fmt"

func main() {
  var scores [5]float32 = [5]float32{85.5, 92.0, 78.3, 88.6, 91.2}
  
  var sum float32 = 0
  for i, score := range scores {
    fmt.Printf("Student %d scored %f\n", i+1, score)
    sum += score
  }
  
  average := sum / float32(len(scores))
  fmt.Printf("The average score is: %.2f\n", average)
}

在这个应用场景中，我们声明了一个数组来存储学生的考试成绩，并计算了平均分。

映射 (Maps)

映射是存储键值对的数据结构，具有常数时间的查找效率。

例子：

package main

import "fmt"

func main() {
  firstReleases := map[string]int{
    "C": 1972,
    "C++": 1985,
    "Java": 1996,
    "Python": 1991,
    "JavaScript": 1996,
    "Go": 2012,
  }
  
  for k, v := range firstReleases {
    fmt.Printf("%s was first released in %d\n", k, v)
  }
}

应用场景：课程注册系统

package main

import "fmt"

func main() {
  var courseRegistration = map[string]int{
    "Math": 101,
    "Science": 102,
    "History": 103,
    "Geography": 104,
  }
  
  fmt.Println("Course Registration Numbers:")
  for course, regNum := range courseRegistration {
    fmt.Printf("%s: %d\n", course, regNum)
  }
}

在这个应用场景中，我们使用映射来存储不同课程的注册编号，并打印这些信息。

控制流

Go提供了if-else和switch等控制流语句。

例子：

package main

import "fmt"

func average(x []float64) (avg float64) {
  total := 0.0
  if len(x) == 0 {
    avg = 0
  } else {
    for _, v := range x {
      total += v
    }
    avg = total / float64(len(x))
  }
  return
}

func main() {
  x := []float64{2.15, 3.14, 42.0, 29.5}
  fmt.Println(average(x)) // 19.197499999999998
}

应用场景：检查考试成绩是否通过

package main

import "fmt"

func main() {
  var score float64 = 75.0
  
  if score >= 60.0 {
    fmt.Println("Congratulations! You have passed the exam.")
  } else {
    fmt.Println("You have failed the exam. Please try again.")
  }
  
  // 使用switch进行更复杂的逻辑判断
  switch {
  case score >= 90.0:
    fmt.Println("A: Excellent work!")
  case score >= 80.0:
    fmt.Println("B: Good job!")
  case score >= 70.0:
    fmt.Println("C: Satisfactory.")
  case score >= 60.0:
    fmt.Println("D: You passed.")
  default:
    fmt.Println("F: You have failed.")
  }
}