02---go语言的基础操作

痛定思痛。 2022-11-13 09:30 162阅读 0赞

### 目录 ###

*   *  一：GO语言最基础操作
     *   *  1： 注释：
         *  2：变量：
         *  3：自动推导类型：
         *  4：输出与输入格式：
         *  5： 变量的命名格式：
         *  6：转义字符：
         *  7： 格式化输出与定义：
         *  8： 常量：
         *  9：iota 枚举：
     *  二：五种基础数据类型：
     *  三：运算符：
     *   *  1：算数运算符：
         *  2：赋值运算符：
         *  3：关系运算符：
         *  4：逻辑运算符：
         *  5：其他运算符：
         *  6：运算符的优先级：
         *  7：类型的转换：
     *  四：流程控制：
     *   *  1： 选择结构：
         *  2：循环结构：
     *  五：函数：
     *   *  1： 函数定义，参数， 类型，返回值：
         *  2：函数嵌套调用：
         *  3: 函数变量作用域：
         *  4：匿名函数：

## 一：GO语言最基础操作 ##

### 1： 注释： ###

*  1：单行注释： //
 *  2：块注释：/\* \*/
 *  3：快捷键： CTRL + /

### 2：变量： ###

*  变量的定义：var 变量名 数据类型 = 值
    
        // var 变量名 数据类型 = 值
        	var sun int = 50
            fmt.Println(sun)
 *  变量的声明：var 变量名 数据类型
    
        //变量的声明 没有赋值 ， 默认是0
        	var sun int
        	//输出是0
        	fmt.Println(sun)
 *  简单的使用数学函数进行计算：
    
        var value float64 = 2
        	var sum float64 = math.Pow(value, 10)
        	fmt.Println(sum)
 *  变量的交换：
    
        a := 10
        	b := 20
        	//交换两个变量的值
        	a, b = b, a
        	fmt.Println(a, b)
        	//输出：20 10
 *  变量的多重赋值：
    
        //多重赋值
        	a, b := 10, 20
        	fmt.Println(a, b)

### 3：自动推导类型： ###

*  go语言使用 := 可以自动推导类型：
    
        // 不同类型的数据类型在内存中开辟的空间是不同的。
        	a := 10 // int
        	b := 20.01 // float64
        	c := "哈哈哈" // string
        	fmt.Println(a)
        	fmt.Println(b)
        	fmt.Println(c)
 *  注意： 不同类型之间不能进行计算，需要转换成相同类型才能计算。
 *  自动推导与多重赋值之间的奇葩：如果只有前面已经定义的，不能使用自动推导，如果存在没有定义的，则可以使用。
    
        //多重复值的奇葩
        	a, b := 10, 20
        	fmt.Println(a, b)
        	// 如果前面定义了a, b 此时进行多重赋值是不可以的
        	//a, b := 100, 200 (错误的)
        
        	// 而下面的这种情况是可以的
        	a, b, c := 300, 400, "hahah"
        	fmt.Println(a, b, c)

### 4：输出与输入格式： ###

*  三种输出操作的区别：
    
        // 输出：换行与不换行的区别
        	fmt.Println("jakdaldn") //存在换行
        	fmt.Print("adaldma")//不存在换行
        	//支持格式的输出
        	a := 10
        	b := 3.14
        	// %d 输出整型数据 %f 输出浮点类型， 默认保存6位小数
        	fmt.Printf("%d, %f", a, b)
            fmt.Printf("%.2f", b) //保留两位小数，对第三位进行四舍五入（包括5）
            fmt.Print("%s\n", "jaaladlas") // %s 表示字符串， \n表示换行操作
 *  输入操作：
    
     *  简单的输入操作：fmt.Scan($变量名)
    
        // 如何输入一个int类型的数据呢？
        	// 1： 首先声明变量
        	var a int
        	// 2：输入到a变量中
        	fmt.Scan(&a)
        	// 3：打印输入的值
        	fmt.Println(a)
    
     *  简单的输入多个数据：
        
            var a, b int
            	//终端输入数据的时候，空格和回车都表示输入一个数据结束。
            	fmt.Scan(&a, &b)
            	fmt.Println(a)
            	fmt.Println(b)
     *  fmt.Scanf的使用：
        
            var a int
            	var b string
            	//注意%d与%s之间不能存在其他的数据
                //注意接收字符串数据的时候也要使用空格，不能使用回车。
            	fmt.Scanf("%d%s", &a, &b)
            	fmt.Println(a)
            	fmt.Println(b)

