이동-퀵 가이드

Go는 시스템 프로그래밍을 염두에두고 설계된 범용 언어입니다. 2007 년에 Robert Griesemer, Rob Pike, Ken Thompson이 Google에서 처음 개발했습니다. 강력하고 정적으로 형식화되어 있으며 가비지 수집에 대한 내장 지원을 제공하고 동시 프로그래밍을 지원합니다.

프로그램은 종속성을 효율적으로 관리하기 위해 패키지를 사용하여 구성됩니다. Go 프로그래밍 구현은 기존의 컴파일 및 링크 모델을 사용하여 실행 가능한 바이너리를 생성합니다. Go 프로그래밍 언어는 2009 년 11 월에 발표되었으며 Google의 일부 프로덕션 시스템에서 사용됩니다.

Go 프로그래밍의 특징

Go 프로그래밍의 가장 중요한 기능은 다음과 같습니다.

• 동적 언어와 유사한 패턴을 채택하는 환경 지원. 예를 들어, 유형 추론 (x : = 0은 int 유형의 변수 x에 대한 유효한 선언입니다)

• 컴파일 시간이 빠릅니다.

• 내장 된 동시성 지원 : 경량 프로세스 (go 루틴을 통해), 채널, select 문.

• Go 프로그램은 간단하고 간결하며 안전합니다.

• 인터페이스 및 유형 임베딩 지원.

• 외부 종속성없이 정적으로 링크 된 기본 바이너리 생성.

의도적으로 제외 된 기능

언어를 간단하고 간결하게 유지하기 위해 다른 유사한 언어에서 일반적으로 사용할 수있는 다음 기능은 Go에서 생략됩니다.

• 유형 상속 지원

• 메서드 또는 연산자 오버로딩 지원

• 패키지 간 순환 종속성 지원

• 포인터 산술 지원

• 어설 션 지원

• 일반 프로그래밍 지원

Go 프로그램

Go 프로그램은 길이가 3 줄에서 수백만 줄까지 다양하며 확장명이 ".go"인 하나 이상의 텍스트 파일에 작성되어야합니다. 예 : hello.go.

"vi", "vim"또는 기타 텍스트 편집기를 사용하여 Go 프로그램을 파일에 작성할 수 있습니다.

지역 환경 설정

여전히 Go 프로그래밍 언어에 대한 환경을 설정하려면 컴퓨터에서 사용할 수있는 다음 두 소프트웨어가 필요합니다.

• 텍스트 편집기
• Go 컴파일러

텍스트 에디터

프로그램을 입력하려면 텍스트 편집기가 필요합니다. 텍스트 편집기의 예로는 Windows 메모장, OS 편집 명령, Brief, Epsilon, EMACS 및 vim 또는 vi가 있습니다.

텍스트 편집기의 이름과 버전은 운영 체제에 따라 다를 수 있습니다. 예를 들어 메모장은 Windows에서 사용되며 vim 또는 vi는 Windows 및 Linux 또는 UNIX에서 사용됩니다.

텍스트 편집기로 만든 파일은 source files. 여기에는 프로그램 소스 코드가 포함되어 있습니다. Go 프로그램의 소스 파일은 일반적으로 확장자로 이름이 지정됩니다.".go".

프로그래밍을 시작하기 전에 텍스트 편집기가 있고 컴퓨터 프로그램을 작성하고 파일에 저장하고 컴파일하고 마지막으로 실행할 수있는 충분한 경험이 있는지 확인하십시오.

Go 컴파일러

소스 파일에 작성된 소스 코드는 프로그램의 사람이 읽을 수있는 소스입니다. CPU가 주어진 지침에 따라 실제로 프로그램을 실행할 수 있도록 컴파일되고 기계어로 변환되어야합니다. Go 프로그래밍 언어 컴파일러는 소스 코드를 최종 실행 프로그램으로 컴파일합니다.

Go 배포판은 FreeBSD (릴리스 8 이상), Linux, Mac OS X (Snow Leopard 이상), 32 비트 (386) 및 64 비트 (amd64) x86 프로세서 아키텍처를 사용하는 Windows 운영 체제 용 바이너리 설치 가능으로 제공됩니다.

다음 섹션에서는 다양한 OS에 Go 바이너리 배포를 설치하는 방법을 설명합니다.

Go 아카이브 다운로드

Go 다운로드에서 최신 버전의 Go 설치 가능 아카이브 파일을 다운로드 합니다. 이 자습서에서는 go1.4.windows-amd64.msi 버전이 사용됩니다 .

C : \> go 폴더에 복사됩니다.

OS	아카이브 이름
윈도우	go1.4.windows-amd64.msi
리눅스	go1.4.linux-amd64.tar.gz
맥	go1.4.darwin-amd64-osx10.8.pkg
FreeBSD	go1.4.freebsd-amd64.tar.gz

UNIX / Linux / Mac OS X 및 FreeBSD에 설치

다운로드 아카이브를 / usr / local 폴더에 추출하여 / usr / local / go에 Go 트리를 만듭니다. 예를 들면-

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

PATH 환경 변수에 / usr / local / go / bin을 추가합니다.

OS	산출
리눅스	내보내기 경로 = $ PATH : / usr / local / go / bin
맥	내보내기 경로 = $ PATH : / usr / local / go / bin
FreeBSD	내보내기 경로 = $ PATH : / usr / local / go / bin

Windows에 설치

MSI 파일을 사용하고 지시에 따라 Go 도구를 설치합니다. 기본적으로 설치 프로그램은 c : \ Go에있는 Go 배포를 사용합니다. 설치 프로그램은 Window의 PATH 환경 변수에 c : \ Go \ bin 디렉토리를 설정해야합니다. 변경 사항을 적용하려면 열려있는 명령 프롬프트를 다시 시작하십시오.

설치 확인

test.go라는 이름의 go 파일을 만듭니다. C:\>Go_WorkSpace.

파일 : test.go

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

이제 test.go를 실행하여 결과를 확인하십시오.

C:\Go_WorkSpace>go run test.go

산출

Hello, World!

Go 프로그래밍 언어의 기본 구성 요소를 연구하기 전에 먼저 다음 장에서 참조 할 수 있도록 Go 프로그램의 최소 구조에 대해 논의하겠습니다.

Hello World 예

Go 프로그램은 기본적으로 다음 부분으로 구성됩니다.

• 패키지 선언
• 패키지 가져 오기
• Functions
• Variables
• 진술 및 표현
• Comments

