Go Language Basic Grammar

Go Language Basic Grammar

note

Why do we write comments?

A project is made up of many. When you write, you can understand it. Half a year, one year (it’s been a long time, and I can’t understand the code when I write it myself)

Docking and projects are often completed by multiple people. (It is difficult to communicate, it is more difficult to read the code directly)

What is a comment: to describe what my current code does, or some comments

package main

import "fmt"

// Comments are not executed by the program

// // single line comment
// Notes are mainly for some businesses that I don't understand well, or complex businesses. In open source projects, comments are very complete.

/* multiline comment
. . . . . . 
Write your own understanding and current code function
*/
func main() {
	
	fmt.Println("Hello,World!")

}

Take helloworld as an example:

// The representative is the main package. If there is a main function below, it is the entry point of the program
package main

// Imported a fmt package, you can use it to call the print function, output a line....
import "fmt"

// main function func function main function name () no arguments
func main() {
   // Printed a helloworld
   fmt.Println("Hello,World!")

}

Writing comments is a very good habit. We should all write comments to our own code as required, for ourselves and for others. Many large companies also have strict requirements for annotations.

variable

variable definition

Program: We have spoken a word to the computer, and the computer needs to understand it (communication mechanism, xxx language-assembly-machine code)

The computer actually recognizes the machine code: 0 1 1 1 0 1 (high and low frequency)

Machine code: perforated paper tape

Assembly: In the early days, many low-level codes of machine hardware are assembled

Human-readable code: English, Chinese

Connect our language with the machine (C, Java, Go —> Compiler --> Execute in the computer: no need to understand, we only need to write code that we can understand)

The world we understand has a one-to-one correspondence with the computer world:

Definition: Everything needs to be defined.

Computers also need to define something.

Name of person: first name name = Night

name (variable)

name = Zhang San

name = Lisi

The computer also needs to understand the code we write in this way, and also needs a format

Variables are defined with the var keyword

Variable name Need to tell the computer what type of information (variable) is, data type: num ber, string, decimal... = "value of variable"

//Describe a person's information programmatically
// string string type
var name string = "Night"
// int number type
var age int = 27

var sex string = "male"

// Java
String name = "Night"

**Formula: define variable var variable name variable type **

package main

import "fmt"

func main() {
   // var variable name variable type
   // Define a variable, if no value is assigned to this variable, it is the default value of this data type.
   // string default value "" int default value 0
   var name string
   var age int

   // You can define multiple variables at the same time, and you only need to use the var() keyword
   var (
      addr  string
      phone int
   )

   // goland shortcut key: Copy the current line to the next line Ctrl + D
   fmt.Println(name)
   fmt.Println(age)
   fmt.Println(addr)
   fmt.Println(phone)

   // The use of variables can be directly manipulated after the variable is defined
   // Assign a value to a variable, the symbol = assignment (cannot be called equal)
   // Assign "Qinjiang" to the variable name.
   name = "Qin Jiang"
   // Use variables, print directly or perform some operations
   fmt.Println(name)

   // Variables can be assigned repeatedly, variables.
   name = "Zhang San"
   fmt.Println(name)

   // Assign values ​​directly when defining variables.
   var dog string = "prosperity"
   fmt.Println(dog)

}

Declaration of short variables (syntactic sugar, convenient for developers to develop)

package main

import "fmt"

func main() {

   // Is it okay to only define variables without using them? Theoretically yes, but actually not in Go language.
   // Meaningless code, error!

   // Question 1: Is it possible not to write the data type
   // Question 2: What about defining variables directly without var?

   // auto-deduction, a short variable declaration
   name := "Night"
   age := 18
   // Syntactic sugar (lazy, simplify development!)
   // := is equivalent to express defining variables. If a value is assigned to this variable, its type will be automatically deduced
   // Definitions of var and data types are omitted.
   // Data type The basic data type in go language.

   fmt.Println(name)
   fmt.Println(age)

   // The variable name2 is defined
   var name2 string
   // In a quick declaration, if the variable to the left of := already exists, it cannot be created and cannot be redefined
   name3 := "zuoyi444"
   fmt.Println(name2)
   fmt.Println(name3)
   name3 = "zhangsan666"
}

summary

1. Define variables using fixed formulas var variable name variable data type

2. Assign values ​​to variables. When defining, assign directly, assign by variable name,

3. Syntactic sugar: = . You can use it to quickly define variables. If it is a basic data type, such as a string or a number, it will automatically deduce the type

The so-called basic grammar, all programming languages ​​are similar.

exchange of variables

package main

import "fmt"

func main() {
   /* The first problem encountered in programming: variable exchange
   var a int = 100
   var b int = 200

   var t int
   t = a
   a = b
   b = t
   */
   // In the Go language, program variable exchange also has syntactic sugar
   var a int = 100
   var b int = 200
   // fmt.Println can pass multiple parameters, separated by commas, and print directly
   fmt.Println("a=", a, ",b=", b)
   // Assigning a,b to b,a is syntactic sugar, and the underlying essence still uses temporary variables. simplify our development
   b, a = a, b
   fmt.Println("after exchange a=", a, ",b=", b)
   
   // Complex problems are simplified for us, our development is very easy, and the compiler helps us deal with them at the bottom.
}

Understanding variables (memory addresses)

package main

import "fmt"