### 5： 变量的命名格式： ###

*  字母或者下划线开头，不能使用数组开头。
 *  不能使用关键字：
    
    <table> 
     <thead> 
      <tr> 
       <th>break</th> 
       <th>default</th> 
       <th>func</th> 
       <th>interface</th> 
       <th>select</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>case</td> 
       <td>defer</td> 
       <td>go</td> 
       <td>map</td> 
       <td>struct</td> 
      </tr> 
      <tr> 
       <td>chan</td> 
       <td>else</td> 
       <td>goto</td> 
       <td>package</td> 
       <td>switch</td> 
      </tr> 
      <tr> 
       <td>const</td> 
       <td>fallthrough</td> 
       <td>if</td> 
       <td>range</td> 
       <td>type</td> 
      </tr> 
      <tr> 
       <td>continue</td> 
       <td>for</td> 
       <td>import</td> 
       <td>return</td> 
       <td>var</td> 
      </tr> 
     </tbody> 
    </table>
 *  不能是预定义的名字：例如 int, uint, uint8等等。
 *  区分大小写

### 6：转义字符： ###

*  \\n : 换行 。
 *  \\0: 字符串的结束符。
 *  \\t: 制表符，一次4个空格。

### 7： 格式化输出与定义： ###

*  1： 打印出% ：fmt.Printf(“35%%” ), 打印出 35%
 *  2：打印进制数据：
    
     *  打印出二进制数据： fmt.Printf("%b\\n", 58)
     *  打印出八进制数据： fmt.Printf("%o\\n", 58)
     *  打印出十六进制数据： fmt.Printf("%x\\n", 58) —10到15用a-f表示
     *  打印出十六进制数据： fmt.Printf("%X\\n", 58) —10到15用A-F表示
     *  %c： 字符, 使用单引号。
     *  %d： 数字
     *  %：字符串， 使用双引号。
     *  %p: 打印变量地址： fmt.Printf("%p\\n", &a): 使用无符号16进制整型表示。
     *  %t: 输出布尔值
 *  3：如何定义进制数据呢？
    
     *  二进制数据不能直接定义。
     *  十进制数据直接定义： var a int = 10
     *  八进制数据以0开头： var b int = 010
     *  十六进制以0x/0X开头： var c int = 0xABC

### 8： 常量： ###

*  常量的定义： const a int = 10
 *  常量不允许进行赋值：
    
    例如： a = a + 10, 这是不允许的。
 *  常量的定义一般采用大写字母，为了和变量进行区分。
 *  常量的定义其实可以不使用类型约束，可以自动识别。
    
    例如： const MAX = ‘哈哈’
 *  常量的地址是不能直接访问的。(为了安全性)
    
    例如：fmt.Printf("%p\\n", &MAX)

### 9：iota 枚举： ###

*  iota枚举
    
     *  iota类型是不允许修改的。
     *  iota默认值是0，如果写在一行则，值是相等的，如果不是一行则依次类推。
        
            func main(){
                    
            	const (
            		a = iota
            		b = iota
            		c = iota
            	)
            
            	fmt.Printf("%d\n", a) // 0
            	fmt.Printf("%d\n", b)  // 1
            	fmt.Printf("%d\n", c) // 2
            }
        
            const (
            		a , b = iota, iota
            		c = iota
            	)
            
            	fmt.Printf("%d\n", a) // 0
            	fmt.Printf("%d\n", b) // 0
            	fmt.Printf("%d\n", c) // 1
     *  iota的另外的定义格式：
        
            const (
            		a = iota
            		b
            		c
            	)
            
            	fmt.Printf("%d\n", a) // 0
            	fmt.Printf("%d\n", b) // 1
            	fmt.Printf("%d\n", c) // 2
     *  iota中间赋值， 后面的则补充遵循iota原则。
        
            const (
            		a = iota
            		b  = 10
            		c
            	)
            
            	fmt.Printf("%d\n", a) // 0
            	fmt.Printf("%d\n", b) // 10
            	fmt.Printf("%d\n", c) // 10
     *  iota如果后续再次出现iota则，直接变成顺序增长的值。
        
            const (
            		a = iota
            		b  = 10
            		c
            		d = iota
            	)
            
            	fmt.Printf("%d\n", a) // 0
            	fmt.Printf("%d\n", b) // 10
            	fmt.Printf("%d\n", c) // 10
            	fmt.Printf("%d\n", d) // 3