"Hello World"라는 단어를 인쇄하는 간단한 코드를 살펴 보겠습니다.

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

위 프로그램의 다양한 부분을 살펴 보겠습니다.

• 프로그램 패키지 main의 첫 번째 줄은이 프로그램이 있어야하는 패키지 이름을 정의합니다. Go 프로그램은 패키지에서 실행되므로 필수 문입니다. 메인 패키지는 프로그램 실행의 시작점입니다. 각 패키지에는 연관된 경로와 이름이 있습니다.

• 다음 줄 import "fmt"는 Go 컴파일러에게 fmt 패키지에있는 파일을 포함하도록 지시하는 전 처리기 명령입니다.

• 다음 줄 func main ()은 프로그램 실행이 시작되는 주 함수입니다.

• 다음 줄 /*...*/는 컴파일러에서 무시되며 프로그램에 주석을 추가합니다. 주석은 // Java 또는 C ++ 주석과 유사하게 표시됩니다.

• 다음 줄 fmt.Println (...)은 Go에서 사용할 수있는 또 다른 함수로 "Hello, World!"라는 메시지를 표시합니다. 화면에 표시됩니다. 여기서 fmt 패키지는 화면에 메시지를 표시하는 데 사용되는 Println 메서드를 내보냈습니다.

• Println 방법의 대문자 P에 주목하십시오. Go 언어에서는 대문자로 시작하는 이름이 내보내집니다. Exported는 함수 또는 변수 / 상수를 각 패키지의 수입자가 액세스 할 수 있음을 의미합니다.

Go 프로그램 실행

소스 코드를 파일에 저장하고 컴파일하고 마지막으로 프로그램을 실행하는 방법에 대해 설명하겠습니다. 아래 단계를 따르십시오-

• 텍스트 편집기를 열고 위에서 언급 한 코드를 추가하십시오.

• 파일을 hello.go 로 저장합니다.

• 명령 프롬프트를 엽니 다.

• 파일을 저장 한 디렉토리로 이동하십시오.

• go run hello.go 를 입력하고 Enter 키 를 눌러 코드를 실행합니다.

• 코드에 오류가 없으면 "Hello World!" 가 표시됩니다 . 화면에 인쇄됩니다.

$ go run hello.go
Hello, World!

Go 컴파일러가 경로에 있고 소스 파일 hello.go가 포함 된 디렉토리에서 실행 중인지 확인합니다.

이전 장에서 Go 프로그램의 기본 구조에 대해 논의했습니다. 이제 Go 프로그래밍 언어의 다른 기본 구성 요소를 쉽게 이해할 수 있습니다.

Go의 토큰

Go 프로그램은 다양한 토큰으로 구성됩니다. 토큰은 키워드, 식별자, 상수, 문자열 리터럴 또는 기호입니다. 예를 들어 다음 Go 문은 6 개의 토큰으로 구성됩니다.

fmt.Println("Hello, World!")

개별 토큰은 다음과 같습니다.

fmt
.
Println
(
   "Hello, World!"
)

줄 분리기

Go 프로그램에서 줄 구분 키는 문 종결 자입니다. 즉, 개별 문에는 ";"와 같은 특수 구분 기호가 필요하지 않습니다. C. Go 컴파일러는 내부적으로 ";"을 배치합니다. 하나의 논리적 엔티티의 끝을 나타내는 문 종결 자로.

예를 들어, 다음 진술을 살펴보십시오.

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

코멘트

주석은 Go 프로그램의 도움말 텍스트와 같으며 컴파일러에서 무시됩니다. 다음과 같이 / *로 시작하고 * / 문자로 끝납니다.

/* my first program in Go */

주석 내에 주석을 포함 할 수 없으며 문자열 또는 문자 리터럴 내에서 발생하지 않습니다.

식별자

Go 식별자는 변수, 함수 또는 기타 사용자 정의 항목을 식별하는 데 사용되는 이름입니다. 식별자는 A에서 Z까지의 문자 또는 a에서 z까지의 문자 또는 밑줄 _로 시작하여 0 개 이상의 문자, 밑줄 및 숫자 (0-9)가 이어집니다.

식별자 = 문자 {문자 | 유니 코드 _ 숫자}.

Go는 식별자 내에 @, $ 및 %와 같은 구두점 문자를 허용하지 않습니다. Go는case-sensitive프로그래밍 언어. 따라서 인력 과 인력 은 Go에서 서로 다른 두 가지 식별자입니다. 다음은 허용되는 식별자의 몇 가지 예입니다.

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

키워드

다음 목록은 Go의 예약어를 보여줍니다. 이러한 예약어는 상수, 변수 또는 기타 식별자 이름으로 사용할 수 없습니다.

단절	기본	func	상호 작용	고르다
케이스	연기하다	가다	지도	구조
찬	그밖에	이동	꾸러미	스위치
const	실패로 끝나다	만약	범위	유형
계속하다	...에 대한	수입	반환	Var

Go의 공백

공백은 Go에서 공백, 탭, 줄 바꿈 문자 및 주석을 설명하는 데 사용되는 용어입니다. 주석이있는 공백 만 포함 된 줄을 빈 줄이라고하며 Go 컴파일러는이를 완전히 무시합니다.

공백은 명령문의 한 부분을 다른 부분과 분리하고 컴파일러가 int와 같은 명령문의 한 요소가 끝나고 다음 요소가 시작되는 위치를 식별 할 수 있도록합니다. 따라서 다음 진술에서-

var age int;

컴파일러가 구분할 수 있으려면 int와 age 사이에 공백 문자 (일반적으로 공백)가 하나 이상 있어야합니다. 한편, 다음 진술에서-

fruit = apples + oranges;   // get the total fruit

과일과 = 사이 또는 =와 사과 사이에는 공백 문자가 필요하지 않지만 가독성을 위해 원하는 경우 일부를 포함 할 수 있습니다.

Go 프로그래밍 언어에서 데이터 유형은 다양한 유형의 변수 또는 함수를 선언하는 데 사용되는 광범위한 시스템을 나타냅니다. 변수의 유형에 따라 저장 공간에서 차지하는 공간과 저장된 비트 패턴이 해석되는 방식이 결정됩니다.

Go의 유형은 다음과 같이 분류 할 수 있습니다.

