Introduction to Source Code Elements

Below is the demo Go program. Please read the comments for explanations. More explanations are following the program.

package main // specify the source file's package

import "math/rand" // import a standard package

const MaxRnd = 16 // a named constant declaration

// A function declaration
/*
 StatRandomNumbers produces a certain number of
 non-negative random integers which are less than
 MaxRnd, then counts and returns the numbers of
 small and large ones among the produced randoms.
 n specifies how many randoms to be produced.
*/
func StatRandomNumbers(n int) (int, int) {
	// Declare two variables (both as 0).
	var a, b int
	// A for-loop control flow.
	for i := 0; i < n; i++ {
		// An if-else control flow.
		if rand.Intn(MaxRnd) < MaxRnd/2 {
			a = a + 1
		} else {
			b++ // same as: b = b + 1
		}
	}
	return a, b // this function return two results
}

// "main" function is the entry function of a program.
func main() {
	var num = 100
	// Call the declared StatRandomNumbers function.
	x, y := StatRandomNumbers(num)
	// Call two built-in functions (print and println).
	print("Result: ", x, " + ", y, " = ", num, "? ")
	println(x+y == num)
}

Save above source code to a file named basic-code-element-demo.go and run this program by:

$ go run basic-code-element-demo.go
Result: 46 + 54 = 100? true

In the above program, package, import, const, func, var, for, if, else, and return are all keywords. Most other words in the program are identifiers. Please read keywords and identifiers for more information about keywords and identifiers.

The four int words at line 15 and line 17 denote the built-in int type, one of many kinds of integer types in Go. The 16 at line 5, 0 at line 19, 1 at line 22 and 100 at line 32 are some integer literals. The "Result: " at line 36 is a string literal. Please read basic types and their value literals for more information about above built-in basic types and their value literals. Some other types (composite types) will be introduced later in other articles.

Line 22 is an assignment. Line 5 declares a named constant, MaxRnd. Line 17 and line 32 declare three variables, with the standard variable declaration form. Variables i at line 19, x and y at line 34 are declared with the short variable declaration form. We have specified the type for variables a and b as int. Go compiler will deduce that the types of i, num, x and y are all int, because they are initialized with integer literals. Please read constants and variables for more information about untyped values, type deduction, value assignments, and how to declare variables and named constants.

There are many operators used in the program, such as the less-than comparison operator < at line 19 and 21, the equal-to operator == at line 37, and the addition operator + at line 22 and line 37. Yes, + at line 36 is not an operator, it is one character in a string literal. The values involved in an operator operation are called operands. Please read common operators for more information. More operators will be introduced in other articles later.

At line 36 and line 37, two built-in functions, print and println, are called. A custom function StatRandomNumbers is declared from line 15 to line 28, and is called at line 34. Line 21 also calls a function, Intn, which is a function declared in the math/rand standard package. A function call is a function operation. The input values used in a function call are called arguments. Please read function declarations and calls for more information.

(Note, the built-in print and println functions are not recommended to be used in formal Go programming. The corresponding functions in the fmt standard packages should be used instead in formal Go projects. In Go 101, the two functions are only used in the several starting articles.)

Line 1 specifies the package name of the current source file. The main entry function must be declared in a package which is also called main. Line 3 imports a package, the math/rand standard code package. Its import name is rand. The function Intn declared in this standard package is called at line 21. Please read code packages and package imports for more information about how to organize code packages and import packages.

The article expressions, statements and simple statements will introduce what are expressions and statements. In particular, all kinds of simple statements, which are special statements, are listed. Some portions of all kinds of control flows must be simple statements, and some portions must be expressions.

In the StatRandomNumbers function body, two control flows are used. One is a for loop control flow, which nests the other one, an if-else conditional control flow. Please read basic control flows for more information about all kinds of basic control flows. Some other special control flows will be introduced in other articles later.

