GoLang基础语法（go语言结构、go语言变量、go语言常量、go语言运算符）

源代码•宸2026-01-08 10:50

文章目录

go语言结构

Hello World 实例​

Go 语言的基础组成有以下几个部分：​

• 包声明​

• 引入包​

• 函数​

• 变量​

• 语句 & 表达式​

• 注释

go 复制代码 
package main​

import "fmt"​

func main() {​
	/* This is my first simple program */​
	fmt.Println("Hello, World!")​
}
  1. 第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
  2. 下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
  3. 下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。​
  4. 下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
  5. 下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
    使用 fmt.Print("hello, world\n") 可以得到相同的结果。 Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
  6. 当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头 ，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public） ；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

执行 Go 程序​

让我们来看下如何编写 Go 代码并执行它。步骤如下：​

  1. 打开编辑器如Goland（去网上找方法解决下），创建一个project，名字叫做gostudy
  2. 将以上代码添加到编辑器中。
  3. 将以上代码保存为 hello.go
  4. 打开命令行，并进入程序文件保存的目录中。
  5. 输入命令 go run hello.go 并按回车执行代码。
  6. 如果操作正确你将在屏幕上看到 "Hello World!" 字样的输出。

还可以使用 go build 命令来生成二进制文件：

bash 复制代码 
$ go build hello.go ​ 
$ ls​ 
hello hello.go​ 
$ ./hello ​ 
Hello, World!

文件结构​

关于包，有以下几点需要注意：​

• 文件名与包名没有直接关系 ，不一定要将文件名与包名定成同一个。​

• 文件夹名与包名没有直接关系 ，并非需要一致。​

• 同一个文件夹下的文件只能有一个包名，否则编译报错 。​

现在在hello目录下有一个helloworld.go文件，在myMath目录下有两个文件，分别为myMath1.go和myMath2.go​

helloworld.go的包名为main，不必和文件夹名hello一致。myMath1.go和myMath2.go的包名必须一致，都为mathClass。

yaml 复制代码 
hello​ 
--helloworld.go​ ​ 

myMath​ 
--myMath1.go​ 
--myMath2.go
go 复制代码 
// helloworld.go
package main

import (
	"fmt"
	"gostudy/mymath"
)

func main() {
	fmt.Println("Hello World!")
	fmt.Println(mathClass.Add(1, 1))
	fmt.Println(mathClass.Sub(1, 1))
}
go 复制代码 
// myMath1.go
package mathClass

func Add(x, y int) int {
	return x + y
}
go 复制代码 
// myMath2.go
package mathClass

func Sub(x, y int) int {
	return x - y
}

go语言变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。​ 声明变量的一般形式是使用 var 关键字：

go 复制代码 
var identifier type

也可以同时声明多个变量

go 复制代码 
var identifier1, identifier2 type
go 复制代码 
package main
import "fmt"

