Переменные GO

Переменные GO

#GO

Типичная программа использует различные значения, которые могут изменяться во время ее выполнения. Например , программа, которая выполняет некоторые операции над значениями, введенными пользователем. Значения, введенные одним пользователем, могут отличаться от значений, введенных другим пользователем. Следовательно, это делает необходимым использование переменных, поскольку другой пользователь не может использовать те же значения. Когда пользователь вводит новое значение, которое будет использоваться в процессе работы, он может временно сохранять в памяти произвольного доступа компьютера, и эти значения в этой части памяти меняются на протяжении всего выполнения, и, следовательно, появился другой термин для этого, который известен в качестве переменных . Таким образом, переменная является заполнителем информации, которая может быть изменена во время выполнения. А переменные позволяют извлекать и манипулировать хранимой информацией.


Правила именования переменных:

Имена переменных должны начинаться с буквы или подчеркивания (_). Имена могут содержать буквы «a-z» или «A-Z» или цифры 0–9, а также символ «_».Geeks, geeks, _geeks23  // valid variable
123Geeks, 23geeks      // invalid variable
Имя переменной не должно начинаться с цифры.234geeks  // illegal variable 
Имя переменной чувствительно к регистру.geeks and Geeks are two different variables
  • Ключевые слова не разрешается использовать в качестве имени переменной.
  • Длина имени переменной не ограничена, но рекомендуется использовать только оптимальную длину 4–15 букв.

Объявление переменной

В Go переменные языка создаются двумя разными способами:

  1. Использование ключевого слова var: В языке Go переменные создаются с использованием ключевого слова var определенного типа, связанного с именем и задающего его начальное значение.Синтаксис:
var variable_name type = expression
  1. Важные моменты:
  2. В приведенном выше синтаксисе, либо выражение типа или = выражение может удалить, но не оба могут удалить в объявлении переменной.
  3. Если тип удаляется, то тип переменной определяется значением initialize в выражении.Пример:

  5. // Перейти к программе для иллюстрации
  6. // понятие переменной
  7. package main
  8.   
  9. import "fmt"
  10.   
  11. func main() {
  12.   
  13. // переменная объявлена и
  14. // инициализируется без
  15. // явный тип
  16. var myvariable1 = 20
  17. var myvariable2 = "GeeksforGeeks"
  18. var myvariable3 = 34.80
  19.   
  20. // Отображаем значение и
  21. // тип переменных
  22. fmt.Printf("The value of myvariable1 is : %d\n",
  23.                                   myvariable1)
  24.                                       
  25. fmt.Printf("The type of myvariable1 is : %T\n",
  26.                                   myvariable1)
  27.       
  28. fmt.Printf("The value of myvariable2 is : %s\n",
  29.                                       myvariable2)
  30.                                         
  31. fmt.Printf("The type of myvariable2 is : %T\n",
  32.                                   myvariable2)
  33.       
  34. fmt.Printf("The value of myvariable3 is : %f\n",
  35.                                       myvariable3)
  36.                                         
  37. fmt.Printf("The type of myvariable3 is : %T\n",
  38.                                   myvariable3)
  39.       
  40. }
  41. Выход:
The value of myvariable1 is : 20
The type of myvariable1 is : int
The value of myvariable2 is : GeeksforGeeks
The type of myvariable2 is : string
The value of myvariable3 is : 34.800000
The type of myvariable3 is : float64
  1. Если выражение удалено, то переменная содержит нулевое значение для типа, например ноль для числа, false для логических значений, «» для строк и nil для интерфейса и ссылочного типа. Таким образом, в языке Go нет такого понятия неинициализированной переменной.Пример:

  3. // Перейти к программе для иллюстрации
  4. // понятие переменной
  5. package main
  6.    
  7. import "fmt"
  8.    
  9. func main() {
  10.   
  11.     // переменная объявлена и
  12.     // инициализируется без выражения
  13.     var myvariable1 int
  14.     var myvariable2 string
  15.     var myvariable3 float64
  16.   
  17.     // Показать нулевое значение переменных
  18.     fmt.Printf("The value of myvariable1 is : %d\n",
  19.                                      myvariable1)
  20.   
  21.     fmt.Printf("The value of myvariable2 is : %s\n",
  22.                                      myvariable2)
  23.   
  24.     fmt.Printf("The value of myvariable3 is : %f",
  25.                                      myvariable3)
  26. }
  27. Выход:
The value of myvariable1 is : 0
The value of myvariable2 is : 
The value of myvariable3 is : 0.000000
  1. Если вы используете тип, то вы можете объявить несколько переменных одного типа в одном объявлении.Пример:

  3. // Перейти к программе для иллюстрации
  4. // понятие переменной
  5. package main
  6. import "fmt"
  7.    
  8. func main() {
  9.    
  10.     // Несколько переменных одного типа
  11.     // объявлены и инициализированы
  12.     // в одной строке
  13.     var myvariable1, myvariable2, myvariable3 int = 2, 454, 67
  14.    
  15.    // Отображаем значения переменных
  16.    fmt.Printf("The value of myvariable1 is : %d\n",
  17.                                        myvariable1)
  18.   
  19.    fmt.Printf("The value of myvariable2 is : %d\n",
  20.                                        myvariable2)
  21.   
  22.    fmt.Printf("The value of myvariable3 is : %d",
  23.                                       myvariable3)
  24. }
  25. Выход:
The value of myvariable1 is : 2
The value of myvariable2 is : 454
The value of myvariable3 is : 67
  1. Если вы удаляете тип, вам разрешается объявлять несколько переменных другого типа в одном объявлении. Тип переменных определяется инициализированными значениями.Пример:

  3. // Перейти к программе для иллюстрации
  4. // понятие переменной
  5. package main
  6. import "fmt"
  7.   
  8. func main() {
  9.   
  10. // Несколько переменных разных типов
  11. // объявляются и инициализируются в одной строке
  12. var myvariable1, myvariable2, myvariable3 = 2, "GFG", 67.56
  13.   
  14. // Показать значение и
  15. // тип переменных
  16. fmt.Printf("The value of myvariable1 is : %d\n",
  17.                                     myvariable1)
  18.   
  19. fmt.Printf("The type of myvariable1 is : %T\n",
  20.                                    myvariable1)
  21.   
  22. fmt.Printf("\nThe value of myvariable2 is : %s\n",
  23.                                      myvariable2)
  24.   
  25. fmt.Printf("The type of myvariable2 is : %T\n",
  26.                                    myvariable2)
  27.   
  28. fmt.Printf("\nThe value of myvariable3 is : %f\n",
  29.                                       myvariable3)
  30.   
  31. fmt.Printf("The type of myvariable3 is : %T\n",
  32.                                    myvariable3)
  33. }
  34. Выход:
The value of myvariable1 is : 2
The type of myvariable1 is : int

The value of myvariable2 is : GFG
The type of myvariable2 is : string

The value of myvariable3 is : 67.560000
The type of myvariable3 is : float64
  1. Вы можете инициализировать набор переменных с помощью вызывающей функции, которая возвращает несколько значений.Пример:
// Here, os.Open function return a
// file in i variable and an error
// in j variable
var i, j = os.Open(name)
  1. Использование краткого объявления переменных: Локальные переменные, которые объявляются и инициализируются в функциях, объявляются с помощью краткого объявления переменных.Синтаксис:
variable_name:= expression
  1. Примечание: пожалуйста, не путайте между : = и =, поскольку : = является объявлением, а = является назначением.
  2. Важные моменты:
  3. В приведенном выше выражении тип переменной определяется типом выражения.Пример:

  5. // Перейти к программе для иллюстрации
  6. // понятие переменной
  7. package main
  8. import "fmt"
  9.   
  10. func main() {
  11.   
  12. // Использование краткого объявления переменной
  13. myvar1 := 39 
  14. myvar2 := "GeeksforGeeks" 
  15. myvar3 := 34.67
  16.   
  17. // Отображаем значение и тип переменных
  18. fmt.Printf("The value of myvar1 is : %d\n", myvar1)
  19. fmt.Printf("The type of myvar1 is : %T\n", myvar1)
  20.   
  21. fmt.Printf("\nThe value of myvar2 is : %s\n", myvar2)
  22. fmt.Printf("The type of myvar2 is : %T\n", myvar2)
  23.   
  24. fmt.Printf("\nThe value of myvar3 is : %f\n", myvar3)
  25. fmt.Printf("The type of myvar3 is : %T\n", myvar3)
  26. }
  27. Выход:
The value of myvar1 is : 39
The type of myvar1 is : int

The value of myvar2 is : GeeksforGeeks
The type of myvar2 is : string