Sr. 아니.	유형 및 설명
1	Boolean types 부울 유형이며 미리 정의 된 두 개의 상수로 구성됩니다. (a) true (b) false
2	Numeric types 이들은 다시 산술 유형이며 프로그램 전체에서 a) 정수 유형 또는 b) 부동 소수점 값을 나타냅니다.
삼	String types 문자열 유형은 문자열 값 세트를 나타냅니다. 그 값은 일련의 바이트입니다. 문자열은 한 번 생성 된 변경 불가능한 유형이며 문자열의 내용을 변경할 수 없습니다. 미리 선언 된 문자열 유형은 문자열입니다.
4	Derived types 여기에는 (a) 포인터 유형, (b) 배열 유형, (c) 구조 유형, (d) 공용체 유형 및 (e) 함수 유형 f) 슬라이스 유형 g) 인터페이스 유형 h) 맵 유형 i) 채널 유형

배열 유형 및 구조 유형은 총칭하여 aggregate types. 함수 유형은 동일한 매개 변수 및 결과 유형을 가진 모든 함수 세트를 지정합니다. 다음 섹션에서 기본 유형에 대해 설명하고 다른 유형은 다음 장에서 다룰 것입니다.

정수 유형

미리 정의 된 아키텍처 독립적 인 정수 유형은 다음과 같습니다.

Sr. 아니.	유형 및 설명
1	uint8 부호없는 8 비트 정수 (0 ~ 255)
2	uint16 부호없는 16 비트 정수 (0 ~ 65535)
삼	uint32 부호없는 32 비트 정수 (0 ~ 4294967295)
4	uint64 부호없는 64 비트 정수 (0 ~ 18446744073709551615)
5	int8 부호있는 8 비트 정수 (-128 ~ 127)
6	int16 부호있는 16 비트 정수 (-32768 ~ 32767)
7	int32 부호있는 32 비트 정수 (-2147483648 ~ 2147483647)
8	int64 부호있는 64 비트 정수 (-9223372036854775808 ~ 9223372036854775807)

부동 유형

미리 정의 된 아키텍처 독립적 인 float 유형은 다음과 같습니다.

Sr. 아니.	유형 및 설명
1	float32 IEEE-754 32 비트 부동 소수점 숫자
2	float64 IEEE-754 64 비트 부동 소수점 숫자
삼	complex64 float32 실수 및 허수 부분이있는 복소수
4	complex128 float64 실수 및 허수 부분이있는 복소수

n 비트 정수의 값은 n 비트이며 2의 보수 산술 연산을 사용하여 표현됩니다.

기타 숫자 유형

구현 별 크기를 가진 숫자 유형 세트도 있습니다.

Sr. 아니.	유형 및 설명
1	byte uint8과 동일
2	rune int32와 동일
삼	uint 32 비트 또는 64 비트
4	int 단위와 같은 크기
5	uintptr 포인터 값의 해석되지 않은 비트를 저장하는 부호없는 정수

변수는 프로그램이 조작 할 수있는 저장 영역에 주어진 이름 일뿐입니다. Go의 각 변수에는 변수 메모리의 크기와 레이아웃, 해당 메모리 내에 저장할 수있는 값의 범위, 변수에 적용 할 수있는 작업 집합을 결정하는 특정 유형이 있습니다.

변수 이름은 문자, 숫자 및 밑줄 문자로 구성 될 수 있습니다. 문자 또는 밑줄로 시작해야합니다. Go는 대소 문자를 구분하기 때문에 대문자와 소문자는 구별됩니다. 이전 장에서 설명한 기본 유형에 따라 다음과 같은 기본 변수 유형이 있습니다.

Sr. 아니요	유형 및 설명
1	byte 일반적으로 단일 옥텟 (1 바이트)입니다. 이것은 바이트 유형입니다.
2	int 기계의 가장 자연스러운 정수 크기입니다.
삼	float32 단 정밀도 부동 소수점 값입니다.

Go 프로그래밍 언어를 사용하면 열거 형, 포인터, 배열, 구조 및 유니온과 같은 다양한 유형의 변수를 정의 할 수 있습니다. 이에 대해서는 다음 장에서 설명합니다. 이 장에서는 기본적인 변수 유형에만 초점을 맞출 것입니다.

Go의 변수 정의

변수 정의는 컴파일러에게 변수에 대해 생성 할 스토리지의 위치와 양을 알려줍니다. 변수 정의는 데이터 유형을 지정하고 다음과 같이 해당 유형의 하나 이상의 변수 목록을 포함합니다.

var variable_list optional_data_type;

여기, optional_data_type byte, int, float32, complex64, boolean 또는 모든 사용자 정의 개체 등을 포함하는 유효한 Go 데이터 유형입니다. variable_list쉼표로 구분 된 하나 이상의 식별자 이름으로 구성 될 수 있습니다. 몇 가지 유효한 선언이 여기에 표시됩니다.

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

진술 “var i, j, k;”변수 i, j 및 k를 선언하고 정의합니다. 컴파일러에게 int 유형의 i, j 및 k라는 변수를 생성하도록 지시합니다.

변수는 선언에서 초기화 (초기 값 할당) 할 수 있습니다. 변수의 유형은 전달 된 값에 따라 컴파일러에 의해 자동으로 판단됩니다. 이니셜 라이저는 다음과 같이 등호와 상수 표현식으로 구성됩니다.

variable_name = value;

예를 들면

d = 3, f = 5;    // declaration of d and f. Here d and f are int

이니셜 라이저가없는 정의 : 정적 저장 기간이있는 변수는 암시 적으로 nil로 초기화됩니다 (모든 바이트의 값은 0). 다른 모든 변수의 초기 값은 데이터 유형의 0 값입니다.

Go의 정적 유형 선언

정적 유형 변수 선언은 주어진 유형 및 이름으로 사용 가능한 하나의 변수가 있음을 컴파일러에 보장하여 컴파일러가 변수의 완전한 세부 사항없이 추가 컴파일을 진행할 수 있도록합니다. 변수 선언은 컴파일시에만 의미가 있으며 컴파일러는 프로그램 연결시 실제 변수 선언이 필요합니다.

예

변수가 유형으로 선언되고 주 함수 내부에서 초기화 된 다음 예제를 시도해보십시오.

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

20
x is of type float64

Go의 동적 유형 선언 / 유형 추론

동적 유형 변수 선언은 컴파일러가 전달 된 값을 기반으로 변수 유형을 해석해야합니다. 컴파일러는 필수 요구 사항으로 정적으로 유형을 갖는 변수가 필요하지 않습니다.

예

변수가 유형없이 선언 된 다음 예제를 시도하십시오. 유형 추론의 경우 변수를 초기화했습니다.y : = 연산자와 함께 x = 연산자를 사용하여 초기화됩니다.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

