Go变量作用域精讲及代码实战

1. 变量的作用域概述

在编程中，变量的作用域（Scope）定义了变量在程序中的可见性和生命周期。理解变量的作用域对于编写健壮且可维护的代码至关重要。Go语言（简称Go）提供了几种不同的作用域类型，使得开发者可以灵活地控制变量的可见范围和生命周期。本章节将详细概述Go语言中变量的各种作用域，帮助读者更好地理解和应用这些概念。

1.1 作用域的类型

在Go语言中，主要有以下几种作用域类型：

1.2 作用域的可见性和生命周期

不同作用域类型决定了变量的可见性和生命周期：

  1. 局部作用域：

  • 可见性：局部变量仅在声明它们的函数或代码块内可见。

  • 生命周期：局部变量的生命周期从它们被声明开始，到函数或代码块执行完毕为止。

  1. 全局作用域：

  • 可见性：全局变量在同一包内的所有文件中都可见。

  • 生命周期：全局变量在程序启动时被分配内存，并在程序结束时释放。

  1. 块作用域：

  • 可见性：块作用域的变量仅在相应的代码块内可见。

  • 生命周期：块作用域的变量从代码块开始执行到结束时结束。

  1. 函数作用域：

  • 可见性：函数作用域的变量仅在函数体内可见。

  • 生命周期：函数作用域的变量从函数调用开始到函数返回时结束。

  1. 包作用域：

  • 可见性：包作用域的变量在整个包范围内可见。

  • 生命周期：包作用域的变量在包被加载时初始化，并在程序结束时释放。

1.3 作用域与内存管理

不同作用域的变量在内存管理上也有所不同：

  • 局部变量：通常分配在栈上，函数或代码块执行完毕后自动释放。

  • 全局变量：通常分配在堆上，直到程序结束时才释放。

  • 块变量：与局部变量类似，通常分配在栈上，块执行完毕后释放。

  • 函数变量：类似于局部变量，在栈上分配并在函数结束后释放。

  • 包变量：与全局变量类似，通常在堆上分配，直到程序结束。

1.4 作用域的实际应用

理解不同作用域的应用场景对于编写高效代码至关重要：

  • 局部变量适用于临时存储和局部计算，避免全局变量的命名冲突。

  • 全局变量适用于跨函数共享数据，但要小心避免数据竞争和不必要的内存占用。

  • 块变量适用于循环和条件判断中的临时数据存储。

  • 函数变量适用于封装函数内部逻辑，保证变量的私有性和安全性。

  • 包变量适用于包内共享数据，实现模块化设计。

通过合理使用不同作用域，开发者可以有效管理变量的生命周期和可见性，提高代码的可维护性和性能。

1.5 作用域的常见问题与调试技巧

处理变量作用域时，可能遇到以下常见问题：

  • 变量遮蔽：内层作用域的变量名与外层作用域相同，导致外层变量被遮蔽。

  • 作用域污染：不合理使用全局变量，导致命名冲突和意外修改。

  • 生命周期管理：误用局部变量和全局变量，导致内存泄漏或性能问题。

调试技巧包括：

  • 使用调试器逐步检查变量的值和生命周期。

  • 利用编译器警告和错误信息，及时发现作用域问题。

  • 编写单元测试，验证不同作用域下变量的行为。

2. 局部作用域

局部作用域是指变量在函数或代码块内部声明，其作用范围仅限于该函数或代码块。理解局部作用域对于编写安全、高效且可维护的代码至关重要。在本章节中，我们将详细探讨局部作用域的定义、内存管理及在并发环境中的使用。

2.1 局部作用域的定义

局部变量是在函数或代码块内部声明的变量。它们只能在声明它们的作用范围内访问，离开该范围后，这些变量将不再可见。局部变量的作用域通常较小，生命周期也较短，这使得它们在使用时非常高效。

  1. 函数内部的局部变量：

  • 这些变量在函数体内声明，仅在函数体内可见。它们的生命周期从函数调用开始，到函数返回时结束。

  • 示例：

