Оператор объявления короткой переменной (: =) в Go

Оператор объявления короткой переменной (: =) в Go


#GO

Оператор объявления короткой переменной (: =) в Golang используется для создания переменных, имеющих собственное имя и начальное значение. Основная цель использования этого оператора для объявления и инициализации локальных переменных внутри функций и для ограничения области видимости переменных. Тип переменной определяется типом выражения. Ключевое слово var также используется для создания переменных определенного типа. Таким образом, вы можете сказать, что есть два способа создания переменных в Golang следующим образом:


  • Использование ключевого слова var
  • Использование оператора объявления короткой переменной (: =)

В этой статье мы обсудим только оператор объявления коротких переменных. Чтобы узнать о ключевом слове var, вы можете обратиться к ключевому слову var в Go . Вы также можете прочитать разницу между ключевым словом var и оператором короткого объявления переменных, чтобы получить правильное представление об использовании обоих.

Синтаксис использования оператора короткого объявления переменных:

variable_name := expression or value

Здесь вы должны инициализировать переменную сразу после объявления. Но используя ключевое слово var, вы можете избежать инициализации во время объявления. Нет необходимости упоминать тип переменной . Выражение или значение в правой части используются для оценки типа переменной.

Пример: здесь мы объявляем переменные с помощью оператора короткого объявления и не указываем тип переменной. Тип переменной определяется типом выражения в правой части оператора := .


// Перейти к программе, чтобы проиллюстрировать использование

// of: = (короткое объявление

// оператор)

package main

  

import "fmt"

  

func main() {

  

    // объявляем и инициализируем переменную

    a := 30

  

    // берём строковую переменную

    Language: = "Go Programming"

  

    fmt.Println("The Value of a is: ", a)

    fmt.Println("The Value of Language is: ", Language)

    

}

Выход:

The Value of a is:  30
The Value of Language is:  Go Programming

Объявление нескольких переменных с помощью оператора короткого объявления (: =)

Оператор короткого объявления может также использоваться для объявления нескольких переменных одного и того же типа или разных типов в одном объявлении. Тип этих переменных оценивается выражением в правой части оператора : = .

Пример:


// Перейти к программе, чтобы проиллюстрировать, как использовать: = short

// оператор объявления для объявления нескольких

// переменные в одном объявлении

package main

   

import "fmt"

  

func main() { 

  

// несколько переменных одного типа (int)

geek1, geek2, geek3 := 117, 7834, 5685 

  

// несколько переменных разных типов

geek4, geek5, geek6 := "GFG", 859.24, 1234

  

// Показать значение и

// тип переменных

fmt.Printf("The value of geek1 is : %d\n", geek1) 

fmt.Printf("The type of geek1 is : %T\n", geek1) 

  

fmt.Printf("\nThe value of geek2 is : %d\n", geek2) 

fmt.Printf("The type of geek2 is : %T\n", geek2) 

  

fmt.Printf("\nThe value of geek3 is : %d\n", geek3) 

fmt.Printf("The type of geek3 is : %T\n", geek3)

  

fmt.Printf("\nThe value of geek4 is : %s\n", geek4) 

fmt.Printf("The type of geek4 is : %T\n", geek4)

  

  

fmt.Printf("\nThe value of geek5 is : %f\n", geek5) 

fmt.Printf("The type of geek5 is : %T\n", geek5)

  

fmt.Printf("\nThe value of geek6 is : %d\n", geek6) 

fmt.Printf("The type of geek6 is : %T\n", geek6)

   

} 

Выход:

The value of geek1 is : 117
The type of geek1 is : int

The value of geek2 is : 7834
The type of geek2 is : int

The value of geek3 is : 5685
The type of geek3 is : int

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

The value of geek5 is : 859.240000
The type of geek5 is : float64

The value of geek6 is : 1234
The type of geek6 is : int