20
42
x is of type float64
y is of type int

Go의 혼합 변수 선언

유형 추론을 사용하여 한 번에 여러 유형의 변수를 선언 할 수 있습니다.

예

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

3
4
foo
a is of type int
b is of type int
c is of type string

Go의 lvalue와 rvalue

Go에는 두 종류의 표현이 있습니다.

• lvalue− 메모리 위치를 참조하는 표현식을 "lvalue"표현식이라고합니다. lvalue는 할당의 왼쪽 또는 오른쪽으로 나타날 수 있습니다.

• rvalue− rvalue라는 용어는 메모리의 일부 주소에 저장된 데이터 값을 의미합니다. rvalue는 할당 된 값을 가질 수없는 표현식입니다. 이는 rvalue가 할당의 오른쪽에 나타날 수 있지만 왼쪽에는 나타나지 않을 수 있음을 의미합니다.

변수는 lvalue이므로 할당의 왼쪽에 나타날 수 있습니다. 숫자 리터럴은 r 값이므로 할당되지 않고 왼쪽에 표시되지 않을 수 있습니다.

다음 진술은 유효합니다-

x = 20.0

다음 문은 유효하지 않습니다. 컴파일 타임 오류를 생성합니다-

10 = 20

상수는 프로그램이 실행 중에 변경할 수없는 고정 값을 나타냅니다. 이러한 고정 값을literals.

상수는 정수 상수, 부동 상수, 문자 상수 또는 문자열 리터럴 과 같은 기본 데이터 유형 중 하나 일 수 있습니다 . 열거 형 상수도 있습니다.

상수는 정의 후에 값을 수정할 수 없다는 점을 제외하고는 일반 변수처럼 취급됩니다.

정수 리터럴

정수 리터럴은 10 진수, 8 진수 또는 16 진수 상수 일 수 있습니다. 접두사는 기수 또는 기수를 지정합니다. 16 진수는 0x 또는 0X, 8 진수는 0, 10 진수는 없습니다.

정수 리터럴은 각각 unsigned 및 long에 대해 U와 L의 조합 인 접미사를 가질 수도 있습니다. 접미사는 대문자 또는 소문자 일 수 있으며 순서에 관계없이 사용할 수 있습니다.

다음은 정수 리터럴의 몇 가지 예입니다.

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

다음은 다양한 유형의 정수 리터럴의 다른 예입니다.

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

부동 소수점 리터럴

부동 소수점 리터럴에는 정수 부분, 소수점, 소수 부분 및 지수 부분이 있습니다. 부동 소수점 리터럴을 10 진수 형식 또는 지수 형식으로 나타낼 수 있습니다.

소수 형식을 사용하여 표시하는 동안 소수점, 지수 또는 둘 다를 포함해야하며 지수 형식을 사용하여 표시하는 동안 정수 부분, 소수 부분 또는 둘 다를 포함해야합니다. 부호있는 지수는 e 또는 E로 도입됩니다.

다음은 부동 소수점 리터럴의 몇 가지 예입니다.

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

탈출 시퀀스

특정 문자 앞에 백 슬래시가 있으면 Go에서 특별한 의미를 갖습니다. 이들은 줄 바꿈 (\ n), 탭 (\ t), 백 스페이스 등을 나타내는 데 사용되는 이스케이프 시퀀스 코드로 알려져 있습니다. 여기에 이러한 이스케이프 시퀀스 코드 목록이 있습니다.

탈출 시퀀스	의미
\\	\ 캐릭터
\ '	' 캐릭터
\ "	" 캐릭터
\?	? 캐릭터
\ㅏ	경고 또는 벨
\비	역행 키이
\에프	양식 피드
\엔	개행
\아르 자형	캐리지 리턴
\티	수평 탭
\V	수직 탭
\ ooo	1 ~ 3 자리의 8 진수
\ xhh. . .	하나 이상의 자릿수의 16 진수

다음 예는 사용 방법을 보여줍니다. \t 프로그램에서-

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Hello World!

Go의 문자열 리터럴

문자열 리터럴 또는 상수는 큰 따옴표 ""로 묶여 있습니다. 문자열에는 일반 문자, 이스케이프 시퀀스 및 범용 문자와 같은 문자 리터럴과 유사한 문자가 포함됩니다.

문자열 리터럴을 사용하여 긴 줄을 여러 줄로 나누고 공백을 사용하여 구분할 수 있습니다.

다음은 문자열 리터럴의 몇 가지 예입니다. 세 가지 형식은 모두 동일한 문자열입니다.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

CONST 키워드

당신이 사용할 수있는 const 다음과 같이 특정 유형의 상수를 선언하는 접두사-

const variable type = value;

다음 예는 const 키워드 −

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

value of area : 50

CAPITALS에서 상수를 정의하는 것이 좋은 프로그래밍 방법입니다.

연산자는 컴파일러에게 특정 수학적 또는 논리적 조작을 수행하도록 지시하는 기호입니다. Go 언어는 내장 된 연산자가 풍부하며 다음 유형의 연산자를 제공합니다.

• 산술 연산자
• 관계 연산자
• 논리 연산자
• 비트 연산자
• 할당 연산자
• 기타 연산자

이 자습서에서는 산술, 관계형, 논리, 비트, 할당 및 기타 연산자를 하나씩 설명합니다.

산술 연산자

다음 표는 Go 언어에서 지원하는 모든 산술 연산자를 보여줍니다. 변수 가정A 10 개와 가변 B holds 20 then −

Show Examples

Operator	Description	Example
+	Adds two operands	A + B gives 30
-	Subtracts second operand from the first	A - B gives -10
*	Multiplies both operands	A * B gives 200
/	Divides the numerator by the denominator.	B / A gives 2
%	Modulus operator; gives the remainder after an integer division.	B % A gives 0
++	Increment operator. It increases the integer value by one.	A++ gives 11
--	Decrement operator. It decreases the integer value by one.	A-- gives 9

Relational Operators

The following table lists all the relational operators supported by Go language. Assume variable A holds 10 and variable B holds 20, then −

Show Examples

Operator	Description	Example
==	It checks if the values of two operands are equal or not; if yes, the condition becomes true.	(A == B) is not true.
!=	It checks if the values of two operands are equal or not; if the values are not equal, then the condition becomes true.	(A != B) is true.
>	It checks if the value of left operand is greater than the value of right operand; if yes, the condition becomes true.	(A > B) is not true.
<	It checks if the value of left operand is less than the value of the right operand; if yes, the condition becomes true.	(A < B) is true.
>=	It checks if the value of the left operand is greater than or equal to the value of the right operand; if yes, the condition becomes true.	(A >= B) is not true.
<=	It checks if the value of left operand is less than or equal to the value of right operand; if yes, the condition becomes true.	(A <= B) is true.