The value of myvar3 is : 34.670000
The type of myvar3 is : float64
  1. Большинство локальных переменных объявляются и инициализируются с помощью кратких объявлений переменных благодаря их краткости и гибкости.
  2. Объявление переменных var используется для тех локальных переменных, которым нужен явный тип, который отличается от выражения инициализатора, или для тех переменных, значения которых присваиваются позже и инициализированное значение не имеет значения.
  3. Используя краткое объявление переменных, вы можете объявить несколько переменных в одном объявлении.Пример:

  5. // Перейти к программе для иллюстрации
  6. // понятие переменной
  7. package main
  8. import "fmt"
  9.   
  10. func main() {
  11.   
  12. // Использование краткого объявления переменной
  13. // Несколько переменных одного типа
  14. // объявлены и инициализированы в
  15. // единственная строка
  16. myvar1, myvar2, myvar3 := 800, 34, 56
  17.   
  18. // Показать значение и
  19. // тип переменных
  20. fmt.Printf("The value of myvar1 is : %d\n", myvar1)
  21. fmt.Printf("The type of myvar1 is : %T\n", myvar1)
  22.   
  23. fmt.Printf("\nThe value of myvar2 is : %d\n", myvar2)
  24. fmt.Printf("The type of myvar2 is : %T\n", myvar2)
  25.   
  26. fmt.Printf("\nThe value of myvar3 is : %d\n", myvar3)
  27. fmt.Printf("The type of myvar3 is : %T\n", myvar3)
  28. }
  29. Выход:
The value of myvar1 is : 800
The type of myvar1 is : int

The value of myvar2 is : 34
The type of myvar2 is : int

The value of myvar3 is : 56
The type of myvar3 is : int
  1. В коротком объявлении переменной вы можете инициализировать набор переменных вызывающей функцией, которая возвращает несколько значений.Пример:
// Here, os.Open function return 
// a file in i variable and an 
// error in j variable
i, j := os.Open(name)
  1. Краткое объявление переменной действует как присваивание только тогда, когда для тех переменных, которые уже объявлены в том же лексическом блоке. Переменные, объявленные во внешнем блоке, игнорируются. И, по крайней мере, одна переменная является новой переменной из этих двух переменных, как показано в примере ниже.Пример:

  3. // Перейти к программе для иллюстрации
  4. // понятие переменной
  5. package main
  6. import "fmt"
  7.   
  8. func main() {
  9.   
  10. // Использование краткого объявления переменной
  11. // Здесь действует краткое объявление переменной
  12. // как присваивание переменной myvar2
  13. // потому что одна и та же переменная присутствует в том же блоке
  14. // поэтому значение myvar2 изменено с 45 на 100
  15. myvar1, myvar2 := 39, 45 
  16. myvar3, myvar2 := 45, 100
  17.   
  18. // Если вы попытаетесь запустить закомментированные строки,
  19. // тогда компилятор выдаст ошибку, потому что
  20. // эти переменные уже определены
  21. // myvar1, myvar2: = 43, 47
  22. // myvar2: = 200
  23.   
  24. // Отображаем значения переменных
  25. fmt.Printf("The value of myvar1 and myvar2 is : %d %d\n",
  26.                                           myvar1, myvar2)
  27.                                             
  28. fmt.Printf("The value of myvar3 and myvar2 is : %d %d\n",
  29.                                           myvar3, myvar2)
  30. }
  31. Выход:
The value of myvar1 and myvar2 is : 39 100
The value of myvar3 and myvar2 is : 45 100
  1. Используя краткое объявление переменных, вы можете объявить несколько переменных разных типов в одном объявлении. Тип этих переменных определяется выражением.Пример:

  3. // Перейти к программе для иллюстрации
  4. // понятие переменной
  5. package main
  6. import "fmt"
  7.   
  8. func main() {
  9.   
  10. // Использование краткого объявления переменной
  11. // Несколько переменных разных типов
  12. // объявляются и инициализируются в одной строке
  13. myvar1, myvar2, myvar3 := 800, "Geeks", 47.56
  14.   
  15. // Отображаем значение и тип переменных
  16. fmt.Printf("The value of myvar1 is : %d\n", myvar1)
  17. fmt.Printf("The type of myvar1 is : %T\n", myvar1)
  18.   
  19. fmt.Printf("\nThe value of myvar2 is : %s\n", myvar2)
  20. fmt.Printf("The type of myvar2 is : %T\n", myvar2)
  21.   
  22. fmt.Printf("\nThe value of myvar3 is : %f\n", myvar3)
  23. fmt.Printf("The type of myvar3 is : %T\n", myvar3)
  24.   
  25. }
  26. Выход:
The value of myvar1 is : 800
The type of myvar1 is : int

The value of myvar2 is : Geeks
The type of myvar2 is : string

The value of myvar3 is : 47.560000
The type of myvar3 is : float64


Report content on this page

Report Page

Please submit your DMCA takedown request to dmca@telegram.org