func main() {
    var a string = "Hello"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

以上实例输出结果为：

bash 复制代码 
Hello
1 2

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

零值就是变量没有做初始化时系统默认设置的值。

go 复制代码 
package main
import "fmt"

func main() {
    var a string = "Hello" // 声明一个变量并初始化
    fmt.Println(a)

    var b int   // 没有初始化就为零值
    fmt.Println(b)

    var c bool  // bool 零值为 false
    fmt.Println(c)
}

以上实例执行结果为：

bash 复制代码 
Hello
0
false

数值类型（包括complex64/128）为 0

布尔类型为 false

字符串为 ""（空字符串）

以下几种类型为 nil：

go 复制代码 
package main

import "fmt"

var a *int
var b []int
var c map[string]int
var d chan int
var e func(string) int
var f error

func main() {
    fmt.Println("Hello World!")
    fmt.Println(a == nil)
    fmt.Println(b == nil)
    fmt.Println(c == nil)
    fmt.Println(d == nil)
    fmt.Println(e == nil)
    fmt.Println(f == nil)
}

输出结果是

bash 复制代码 
Hello World!
true
true
true
true
true
true
go 复制代码 
package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

输出结果是：

bash 复制代码 
0 0 false ""

第二种，根据值自行判定变量类型

go 复制代码 
var v_name = value
go 复制代码 
package main

import "fmt"

func main() {
    var d = true
    fmt.Println(d)
}

输出结果是：

bash 复制代码 
true

第三种，:= 声明变量

go 复制代码 
v_name := value

intVal := 1 相当于 var intVal int = 1

可以将 var f string = "Runoob" 简写为：f := "Runoob"

如果变量已经使用 var 声明过，再使用 := 声明变量，会产生编译错误。

go 复制代码 
var intVal int ​ 
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明

直接使用下面的语句即可：

go 复制代码 
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
go 复制代码 
package main

import "fmt"

func main() {
    f := "Hello" // var f string = "Hello"
    fmt.Println(f)
}

输出结果是：

bash 复制代码 
Hello

多变量声明

go 复制代码 
// 类型相同多个变量，非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误

// 这种形式分解关键字的写法，一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)
go 复制代码 
package main

var x, y int
var ( // 这种形式分解关键字的写法，一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

// 这种不带声明格式的只能在函数体中出现
// g, h := 123, "hello"

func main() {
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为：

bash 复制代码 
0 0 0 false 1 2 123 hello 123 hello

注意事项

我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此我们可以将它们简写为：a := 50 或 b := false

a 和 b 的类型（int 和 bool）将由编译器自动推断。

这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。

如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如： a := 20 这是不被允许的，编译器会提示错误：no new variables on left side of := 但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

如果你在定义变量 a 之前使用它，则会得到编译错误：undefined: a

如果你声明了一个局部变量却没有在相同的代码块中使用，也同样会得到编译错误，例如下面这个例子中的变量 a：

go 复制代码 
package main

import "fmt"

func main() {
    var a string = "abc"
    fmt.Println("hello, world")
}

尝试编译这段代码将得到错误：a declared but not used

此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用：fmt.Println("hello, world", a) 会移除错误。

但是全局变量是允许声明但不使用的。同一类型的多个变量可以声明在同一行，如：

go 复制代码 
var a, b, c int

多变量可以在同一行进行赋值，如：

go 复制代码 
var a, b int
var c string
a, b, c = 5, 7, "abc"

上面这行假设了变量 a、b 和 c 都已经被声明，否则的话应该这样使用：

go 复制代码 
a, b, c := 5, 7, "abc"

右边的这些值以相同的顺序赋值给左边的变量，所以：a 的值是 5，b 的值是 7，c 的值是 "abc"，这被称为并行或同时赋值。

如果你想要交换两个变量的值，则可以简单地使用：a, b = b, a 两个变量的类型必须相同。

空白标识符 _ 也被用于抛弃值，如值5在 _, b = 5, 7 被抛弃。

实际上 _ 是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)

变量的生命周期

全局变量生命周期是程序存活时间。在不发生内存逃逸的情况下，局部变量是函数存活时间。

go 复制代码 
package main

import "fmt"

var globalStr string
var globalInt int

func main() {
    var localStr string
    var localInt int
    localStr = "first local"
    localInt = 2021
    globalInt = 1024
    globalStr = "first global"
    fmt.Printf("globalStr is %s\n", globalStr) //globalStr is first global
    fmt.Printf("globalInt is %d\n", globalInt) //globalInt is 1024
    fmt.Printf("localInt is %s\n", localStr)   //localInt is first local
    fmt.Printf("localInt int is %d\n", localInt) //localInt int is 2021
}

go语言常量

常量的定义​

go语言常量的定义跟其他语言类似，是一个简单值的标识符，在程序运行时，不可以被修改 。​ 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。​ 常量的定义方式：

go 复制代码 
const identifier [type] = value

其中类型说明符 [type]可以省略，因为编译器可以根据变量的值来推断其类型。

go 复制代码 
const b string = "abc" // 显式常量定义​ 
const b = "abc" // 隐式常量定义

多个相同类型的声明可以简写为：const c_name1, c_name2 = value1, value2

go 复制代码 
const a, b = "abc", "def"

常量用作枚举​

go语言不像c++，java一样有专门的枚举类型，go语言的枚举一般用常量表示

go 复制代码 
const (​ 
	Unknown = 0​ 
	Success = 1​ 
	Fail = 2​ 
)

数字 0、1 和 2 分别代表未知成功和失败。​

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，必须是编译期可以确定的值，否则编译不过

go 复制代码 
package main

import (
    "fmt"
    "unsafe"
)

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main() {
    fmt.Printf("a = %s, b = %d, c = %d\n", a, b, c)
}

以上实例运行结果为：

bash 复制代码 
abc 3 16

思考题：为什么字符串"abc"的 unsafe.Sizeof() 是16呢？

实际上字符串类型的 unsafe.Sizeof() 一直是16 ，这又是为什么呢？因为字符串类型对应一个结构体，该结构体有两个域，第一个域是指向该字符串的指针，第二个域是字符串的长度，每个域8个字节，但是并不包含指针指向的字符串的内容，这也就是为什么sizeof给返回的是16。

组成可以理解成此结构体

go 复制代码 
typedef struct {
    char* buffer;   // 8字节
    size_t len;     // 8字节
} string;

iota

iota是一个特殊常量，可以认为是一个可以被编译器修改的常量

iota 在 const关键字出现时将被重置为0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

看例子：

go 复制代码 
const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0,b=1,c=2 可以简写为如下形式

go 复制代码 
const (
    a = iota
    b
    c
)

具体使用：

go 复制代码 
package main

import "fmt"

func main() {
    const (
        a = iota //0
        b        //1
        c        //2
        d = "ha" //独立值，iota += 1
        e        //"ha"，iota += 1
        f = 100  //iota += 1
        g        //100  iota += 1
        h = iota //7，恢复计数
        i        //8
    )
    fmt.Println(a, b, c, d, e, f, g, h, i)
}

以上实例运行结果为：

bash 复制代码 
0 1 2 ha ha 100 100 7 8

iota 在 同一个 const 块里，从 0 开始，每一行 +1；

这一行的表达式如果没写，就"沿用上一行的表达式"；
但即使你写了独立的值（比如 "ha"、100），iota 照样继续 +1，不会停。

const (

a = iota // iota=0 -> a=0

b // 沿用 "iota"；iota=1 -> b=1

c // 沿用 "iota"；iota=2 -> c=2

d = "ha" // 这行表达式是 "ha"；但 iota 仍然变为 3

e // 沿用上一行表达式 "ha"；iota=4 -> e="ha"

f = 100 // 表达式 100；iota=5 -> f=100

g // 沿用 100；iota=6 -> g=100

h = iota // 表达式又写回 iota；iota=7 -> h=7

i // 沿用 iota；iota=8 -> i=8

)

关于iota的一个有趣的例子：

go 复制代码 
package main

import "fmt"

const (
    i = 1 << iota // iota = 0, i = 1 << 0 = 1 *2^0, iota++
    j = 3 << iota // iota = 1, j = 3 << 1 = 3 *2^1, iota++
    k             // iota = 2, k = 3 << 2 = 3 *2^2, iota++
    			  // k 没写表达式，沿用上一行 3 << iota
    l             // iota = 3, l = 3 << 3 = 3 *2^3, iota++
)

func main() {
    fmt.Println("i=", i) // 1
    fmt.Println("j=", j) // 6
    fmt.Println("k=", k) // 12
    fmt.Println("l=", l) // 24
}

<<表示左移操作，i，j，k，l各是多少？

先说答案：

bash 复制代码 
i = 1
j = 6
k = 12
l = 24

<<表示左移，学过计算机我们都知道，左移1位其实就是乘以2，左移n位其实就是乘以2的n次方。所以：

i=1：左移 0 位，不变仍为 1，即1 * 2^0=11=1。

j=3：左移 1 位，变为二进制 110，即3 * 2^1=3 * 2=6。

k=3：左移 2 位，变为二进制 1100，即3 * 2^2=3 * 4=12。

l=3：左移 3 位，变为二进制 11000，即3 * 2^3=3 * 8=24。

尤其是在使用const和iota时 。这种行为表现为，在连续的常量声明中，如果没有显式指定新的值或表达式，新的常量将继承前一个常量的表达式。

go语言运算符

go语言跟其他语言一样，运算符大体上也分为以下几种：

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 其他运算符

算术运算符

A=10，B=20

代码展示：

go 复制代码 
package main

import "fmt"

func main() {

    var a int = 21
    var b int = 10
    var c int

    c = a + b
    fmt.Printf("第一行 - c 的值为 %d\n", c )
    c = a - b
    fmt.Printf("第二行 - c 的值为 %d\n", c )
    c = a * b
    fmt.Printf("第二行 - c 的值为 %d\n", c )
    c = a * b
    fmt.Printf("第三行 - c 的值为 %d\n", c )
    c = a / b
    fmt.Printf("第四行 - c 的值为 %d\n", c )
    c = a % b
    fmt.Printf("第五行 - c 的值为 %d\n", c )
    a++
    fmt.Printf("第六行 - a 的值为 %d\n", a )
    a=21    // 为了方便测试，a 这里重新赋值为 21
    a--
    fmt.Printf("第七行 - a 的值为 %d\n", a )

}

运算结果：

bash 复制代码 
第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20

关系运算符

A=10，B=20

代码展示：

go 复制代码 
package main

import "fmt"

func main() {
    var a int = 21
    var b int = 10

    if( a == b ) {
        fmt.Printf("第一行 - a 等于 b\n" )
    } else {
        fmt.Printf("第一行 - a 不等于 b\n" )
    }

    if ( a < b ) {
        fmt.Printf("第二行 - a 小于 b\n" )
    } else {
        fmt.Printf("第二行 - a 不小于 b\n" )
    }

    if ( a > b ) {
        fmt.Printf("第三行 - a 大于 b\n" )
    } else {
        fmt.Printf("第三行 - a 不大于 b\n" )
    }

    /* Lets change value of a and b */
    a = 5
    b = 20
    
    if ( a <= b ) {
        fmt.Printf("第四行 - a 小于等于 b\n" )
    }

    if ( b >= a ) {
        fmt.Printf("第五行 - b 大于等于 a\n" )
    }
}

运行结果

bash 复制代码 
第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 a

逻辑运算符

A=true，B=false

代码展示：

go 复制代码 
package main

import "fmt"

func main() {
    var a bool = true
    var b bool = false
    if ( a && b ) {
        fmt.Printf("第一行 - 条件为 true\n" )
    }
    if ( a || b ) {
        fmt.Printf("第二行 - 条件为 true\n" )
    }
    /* 修改 a 和 b 的值 */
    a = false
    b = true
    if ( a && b ) {
        fmt.Printf("第三行 - 条件为 true\n" )
    } else {
        fmt.Printf("第三行 - 条件为 false\n" )
    }
    if ( !(a && b ) ) {
        fmt.Printf("第四行 - 条件为 true\n" )
    }
}

运行结果

bash 复制代码 
第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

位运算符

为运算符是对内存中的二进制数进行按位运算，包括&, |, ^, <<, <<这么几种

A=60，B=13

代码展示：

go 复制代码 
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.Printf("第一行 - c 的值为 %d\n", c )

    c = a | b              /* 61 = 0011 1101 */
    fmt.Printf("第二行 - c 的值为 %d\n", c )

    c = a ^ b              /* 49 = 0011 0001 */
    fmt.Printf("第三行 - c 的值为 %d\n", c )

    c = a << 2             /* 240 = 1111 0000 */
    fmt.Printf("第四行 - c 的值为 %d\n", c )

    c = a >> 2             /* 15 = 0000 1111 */
    fmt.Printf("第五行 - c 的值为 %d\n", c )
}

运行结果

bash 复制代码 
第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

赋值运算符

代码展示：

go 复制代码 
package main

import "fmt"

func main() {

    var a int = 21
    var c int

    c = a
    fmt.Printf("第 1 行 - =  运算符实例, c 值为 = %d\n", c )

    c += a
    fmt.Printf("第 2 行 - += 运算符实例, c 值为 = %d\n", c )

    c -= a
    fmt.Printf("第 3 行 - -= 运算符实例, c 值为 = %d\n", c )

    c *= a
    fmt.Printf("第 4 行 - *= 运算符实例, c 值为 = %d\n", c )

    c /= a
    fmt.Printf("第 5 行 - /= 运算符实例, c 值为 = %d\n", c )

    c = 200;

    c <<= 2
    fmt.Printf("第 6行 - <<= 运算符实例, c 值为 = %d\n", c )

    c >>= 2
    fmt.Printf("第 7 行 - >>= 运算符实例, c 值为 = %d\n", c )

    c &= 2
    fmt.Printf("第 8 行 - &= 运算符实例, c 值为 = %d\n", c )

    c ^= 2
    fmt.Printf("第 9 行 - ^= 运算符实例, c 值为 = %d\n", c )

    c |= 2
    fmt.Printf("第 10 行 - |= 运算符实例, c 值为 = %d\n", c )
}

运行结果

bash 复制代码 
第 1 行 - =  运算符实例, c 值为 = 21
第 2 行 - += 运算符实例, c 值为 = 42
第 3 行 - -= 运算符实例, c 值为 = 21
第 4 行 - *= 运算符实例, c 值为 = 441
第 5 行 - /= 运算符实例, c 值为 = 21
第 6行 - <<= 运算符实例, c 值为 = 800
第 7 行 - >>= 运算符实例, c 值为 = 200
第 8 行 - &= 运算符实例, c 值为 = 0
第 9 行 - ^= 运算符实例, c 值为 = 2
第 10 行 - |= 运算符实例, c 值为 = 2

其他运算符

go语言跟c++语言一样也有指针和地址的概念，所以也会有取地址运算符&和指针运算符*

代码展示：

go 复制代码 
package main

import "fmt"

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

    /* 运算符实例 */
    fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
    fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
    fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

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

运行结果

go 复制代码 
第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。

下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

把 a 中那些在 b 对应位为 1 的位清零，其余位保持不变

等价关系（直观理解）：

a &^ b 约等于 a & (^b)（把 b 取反后再与 a 做按位与）

go 复制代码 
a := uint8(0b11001100)
b := uint8(0b10101010)

c := a &^ b // 把 a 中 b 为 1 的位清零
// a: 11001100
// b: 10101010
// c: 01000100  => 0b01000100

跟其他语言一样，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

代码展示：

go 复制代码 
package main

import "fmt"

func main() {
    var a int = 20
    var b int = 10
    var c int = 15
    var d int = 5
    var e int;

    e = (a + b) * c / d;        // ( 30 * 15 ) / 5
    fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );

    e = ((a + b) * c) / d;      // (30 * 15 ) / 5
    fmt.Printf("((a + b) * c) / d 的值为  : %d\n",  e );

    e = (a + b) * (c / d);      // (30) * (15/5)
    fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );

    e = a + (b * c) / d;        // 20 + (150/5)
    fmt.Printf("a + (b * c) / d 的值为  : %d\n",  e );
}