Logical Operators

The following table lists all the logical operators supported by Go language. Assume variable A holds 1 and variable B holds 0, then −

Show Examples

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non-zero, then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A && B) is true.

The following table shows all the logical operators supported by Go language. Assume variable A holds true and variable B holds false, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are false, then the condition becomes false.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is true, then the condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume A = 60; and B = 13. In binary format, they will be as follows −

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

The Bitwise operators supported by C language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Show Examples

Operator	Description	Example
&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12, which is 0000 1100
|	Binary OR Operator copies a bit if it exists in either operand.	(A | B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240 which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15 which is 0000 1111

Assignment Operators

The following table lists all the assignment operators supported by Go language −

Show Examples

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Miscellaneous Operators

There are a few other important operators supported by Go Language including sizeof and ?:.

Show Examples

Operator	Description	Example
&	Returns the address of a variable.	&a; provides actual address of the variable.
*	Pointer to a variable.	*a; provides pointer to a variable.

Operators Precedence in Go

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Show Examples

Category	Operator	Associativity
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Assignment	= += -= *= /= %=>>= <<= &= ^= |=	Right to left
Comma	,	Left to right

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

Go programming language provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).
4	switch statement A switch statement allows a variable to be tested for equality against a list of values.
5	select statement A select statement is similar to switch statement with difference that case statements refers to channel communications.

There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

Go programming language provides the following types of loop to handle looping requirements.

Sr.No	Loop Type & Description
1	for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
2	nested loops These are one or multiple loops inside any for loop.

Loop Control Statements

Loop control statements change an execution from its normal sequence. When an execution leaves its scope, all automatic objects that were created in that scope are destroyed.

Go supports the following control statements −

Sr.No	Control Statement & Description
1	break statement It terminates a for loop or switch statement and transfers execution to the statement immediately following the for loop or switch.
2	continue statement It causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	goto statement It transfers control to the labeled statement.

The Infinite Loop

A loop becomes an infinite loop if its condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty or by passing true to it.

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but C programmers more commonly use the for(;;) construct to signify an infinite loop.

Note − You can terminate an infinite loop by pressing Ctrl + C keys.

A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division should be such that each function performs a specific task.

A function declaration tells the compiler about a function name, return type, and parameters. A function definition provides the actual body of the function.

The Go standard library provides numerous built-in functions that your program can call. For example, the function len() takes arguments of various types and returns the length of the type. If a string is passed to it, the function returns the length of the string in bytes. If an array is passed to it, the function returns the length of the array.

Functions are also known as method, sub-routine, or procedure.

Defining a Function

The general form of a function definition in Go programming language is as follows −

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

• Func − It starts the declaration of a function.

• Function Name − It is the actual name of the function. The function name and the parameter list together constitute the function signature.

• Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.

• Return Type − A function may return a list of values. The return_types is the list of data types of the values the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the not required.

• Function Body − It contains a collection of statements that define what the function does.

Example

The following source code shows a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two −

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Calling a Function

While creating a Go function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program.

To call a function, you simply need to pass the required parameters along with its function name. If the function returns a value, then you can store the returned value. For example −

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

We have kept the max() function along with the main() function and compiled the source code. While running the final executable, it would produce the following result −

Max value is : 200

Returning multiple values from Function

A Go function can return multiple values. For example −

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

When the above code is compiled and executed, it produces the following result −

Kumar Mahesh

Function Arguments

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function −

Sr.No	Call Type & Description
1	Call by value This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
2	Call by reference This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

By default, Go uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. The above program, while calling the max() function, used the same method.

Function Usage

A function can be used in the following ways:

Sr.No	Function Usage & Description
1	Function as Value Functions can be created on the fly and can be used as values.
2	Function Closures Functions closures are anonymous functions and can be used in dynamic programming.
3	Method Methods are special functions with a receiver.

A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −

• Inside a function or a block (local variables)

• Outside of all functions (global variables)

• In the definition of function parameters (formal parameters)

Let us find out what are local and global variables and what are formal parameters.

Local Variables

Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

When the above code is compiled and executed, it produces the following result −

value of a = 10, b = 20 and c = 30

글로벌 변수

전역 변수는 일반적으로 프로그램 상단에서 함수 외부에서 정의됩니다. 전역 변수는 프로그램의 수명 내내 해당 값을 유지하며 프로그램에 대해 정의 된 함수 내에서 액세스 할 수 있습니다.

전역 변수는 모든 함수에서 액세스 할 수 있습니다. 즉, 전역 변수는 선언 후 프로그램 전체에서 사용할 수 있습니다. 다음 예제는 전역 및 지역 변수를 모두 사용합니다-

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

value of a = 10, b = 20 and g = 30

프로그램은 지역 및 전역 변수에 대해 동일한 이름을 가질 수 있지만 함수 내부의 지역 변수 값이 우선합니다. 예를 들면-

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

value of g = 10

공식 매개 변수

형식 매개 변수는 해당 함수 내에서 지역 변수로 취급되며 전역 변수보다 우선합니다. 예를 들면-

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

로컬 및 글로벌 변수 초기화

지역 및 전역 변수는 기본값 인 0으로 초기화됩니다. 포인터는 nil로 초기화됩니다.

데이터 형식	초기 기본값
int	0
float32	0
바늘	무

Go 프로그래밍에서 널리 사용되는 문자열은 읽기 전용 바이트 조각입니다. Go 프로그래밍 언어에서 문자열은slices. Go 플랫폼은 문자열을 조작 할 수있는 다양한 라이브러리를 제공합니다.

• unicode
• regexp
• strings

문자열 만들기

문자열을 만드는 가장 직접적인 방법은 다음과 같습니다.

var greeting = "Hello world!"

코드에서 문자열 리터럴을 발견 할 때마다 컴파일러는이 경우 "Hello world!"라는 값을 사용하여 문자열 개체를 만듭니다.

문자열 리터럴에는 룬이라고하는 유효한 UTF-8 시퀀스가 ​​있습니다. 문자열은 임의의 바이트를 보유합니다.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*q flag escapes unprintable characters, with + flag it escapses non-ascii 
   characters as well to make output unambigous  
   */
   fmt.Printf("quoted string: ")
   fmt.Printf("%+q", sampleText)
   fmt.Printf("\n")  
}

