Golang Modifiable : Explorez la variabilité de Golang
Golang (également connu sous le nom de Go) est un langage de programmation qui est devenu de plus en plus populaire ces dernières années. L'objectif principal de conception de Golang est d'améliorer l'efficacité du développement et la lisibilité du code tout en maintenant des performances et une fiabilité élevées. Comparé à d’autres langages, Golang a une conception et une gestion uniques de la variabilité des données. Cet article explorera la variabilité de Golang et, sur cette base, explorera quelques idées de conception de base de Golang et certains problèmes que vous pourriez rencontrer.
Dans Golang, les types de données sont divisés en types valeur et types référence. Les types de valeurs incluent des entiers, des nombres à virgule flottante, des valeurs booléennes, etc., et leurs valeurs sont stockées dans la mémoire de la pile. Les types de référence incluent des tranches, des structures, des fonctions, etc. Leurs valeurs sont stockées dans la mémoire tas et référencées sur la pile via des pointeurs.
Tout d’abord, examinons la mutabilité des types de valeur. Dans Golang, les types de valeur peuvent être modifiés, mais ce changement ne se produira que dans la portée actuelle. Par exemple :
package main
import "fmt"
func main() {
i := 1
fmt.Println(i) // 输出 1
modify(i)
fmt.Println(i) // 仍然输出 1
}
func modify(i int) {
i = 2
}Dans cet exemple, nous voyons que modifier la valeur de i dans la fonction modify n'affectera que les valeurs à l'intérieur du modify<.> variable sans affecter <code>i dans la fonction main. En effet, le type de valeur sera copié lorsque la fonction est appelée et seule la valeur copiée est modifiée à l'intérieur de la fonction. modify函数中修改i的值只会影响到modify函数内部的变量，而不会影响到main函数中的i。这是因为，值类型在函数调用时会被复制，而在函数内部修改的只是这个复制的值。
与此相反，引用类型在函数调用时传递的是引用，也就是指向内存地址的指针。因此，在函数内部对引用类型的修改会影响到该引用类型所指向的地址中存储的值。例如：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p := Person{"Tom", 18}
fmt.Println(p) // 输出 {Tom 18}
modify(&p)
fmt.Println(p) // 输出 {Jerry 20}
}
func modify(p *Person) {
p.Name = "Jerry"
p.Age = 20
}在这个例子中，我们通过定义一个Person结构体，并在main函数中将其实例化。然后，我们将这个结构体的指针传递给modify函数，并在modify函数中修改了这个结构体实例的值。可以看到，在main函数中打印出的结构体已经被修改为{Jerry 20}。
但值类型和引用类型之间的关系有时并不那么简单。例如，在Golang中还有一个叫做string的类型，它实际上是一个只读的引用类型。也就是说，对于一个string变量，我们不能直接修改其内部的值。例如：
package main
import "fmt"
func main() {
s := "hello"
fmt.Println(s) // 输出 hello
modify(s)
fmt.Println(s) // 仍然输出 hello
}
func modify(s string) {
s = "world"
}在这个例子中，我们在modify函数中试图修改string类型的值，但是没有生效。这是因为，string类型是只读的，而在函数调用时会被复制，因此，对参数进行的任何修改都不会影响原始的string变量。如果要修改string类型的值，我们需要将其转换为一个可写的[]byte类型，例如：
package main
import "fmt"
func main() {
s := "hello"
fmt.Println(s) // 输出 hello
modify(&s)
fmt.Println(s) // 输出 world
}
func modify(s *string) {
b := []byte(*s)
b[0] = 'w'
*s = string(b)
}在这个例子中，我们将string类型的指针传递给modify函数，并在函数内部将其转换为[]byte类型，然后修改最后一个字母并再次转换回string类型。这种方式虽然可以实现string类型的修改，但是增加了代码的复杂度。
Golang在设计时考虑了数据的可变性问题，并做出了相应的设计。在Golang中，尽量避免使用全局变量和不可预测的函数调用，同时，Golang的内置函数都是纯函数，不会进行任何修改操作。这些设计使Golang代码更加易于理解和维护，同时也降低了代码运行时的风险。
总结来说，Golang值类型的修改只会影响当前作用域，而引用类型的修改会改变指向的地址中存储的值。在对string类型进行修改时需要注意其只读特性，可以使用[]byte
Person et l'instancions dans la fonction main. Ensuite, nous passons le pointeur de cette structure à la fonction modify, et modifions la valeur de l'instance de structure dans la fonction modify. Comme vous pouvez le voir, la structure imprimée dans la fonction main a été modifiée en {Jerry 20}. 🎜🎜Mais la relation entre les types valeur et les types référence n’est parfois pas si simple. Par exemple, il existe un type appelé string dans Golang, qui est en fait un type de référence en lecture seule. Autrement dit, pour une variable string, on ne peut pas modifier directement sa valeur interne. Par exemple : 🎜rrreee🎜Dans cet exemple, nous avons essayé de modifier la valeur de type string dans la fonction modify, mais cela n'a pas pris effet. En effet, le type string est en lecture seule et sera copié lorsque la fonction est appelée. Par conséquent, toute modification des paramètres n'affectera pas la variable string d'origine. Si nous voulons modifier la valeur du type string, nous devons la convertir en un type []byte inscriptible, par exemple : 🎜rrreee🎜Dans cet exemple, nous allons string est passé à la fonction modify et à l'intérieur de la fonction il est converti en type []byte, puis la dernière lettre est modifié et reconverti Renvoie le type string. Bien que cette méthode puisse réaliser une modification du type string, elle augmente la complexité du code. 🎜🎜Golang prend en compte la variabilité des données lors de la conception et conçoit en conséquence. Dans Golang, essayez d'éviter d'utiliser des variables globales et des appels de fonctions imprévisibles. En même temps, les fonctions intégrées de Golang sont de pures fonctions et ne seront en aucun cas modifiées. Ces conceptions rendent le code Golang plus facile à comprendre et à maintenir, tout en réduisant les risques lors de l'exécution du code. 🎜🎜En résumé, les modifications apportées aux types de valeur Golang n'affecteront que la portée actuelle, tandis que les modifications apportées aux types de référence modifieront la valeur stockée dans l'adresse pointée. Lors de la modification du type string, vous devez faire attention à sa fonctionnalité en lecture seule. Vous pouvez utiliser le type []byte pour effectuer la conversion et la modification. Les idées de conception et les méthodes de traitement de Golang reflètent l'importance accordée à la lisibilité et à la fiabilité du code. Dans le développement de Golang, nous devons pleinement comprendre ses caractéristiques de variabilité et nous adapter progressivement à ses idées de conception et à ses méthodes de traitement pour améliorer la qualité et l'efficacité du code. 🎜Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
