package main
import "fmt"
func main(){
	var ageOfGirl int
	fmt.Println("请输入年龄：")
	fmt.Scanln(&ageOfGirl)
	if ageOfGirl < 24 {
		fmt.Println("要号码")
	}else if ageOfGirl >24 && ageOfGirl<28 {
		fmt.Println("加微信")
	}else {
		fmt.Println("打扰了")
二、if判断
 
if 条件 {
package main
import "fmt"
func main(){
	var ageOfGirl int = 20
	if ageOfGirl < 24 {
		fmt.Println("要号码")
2.2、if-else
 
if 条件 {
}else{
var ageOfGirl int = 18
if ageOfGirl > 30 {
    fmt.Println("阿姨")
}else{
    fmt.Println("小姐姐")
2.3、if-else if-else
 
if 条件1 {
}else if 条件2{
}else if 条件3{
}.....             //可以写很多else if
}else{
//如果：成绩》=90，那么：优秀，
//如果：成绩》=80且<90，那么：良好，
//如果：成绩》=70且<80，那么：普通
//其它情况：很差
var score int = 50
if score >= 90 {
    fmt.Println("优秀")
}else if score >= 80 {
	fmt.Println("良好")
}else if score >= 70 {
	fmt.Println("普通")
}else {
	fmt.Println("很差")
2.4、if的嵌套
 
if 条件1 {
    代码...
    if 条件x {
	    代码...
    }else{
	    代码...
}else{
	代码...
var ageOfGirl int = 18
var isSuccess bool = True      //是否表白成功
if ageOfGirl > 30 {
    fmt.Println("阿姨好")
}else{
    fmt.Println("表白...")
    if isSuccess {
	    fmt.Println("在一起...")
    }else{
	    fmt.Println("强行在一起...")
2.5、判断条件之前加可执行语句，用分号隔开
 
if ageOfGirl := 18；ageOfGirl > 30 {
    //强调：如果是定义变量，这里只能用短声明 :=
    //且这里定义的变量只能在当前if相关的代码体中使用
    fmt.Println("阿姨好")
}else{
    fmt.Println("小姐好")
三、switch分支选择
 
3.1、switch选择分支是什么？
 
 
switch英语里是岔道的意思，表明你面临了选择，在go语言里，当满足了岔道（分支）的条件，就会去执行岔道（分支）里的代码。这个if判断很类似，满足这个条件我就执行这块代码，满足另一个条件我就执行另一块代码。
 
3.2、为什么要有 switch选择分支？
 
 
既然switch分支选择功能上和if判断类似，那为什么还要有它啊？存在即合理。虽然switch分支选择也可以用if判断来实现，但是在特定的情况下，switch分支选择要比if判断更简洁。
 
3.3、怎么用switch分支选择？
 
 方式一（判等）：
 
 
因为switch的判断就相当于“判断量==被判断量”，所以两者类型要相同，准确的讲是要能够写成“判断量==被判断量”的形式
 
switch + break:终止switch代码
 switch + fallthrough:跳过紧跟其后的case判断,直接执行他下面的代码体(只能写在case代码体最后一行)
 
 
我们平时开发中尽量不要去使用break和fallthrough，break和fallthrough是用来解决历史遗留问题的，现在很多公司都在拿go去重写c++的程序，在c++里，switch的一个case运行结束后，会直接去运行下一个case的体代码，除非手动在case的末尾加上break。为了兼容c++里的break功能和一个case运行完直接运行下一个case的体代码这种情况，go语言里才加入了break和fallthrough的功能
 
var isUgly bool = true      //客户是否长得丑
switch name := "女总经理"; name {
case "男总经理","女总经理":    //这里是或的关系
    fmt.Println("总经理好")
case "预约访客"：
	if isUgly {
		break              //长得丑就直接终止程序
	}else{
		fmt.Println("你微信号多少")
	fmt.Println("你好")
default：
	fmt.Println("出门右转")    
方式二（比较）：
 
var studentFather string = "校长"
switch score := 82; {
case score>=90,studentFather == "校长" :
    fmt.Println("优秀")
case score>=80 :
    fmt.Println("良好")
case score>=70 :
    fmt.Println("一般")
default :
    fmt.Println("很差")
四、for循环
 
4.1、基本形式：
 
for 初始条件；循环条件；追加语句{
    循环体代码...
for循环开始时会首先执行一次“初始条件”，然后接着判断“循环条件”是否为true，如果是true，那就开始执行“循环体代码”，每一次循环结束都会执行一次“追加语句”，然后继续判断“循环条件”，false就结束循环。
 
正常情况下，我们会在“初始条件”里写一个变量声明，通过对这个变量的判断，以及赋值来控制循环的次数。如：
 
for i := 0; i < 3; i++ {
    fmt.Println(i)
每次循环后变量i都会加1，直到不满足i<3这个循环条件，如此，循环就被限制成了3次。
 
九九乘法表：
 
    for i:=1;i<=9;i++{
		for j:=1;j<=i;j++{
			fmt.Printf("%d * %d = %d  ",j,i,i*j)
		fmt.Println()
4.2、省略形式：
 
初始语句，循环条件和追加条件都可以被省略，但“；”要保留，如下：
 
1、省略初始语句。
 
 
这没什么好说的，初始语句就是在for循环第一次执行的时候有且只只会执行一次。省略了它，写在for循环外面也一样。但需要注意的是，如果变量在初始化语句中定义，那么它就只能在for中被使用
 
var i int = 0
for ; i < 3; i++{
    .......
 2、省略追加语句。 
 
 
这也没什么好说的，追加语句就是在每次循环结束的时候会执行的语句。省略了它，就写在for循环的循环体代码内，效果也一样。它的省略是为了让循环更加灵活，我们可以把“i++”写在循环体的任意一行，也可以通过判断对它进行逻辑修饰。
 
var isAdd2 = true
for i := 0; i < 3; {
    if isAdd2{
	    i += 2
    }else{
 同时省略初始语句和追加语句时，“；”可以不写，如：
 
var i int = 0 
var isAdd2 = true
for i < 3 {
    if isAdd2{
	    i += 2
    }else{
3、省略循环条件。
 
当循环条件被省略的时候，for循环运行一次之后进行循环条件判断的时候，会把循环条件当成true。换句话说，就是会一直循环。如：
 
for i:=0; ; i++{
    fmt.Println(i)
//相当于：
for i:=0; true; i++{
    fmt.Println(i)
for后面的语句都省略的时候，“；”也可以不写：
 
for {
    fmt.Println(i)
4.3、for循环的嵌套
 
for循环里嵌套了一个或者多个for循环，如下：
 
for i:=0; i<3; i++ {
    fmt.Println("第一层：",i)
    for j:=0; j<3; j++ {
	    fmt.Println("第二层：",j)
4.4、for循环的终止
 
1、变量开关
 
for tag:=true; tag;{
	.....
    for tag {
	    tag = false
我们把变量开关放在循环条件里，通过对变量开关的控制（赋值为false），来跳出循环。
 
2、continue
 
for i:=0; i<10; i++{
    if i == 5 {
	    continue
    fmt.Println(i)
当前循环一旦碰到continue，不管循环体里剩下多少代码没有执行，都会直接跳过，开始下一次循环
 
3、break
 
for i:=0; i<3; i++{
    fmt.Println("第一层：",i)
    for j:=0; j<10; j++{
	    fmt.Println("第二层：",j)
	    if j==1 {
		    break
第一层： 0
第二层： 0
第二层： 1
第一层： 1
第二层： 0
第二层： 1
说明： 如果没有break，那么第二层循环应该执行10次，但我在j=1（第二层循环执行到第二次）的时候加上了break，那么就直接跳出了第二层循环，剩下的8次都不会再执行
 
1、什么是标签：
 
生活中标签是用来附在某样东西上，并给它做标记的。go语言中，标签是用来给代码做标记的，会记录住代码在程序中的位置。
 
2、为什么要有标签：
 
标记不是目的，目的是使用。我们记录位置是为了干什么呀？当然是为了快速的找到被标记的代码，方便进行相应的操作。
 
3、怎么用标签：
 
标签的格式如下：
 
标签名1：
    for i := 0; i < 5; i++ {
	    代码...
标签名2：
    switch {
	    代码...
标签名3：
    fmt.Println("今天天气不错")
 
1、为了区分标签和变量，通常标签名我们会用大写字母加数字来表示。
2、创建了标签就一定要使用，不然会引发错误。
 
4、break + 标签
 
我们在for循环里讲到过break，for循环里单独写break是用来跳出本层循环的。如：
 
for {
    for i:=0; ; i++ {
	    if i == 2 {
			fmt.Println(i)
			break
运行的结果是控制台无限打印2，原因是这里的break只是跳出了里层循环，而最外层的循环并没有被终止。
 
那现在我就想满足条件时，终止所有循环，怎么办？我们改变它的循环条件不就完了嘛，之前是不是学过一个变量开关的方法啊？如下：
 
for tag:=true; tag; {
    for i:=0; tag; i++ {
	    if i==2 {
		    fmt.Println(i)
		    tag = false
还有其它方法吗？当然有，就是我们下面要说的break + 标签。如下：
 
LABEL1:
    for {
	    for i:=0; ; i++ {
		    if i == 2 {
				fmt.Println(i)
				break LABEL1
我们用LABEL1来标记最外层循环，然后用break LABEL1来指定要跳出的循环，这里跳出的是最外层循环。 当然也可以用标签去标记内层循环，如：
 
for {
    LABEL1:
	    for {
		    for i:=0; ; i++ {
			    if i == 2 {
					fmt.Println(i)
					break LABEL1
5、continue + 标签
 
continue + 标签，用于终止指定循环的本次循环并继续下一次循环。用法和break一样，只是关键字不同。如：
 
LABEL1:
    for i:=0; i<3; i++ {
	    for j:=0; j<3; j++ {
		    continue LABEL1
		    fmt.Println("我是内层循环，j=",j)
	    fmt.Println("我是外层，i=",i)
6、goto + 标签
 
代码都是从上而下一行行执行的，而goto + 标签，可以强行跳转到函数体内指定代码，并继续向下执行。
 
在一般的开发中，“goto LABEL”能不用就不用，除非是遇到的问题再也没有其它更好的办法可以解决。因为“goto LABEL”牺牲的是代码可读性和可维护性。
 
func main(){
    for i:=0; i<3; i++ {
	    fmt.Println(i)
	    if i>1 {
		    goto EXIT
EXIT:
    fmt.Println("exit....")
1、goto语句仅适用于函数内部跳转，不可跳转到其它函数。这和函数作用域有关
 
func text1() {
LABEL1:            //报错 label LABEL1 defined and not used
	fmt.Println("我是text1")
func main() {
	goto LABEL1    //报错 label LABEL1 not defined
2、goto语句不能跳过变量声明语句
 
        goto LABEL1   
	//报错 goto LABEL1 jumps over declaration of a
	//goto LABEL1 跳过了a的声明
	var a int= 111
LABEL1:
	fmt.Println("测试......")
 
                    一、命令行交互命令行交互一般使用 fmt.Scanln()用于接收输入，然后通过指针用输入的值修改定义好的变量的值package mainimport (	"fmt"	"reflect")func main()  {	var name string	var age int	fmt.Print("请输入你的名字和年龄：")	// _是占位符，如果该位接收的话，输出...
// 需认证的路由代码
func registerTgWsRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
	api := apis.TgWs{}
	r := v1.Group("")
		// 协议、IP、端口
		r.GET("/
				
go env 用于打印Go语言的环境信息。
go run 命令可以编译并运行命令源码文件。
go get 可以根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，并对它们进行编译和安装。
go build 命令用于编译我们指定的源码文件或代码包以及它们的依赖包。
go install 用于编译并安装指定的代码包及它们的依赖包。
go clean 命令会删除掉执行其它命令时产生的一些文件和目录。
go doc 命令可以打印附于Go语言程序实体上的文档。我们可以通过把程序实体的标识符作为该命令的...
error: Cannot assign requested address
无法将当前地址分配给jupyter notebook
c.NotebookApp.ip='123.21.242.32'
c.NotebookApp.passwo...
				
cron，是一个Linux定时执行工具，可以在无需人工干预的情况下运行作业。
在Ubuntu server 下，cron是被默认安装并启动的；如果没有启动，自行设置并启动(chkconfigsysv-rc-conf)。通过其配置文件 /etc/crontab 可以看到以下内容：ununtu 通过调用 run-parts 命令，定时运行四个目录下的所有脚本。
1）/etc/cron.hourly，目录下的脚本会每个小时让执行一次，在每小时的17分钟时运行；
2）/etc/cron.daily，目录下的脚本会每
	t , err := term . Open ( "/dev/tty" )
	if err != nil {
		log . Fatalf ( "error: %s \n " , err )
	t . SetRaw ()
	defer t . Restore ()
	fmt . Pri
				
在 Golang 中，可以使用 defer 和 recover 函数来捕获和处理 panic 异常。您可以在 for 循环中使用 defer 和 recover 函数来拦截 panic 异常，如下所示：
```go
for i := 0; i < 10; i++ {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("Recovered from panic:", err)
    // your code here
在上面的代码中，defer 函数会在每次循环后执行，它会调用 recover 函数来捕获 panic 异常，如果有异常发生，它就会打印异常信息并继续执行下一次循环，而不是退出整个循环。这样可以确保程序不会因为一个循环中的 panic 而崩溃。