이것은 다음 결과를 생성합니다-

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

Note − 문자열 리터럴은 변경 불가능하므로 일단 생성 된 문자열 리터럴은 변경할 수 없습니다.

문자열 길이

len (str) 메서드는 문자열 리터럴에 포함 된 바이트 수를 반환합니다.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

이것은 다음 결과를 생성합니다-

String Length is : 12

문자열 연결

strings 패키지에는 메소드가 포함되어 있습니다. join 여러 문자열을 연결하기 위해-

strings.Join(sample, " ")

Join은 배열의 요소를 연결하여 단일 문자열을 만듭니다. 두 번째 매개 변수는 배열의 요소 사이에 배치되는 구분자입니다.

다음 예를 살펴 보겠습니다.

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

이것은 다음 결과를 생성합니다-

Hello world!

Go 프로그래밍 언어는 다음과 같은 데이터 구조를 제공합니다. the array, 동일한 유형의 요소의 고정 크기 순차 컬렉션을 저장할 수 있습니다. 배열은 데이터 모음을 저장하는 데 사용되지만 배열을 동일한 유형의 변수 모음으로 생각하는 것이 더 유용합니다.

number0, number1, ..., number99와 같은 개별 변수를 선언하는 대신 숫자와 같은 하나의 배열 변수를 선언하고 numbers [0], numbers [1] 및 ..., numbers [99]를 사용하여 개별 변수. 배열의 특정 요소는 인덱스로 액세스됩니다.

모든 어레이는 연속적인 메모리 위치로 구성됩니다. 가장 낮은 주소는 첫 번째 요소에 해당하고 가장 높은 주소는 마지막 요소에 해당합니다.

배열 선언

Go에서 배열을 선언하기 위해 프로그래머는 다음과 같이 배열에 필요한 요소의 유형과 요소의 수를 지정합니다.

var variable_name [SIZE] variable_type

이것을 1 차원 배열 이라고합니다 . 그만큼arraySize 0보다 큰 정수 상수 여야하며 type모든 유효한 Go 데이터 유형이 될 수 있습니다. 예를 들어, 10 개의 요소 배열을 선언하려면balance float32 유형의 경우 다음 문을 사용하십시오.

var balance [10] float32

여기, balance 최대 10 개의 부동 숫자를 보유 할 수있는 가변 배열입니다.

배열 초기화

Go에서 배열을 하나씩 초기화하거나 다음과 같이 단일 문을 사용하여 초기화 할 수 있습니다.

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

중괄호 {} 사이의 값 수는 대괄호 [] 사이의 배열에 대해 선언 한 요소 수보다 클 수 없습니다.

배열의 크기를 생략하면 초기화를 저장할 수있을만큼 큰 배열이 생성됩니다. 따라서 다음과 같이 쓰면-

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

이전 예제에서했던 것과 똑같은 배열을 만들 것입니다. 다음은 배열의 단일 요소를 할당하는 예입니다.

balance[4] = 50.0

상기 문 양수인 요소 번호 5 ^번째 50.0의 값을 배열한다. 모든 배열은 기본 인덱스라고도하는 첫 번째 요소의 인덱스로 0을 가지며 배열의 마지막 인덱스는 배열의 전체 크기에서 1을 뺀 값이됩니다. 다음은 위에서 논의한 동일한 배열의 그림 표현입니다.

배열 요소에 액세스

배열 이름을 인덱싱하여 요소에 액세스합니다. 이는 배열 이름 뒤에 대괄호 안에 요소의 인덱스를 배치하여 수행됩니다. 예를 들면-

float32 salary = balance[9]

위의 명령문은 배열에서 10 ^번째 요소를 가져와 급여 변수에 값을 할당합니다. 다음은 위에서 언급 한 세 가지 개념을 모두 사용하는 예입니다. 선언, 할당 및 액세스 배열-

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize elements of array n to 0 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* set element at location i to i + 100 */
   }
   /* output each array element's value */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

자세한 Go 어레이

Go 프로그래머에게 명확해야하는 배열과 관련된 중요한 개념이 있습니다.

Sr. 아니요	개념 및 설명
1	다차원 배열 Go는 다차원 배열을 지원합니다. 다차원 배열의 가장 간단한 형태는 2 차원 배열입니다.
2	함수에 배열 전달 인덱스없이 배열의 이름을 지정하여 배열에 대한 포인터를 함수에 전달할 수 있습니다.

Go의 포인터는 쉽고 재미있게 배울 수 있습니다. 일부 Go 프로그래밍 작업은 포인터를 사용하여 더 쉽게 수행되며 참조에 의한 호출과 같은 다른 작업은 포인터를 사용하지 않고 수행 할 수 없습니다. 그래서 완벽한 Go 프로그래머가되기 위해서는 포인터를 배워야합니다.

아시다시피 모든 변수는 메모리 위치이며 모든 메모리 위치에는 메모리의 주소를 나타내는 앰퍼샌드 (&) 연산자를 사용하여 액세스 할 수있는 주소가 정의되어 있습니다. 정의 된 변수의 주소를 인쇄 할 다음 예제를 고려하십시오.

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Address of a variable: 10328000

그래서 당신은 메모리 주소가 무엇이며 어떻게 액세스하는지 이해했습니다. 이제 포인터가 무엇인지 살펴 보겠습니다.

포인터 란?

ㅏ pointer다른 변수의 주소, 즉 메모리 위치의 직접 주소 인 변수입니다. 다른 변수 나 상수와 마찬가지로 포인터를 사용하여 변수 주소를 저장하려면 먼저 포인터를 선언해야합니다. 포인터 변수 선언의 일반적인 형식은 다음과 같습니다.

var var_name *var-type

여기, type포인터의 기본 유형입니다. 유효한 C 데이터 유형이어야하며var-name포인터 변수의 이름입니다. 포인터를 선언하는 데 사용한 별표 *는 곱하기에 사용하는 것과 동일한 별표입니다. 그러나이 명령문에서 별표는 변수를 포인터로 지정하는 데 사용됩니다. 다음은 유효한 포인터 선언입니다-

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

정수, 부동 또는 기타 모든 포인터 값의 실제 데이터 유형은 메모리 주소를 나타내는 긴 16 진 숫자와 동일합니다. 데이터 유형이 다른 포인터 간의 유일한 차이점은 포인터가 가리키는 변수 또는 상수의 데이터 유형입니다.

포인터를 사용하는 방법?