Blank lines have been used in the above program to improve the readability of the code. And as this program is for code elements introduction purpose, there are many comments in it. Except the documentation comment for the StatRandomNumbers function, other comments are for demonstration purpose only. We should try to make code self-explanatory and only use necessary comments in formal projects.

Like many other languages, Go also uses a pair of braces ({ and }) to form an explicit code block. However, in Go programming, coding style can't be arbitrary. For example, many of the starting curly braces ({) can't be put on the next line. If we modify the StatRandomNumbers function declaration in the above program as the following, the program will fail to compile.

func StatRandomNumbers(n int) (int, int)
{ // syntax error
	var a, b int
	for i := 0; i < n; i++
	{ // syntax error
		if rand.Intn(MaxRnd) < MaxRnd/2
		{ // syntax error
			a = a + 1
		} else {
			b++
		}
	}
	return a, b
}

Some programmers may not like the line break restrictions. But the restrictions have two benefits:

1. they make code compilations become faster.
2. they make the coding styles written by different gophers look similar, so that it is more easily for gophers to read and understand the code written by other gophers.

We can learn more about line break rules in a later article. At present, we should avoid putting a starting curly brace on a new line. In other words, generally, the first non-blank character of a code line should not be the starting curly brace character. (But, please remember, this is not a universal rule.)

• Go 101에 대해 - 이 책이 쓰여진 이유
• 감사의 말

• Go 소개 - Go를 배우는 가치
• Go 툴체인 - Go 프로그램을 컴파일하고 실행하는 방법

• Go 코드에 익숙해지기
  • 소스 코드 요소 소개
  • 키워드와 식별자
  • 기본 자료형과 기본 값 리터럴
  • 상수와 변수 - 무형성(untyped) 값과 자료형 추론 소개를 포함
  • 일반 연산자 - 더 많은 자료형 추론 규칙 소개를 포함
  • 함수 선언과 호출
  • 코드 패키지와 패키지 들여오기
  • 표현식, 구문과 단순 구문
  • 기본 흐름 제어
  • 고루틴, 지연된 함수 호출과 패닉/복구

• Go 자료형 체계
  • Go 자료형 체계 개요 - Go 프로그래밍 숙달을 위해 반드시 읽어봐야 하는
  • 포인터
  • 구조체
  • 변수 - Go 변수에 대한 더 깊은 이해
  • 배열, 슬라이스와 맵 - 1급 객체 컨테이너 자료형
  • 문자열
  • 함수 - 함수 자료형과 값, 가변 인자 함수
  • 채널 - Go에서 동시성 동기화를 하는 방법
  • 메서드
  • 인터페이스 - 리플렉션과 다형성을 하는 값 상자
  • 자료형 임베딩 - 자료형을 확장하는 방법
  • 자료형에 안전하지 않는 포인터
  • 제네릭 - 합성 자료형의 사용과 읽는 법
  • 리플렉션 - reflect 표준 패키지

• 특별 주제
  • 개행 규칙
  • 지연된 함수 호출 더 알아보기
  • 패닉/복구 사용 사례
  • 패닉/복구 메커니즘에 대한 고찰 - 함수 호출 종료 단계를 포함
  • 코드 블록과 식별자 스코프
  • 표현식 평가 순서
  • Go의 값 복사 비용
  • 경계 검사 제거(BCE)

• 동시성 프로그래밍
  • 동시성 동기화 개요
  • 채널 사용 사례
  • 채널을 깔끔하게 닫는 방법
  • 기타 동시성 동기화 기술 - sync 표준 패키지
  • 원자적 연산 - sync/atomic 표준 패키지
  • Go의 메모리 순서 보장
  • 흔히들 저지르는 동시성 프로그래밍 실수들

• 메모리 관련
  • 메모리 블록
  • 메모리 레이아웃
  • 메모리 누수 시나리오

• 일부 요약
  • 몇 가지 간단한 요약
  • Go의 nil
  • 값 변환, 할당과 비교 규칙
  • 구문/의미 예외
  • Go Details 101
  • Go FAQ 101
  • Go Tips 101

• 더 많은 토픽