Goland 基础语法

标签：数据   移动   函数   min   lock   var   科学   ali   数值   

1. 命名规则

• go 语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则

• 必须以一个字母或下划线_开头，后面可以跟任意数量的字母、数字或下划线

• go 语言中大小写字母认为是不同的

• go 语言中有 25 个关键字，不能用于自定义名字

还有 30 多个预定义的名字，用于内建的常量、类型和函数

内建常量

true    false    iota    nil

内建类型

int   int8   int16  int32      int64
uint    uint8    uint16  uint32  uint64  uintptr
float32     float64     complex128  complex64
bool    byte    rune    string  error

内建函数

make    len cap new append  copy    close   delete
complex  real    imag
panic   recover

2. 变量

声明变量

语法格式: var 变量名 变量类型

package main

import "fmt"

func main() {
/*
    变量不引用会报错
    */

// 1. 直接声明
var v1 int
var v2 int

// 2. 一次声明多个变量
var v3, v4 int

var (
    v5 int
    v6 int
)
fmt.Println(v1, v2, v3, v4, v5, v6)
}

变量初始化

package main

import "fmt"

func main() {
// 1. 直接初始化
var v1 int = 1

// 2. 自动推导初始化
var v2 = 2

// 3. 声明并初始化
v3 := 3

fmt.Println(v1, v2, v3)
}

变量赋值

package main

import "fmt"

func main() {
// 1. 直接赋值
var v1 int
v1 = 1

// 2. :=
v2 := 2

// 3. 多重赋值
var v3, v4 int

fmt.Println(v1, v2, v3, v4)
}

匿名变量

_ 单下滑线表示匿名变量，为了防止变量为被引用报错

package main

import "fmt"

func test() (int, int) {
return 1,2
}

func main() {
//  _单下滑线表示匿名变量，了不报错
v1, _ := test()
fmt.Println(v1)
}

3. 常量与枚举

const 关键字 定义常量

package main

import "fmt"

// 声明在函数外部
const filename = "123.txt"

const (
username = "admin"
password = "admin"
)

func main() {
// 声明在函数的内部
const filename = "456.txt"

fmt.Println(filename)
}

iota 常量生成器和枚举类型

  package main

  import "fmt"

  // 枚举
  func enums001() {
    const (
        v1 = 0
        v2 = 1
        v3 = 2
    )
    fmt.Println(v1, v2, v3)

    // 输出结果 0 1 2
  }

  // 可省略的枚举
  func enums002() {
    const (
        v1 = 0
        v2
        v3 = 1
        v4
    )

    fmt.Println(v1, v2, v3, v4)

    // 输出结果 0 0 1 1
  }

  // 定义自增的枚举类型
  // iota默认值为0
  // 往下依次自增
  func enums003() {
    const (
        v1 = iota
        v2
        v3
        v4
    )

    fmt.Println(v1, v2, v3, v4)

    // 输出结果 0 1 2 3
  }

  // 计算枚举
  func enums004() {
    // b等于1左移
    // 1<<(10 * 0)    1 << 0     相当于 1*2^0
    const (
        b = 1 << (10*iota)
        kb
        mb
        gb
        tb
        pb
    )
    fmt.Println(b, kb, mb, gb, tb, pb)

    // 输出结果
  }

  func main() {
    //enums001()
    //enums002()
    //enums003()
    enums004()
  }

常见面试题

package main

import "fmt"

func main() {
// iota会接着走不会重新来
const (
    a = iota
    b
    c
    d = 9
    e = 8
    f = iota
    g
)
fmt.Println(a,b,c,d,e,g,f)

// iota不在同一个const里，不是同一个
const (
    x = iota
    y
)
fmt.Println(x,y)
}

// 输出结果
// 0 1 2 9 8 5 6

4. 基本数据类型

int8 是有符号类型，uint8 是无符号类型

go 语言中不同类型的数据不能相加，会编译错误

整型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var v1 int
    v1 = 123
    v2 := 42
    fmt.Println(reflect.TypeOf(v1))
    fmt.Println(reflect.TypeOf(v2))
}

浮点型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var f1 float32
    f1 = 12.5
    f2 := 13.66
    fmt.Println(reflect.TypeOf(f1))
    fmt.Println(reflect.TypeOf(f2))
}

布尔型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 只有true和false两个值
    var b1 bool
    b1 = false
    fmt.Println(b1)

    // 可以使用 == 或 != 得到布尔值
    b2 := (1!=2)
    fmt.Println(reflect.TypeOf(b2))

    // 使用 ! 对布尔类型进行取反
    b3 := !b2
    fmt.Println(b3)
}