func main() {var x int = 10fmt.Println("x in main:", x) // 输出: x in main: 10
}

  1. 代码块内部的局部变量：

  • 这些变量在代码块（如条件语句、循环语句）内部声明，仅在该代码块内可见。它们的生命周期从代码块开始执行，到代码块结束时结束。

  • 示例：

func main() {if true {var y int = 20fmt.Println("y in if block:", y) // 输出: y in if block: 20}// fmt.Println("y outside if block:", y) // 编译错误: y 未定义
}

  1. 嵌套作用域：

  • 局部作用域可以嵌套，一个函数或代码块内部可以包含多个嵌套的代码块，每个代码块都有自己的局部变量。

  • 示例：

func main() {var x int = 10if x > 5 {var y int = 20if y > 15 {var z int = 30fmt.Println("z in nested if block:", z) // 输出: z in nested if block: 30}// fmt.Println("z outside nested if block:", z) // 编译错误: z 未定义}// fmt.Println("y outside if block:", y) // 编译错误: y 未定义
}

局部变量的优点

  1. 避免命名冲突：由于局部变量的作用范围有限，它们不会与全局变量或其他函数的局部变量发生命名冲突。

  2. 内存管理高效：局部变量通常分配在栈上，函数或代码块执行完毕后自动释放，内存管理非常高效。

  3. 代码可读性强：局部变量使得变量的作用范围明确，增强了代码的可读性和可维护性。

2.2 内存管理

局部变量通常分配在栈上。当函数或代码块执行完毕后，这些局部变量会被自动释放。这种内存管理方式使得局部变量的分配和释放非常高效。

func calculate() int {var result int = 0for i := 0; i < 10; i++ {result += i}return result
}func main() {sum := calculate()fmt.Println("Sum:", sum) // 输出: Sum: 45
}

在calculate函数中，变量result和i都是局部变量，它们的内存分配在栈上。当calculate函数执行完毕后，这些变量会被自动释放。

2.3 并发环境中的局部变量

在Go语言中，并发编程是其一大特性。在并发环境中使用局部变量可以避免数据竞争，因为每个goroutine都有自己独立的栈空间，局部变量不会在不同的goroutine之间共享。

package mainimport ("fmt""sync"
)func printNumber(wg *sync.WaitGroup, num int) {defer wg.Done()fmt.Println("Number:", num)
}func main() {var wg sync.WaitGroupfor i := 0; i < 5; i++ {wg.Add(1)go printNumber(&wg, i)}wg.Wait()
}

在上述示例中，每个printNumber函数调用都会在新的goroutine中执行，num作为局部变量不会在不同的goroutine之间共享，确保了并发执行的安全性。

3. 全局作用域

全局作用域指的是在包级别声明的变量，它们在同一包内的所有文件中都可见。全局变量的使用需要谨慎，因为它们的生命周期贯穿整个程序运行过程，如果管理不当，可能会导致命名冲突、数据竞争等问题。在本章节中，我们将详细探讨全局作用域的定义、内存管理及在并发环境中的使用。

3.1 全局作用域的定义

全局变量是在包级别声明的变量，这些变量在包内的所有文件中都可见，并且它们的生命周期从程序启动开始，到程序结束时结束。全局变量可以在包的任意位置声明，一般在包级别的开头声明。

  1. 包级别声明：

  • 全局变量通常在包的开头声明，使得包内所有文件都可以访问这些变量。

  • 示例：

package mainimport "fmt"var globalVar int = 100 // 全局变量func main() {fmt.Println("globalVar in main:", globalVar) // 输出: globalVar in main: 100
}

  1. 跨文件访问：

  • 全局变量可以在同一包内的不同文件中访问。这对于共享数据或状态信息非常有用。

  • 示例：

// file1.go
package mainvar sharedVar int = 200 // 全局变量// file2.go
package mainimport "fmt"func printSharedVar() {fmt.Println("sharedVar in printSharedVar:", sharedVar) // 输出: sharedVar in printSharedVar: 200
}func main() {printSharedVar()
}

全局变量的优点

  1. 跨文件共享数据：全局变量可以在包内的所有文件中共享数据或状态信息，方便模块化编程。

  2. 持久性：全局变量的生命周期贯穿程序运行始终，适用于需要持久存储的数据。

3.2 内存管理

全局变量通常分配在堆上。由于全局变量的生命周期从程序启动到程序结束，内存管理需要特别注意，确保没有不必要的内存占用。

package mainimport "fmt"var counter int = 0 // 全局变量func increment() {counter++
}func main() {for i := 0; i < 10; i++ {increment()}fmt.Println("Final counter value:", counter) // 输出: Final counter value: 10
}

在上述示例中，变量counter是全局变量，生命周期贯穿整个程序运行过程。当increment函数被调用时，counter的值会递增。

3.3 并发环境中的全局变量

在Go语言中，并发编程是其一大特性。全局变量在并发环境中需要特别小心，因为多个goroutine可能会同时访问和修改全局变量，从而导致数据竞争和不一致性。

package mainimport ("fmt""sync"
)var counter int = 0 // 全局变量
var mu sync.Mutex   // 互斥锁func increment(wg *sync.WaitGroup) {defer wg.Done()mu.Lock()   // 加锁counter++mu.Unlock() // 解锁
}func main() {var wg sync.WaitGroupfor i := 0; i < 10; i++ {wg.Add(1)go increment(&wg)}wg.Wait()fmt.Println("Final counter value:", counter) // 输出: Final counter value: 10
}