## 二：五种基础数据类型： ##

*  布尔类型：true或者false(默认值是flase)
 *  字符类型：
    
     *  所有的字符都有自己对应的一个码值，如果直接打印输出的是数字。
     *  a—>97, A—>65, ‘0’—>48,
     *  如果想打印字符串可以使用printf进行打印：使用%c
        
         *  fmt.Printf("%c\\n", 97) —>打印出a
         *  
 *  整型：
    
     *  int类型根据操作系统的不同，占的字节也是不同的。
        
        <table> 
         <thead> 
          <tr> 
           <th>int</th> 
           <th>有符号32位</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td>uint</td> 
           <td>无符号64位</td> 
          </tr> 
          <tr> 
           <td>int8</td> 
           <td>-128到127</td> 
          </tr> 
          <tr> 
           <td>uint8</td> 
           <td>0到255</td> 
          </tr> 
          <tr> 
           <td>int16</td> 
           <td>类推即可</td> 
          </tr> 
          <tr> 
           <td>uint16</td> 
           <td>类推即可</td> 
          </tr> 
          <tr> 
           <td>int32</td> 
           <td>类推即可</td> 
          </tr> 
          <tr> 
           <td>uint32</td> 
           <td>类推即可</td> 
          </tr> 
          <tr> 
           <td>int64</td> 
           <td>类推即可</td> 
          </tr> 
          <tr> 
           <td>uint64</td> 
           <td>类推即可</td> 
          </tr> 
         </tbody> 
        </table>
 *  浮点型：
    
    <table> 
     <thead> 
      <tr> 
       <th>float32</th> 
       <th>单精度浮点类型</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>float64</td> 
       <td>双精度浮点类型</td> 
      </tr> 
     </tbody> 
    </table>
    
     *  1：float64比float32精确度更高。
     *  2：小数位精确到7位， 小数位精确到15位。
     *  3：自动推导类型创建的浮点类型，默认就是float64
 *  字符串类型
 *  go语言中如何输出一个变量对应的数据类型呢？
    
        //使用Printf， %T 表示打印对应变量的类型
        	a := false
        	b := 1
        	c := "哈哈哈"
        	fmt.Printf("%T\n%T\n%T", a, b, c)

## 三：运算符： ##

### 1：算数运算符： ###

*   *  
 *   *  
 *   *  
 *  / ：
    
     *  **两个数相除，对最后的结果取整**。（不是四舍五入）
     *  **除数不能是0**
 *  % ：
 *  \++ (自增)
 *  –（自减）

### 2：赋值运算符： ###

*  =
 *  \+=
 *  \-=
 *  \*=
 *  /=
 *  %=

### 3：关系运算符： ###

*  == ：相等
 *  `>=` :
 *  `<=`:
 *  != :

### 4：逻辑运算符： ###

*  ! : 非
 *  && ：与
 *  || 或

### 5：其他运算符： ###

*  & 取地址：
 *  \*指针运算符：

### 6：运算符的优先级： ###

*  （）
 *  \[\]
 *  .
 *  单目运算符：！ ++ – & \*
 *  双目运算符：\* / % + - (乘除，取余高于加减)
 *  比较运算符：> < >= <= == !=
 *  逻辑运算符：&& || （逻辑与高于逻辑或）
 *  赋值运算符：/= += -= /= %= （优先级均相等）

### 7：类型的转换： ###

*  格式1：数据类型（变量）
 *  格式2： 数据类型（表达式）

## 四：流程控制： ##

### 1： 选择结构： ###