运行结果

bash 复制代码 
(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！

相关推荐
林恒smileZAZ1 天前
前端技巧：检测到省略号文本自动显示 Tooltip
开发语言·前端·javascript
Zzz不能停1 天前
阻止冒泡和阻止元素默认行为的区别
开发语言·前端·javascript
小白学大数据1 天前
Redis 在定时增量爬虫中的去重机制与过期策略
开发语言·数据库·redis·爬虫
心在飞扬1 天前
langchain学习总结-ChatMessage 组件学习笔记
后端
CoderCodingNo1 天前
【GESP】C++五级真题（二分答案考点） luogu-P13013 [GESP202506 五级] 奖品兑换
开发语言·c++
Alice10291 天前
如何在windows本地打包python镜像
开发语言·windows·python
小高0071 天前
Elips：领域模型与 DSL 设计实践：从配置到站点的优雅映射
前端·javascript·后端
南屿欣风1 天前
Sentinel @SentinelResource：用 blockHandler 实现优雅的接口降级
开发语言·python
热门推荐
01GitHub 镜像站点02安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）03Linux下V2Ray安装配置指南04Labelme从安装到标注：零基础完整指南05【踩坑笔记】50系显卡适配的 PyTorch 安装06手把手教你通过Gemini3 pro 学生认证，白用一年，手慢无！07jdk21下载、安装（Windows、Linux、macOS）08GitLab 零基础入门指南：从安装到项目管理全流程09Opencode CLI 安装成功,但是启动失败10UV安装并设置国内源