文件名&关键字&标识符、变量声明、流程控制语句

文件名&关键字&标识符

1、所有go源码以.go结尾

2、标识符以字母或下划线开头，大小写敏感（Boy 大写的标识符其他包可以调用）

3、_是特殊标识符，用来忽略结果

4、保留关键字

2、go程序的基本结构

package main
import “fmt”
func main() {
    fmt.Println(“hello, world”)
}

1. 任何一个代码文件隶属于一个包

2. import 关键字，引用其他包：

import(“fmt”)

import(“os”)

通常习惯写成：

import (

　　“fmt”

　　“os”

 )

3. golang可执行程序，package main， 并且有且只有一个main入口函数

4. 包中函数调用：

　　a. 同一个包中函数，直接调用　　

　　b. 不同包中函数，通过包名+点+ 函数名进行调用

　　c.每个源文件都可以包含一个init函数，这个init函数自动被go运行框架调用。

　　d.执行顺序，先执行全局变量初始化，然后执行init函数，然后实行main函数。

5. 包访问控制规则：

　　a.大写意味着这个函数/变量是可导出的

　　b.小写意味着这个函数/变量是私有的， 包外部不能访问

add/add.go

package add

var Name string = "xxxxx"
var Age int = 100    //声明变量的时候赋值，:=相当于执行的时候赋值，执行语句必须有入口

/*

var Name string
var Age int

//Name = "hello world"  直接赋值报错，因为这就相当于执行语句，go中执行语句必须有入口，不然编译报错
//Age = 10
    

// 每个源文件都可以包含一个init函数，这个init函数自动被go运行框架调用。

*/

func init () {
    Name = "hello world"
    Age = 10
    
}

main/main.go

package main

import(
    a "go_dev/day2/example2/add" // a为包的别名，如果别名为_导入初始化而不引用
    "fmt"
)


func main() {
    fmt.Println("Name=", a.Name)
    fmt.Println("age=", a.Age)
}

函数声明和注释

1、函数声明： func   函数名字 (参数列表) (返回值列表）{}

func add() {
} 

func add(a int , b int) int {
} 

func add(a int , b int) (int, int) {
} 

2、 注释，两种注释，单行注释: // 和多行注释  /* */

变量声明

var v1 int
var v2 string
var v3 [10]int
var v4 []int
var v5 struct{
    f int
}
var v6 *int
var v7 map[string]int
var v8 func(a int) int

变量声明时的初始化：

var v1 int = 10
var v2 = 10
v3 := 10 //不能用于全局变量的声明

条件判断、选择、循环

1、条件判断

if case1{
　　//
}else if case2{
　　//
}else{

}

if ture{
    //
}
if a==1&&b==1{
    //
}
if b<0 || b>10{
    //
}
if c !=0{
    //
}

if语法糖

var b=100
if b>200{

}

//语法糖

if b:=10;b>200{

}

2、选择语句

    switch i {
        case 0:
            fmt.Println(0)
        case 1:
            fmt.Println(1)
    }

3、循环语句

for init;case1;modify{

}
for a = 0; a < 10; a++ {
  fmt.Println(a)
}

死循环

for case1{

}
var a int = 0
for a < 10 {
  fmt.Println(a)
  a++
}


//无限循环
for{

}

跳出指定的外层循环、继续循环：

break

break 语句可以结束 for、switch 和 select 的代码块。break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的 for、switch 和 select 的代码块上。

for{
    if i>10{
         break   
    }
}

JLoop:
        for j:=0;j<5;j++{
            for i:=0;i<10;i++{
                if i>5{
                    break JLoop
                }
                fmt.Println(i)
            }
        }

continue

continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。在 continue 语句后添加标签时，表示开始标签对应的循环。

for{
    if i>10{
        continue
    }
}

OuterLoop:
    for i := 0; i < 2; i++ {
        for j := 0; j < 5; j++ {
            switch j {
            case 2:
                fmt.Println(i, j)
                continue OuterLoop
            }
        }
    }

 4、跳转语句

i:=0
HERE:
fmt.Println(i)
i++
if i<10{
　　goto HERE
}

5、for range: 遍历数组、切片、map、管道类型

• 数组、切片、字符串返回索引和值。
• map 返回键和值。
• 通道（channel）只返回通道内的值。

遍历数组、切片

for key, value := range []int{1, 2, 3, 4} {
    fmt.Printf("key:%d  value:%d
", key, value)
}

字符串：

• ASCII 字符串遍历直接使用下标。
• Unicode 字符串遍历用 for range。

    str := "hello world"
    for index, val := range str {
        fmt.Printf("index:%d val:%c 
", index, val)
    }

//这种遍历是以字节的形式遍历的
str := "hello 世界"
n := len(str)
for i :=0;i<n;i++{
   ch := str[i]
   fmt.Println(i,ch)
}

map：

m := map[string]int{
        "hello": 100,
        "world": 200,
    }
    for key, value := range m {
        fmt.Println(key, value)
    }

 习题：

1. 判断 101-200 之间有多少个素数，并输出所有素数。

2. 打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字 立方和等于该数本身。例如：153 是一个“水仙花数”，因为 153=1 的三次 方＋5 的三次方＋3 的三次方。 

3. 对于一个数n，求n的阶乘之和，即： 1！ + 2！ + 3！+…n! 

package main

// godoc -http=:9001  然后127.0.0.1查看go的文档
import{
    "fmt"
    "math"   
}

func main(){
    for i:=101;i<200,i++{
        if isPrime(i){
            fmt.Println(i)
        }        
    }
    
    for i:=100,i<999;i++{
        if isNarcissistic(i){
            fmt.Println(i)
        }
    }    
    fmt.Println(factorial(10))    
    
}


func isPrime(n int) bool{
    if n<=1{
        return false
    }
    for i:=2;i<n;i++{
        if n%i==0{
            return false
        }
    }
    
    return true
}


func isNarcissistic(n int) bool{
    if n<100 || n>999{
        return false
    }
    i,j,k := float64(n/100),float64(n/10%10),float64(n%10)
    if math.Pow(i,3)+math.Pow(j,3)+math.Pow(k,3)==float64(n){
        return true
    }    
    return false    
}

func factorial{
    if n<=0{
        return -1
    
    
    var cnt int
    for i:=2;i<=n;i++{
        cnt=cnt *i
    }
    
    return cnt
    
}