Keywords and Identifiers in Go

Keywords are the special words which help compilers understand and parse user code.

break     default      func    interface  select
case      defer        go      map        struct
chan      else         goto    package    switch
const     fallthrough  if      range      type
continue  for          import  return     var

• const, func, import, package, type and var are used to declare all kinds of code elements in Go programs.
• chan, interface, map and struct are used as parts in some composite type denotations.
• break, case, continue, default, else, fallthrough, for, goto, if, range, return, select and switch are used to control flow of code.
• defer and go are also control flow keywords, but in other specific manners. They modify function calls, which we'll talk about in this article.

These keywords will be explained in details in other articles.

• Unicode letters mean the characters defined in the Letter categories Lu, Ll, Lt, Lm, or Lo of The Unicode Standard 8.0.
• Unicode digits mean the characters defined in the Number category Nd of The Unicode Standard 8.0.

Player_9
DoSomething
VERSION
Ĝo
Π

_
_status
memStat
book
π
一个类型
변수
エラー

// Starting with a Unicode digit.
123
3apples

// Containing Unicode characters not
// satisfying the requirements.
a.b
*ptr
$name
a@b.c

// These are keywords.
type
range

• About Go 101 - why this book is written.
• Acknowledgments

• An Introduction of Go - why Go is worth learning.
• The Go Toolchain - how to compile and run Go programs.

• Become Familiar With Go Code
  • Introduction of Source Code Elements
  • Keywords and Identifiers
  • Basic Types and Their Value Literals
  • Constants and Variables - also introduces untyped values and type deductions.
  • Common Operators - also introduces more type deduction rules.
  • Function Declarations and Calls
  • Code Packages and Package Imports
  • Expressions, Statements and Simple Statements
  • Basic Control Flows
  • Goroutines, Deferred Function Calls and Panic/Recover

• Go Type System
  • Go Type System Overview - a must read to master Go programming.
  • Pointers
  • Structs
  • Value Parts - to gain a deeper understanding into Go values.
  • Arrays, Slices and Maps - first-class citizen container types.
  • Strings
  • Functions - function types and values, including variadic functions.
  • Channels - the Go way to do concurrency synchronizations.
  • Methods
  • Interfaces - value boxes used to do reflection and polymorphism.
  • Type Embedding - type extension in the Go way.
  • Type-Unsafe Pointers
  • Generics - use and read composite types
  • Reflections - the reflect standard package.

• Some Special Topics
  • Line Break Rules
  • More About Deferred Function Calls
  • Some Panic/Recover Use Cases
  • Explain Panic/Recover Mechanism in Detail - also explains exiting phases of function calls.
  • Code Blocks and Identifier Scopes
  • Expression Evaluation Orders
  • Value Copy Costs in Go
  • Bounds Check Elimination

• Concurrent Programming
  • Concurrency Synchronization Overview
  • Channel Use Cases
  • How to Gracefully Close Channels
  • Other Concurrency Synchronization Techniques - the sync standard package.
  • Atomic Operations - the sync/atomic standard package.
  • Memory Order Guarantees in Go
  • Common Concurrent Programming Mistakes

• Memory Related
  • Memory Blocks
  • Memory Layouts
  • Memory Leaking Scenarios

• Some Summaries
  • Some Simple Summaries
  • nil in Go
  • Value Conversion, Assignment and Comparison Rules
  • Syntax/Semantics Exceptions
  • Go FAQ 101

• More Go Related Topics