*  if—else if—else语句：
    
    案例：如果成绩小于60，输出‘垃圾’，如果成绩在60-80之间输出"还行", 如果大于80，输出’牛逼’。
    
        func main(){
              
        	var score int
        	fmt.Scan(&score)
        	if score < 60 {
              
        		fmt.Println("垃圾")
        	}else if score >= 60 && score <= 80 {
              
        		fmt.Println("还行")
        	}else{
              
        		fmt.Println("牛逼")
        	}
        }
 *  switch分支结构：
    
        var num int
        	fmt.Scan(&num)
        	switch num {
              
        	case 1:
        		fmt.Println("去清华")
        	case 2:
        		fmt.Print("去北大")
        	case 3:
        		fmt.Print("去交大")
        	}
    
        func main(){
              
        	var score int
        	fmt.Scan(&score)
        	switch {
              
        	case score >= 90:
        		fmt.Println("A")
        	case score >= 80:
        		fmt.Println("B")
        	case score >= 70:
        		fmt.Println("C")
        	case score >= 60:
        		fmt.Println("D")
        	default:
        		fmt.Println("E")
        	}
        
        }
    
        func main(){
              
        	var score int
        	fmt.Scan(&score)
        	switch score > 60{
              
        	case true:
        		fmt.Println("及格")
        	case false:
        		fmt.Println("不及格")
        	}
        
        }

### 2：循环结构： ###

*  案例：循环输出1到10：
    
        func main(){
              
        	for i:= 0; i < 10; i++{
              
        		fmt.Println(i)
        	}
 *  循环的跳出：
    
     *  break ： 跳出一层循环。
     *  continue ： 跳出后继续执行。
     *  go ： 跳出循环到指定的地方去执行。
    
        //跳转到标志位继续执行， 习惯使用大写字母表示。 
        func main(){
              
        	fmt.Println("hello word1")
        	fmt.Println("hello word2")
        	fmt.Println("hello word3")
        	goto FLAG
        	fmt.Println("hello word4")
        	FLAG:
        	fmt.Println("hello word5")
        }

## 五：函数： ##

### 1： 函数定义，参数， 类型，返回值： ###

*  1：函数的定义：
    
        func 函数名（参数列表）（返回值列表）{
              
            //代码体
        }
    
    案例：创建实现两数之和的函数。
    
        func add(n1 int , n2 int) {
              
        	sum := n1 + n2
        	fmt.Println(sum)
        }
        func main(){
              
        	a := 10
        	b := 20
        	add(a , b)
        }
 *  2：不定长参数列表：
    
        // ...表示不定长参数， 调用时可以传递不定长参数
        func add(arr ...int){
              
        	//arr是一个数据的集合
        	fmt.Println(arr)
        	// 计算数据集合的个数
        	fmt.Println(len(arr))
        	//arr[]找到具体元素值
        	fmt.Println(arr[0])
        	// 遍历数据的集合
        	for i := 0; i < len(arr); i++{
              
        		fmt.Print(arr[i])
        	}
        }
        
        
        func main(){
              
        	add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        }
 *  3：函数的返回值：
    
     *  return : 返回
    
        // func 函数名（函数参数列表）（函数返回值类型）
        func test01(a int, b int) int {
              
        	return a + b
        }
        
        func main(){
              
        	fmt.Println(test01(1, 2))
        }
 *  4：函数的类型：
    
     *  内存四区模型：当加载函数的时候，会将函数从代码区域加载到栈区，然后执行函数，函数结束后销毁栈区的函数信息。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]