byte 字符型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 单引号赋值byte
    var ch byte
    ch = 'a'
    fmt.Println(ch)

    // 格式化输出
    fmt.Printf("ch = %c\n", ch)

    // uint8
    fmt.Println(reflect.TypeOf(ch))
}

字符串

package main

import "fmt"

func main() {
    // 字符串使用双引号赋值
    var s1 string
    s1 = "abc"
    fmt.Println(s1)

    // 取字符串中第一个字符
    ch := s1[0]
    fmt.Println(ch)

    // 反引号用来创建原生的字符串字面量(原格式输出)

    s2 := `hello
xxxxx
    world
`
    fmt.Println(s2)
}

5.fmt 包的使用

格式化参数列表

输出

package main

import "fmt"

func main() {
    // 整型
    a := 16

    // %b 二进制输出
    fmt.Printf("%b\n", a)
    fmt.Printf("%%\n", a)
}

输入

package main

import "fmt"

func main() {
    // 定义接收输入内容的变量
    var age int
    fmt.Printf("请输入你的年龄: ")
    // 接收输入
    fmt.Scan(&age)

    fmt.Printf("输入的年龄为: %d", age)
}

6. 类型别名

使用 type 关键字自定义类型

package main

import (
    "fmt"
    "reflect"
)

// type 自定义类型名 原类型
type myint int

func main() {
    var v1 myint
    v1 = 10
    fmt.Println(reflect.TypeOf(v1))
}

// 输出结果: main.myint

7. 类型转换

go 语言不允许隐式转换

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a byte
    a = 97

    var b int
    b = int(a)
    // 输出变量类型
    fmt.Println(reflect.TypeOf(b))
}

8. 运算符

算数运算符

package main

import "fmt"

func main() {
    a := 10
    b := 6
    // +
    fmt.Println(a+b)
    // -
    fmt.Println(a-b)
    // *
    fmt.Println(a*b)
    // /
    fmt.Println(a/b)
    // %
    fmt.Println(a%b)
    // ++
    fmt.Println(a)
    a++
    fmt.Println(a)
    // -
    fmt.Println(b)
    b--
    fmt.Println(b)
}

关系运算符

package main

import "fmt"

func main() {
    a := 10
    b := 6
    // ==
    fmt.Println(a==b)
    // !=
    fmt.Println(a!=b)
    // >
    fmt.Println(a>b)
    // <
    fmt.Println(a<b)
    // >=
    fmt.Println(a>=b)
    // <=
    fmt.Println(a<=b)
    // ==
    fmt.Println(a==b)
}

逻辑运算符

package main

import "fmt"

func main() {
    a := 10
    b := 6
    c := 6
    // &&
    fmt.Println(a > b && b >= c)
    // ||
    fmt.Println(a > b || b > c)
    // !
    var d bool
    fmt.Println(!d)
}

赋值运算符

位运算

package main

import "fmt"

func main() {

    var a uint = 60      /* 60 = 0011 1100 */
    var b uint = 13      /* 13 = 0000 1101 */
    var c uint = 0

    c = a & b       /* 12 = 0000 1100 */
    fmt.Println(c)

    c = a | b       /* 61 = 0011 1101 */
    fmt.Println(c)

    c = a ^ b       /* 49 = 0011 0001 */
    fmt.Println(c)

    c = a << 2     /* 240 = 1111 0000  a*(2**2) */
    fmt.Println(c)

    c = a >> 2     /* 15 = 0000 1111 a/(2*2) */
    fmt.Println(c)
}

其他运算符

package main

import "fmt"

func main() {
    var a int = 4
    var b int32
    var c float32
    var ptr *int

    /* 运算实例 */
    fmt.Printf("a 变量类型为 = %T\n", a );
    fmt.Printf("b 变量类型为 = %T\n", b );
    fmt.Printf("c 变量类型为 = %T\n", c );

    /*  & 和 * 运算符实例 */
    ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
    fmt.Printf("a 的值为  %d\n", a);
    fmt.Printf("*ptr 为 %d\n", *ptr);
}

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

当然，我们可以通过使用括号来临时提升某个表达式的整体运算优先级。

Goland 基础语法

标签：数据   移动   函数   min   lock   var   科学   ali   数值   

原文地址：https://www.cnblogs.com/zhichaoma/p/12509452.html