func main() {
   // What the hell is a variable?
   // num is actually a piece of memory space
   // We want to see the memory address of a variable, just add & before the variable name.
   // Get address character (pointer)
   var num int
   num = 1000
   // Thinking: What does this num look like in a computer.  num
   fmt.Printf("num the value of:%d,memory address:%p\n", num, &num)
   num = 2000
   fmt.Printf("num the value of:%d,memory address:%p\n", num, &num)

   // compilation. understand everything

   var name string
   name = "Zhang San"
   // Thinking: What does this num look like in a computer.  num
   fmt.Printf("num the value of:%s,memory address:%p\n", name, &name)
   name = "Li Si"
   fmt.Printf("num the value of:%s,memory address:%p\n", name, &name)

   // One of the ways to print the memory address.  Print f formatted output
   // Memory
   // The first parameter output string
   // % Placeholder.
   // The number of placeholders must be the same as the number to be output later
   // %d number int d
   // %p memory address, num needs to take out the address of the variable.
   // %s String.
   // \n newline
   //fmt.Printf("value of num:%d",num)
}

anonymous variable

package main

import "fmt"

// variable (with name, without name: anonymous)
// Very special, anonymous variable (black hole, throw everything in, any value assigned to anonymous variable will be discarded)
// _ The underscore is an anonymous variable in Go language

// function A collection of pieces of code.
//
// func test function-name(parameters,parameters....) return something{
//  A collection of codes, with or without parameters, returns the result
// }
//
// The basic manipulation function, calling a function, returns two numbers.
func test() (int, int) {
   // return returns the result
   return 100, 200
}

// It will be used extensively in the Go language
// Anonymous variables do not occupy memory space and do not allocate memory.
func main() {
   // Calling this test function should return two results, 100,200

   // Variable: In addition to direct definition, it can also be an assignment of a result
   //var a int = 100
   // If you only want the first result returned by test, you need to use the anonymous variable _.
   a, _ := test() // a,b := 100,200
   fmt.Println(a)
   // If you only want the second result returned by test, you need to use the anonymous variable _.
   _, b := test()
   fmt.Println(b)
}

variable scope

package main

import "fmt"

// Global variables: take effect in the current go file...
// Defined in the non-function of the go file, under package and import
// The definition of global variables must use the var keyword, if you use := directly, you cannot create the variable
// Global variables and local variables can have the same name, priority. who on earth
var c int

func main() {
   // Local variables: valid only within a certain range...
   // Declare variables inside the function body
   var a int = 3
   var b int = 4
   // If there is a global variable, then directly use the global variable to receive it.
   c = a + b
   fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
   fmt.Printf("c memory address:%p\n", &c)
   b = 1
   // But if there is a local variable with the same name as the global variable, the local variable is preferred
   c := a + b
   fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
   fmt.Printf("c memory address:%p\n", &c)
   b = 5
   // The principle of proximity
   c = a + b
   fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
   fmt.Printf("c memory address:%p\n", &c)

   // Printf formatted output (parameter 1: the content to be printed, % is a placeholder, assign values ​​to him one by one through subsequent parameters)
   fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
}

The principle of proximity

package main

import "fmt"

// In a Go language program, the names of global variables and local variables can be the same, but the local variables in the function body will be given priority.
// string int float64 floating point number (decimal)
var a float64 = 3.14

func main() {
   var a float64 = 2.18
   fmt.Println(a)
}

constant

Constant: A quantity that cannot be changed. This variable is a special variable and cannot be changed. keyword const

Two differences: variables are defined using var and constants are defined using const

What mechanism caused him to be unable to change?

The underlying convention of the Go language can actually be changed. You need to skip the constant name and directly find the memory address to modify the value.

package main

import "fmt"

// Constants and variables are placed at different memory addresses (stack, heap, constant pool)
// The program executes normally, pushing the stack

// constant
func main() {
   // Regulations: It is recommended to do so
   // When we define constants, we recommend that you use capital letters to define them. Differentiate from ordinary variables
   // Once defined, it will not change.
   // Definition format const constant name [type] = value
   const URL string = "https://blog.csdn.net/qq_45371023"

   // The automatic deduction of implicit definition constants can omit some basic types,
   const URL2 = "www.baidu.com"

   // Multiple constants can be defined at the same time
   const URL3, URL4 string = "https://blog.csdn.net/qq_45371023", "www.baidu.com"

   //
   fmt.Println(URL)
   fmt.Println(URL2)
   fmt.Println(URL3)
   fmt.Println(URL4)

   // In our real world, there are also many variables that will not change, so the corresponding ones in the program are constants
   const PI = 3.14
   // For fixed things, it is recommended to define them as constants.
   const LENGTH int = 8000
   const WIDTH int = 8000

   // Constants cannot be modified.
   //LENGTH = 13

   fmt.Println(LENGTH)

}

.com"

// Multiple constants can be defined at the same time
const URL3, URL4 string = "https://blog.csdn.net/qq_45371023", "www.baidu.com"

//
fmt.Println(URL)
fmt.Println(URL2)
fmt.Println(URL3)
fmt.Println(URL4)

// In our real world, there are many variables that will not change, so the corresponding ones in the program are constants
const PI = 3.14
// For fixed things, it is recommended to define them as constants.
const LENGTH int = 8000
const WIDTH int = 8000

// Constants cannot be modified.
//LENGTH = 13

fmt.Println(LENGTH)

}







Tags: Go programming language

Posted by 1981tarun on Tue, 14 Feb 2023 06:22:34 +1030