포인터로 자주 수행하는 몇 가지 중요한 작업이 있습니다. (a) 포인터 변수를 정의하고, (b) 변수의 주소를 포인터에 할당하고, (c) 포인터 변수에 저장된 주소의 값에 액세스 .

이러한 모든 연산은 피연산자가 지정한 주소에있는 변수의 값을 반환하는 단항 연산자 *를 사용하여 수행됩니다. 다음 예제는 이러한 작업을 수행하는 방법을 보여줍니다-

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Go의 Nil 포인터

Go 컴파일러는 할당 할 정확한 주소가없는 경우 포인터 변수에 Nil 값을 할당합니다. 이것은 변수 선언시 수행됩니다. nil이 할당 된 포인터는nil 바늘.

nil 포인터는 여러 표준 라이브러리에 정의 된 값이 0 인 상수입니다. 다음 프로그램을 고려하십시오-

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

The value of ptr is 0

대부분의 운영 체제에서는 해당 메모리가 운영 체제에 의해 예약되어 있기 때문에 프로그램이 주소 0의 메모리에 액세스 할 수 없습니다. 그러나 메모리 주소 0은 특별한 의미가 있습니다. 포인터가 액세스 가능한 메모리 위치를 가리 키도록 의도되지 않았 음을 나타냅니다. 그러나 관례 적으로 포인터에 nil (영) 값이 포함되어 있으면 아무 것도 가리키는 것으로 간주되지 않습니다.

nil 포인터를 확인하려면 다음과 같이 if 문을 사용할 수 있습니다.

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

자세한 Go 포인터

포인터는 많지만 쉬운 개념을 가지고 있으며 Go 프로그래밍에 매우 중요합니다. 다음 포인터 개념은 Go 프로그래머에게 명확해야합니다.

Sr. 아니요	개념 및 설명
1	Go-포인터 배열 여러 포인터를 보유하도록 배열을 정의 할 수 있습니다.
2	이동-포인터에 대한 포인터 Go를 사용하면 포인터에 포인터를 놓을 수 있습니다.
삼	Go에서 함수에 대한 포인터 전달 참조 또는 주소로 인수를 전달하면 호출 된 함수에서 전달 된 인수를 호출 함수에서 변경할 수 있습니다.

Go 배열을 사용하면 동일한 종류의 여러 데이터 항목을 보유 할 수있는 변수를 정의 할 수 있습니다. Structure Go 프로그래밍에서 사용할 수있는 또 다른 사용자 정의 데이터 유형으로, 다양한 종류의 데이터 항목을 결합 할 수 있습니다.

구조는 레코드를 나타내는 데 사용됩니다. 도서관에있는 책을 추적하고 싶다고 가정 해 보겠습니다. 각 책의 다음 속성을 추적 할 수 있습니다.

• Title
• Author
• Subject
• 도서 ID

이러한 시나리오에서 구조는 매우 유용합니다.

구조 정의

구조를 정의하려면 다음을 사용해야합니다. type 과 struct진술. struct 문은 프로그램에 대한 여러 멤버를 사용하여 새 데이터 유형을 정의합니다. type 문은 우리의 경우 struct 인 유형으로 이름을 바인딩합니다. struct 문의 형식은 다음과 같습니다.

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

구조 유형이 정의되면 다음 구문을 사용하여 해당 유형의 변수를 선언하는 데 사용할 수 있습니다.

variable_name := structure_variable_type {value1, value2...valuen}

구조 멤버 액세스

구조의 구성원에 액세스하려면 member access operator (.).멤버 액세스 연산자는 구조 변수 이름과 액세스하려는 구조 멤버 사이의 마침표로 코딩됩니다. 당신은 사용할 것입니다struct구조 유형의 변수를 정의하는 키워드입니다. 다음 예제는 구조를 사용하는 방법을 설명합니다-

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Book 1 title      : Go Programming
Book 1 author     : Mahesh Kumar
Book 1 subject    : Go Programming Tutorial
Book 1 book_id    : 6495407
Book 2 title      : Telecom Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

함수 인수로서의 구조

다른 변수 나 포인터를 전달하는 것과 매우 유사한 방식으로 구조를 함수 인수로 전달할 수 있습니다. 위의 예에서했던 것과 같은 방식으로 구조 변수에 액세스합니다.

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

구조에 대한 포인터

다음과 같이 다른 변수에 대한 포인터를 정의하는 것과 같은 방식으로 구조체에 대한 포인터를 정의 할 수 있습니다.

var struct_pointer *Books

이제 위에서 정의한 포인터 변수에 구조 변수의 주소를 저장할 수 있습니다. 구조 변수의 주소를 찾으려면 다음과 같이 구조 이름 앞에 & 연산자를 배치하십시오.

struct_pointer = &Book1;

해당 구조에 대한 포인터를 사용하여 구조의 멤버에 액세스하려면 "."를 사용해야합니다. 다음과 같이 연산자-

struct_pointer.title;

구조 포인터를 사용하여 위의 예를 다시 작성해 보겠습니다.

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books   /* Declare Book1 of type Book */
   var Book2 Books   /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Go Slice는 Go Array에 대한 추상화입니다. Go Array를 사용하면 동일한 종류의 여러 데이터 항목을 보유 할 수있는 변수를 정의 할 수 있지만 동적으로 크기를 늘리거나 자체 하위 배열을 가져 오는 내장 된 방법을 제공하지 않습니다. 슬라이스는이 한계를 극복합니다. Array에 필요한 많은 유틸리티 기능을 제공하며 Go 프로그래밍에서 널리 사용됩니다.

슬라이스 정의

슬라이스를 정의하려면 크기를 지정하지 않고 배열로 선언 할 수 있습니다. 또는 다음을 사용할 수 있습니다.make 슬라이스를 만드는 함수.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

len () 및 cap () 함수

슬라이스는 배열에 대한 추상화입니다. 실제로 배열을 기본 구조로 사용합니다. 그만큼len() 함수는 슬라이스에있는 요소를 반환합니다. cap()함수는 슬라이스의 용량 (즉, 수용 할 수있는 요소 수)을 반환합니다. 다음 예제는 슬라이스의 사용법을 설명합니다-

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

len = 3 cap = 5 slice = [0 0 0]

무 슬라이스

슬라이스가 입력없이 선언되면 기본적으로 nil로 초기화됩니다. 길이와 용량은 0입니다. 예를 들면-

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

len = 0 cap = 0 slice = []
slice is nil

서브 슬라이싱