在上述示例中，counter是一个全局变量，为了在并发环境中安全地访问和修改它，我们使用了互斥锁（sync.Mutex）来避免数据竞争。

4. 块作用域

块作用域（Block Scope）是指在特定代码块（如条件语句、循环语句等）内部声明的变量，其作用范围仅限于该代码块。块作用域变量在声明它们的代码块外部不可见。理解块作用域对于编写高效且可维护的代码非常重要。在本章节中，我们将详细探讨块作用域的定义、内存管理及在不同代码结构中的使用。

1. 块作用域的定义

块作用域指的是变量在代码块内部声明，其作用范围仅限于该代码块。代码块可以是由大括号 {} 包围的一段代码，如函数、条件语句、循环语句等。块作用域变量的生命周期从代码块开始到代码块结束。

  1. 条件语句中的块作用域：

  • 在条件语句（如 if、else if、else）内部声明的变量，其作用范围仅限于该条件语句块。

  • 示例：

package mainimport "fmt"func main() {x := 10if x > 5 {y := 20fmt.Println("y in if block:", y) // 输出: y in if block: 20}// fmt.Println("y outside if block:", y) // 编译错误: y 未定义
}

  1. 循环语句中的块作用域：

  • 在循环语句（如 for、range）内部声明的变量，其作用范围仅限于该循环语句块。

  • 示例：

package mainimport "fmt"func main() {for i := 0; i < 3; i++ {msg := "Iteration"fmt.Println(msg, i) // 输出: Iteration 0, Iteration 1, Iteration 2}// fmt.Println(msg) // 编译错误: msg 未定义
}

  1. 嵌套块作用域：

  • 块作用域可以嵌套，一个代码块内部可以包含多个嵌套的代码块，每个代码块都有自己的局部变量。

  • 示例：

package mainimport "fmt"func main() {x := 10if x > 5 {y := 20if y > 15 {z := 30fmt.Println("z in nested if block:", z) // 输出: z in nested if block: 30}// fmt.Println("z outside nested if block:", z) // 编译错误: z 未定义}// fmt.Println("y outside if block:", y) // 编译错误: y 未定义
}

块作用域的优点

  1. 避免命名冲突：由于块作用域变量的作用范围有限，它们不会与其他块或函数的变量发生命名冲突。

  2. 内存管理高效：块作用域变量通常分配在栈上，代码块执行完毕后自动释放，内存管理非常高效。

  3. 代码可读性强：块作用域使得变量的作用范围明确，增强了代码的可读性和可维护性。

2. 内存管理

块作用域变量通常分配在栈上。当代码块执行完毕后，这些变量会被自动释放。这种内存管理方式使得块作用域变量的分配和释放非常高效。

package mainimport "fmt"func calculateSum() int {sum := 0for i := 1; i <= 10; i++ {sum += i}return sum
}func main() {result := calculateSum()fmt.Println("Sum:", result) // 输出: Sum: 55
}

在上述示例中，变量 sum 和 i 都是在 for 循环语句块内部声明的块作用域变量，它们的内存分配在栈上，for 循环执行完毕后，这些变量会被自动释放。

3. 块作用域在不同代码结构中的使用

块作用域在条件语句中非常有用，因为它们可以限制变量的作用范围，使得变量只在条件成立时存在。

package mainimport "fmt"func main() {x := 5if x < 10 {message := "x is less than 10"fmt.Println(message) // 输出: x is less than 10} else {message := "x is 10 or more"fmt.Println(message)}// fmt.Println(message) // 编译错误: message 未定义
}

在上述示例中，变量 message 在 if 和 else 块中分别声明，具有各自独立的作用域。

**循环语句中的块作用域

在循环语句中使用块作用域变量，可以确保每次迭代都有独立的变量实例，避免变量状态被意外修改。

package mainimport "fmt"func main() {for i := 0; i < 5; i++ {count := i * 2fmt.Println("Count:", count) // 输出: Count: 0, 2, 4, 6, 8}// fmt.Println("Count outside loop:", count) // 编译错误: count 未定义
}

在上述示例中，变量 count 在 for 循环的每次迭代中声明，并且每次迭代都是一个新的实例。

**嵌套代码块中的块作用域

使用嵌套代码块可以有效地管理变量的作用范围，避免变量的命名冲突。

package mainimport "fmt"func main() {total := 0for i := 1; i <= 3; i++ {partial := i * 10{temp := partial + 5fmt.Println("Temp:", temp) // 输出: Temp: 15, 25, 35}// fmt.Println("Temp outside nested block:", temp) // 编译错误: temp 未定义}
}

在上述示例中，变量 temp 仅在嵌套的代码块内可见，离开该块后即不可见。

5. 包作用域

包作用域（Package Scope）是指变量在包级别声明，其作用范围覆盖整个包，即同一个包中的所有文件都可以访问这些变量。包作用域在Go语言中非常重要，因为它有助于实现模块化编程和代码的可维护性。在本章节中，我们将详细探讨包作用域的定义、内存管理及其在不同代码结构中的使用。

5.1 包作用域的定义

包作用域变量是在包级别声明的，这些变量在同一个包中的所有文件中都可见。包作用域变量的生命周期从包被加载开始，到程序结束时结束。通常，包作用域变量在包的顶层声明。

  1. 包级别声明：

  • 包作用域变量通常在包的开头或文件的最顶层声明，使得包内所有文件都可以访问这些变量。

  • 示例：

package mainimport "fmt"var packageVar int = 100 // 包作用域变量func main() {fmt.Println("packageVar in main:", packageVar) // 输出: packageVar in main: 100
}

  1. 跨文件访问：

  • 包作用域变量可以在同一个包内的不同文件中访问，这对于共享数据或状态信息非常有用。

  • 示例：

// file1.go
package mainvar sharedVar int = 200 // 包作用域变量// file2.go
package mainimport "fmt"func printSharedVar() {fmt.Println("sharedVar in printSharedVar:", sharedVar) // 输出: sharedVar in printSharedVar: 200
}func main() {printSharedVar()
}

包作用域的优点

  1. 跨文件共享数据：包作用域变量可以在包内的所有文件中共享数据或状态信息，方便模块化编程。

  2. 持久性：包作用域变量的生命周期从包加载到程序结束，适用于需要持久存储的数据。

5.2 内存管理

包作用域变量通常分配在堆上。由于包作用域变量的生命周期从程序启动到程序结束，内存管理需要特别注意，确保没有不必要的内存占用。

package mainimport "fmt"var counter int = 0 // 包作用域变量func increment() {counter++
}func main() {for i := 0; i < 10; i++ {increment()}fmt.Println("Final counter value:", counter) // 输出: Final counter value: 10
}

在上述示例中，变量counter是包作用域变量，其生命周期贯穿整个程序运行过程。当increment函数被调用时，counter的值会递增。

5.3 包作用域在不同代码结构中的使用

模块化编程中的包作用域

包作用域在模块化编程中非常重要，它可以将相关的功能和数据封装在一个包中，实现高内聚、低耦合的设计。

// config.go
package configvar AppName string = "MyApp" // 包作用域变量
var Version string = "1.0"// main.go
package mainimport ("fmt""config"
)func main() {fmt.Println("App Name:", config.AppName) // 输出: App Name: MyAppfmt.Println("Version:", config.Version)  // 输出: Version: 1.0
}

在上述示例中，config包中的变量AppName和Version具有包作用域，可以在main包中访问，从而实现配置的集中管理。

包作用域与初始化函数

包作用域变量可以与初始化函数（init函数）结合使用，在程序开始时进行必要的初始化操作。

package mainimport "fmt"var configVar stringfunc init() {configVar = "Initialized" // 初始化包作用域变量
}func main() {fmt.Println("configVar:", configVar) // 输出: configVar: Initialized
}

在上述示例中，init函数在程序启动时自动执行，对包作用域变量configVar进行初始化。

包作用域与并发编程

在并发编程中，包作用域变量需要特别小心，因为多个goroutine可能会同时访问和修改包作用域变量，从而导致数据竞争和不一致性。

package mainimport ("fmt""sync"
)var counter int = 0 // 包作用域变量
var mu sync.Mutex   // 互斥锁func increment(wg *sync.WaitGroup) {defer wg.Done()mu.Lock()   // 加锁counter++mu.Unlock() // 解锁
}func main() {var wg sync.WaitGroupfor i := 0; i < 10; i++ {wg.Add(1)go increment(&wg)}wg.Wait()fmt.Println("Final counter value:", counter) // 输出: Final counter value: 10
}

在上述示例中，counter是一个包作用域变量，为了在并发环境中安全地访问和修改它，我们使用了互斥锁（sync.Mutex）来避免数据竞争。

6. 函数作用域

函数作用域（Function Scope）指的是在函数内部声明的变量，其作用范围仅限于该函数。这些变量在函数外部不可见，离开函数后即被销毁。函数作用域在Go语言中非常重要，因为它可以有效地管理变量的生命周期，避免命名冲突和内存泄漏。在本章节中，我们将详细探讨函数作用域的定义、内存管理及其在不同代码结构中的使用。

6.1 函数作用域的定义

函数作用域是指在函数内部声明的变量，这些变量只能在该函数内部访问，函数执行结束后，这些变量就会被销毁。函数作用域的变量包括函数参数、局部变量以及在函数内部声明的任何其他变量。

  1. 函数内部声明的变量：

  • 这些变量只能在声明它们的函数内部访问，生命周期从函数调用开始，到函数返回结束。

  • 示例：

package mainimport "fmt"func calculate(a int, b int) int {sum := a + b // sum 是函数作用域变量return sum
}func main() {result := calculate(3, 4)fmt.Println("Result:", result) // 输出: Result: 7
}

  1. 函数参数：

  • 函数参数也是函数作用域的一部分，它们在函数调用时被传递，在函数内部使用。

  • 示例：

package mainimport "fmt"func greet(name string) {message := "Hello, " + name // name 是函数参数，具有函数作用域fmt.Println(message)
}func main() {greet("Alice") // 输出: Hello, Alice
}

函数作用域的优点

  1. 避免命名冲突：由于函数作用域变量的作用范围仅限于函数内部，它们不会与其他函数的变量发生命名冲突。

  2. 内存管理高效：函数作用域变量通常分配在栈上，函数执行完毕后自动释放，内存管理非常高效。

  3. 代码可读性强：函数作用域使得变量的作用范围明确，增强了代码的可读性和可维护性。

6.2 内存管理

函数作用域变量通常分配在栈上。当函数执行完毕后，这些变量会被自动释放。这种内存管理方式使得函数作用域变量的分配和释放非常高效。

内存分配示例

package mainimport "fmt"func factorial(n int) int {if n == 0 {return 1}return n * factorial(n-1)
}func main() {result := factorial(5)fmt.Println("Factorial:", result) // 输出: Factorial: 120
}

在上述示例中，n 是函数 factorial 的参数，其内存分配在栈上，函数执行完毕后自动释放。

6.3 函数作用域在不同代码结构中的使用

嵌套函数中的函数作用域

Go语言支持在一个函数内部声明另一个函数，这使得函数作用域可以嵌套使用。

package mainimport "fmt"func outerFunction() {outerVar := "I am outside!"func innerFunction() {innerVar := "I am inside!"fmt.Println(outerVar) // 输出: I am outside!fmt.Println(innerVar) // 输出: I am inside!}innerFunction()// fmt.Println(innerVar) // 编译错误: innerVar 未定义
}func main() {outerFunction()
}

在上述示例中，innerFunction 是在 outerFunction 内部声明的嵌套函数。outerVar 是 outerFunction 的局部变量，但在 innerFunction 中可见，而 innerVar 仅在 innerFunction 内部可见。

闭包中的函数作用域

闭包是指在其词法作用域内引用了自由变量的函数。Go语言中的闭包可以捕获并记住其外层函数中的变量。

package mainimport "fmt"func adder() func(int) int {sum := 0return func(x int) int {sum += xreturn sum}
}func main() {pos, neg := adder(), adder()for i := 0; i < 10; i++ {fmt.Println(pos(i))  // 累加正数fmt.Println(neg(-2*i)) // 累加负数}
}

在上述示例中，adder 函数返回一个闭包，该闭包捕获了外层函数的变量 sum，并在多次调用中累加 sum 的值。

6.4 函数作用域与并发编程

在并发编程中，函数作用域变量对于保证数据安全和避免数据竞争非常重要。每个 goroutine 都有自己的函数作用域，因此函数内部的局部变量在不同的 goroutine 之间不会共享。

package mainimport ("fmt""sync"
)func printNumbers(wg *sync.WaitGroup, start int) {defer wg.Done()for i := start; i < start+5; i++ {fmt.Println(i)}
}func main() {var wg sync.WaitGroupfor i := 0; i < 3; i++ {wg.Add(1)go printNumbers(&wg, i*10)}wg.Wait()
}

在上述示例中，每个 printNumbers 函数调用在不同的 goroutine 中执行，且 i 和 start 变量均具有函数作用域，保证了并发执行的安全性。

文章转载自：techlead_krischang

原文链接：https://www.cnblogs.com/xfuture/p/18242545

体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/354627.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Ubuntu/Linux系统安装JDK1.8（带jdk1.8资源和操作教程）

Ubuntu/Linux系统安装JDK1.8（带jdk1.8资源和操作教程）

文章目录 前言一、JDK1.8下载二、上传三、安装四、配置环境变量五、查看总结 前言 &#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;Ubuntu/Linux jdk1.8安装包&#xff…
阅读更多...
SpringBootWeb 篇-入门了解 Spring Cache 、Spring Task 与 WebSocket 框架

SpringBootWeb 篇-入门了解 Spring Cache 、Spring Task 与 WebSocket 框架

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 Spring Cache 概述 1.1 Spring Cache 具体使用 1.1.1 引入依赖 1.1.2 Spring Cache 相关注解的介绍 2.0 Spring Task 概述 2.1 cron 表达式 2.2 Spring Task 使用…
阅读更多...
云平台DNS故障导致网站访问卡顿异常排查过程，wireshark、strace等工具在实际问题排查过程中的应用方法

云平台DNS故障导致网站访问卡顿异常排查过程，wireshark、strace等工具在实际问题排查过程中的应用方法

一、问题现象 项目上使用华为私有云&#xff0c;前段时间华为升级云平台后&#xff0c;云上用户反馈业务系统出现卡顿&#xff0c;之前几秒可以刷新出来的页面现在需要几十秒。提供了一个比较明显的url和curl调用方法。 10.213.x.xxx:8082/files/login curl -H "Content-…
阅读更多...
LabVIEW开发指针式压力仪表图像识别

LabVIEW开发指针式压力仪表图像识别

系统利用LabVIEW编程实现对指针式压力仪表的读取&#xff0c;通过相机、光源、固定支架等硬件捕捉仪表图像&#xff0c;并通过图像识别技术解析压力值。系统分为两个阶段&#xff1a;第一阶段固定相机更换仪表&#xff0c;第二阶段移动相机识别多个固定仪表。本文介绍硬件选择、…
阅读更多...
Jenkins 发测试邮件报错 553 Mail from must equal authorized user

Jenkins 发测试邮件报错 553 Mail from must equal authorized user

Jenkins 发测试邮件报错 553 Mail from must equal authorized user 报错信息报错原因解决办法 报错信息 org.eclipse.angus.mail.smtp.SMTPSenderFailedException: 553 Mail from must equal authorized user at org.eclipse.angus.mail.smtp.SMTPTransport.mailFrom(SMTPTra…
阅读更多...
我工作中用Redis的10种场景

我工作中用Redis的10种场景

Redis作为一种优秀的基于key/value的缓存&#xff0c;有非常不错的性能和稳定性&#xff0c;无论是在工作中&#xff0c;还是面试中&#xff0c;都经常会出现。 今天这篇文章就跟大家一起聊聊&#xff0c;我在实际工作中使用Redis的10种场景&#xff0c;希望对你会有所帮助。 …
阅读更多...
丹尼尔·T·琼斯：精益生产到底是什么？

丹尼尔·T·琼斯：精益生产到底是什么？

本文摘要自《精益思想》、《改变世界的机器》作者之一丹尼尔T琼斯的文章。丹尼尔T琼斯是一位学者、英国作家和研究员。他曾多次获得瑞士山吉奥卓越运营奖研究与专业出版类别的奖项&#xff0c;也包括了国际精益六西格玛研究所&#xff08;ILSSI&#xff09;[1]的"精益思想…
阅读更多...
【Java】已解决java.sql.SQLException异常

【Java】已解决java.sql.SQLException异常

文章目录 一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项 已解决java.sql.SQLException异常 在Java中&#xff0c;java.sql.SQLException是一个通用的异常类&#xff0c;用于表示在数据库操作中发生的错误。无论是类型错误、数据类型不匹配…
阅读更多...
Nacos 2.x 系列【15】数据源插件支持达梦、Oracel、PostgreSQL......

Nacos 2.x 系列【15】数据源插件支持达梦、Oracel、PostgreSQL......

文章目录 1. 概述2. 持久层机制2.1 固定语句2.2 数据源插件 3. 案例演示3.1 编译已实现插件3.2 自定义插件3.3 数据库初始化3.4 插件引入3.4.1 方式一&#xff1a;引入到源码3.4.2 方式二&#xff1a;插件加载目录 3.5 修改配置3.6 测试 1. 概述 在实际项目开发中&#xff0c;…
阅读更多...
[Linux] 历史根源

[Linux] 历史根源

UNIX系统&#xff1a; 1969年&#xff0c;由贝尔实验室的K.Thompson和D.M.Ritchie为PDP-7机器编写的一个分时操作系统&#xff0c; 最初使用汇编语言编写&#xff0c; 后来1972年C语言出世以后&#xff0c;二人由使用C写了UNIX3&#xff0c; 此后UNIX大为流行开来 UNIX流派树&a…
阅读更多...
vxe-table 列表过滤踩坑_vxe-table筛选

vxe-table 列表过滤踩坑_vxe-table筛选

但是这个过滤输入值必须是跟列表的值必须一致才能查到&#xff0c;没做到模糊查询的功能&#xff0c;根据关键字来过滤并没有实现。 下面提供一下具体实现方法&#xff1a;&#xff08;关键字来过滤&#xff09; filterNameMethod({ option, row }) {if (row.name.indexOf(op…
阅读更多...
不拼搏不是兄弟的京东，618被指「心眼子」太多上热榜……

不拼搏不是兄弟的京东，618被指「心眼子」太多上热榜……

好多年不咋公开露面的刘强东&#xff0c;在明尼苏达州事件逐渐不被人提起后&#xff0c;其按捺不住的互联网企业家网红属性&#xff0c;这大半年内&#xff0c;好像又血脉觉醒了……‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ 比如在今年618前夕&#xff0c;刘强东因跨国操盘京东&a…
阅读更多...
GlusterFS企业分布式存储

GlusterFS企业分布式存储

GlusterFS 分布式文件系统代表-nfs常见分布式存储Gluster存储基础梳理GlusterFS 适合大文件还是小文件存储&#xff1f; 应用场景术语Trusted Storage PoolBrickVolumes Glusterfs整体工作流程-数据访问流程GlusterFS客户端访问流程 GlusterFS常用命令部署 GlusterFS 群集准备环…
阅读更多...
轻松选购指南：如何挑选3D建模和3D渲染的高效计算机？

轻松选购指南：如何挑选3D建模和3D渲染的高效计算机？

选择最适合 3D 建模和3D渲染的计算机可能是一项艰巨的任务&#xff0c;特别是对于初学者来说。有很多因素需要考虑&#xff0c;包括处理器、显卡、内存和存储容量。 如果你计划购买一台计算机或利用3D产品渲染服务&#xff0c;那么你必须了解需要考虑的特性。以下是选择3D建模…
阅读更多...
中望CAD 2025 (ZW3D2025) 简体中文修改版

中望CAD 2025 (ZW3D2025) 简体中文修改版

名称&#xff1a;中望CAD 2025 (ZW3D2025) 简体中文修改版 描述&#xff1a;一款三维CAD设计工具&#xff0c;运行破解补丁ZW3D2025-2024-Patch执行修补。 链接&#xff1a;夸克网盘分享 &#x1f4c1; 大小&#xff1a;3.2GB &#x1f3f7; 标签&#xff1a;#PC软件 #CAD #设…
阅读更多...
项目四 OpenStack身份管理

项目四 OpenStack身份管理

任务一 理解身份服务 1.1 •Keystone的基本概念 • 认证 &#xff08; Authentication &#xff09; —— 确认用户身份的过程 &#xff0c;又称身份验证 。 • 凭证 &#xff08; Credentials &#xff09; —— 又 称凭据&#xff0c;是用于 确认用户身份的数据 。 • 令牌…
阅读更多...
jeecg快速启动（附带本地运行可用版本下载）

jeecg快速启动（附带本地运行可用版本下载）

版本整理&#xff08;windows x64位&#xff09;&#xff1a; redis&#xff1a;3.0.504 MYSQL&#xff1a;5.7 Maven&#xff1a;3.9.4(setting文件可下载) Nodejs&#xff1a;v16.20.2&#xff08;建议不要安装默认路径下&#xff0c;如已安装在c盘&#xff0c;运行yarn报…
阅读更多...
多线程（总结黑马程序员）

多线程（总结黑马程序员）

一、什么是线程&#xff1f; 是一个程序内部的一条执行流程 多线程是什么&#xff1f; 多条线程由CPU负责调度执行 多线程的创建方式一&#xff1a;继承Thread类 //1.继承Thread类 public class MyThread extends Thread {//2.必须重写run方法Overridepublic void run() {…
阅读更多...
机器人学习和研究的物质基础包含哪些内容？

机器人学习和研究的物质基础包含哪些内容？

为啥写这个&#xff1f; 在很多博客里面提及物质基础&#xff0c;没想到询问的也非常多&#xff0c;写一篇详细一点的。 之前的故事 不合格且失败机器人讲师个人理解的自身课程成本情况-CSDN博客 迷失自我无缘多彩世界-2024--CSDN博客 物质基础与情绪稳定的关系-CSDN博客 …
阅读更多...
Javaweb登录校验

Javaweb登录校验

登录校验 JWT令牌的相关操作需要添加相关依赖 <dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>0.9.1</version> </dependency>一、摘要 场景&#xff1a;当我们想要访问一个网站时&am…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023