Важные моменты:

  • Оператор короткого объявления можно использовать, когда хотя бы одна переменная в левой части оператора: = была объявлена заново. Оператор короткого объявления переменных ведет себя как присваивание тем переменным, которые уже объявлены в том же лексическом блоке. Чтобы получить лучшее представление об этой концепции, давайте рассмотрим пример.Пример 1: Программа ниже выдаст ошибку, поскольку в левой части оператора: = нет новых переменных.

  • // Перейти к программе, чтобы проиллюстрировать концепцию
  • // краткого объявления переменной
  • package main
  •   
  • import "fmt"
  •   
  • func main() {  
  •   
  •     // берём две переменные
  •     p, q := 100, 200
  •   
  •     fmt.Println("Value of p ", p, "Value of q ", q)
  •   
  •     // это даст ошибку как
  •     // нет новой переменной
  •     // в левой части: =
  •     p, q := 500, 600 
  •      
  •     fmt.Println("Value of p ", p, "Value of q ", q)
  • }
  • Ошибка:
  • Пример 2: В приведенной ниже программе вы можете видеть, что строка кода geek3, geek2: = 456, 200 будет работать без ошибок, поскольку по крайней мере есть новая переменная, то есть geek3, в левой части оператора: = ,

  • // Перейти в программу, чтобы показать, как использовать
  • // оператор объявления короткой переменной
  • package main 
  •   
  • import "fmt"
  •   
  • func main() { 
  •   
  • // Здесь действует краткое объявление переменной
  • // как присваивание переменной geek1
  • // потому что одна и та же переменная присутствует в том же блоке
  • // поэтому значение geek2 изменено с 100 на 200
  • geek1, geek2 := 78, 100
  •   
  • // здесь: = используется как назначение для geek2
  • // как уже заявлено. Также эта линия
  • // будет работать нормально, так как geek3 только что создан
  • // переменная
  • geek3, geek2 := 456, 200
  •   
  • // Если вы попытаетесь запустить закомментированные строки,
  • // тогда компилятор выдаст ошибку, потому что
  • // эти переменные уже определены
  • // geek1, geek2: = 745, 956
  • // geek3: = 150
  •   
  • // Отображаем значения переменных
  • fmt.Printf("The value of geek1 and geek2 is : %d %d\n", geek1, geek2) 
  •                                               
  • fmt.Printf("The value of geek3 and geek2 is : %d %d\n", geek3, geek2) 
  • } 
  • Выход:
The value of geek1 and geek2 is : 78 200
The value of geek3 and geek2 is : 456 200
  • Go — это строго типизированный язык, так как вы не можете присвоить значение другого типа объявленной переменной.Пример:

  • // Перейти в программу, чтобы показать, как использовать
  • // оператор объявления короткой переменной
  • package main 
  •   
  • import "fmt"
  •   
  • func main() { 
  •   
  •     // берём переменную типа int
  •     z := 50
  •       
  •     fmt.Printf("Value of z is %d", z)
  •       
  •     // переназначение значения строкового типа
  •     // это даст ошибку
  •     z := "Golang"
  • } 
  • Ошибка:
  • В коротком объявлении переменной разрешено инициализировать набор переменных вызывающей функцией, которая возвращает несколько значений. Или вы можете сказать, что переменным также могут быть назначены значения, которые оцениваются во время выполнения.Пример:
// Here, math.Max function return 
// the maximum number in i variable
i := math.Max(x, y)

Локальные переменные или глобальные переменные?

С помощью оператора короткого объявления переменной (: =) вы можете объявить только локальную переменную, которая имеет только область действия уровня блока. Как правило, локальные переменные объявляются внутри функционального блока. Если вы попытаетесь объявить глобальные переменные с помощью оператора короткого объявления, вы получите ошибку.

Пример 1:


// Перейти в программу, чтобы показать использование оператора: =

// объявляем локальные переменные

package main 

    

import "fmt"

    

// используем ключевое слово var для объявления

// и инициализируем переменную

// это пакет или вы можете сказать

// область глобального уровня

var geek1 = 900 

    

// используя краткое объявление переменной

// это даст ошибку

geek2 := 200 

    

func main() { 

    

// доступ к geek1 внутри функции

fmt.Println(geek1) 

   

// доступ к geek2 внутри функции

fmt.Println(geek2) 

        

} 

Ошибка:

Пример 2:


// Перейти в программу, чтобы показать использование оператора: =

// объявляем локальные переменные

package main 

    

import "fmt"

    

// используем ключевое слово var для объявления

// и инициализируем переменную

// это пакет или вы можете сказать

// область глобального уровня

var geek1 = 900 

  

    

func main() { 

  

// используя краткое объявление переменной

// внутри основной функции

// имеет локальную область видимости, т.е. не может

// доступ вне основной функции

geek2 := 200 

    

// доступ к geek1 внутри функции

fmt.Println(geek1) 

   

// доступ к geek2 внутри функции

fmt.Println(geek2) 

        

} 

Выход:

900
200


Report content on this page

Report Page

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