*  当打印函数的时候， 默认打印的是代码区的地址。
 *  函数可以赋值给一个变量吗？
    
        func demo01(a int , b int){
              
        	fmt.Println(a + b)
        }
        func main(){
              
        	// 打印函数地址:
        	fmt.Println(demo01)
        	// 函数赋值给变量
        	f := demo01
        	// 打印f, 发现和函数demo的地址是相同的。
        	fmt.Println(f)
        	// 调用函数，运行结果是30
        	f(10, 20)
        	
        }
 *  案例： 定义一个函数类型变量， 然后将变量赋值一个函数类型，再使用变量进行调用。
    
        func demo01(a int , b int){
              
        	fmt.Println(a + b)
        }
        
        func main(){
              
        	// 定义一个变量，变量的类型是函数类型
        	var f func(int, int)
        	// 给这个变量赋值函数
        	f = demo01
        	//打印这个函数以及函数类型
        	fmt.Println(f)
        	fmt.Printf("%T\n", f)
        	// 调用这个函数
        	f(10, 20)
        }
 *  变量被赋值成函数还能再次被赋值成其他的函数吗？
    
     *  答：可以， 但是函数的类型必须跟之前函数的类型相同才可以。
     *  案例：
        
            import "fmt"
            
            func demo01(a int , b int){
                    
            	fmt.Println(a + b)
            }
            
            
            func demo02(a int , b int) int{
                    
            	return a + b
            }
            
            func demo03(a int, b int){
                    
            	fmt.Println( a + b)
            }
            
            func main(){
                    
            	// 定义一个变量，变量的类型是函数类型
            	var f func(int, int)
            	// 给这个变量赋值函数
            	f = demo01
            	//打印这个函数以及函数类型
            	fmt.Println(f)
            	fmt.Printf("%T\n", f)
            	// 调用这个函数
            	f(10, 20)
            
            	// 再次赋值demo2：注意此时函数的类型是 func(int int) int 类型， 而不是原来的 func (int int)类型了。
            	//此时必然报错
            	//f = demo02
            	//fmt.Println(f)
            
            
            	// 再次赋值给demo3, 此时类型是相同的。
            	f = demo03
            	f(100, 200) // 得到答案300
            }
 *  通过type关键字定义类型：

import "fmt"
    
    func demo01(a int , b int){
        
    	fmt.Println(a + b)
    }
    
    
    // 定义变量类型
    type FUNCDEMO func(int, int)
    
    func main(){
        
    	// 定义函数类型变量
    	var f FUNCDEMO
    	// 变量赋值
    	f = demo01
    	//标量调用
    	f(10, 20)
    }

### 2：函数嵌套调用： ###

*  简单的函数嵌套：
    
        func test2(a int, b int){
              
        	fmt.Println("我是test2")
        	fmt.Println(a + b)
        }
        
        
        func test1(a int , b int){
              
        	fmt.Println("我是test1")
        	test2(a, b)
        }
        
        //函数嵌套调用:
        func main(){
              
        	a := 10
        	b := 20
        	test1(a, b)
        }
        /*结果：
        我是test1
        我是test2
        30
        */
 *  不定长参数的嵌套调用：
    
        func test2(arr ...int){
              
        	fmt.Println("我是test2")
        	fmt.Println(arr[0] + arr[1])
        }
        
        
        func test1(arr ...int){
              
        	fmt.Println("我是test1")
        	test2(arr[0], arr[1])
        }
        
        //函数嵌套调用:
        func main(){
              
        	test1(10, 20)
        }

### 3: 函数变量作用域： ###

*  函数内部定义的变量只能在函数内部使用。—局部变量
 *  函数外部定义的变量整个项目都能使用和修改。—全局变量。
 *  定义的全局变量名不能和其他全局变量名重名。

### 4：匿名函数： ###

*  1： 定义匿名函数：
    
        func main(){
              
        	a := 10
        	b := 20
        	// 定义一个匿名函数，然后进行调用。（）表示调用。
        	func(a int, b int){
              
        		fmt.Println(a + b)
        	}(a, b)
        }
 *  2：匿名函数增加返回值：
    
        func main(){
              
        	a := 10
        	b := 20
        	res := func (a int, b int) int {
              
        		return a + b
        	}(a, b)
        	fmt.Println(res)
        }
 *  3: 区别两个res:注意第一个res是个返回值，而第二个res是个函数。
    
        import "fmt"
        
        func main(){
              
        	a := 10
        	b := 20
        	res := func (a int, b int) int {
              
        		return a + b
        	}(a, b)
        	fmt.Println(res)
        
        	//此时的res函数，而不是返回值
        	res2 := func(a int, b int){
              
        		fmt.Println(a + b)
        	}
        	// 调用res
        	res2(a, b)
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70]: /images/20221022/71b682420ad74abca950baf8bc467e01.png