Slice를 사용하면 하위 경계 및 상위 경계를 지정하여 하위 경계를 얻을 수 있습니다.[lower-bound:upper-bound]. 예를 들면-

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

append () 및 copy () 함수

다음을 사용하여 슬라이스의 용량을 늘릴 수 있습니다. append()함수. 사용copy()함수를 사용하면 소스 슬라이스의 내용이 대상 슬라이스로 복사됩니다. 예를 들면-

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

그만큼 range 키워드는 for루프는 배열, 슬라이스, 채널 또는 맵의 항목을 반복합니다. 배열과 슬라이스를 사용하면 항목의 인덱스를 정수로 반환합니다. 맵을 사용하면 다음 키-값 쌍의 키를 반환합니다. 범위는 하나 또는 두 개의 값을 반환합니다. 범위 표현식의 왼쪽에 하나의 값만 사용되는 경우 다음 표에서 첫 번째 값입니다.

범위 표현	첫 번째 가치	두 번째 값 (선택 사항)
[n] E 배열 또는 슬라이스	인덱스 i int	a [i] E
문자열의 문자열 유형	인덱스 i int	룬 정수
맵 m 맵 [K] V	키 k K	값 m [k] V
채널 c 채널 E	요소 e E	없음

예

다음 단락은 범위를 사용하는 방법을 보여줍니다-

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice item",i,"is",numbers[i])
   }
   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* print map using key-value*/
   for country,capital := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",capital)
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo

Go는 고유 키를 값에 매핑하는 map이라는 또 다른 중요한 데이터 유형을 제공합니다. 키는 나중에 값을 검색하는 데 사용하는 개체입니다. 키와 값이 주어지면 값을 Map 객체에 저장할 수 있습니다. 값이 저장된 후 해당 키를 사용하여 검색 할 수 있습니다.

지도 정의

당신은 사용해야합니다 make 지도를 만드는 기능.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

예

다음 예제는지도를 만들고 사용하는 방법을 보여줍니다.

package main

import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* create a map*/
   countryCapitalMap = make(map[string]string)
   
   /* insert key-value pairs in the map*/
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* test if entry is present in the map or not*/
   capital, ok := countryCapitalMap["United States"]
   
   /* if ok is true, entry is present otherwise entry is absent*/
   if(ok){
      fmt.Println("Capital of United States is", capital)  
   } else {
      fmt.Println("Capital of United States is not present") 
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present

delete () 함수

delete () 함수는지도에서 항목을 삭제하는 데 사용됩니다. 삭제할지도와 해당 키가 필요합니다. 예를 들면-

package main

import "fmt"

func main() {   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
   
   fmt.Println("Original map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* delete an entry */
   delete(countryCapitalMap,"France");
   fmt.Println("Entry for France is deleted")  
   
   fmt.Println("Updated map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo

재귀는 유사한 방식으로 항목을 반복하는 프로세스입니다. 프로그래밍 언어에도 동일한 개념이 적용됩니다. 프로그램이 동일한 함수 내에서 함수를 호출 할 수있는 경우이를 재귀 함수 호출이라고합니다. 다음 예를 살펴보십시오-

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

Go 프로그래밍 언어는 재귀를 지원합니다. 즉, 함수가 자신을 호출 할 수 있습니다. 그러나 재귀를 사용하는 동안 프로그래머는 함수에서 종료 조건을 정의 할 때주의해야합니다. 그렇지 않으면 계속해서 무한 루프가됩니다.

Go에서의 재귀 예제

재귀 함수는 숫자의 계승 계산, 피보나치 시리즈 생성 등과 같은 많은 수학적 문제를 해결하는 데 매우 유용합니다.

예제 1 : Go에서 재귀를 사용하여 팩토리얼 계산

다음 예제는 재귀 함수를 사용하여 주어진 숫자의 계승을 계산합니다-

package main

import "fmt"

func factorial(i int)int {
   if(i <= 1) {
      return 1
   }
   return i * factorial(i - 1)
}
func main() { 
   var i int = 15
   fmt.Printf("Factorial of %d is %d", i, factorial(i))
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Factorial of 15 is 1307674368000

예제 2 : Go에서 재귀를 사용하는 피보나치 시리즈

다음 예제는 재귀 함수를 사용하여 주어진 숫자의 피보나치 시리즈를 생성하는 방법을 보여줍니다.

package main

import "fmt"

func fibonaci(i int) (ret int) {
   if i == 0 {
      return 0
   }
   if i == 1 {
      return 1
   }
   return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
   var i int
   for i = 0; i < 10; i++ {
      fmt.Printf("%d ", fibonaci(i))
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

0 1 1 2 3 5 8 13 21 34

유형 캐스팅은 한 데이터 유형에서 다른 데이터 유형으로 변수를 변환하는 방법입니다. 예를 들어, long 값을 간단한 정수에 저장하려면 cast long을 int로 입력 할 수 있습니다. 다음을 사용하여 한 유형에서 다른 유형으로 값을 변환 할 수 있습니다.cast operator. 구문은 다음과 같습니다.

type_name(expression)

예

캐스트 연산자가 한 정수 변수를 다른 정수 변수로 나누면 부동 숫자 연산으로 수행되는 다음 예제를 고려하십시오.

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Value of mean : 3.400000

Go 프로그래밍은 interfaces메소드 서명 세트를 나타냅니다. struct 데이터 유형은 인터페이스의 메소드 서명에 대한 메소드 정의를 갖도록 이러한 인터페이스를 구현합니다.

통사론

/* define an interface */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* define a struct */
type struct_name struct {
   /* variables */
}

/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* method implementation */
}

예

package main

import (
   "fmt" 
   "math" 
)

/* define an interface */
type Shape interface {
   area() float64
}

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a rectangle */
type Rectangle struct {
   width, height float64
}

/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

/* define a method for shape */
func getArea(shape Shape) float64 {
   return shape.area()
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}
   
   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Circle area: 78.539816
Rectangle area: 50.000000

Go 프로그래밍은 다음 선언의 내장 오류 인터페이스 유형으로 매우 간단한 오류 처리 프레임 워크를 제공합니다.

type error interface {
   Error() string
}

함수는 일반적으로 마지막 반환 값으로 오류를 반환합니다. 사용하다errors.New 다음과 같이 기본 오류 메시지를 구성하려면-

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

반환 값 및 오류 메시지를 사용합니다.

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

예

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}
func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
   
   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
}

위의 코드가 컴파일되고 실행되면 다음과 같은 결과가 생성됩니다.

Math: negative number passed to Sqrt
3