GO Language Core Programming Course

• Chapter1 Introduction to GO language
• 1-1 What can Golang do?
• 1-2 How to learn Golang more efficiently (1)
• 1-3 How to learn Golang more efficiently (2)
• 1-4 Basic concepts of program
• 1-5 A brief history of the development of Go language
• 1-6 Go language features and fast experience
• Chapter2 Development tools and environment setup
• 2-1 Introduction to Golang development tools
• 2-2 Installation of vscode under windows
• 2-3 Use of vscode under windows
• 2-4 Installation and use of vscode under Linux
• 2-5 Installation and use of vscode under mac
• 2-6 Building a Go development environment under windows
• 2-7 Building a Go development environment under Linux
• 2-8 Building a Go development environment on Mac
• Chapter3 Golang program development instructions
• 3-1 Go program development and basic structure description
• 3-2 Developing Go programs under Linux and Mac
• 3-3 Golang performs popularity analysis
• 3-4 Golang compilation and running instructions
• 3-5 Go syntax requirements and considerations
• Chapter4 Go basics
• 4-1 Go escape characters
• 4-2 Common Go development mistakes and solutions
• 4-3 Comments on Go language
• 4-4 Standard coding style requirements
• 4-5 Go Official Programming Guide
• 4-6 Go language standard library API
• 4-7 Introduction to common Dos instructions
• 4-8 Directory operations
• 4-9 File operations
• 4-10 Additional guides and comprehensive exercises
• 4-11 Review and summary of practice questions
• 4-12 Why variables are needed
• 4-13 Introduction to variables and quick start
• 4-14 Variable usage details (1)
• 4-15 Variable usage details (2)
• 4-16 Clarify several concepts of variables
• Chapter5 type of data
• 5-1 Introduction to data types
• 5-2 Basic use of integer types
• 5-3 Integer type usage details
• 5-4 Basic uses of floating point types
• 5-5 Floating point type usage details
• 5-6 Basic usage of character types
• 5-7 Character type considerations
• 5-8 Use of Boolean types
• 5-9 Basic use of string types
• 5-10 String type details
• 5-11 Basic data type default value
• 5-12 Basic data conversion
• 5-13 Discussion of basic data conversion details
• 5-14 Convert basic data to string
• 5-15 string to basic data type
• 5-16 String to basic type details
• Chapter6 pointer/reference type
• 6-1 Pointers and their memory layout
• 6-2 Pointer Cases and Usage Pitfalls
• 6-3 Value types and reference types
• Chapter7 identifier/keyword
• 7-1 Basic usage of identifiers
• 7-2 Go identifier naming characteristics and specifications
• 7-3 Reserved keywords and predefined identifiers
• Chapter8 operator
• 8-1 Basic introduction to operators
• 8-2 Basic use of arithmetic operators
• 8-3 Arithmetic operators discussed in detail
• 8-4 Arithmetic Operators Classroom Exercises
• 8-5 Relational operators
• 8-6 Basic use of logical operators
• 8-7 short circuit with and and short circuit or
• 8-8 Basic usage of assignment operators
• 8-9 Assignment operation classic interview questions
• 8-10 operator precedence
• 8-11 Other operators
• Chapter9 Keyboard input statement
• 9-1 Get user terminal input
• Chapter10 computer base
• 10-1 Introduction to computer base
• 10-2 Convert other bases to decimal
• 10-3 Convert decimal to other bases
• 10-4 Convert binary to other bases
• 10-5 Convert other bases to binary
• 10-6 Original code, inverse code, complement code
• 10-7 An in-depth explanation of bit operations
• Chapter11 process control
• 11-1 Introduction to process control
• 11-2 Basic use of single branch
• 11-3 Single branch flowchart and details
• 11-4 Basic use of dual branches
• 11-5 Dual branch flowchart and details
• 11-6 Single branch and double branch classroom exercises (1)
• 11-7 Single branch and double branch classroom exercises (2)
• 11-8 Basic use of multiple branches
• 11-9 Multi-branch application cases
• 11-10 Nested branches
• 11-11 basic use of switch
• 11-12 switch usage details (1)
• 11-13 switch usage details (2)
• 11-14 Classroom exercises for switch
• Chapter12 loop control
• 12-1 Basic introduction and introduction to loop control
• 12-2 for loop syntax and execution flow
• 12-3 for loop considerations and details (1)
• 12-4 for loop considerations and details (2)
• 12-5 for loop classroom exercises
• 12-6 Implement while and dowhile control
• 12-7 Multiple cycle application cases
• 12-8 Classic case printing hollow pyramid
• 12-9 Classic case ninety-nine multiplication tables
• 12-10 Process control after-class exercise instructions
• 12-11 break introduction and quick start
• 12-12 break syntax and flow chart
• 12-13 break precautions and details
• 12-14 break classroom exercises
• 12-15 continue introduction and flow chart
• 12-16 continue execution process analysis
• 12-17 continue classroom exercises
• 12-18 goto and return
• Chapter13 Functions and packages
• 13-1 Why functions are needed
• 13-2 Function introduction and application cases
• 13-3 Principles of introduction and use of packages
• 13-4 Quick start with packages
• 13-5 Precautions and details for package use (1)
• 13-6 Package usage notes and library files (2)
• 13-7 Underlying analysis of function calling mechanism
• 13-8 Recursive call process analysis
• 13-9 Recursive call class exercise
• 13-10 Recursive call class exercise (2)
• 13-11 Function notes and details (1)
• 13-12 Function notes and details (2)
• 13-13 Function notes and details (3)
• 13-14 Function classroom exercises
• 13-15 init function
• 13-16 anonymous function
• 13-17 Basic introduction to closures
• 13-18 Closure Best Practices and Analysis
• 13-19 Basic usage of defer
• 13-20 defer considerations and best practices
• 13-21 Function parameter passing method
• 13-22 variable scope
• 13-23 Variable scope classroom exercises
• 13-24 Function Class Exercises and Assignments
• Chapter14 Go function
• 14-1 Detailed explanation of Go string functions (1)
• 14-2 Detailed explanation of Go string functions (2)
• 14-3 Detailed explanation of Go string functions (3)
• 14-4 Detailed explanation of Go time and date functions (1)
• 14-5 Detailed explanation of Go time and date functions (2)
• 14-6 Go time function classroom exercises
• 14-7 Go built-in functions
• Chapter15 Error handling mechanism
• 15-1 Go error handling mechanism
• 15-2 Custom errors in Go
• 15-3 Go function after-class exercise arrangement
• Chapter16 array
• 16-1 Array usage value
• 16-2 A quick start with arrays
• 16-3 Array definition and memory layout
• 16-4 Use of arrays
• 16-5 Array for-range traversal
• 16-6 Array Notes and Details (1)
• 16-7 Array considerations and details (2)
• 16-8 Array application examples (1)
• 16-9 Array application examples (2)
• 16-10 Array complex application-reversal
• Chapter17 slice
• 17-1 Basic introduction and introduction to slicing
• 17-2 Memory layout analysis of slices
• 17-3 Three ways to use slices
• 17-4 Differential analysis using slices
• 17-5 Slice traversal
• 17-6 Slicing considerations and details (1)
• 17-7 Slicing considerations and details (2)
• 17-8 Slicing considerations and details (3)
• 17-9 string and slice
• 17-10 Slicing Classroom Exercises
• Chapter18 Sort and search
• 18-1 Basic introduction to array sorting
• 18-2 Analysis of bubble sorting ideas
• 18-3 Implementation of bubble sort
• 18-4 sequential search
• 18-5 Analysis of ideas of binary search
• 18-6 Code implementation of binary search
• Chapter19 Two-dimensional array
• 19-1 Introduction and Getting Started with Two-Dimensional Arrays
• 19-2 Two-dimensional array usage and memory layout
• 19-3 Two-dimensional array traversal method
• 19-4 Two-dimensional array application examples
• 19-5 Array and search assignments
• Chapter20 map
• 20-1 Introduction and declaration of map
• 20-2 Three usages and application examples of map
• 20-3 crud operation of map
• 20-4 map traversal
• 20-5 map slice
• 20-6 map sorting
• 20-7 Map usage details and pitfalls
• 20-8 map comprehensive application examples
• Chapter21 object-oriented
• 21-1 The necessity of object-oriented programming
• 21-2 Go’s unique object-oriented features
• 21-3 Quick Start with GO Object-Oriented Programming
• 21-4 struct memory layout
• 21-5 Structure declaration and usage pitfalls
• 21-6 Four ways to create structure instances
• 21-7 Structure memory allocation mechanism
• 21-8 Structure usage details (1)
• 21-9 Structure usage details (2)
• 21-10 Structure usage details (3)
• Chapter22 method
• 22-1 Method introduction and use
• 22-2 A quick start with methods
• 22-3 Method calling and parameter passing mechanism
• 22-4 In-depth analysis of method usage (1)
• 22-5 In-depth analysis of method usage (2)
• 22-6 Method Classroom Exercises (1)
• 22-7 Method Classroom Exercises (2)
• 22-8 Explanation of the difference between methods and functions
• Chapter23 Object-oriented programming ideas
• 23-1 Object-oriented programming application examples
• 23-2 Create a struct instance to specify field values
• 23-3 Detailed explanation of factory mode
• 23-4 vscode configuration and shortcut keys
• 23-5 Object-oriented programming ideas-abstraction
• 23-6 Object-oriented programming - introduction to encapsulation
• 23-7 Package quick start case
• 23-8 Encapsulation classroom exercises explained
• 23-9 Object-oriented programming - inheritance and introduction
• 23-10 Inherit basic syntax
• 23-11 Inherit quick start application example
• 23-12 In-depth discussion of inheritance (1)
• 23-13 In-depth discussion of inheritance (2)
• 23-14 Introduction to multiple inheritance
• 23-15 Interface introduction and quick start
• 23-16 Interface features and syntax description
• 23-17 Description of interface application scenarios
• 23-18 Interface considerations and details (1)
• 23-19 Interface considerations and details (2)
• 23-20 Interface classroom exercises
• 23-21 Classic cases of interface programming
• 23-22 Comparison between implementing interfaces and inheritance (1)
• 23-23 Comparison between implementing interfaces and inheritance (2)
• 23-24 Polymorphism and manifestation
• 23-25 Type assertion elicitation and basic usage
• 23-26 Type assertion best practices (1)
• 23-27 Type assertion best practices (2)
• Chapter24 Household income and expenditure accounting items
• 24-1 Introduction to household income and expenditure accounting projects
• 24-2 Introduction to project development process
• 24-3 Household budget software requirements and interfaces
• 24-4 Household Income and Expenditure Software-Show Main Menu
• 24-5 Income and expenditure software-details and registration of income
• 24-6 Income and Expenditure Software - Register Expenditures and Complete Exits
• 24-7 Income and expenditure software-improve detailed display
• 24-8 Income and expenditure software-object-oriented approach
• Chapter25 Customer management system
• 25-1 Requirements analysis and interface
• 25-2 Program framework diagram (1)
• 25-3 Program framework diagram (2)
• 25-4 Main menu and exit
• 25-5 Show customer list
• 25-6 add customer
• 25-7 Delete customer
• 25-8 Modify clients and jobs
• Chapter26 document
• 26-1 Basic introduction to files
• 26-2 Open files and close files
• 26-3 Buffered Reader reads files
• 26-4 Read file in one go
• 26-5 Create file and write content
• 26-6 Four ways to write files
• 26-7 Determine the existence of a file or directory
• 26-8 Copy files (pictures, videos and audio)
• 26-9 Count the number of characters of different types
• 26-10 Basic use of command line parameters
• 26-11 The flag package parses command line parameters
• Chapter27 Json
• 27-1 json introduction and application scenarios
• 27-2 json format and online parsing
• 27-3 Structure map slice serialization
• 27-4 tag used when serializing struct
• 27-5 Deserialization introduction and application examples
• Chapter28 unit test
• 28-1 Introduction to unit testing
• 28-2 Quick Start with Unit Testing
• 28-3 Unit test details
• 28-4 Comprehensive case for unit testing
• Chapter29 _goroutine
• 29-1 Export of _goroutine
• 29-2 _Basic introduction to goroutine
• 29-3 go coroutine and go main thread
• 29-4 Quick Start with Coroutines
• 29-5 Introduction to MPG mode
• 29-6 Go sets the number of running cpu
• 29-7 Coroutine concurrency (parallel) resource competition problem
• 29-8 Global mutex solves resource competition
• Chapter30 pipeline
• 30-1 Basic introduction to pipelines
• 30-2 Pipeline Quick Start Case
• 30-3 Piping Details and Classroom Exercises
• 30-4 Pipe closing and traversal
• 30-5 Comprehensive case of coroutines and pipelines
• 30-6 The mechanism of pipe blocking
• 30-7 Analysis of Ctrip’s ideas for finding prime numbers
• 30-8 Code implementation of coroutine for finding prime numbers
• 30-9 Code efficiency test for coroutine finding prime numbers
• 30-10 Plumbing Precautions and Details (1)
• 30-11 Piping Precautions and Details (2)
• 30-12 Piping Precautions and Details (3)
• Chapter31 reflection
• 31-1 Introduction and application scenarios of reflection
• 31-2 Basic introduction and schematic diagram of reflection
• 31-3 Reflection related functions and transformations
• 31-4 A quick primer on reflection (1)
• 31-5 A quick primer on reflection (2)
• 31-6 Reflection considerations and details (1)
• 31-7 Reflection considerations and details (2)
• 31-8 Reflection exercises
• 31-9 Best Practices for Reflection (1)
• 31-10 Reflection Best Practices (2)
• Chapter32 network programming
• 32-1 Basic introduction to network programming (1)
• 32-2 Basic knowledge of network programming (2)
• 32-3 IP and port for network programming
• 32-4 TCP Programming Quick Start Case Analysis
• 32-5 TCP Programming-Server Listening
• 32-6 Server receives client message
• 32-7 The server loops to receive client messages
• 32-8 Massive user instant messaging system requirements
• Chapter33 Redis
• 33-1 Basic introduction and principle illustration of redis
• 33-2 Basic use of redis
• 33-3 Redis squadron string operations
• 33-4 Basic use of Hash in redis
• 33-5 Details of using Hash in redis
• 33-6 Basic introduction to List in redis
• 33-7 Basic use of List in redis
• 33-8 Details of using List in redis
• 33-9 Introduction and use of Set in redis
• 33-10 Go connect to redis
• 33-11 Go operates redis (string type)
• 33-12 Go operates redis (hash type)
• 33-13 Introduction and principles of redis connection pool
• 33-14 Use cases of redis connection pool
• Chapter34 Mass user communication system
• 34-1 Complete interface
• 34-2 Analysis of sending and receiving messages
• 34-3 Server received length
• 34-4 Server receives message -1
• 34-5 Server receives message -2
• 34-6 Login (specified user)
• 34-7 Server-side structure improvement-1
• 34-8 Server-side structure improvement-2
• 34-9 Client structure improvements-1
• 34-10 Client structure improvements-2
• 34-11 redis user verification analysis
• 34-12 redis add user
• 34-13 User login (1)
• 34-14 User login(2)
• 34-15 User registration (1)
• 34-16 User registration (2)
• 34-17 Show online user list (1)
• 34-18 Show online user list (2)
• 34-19 Show online user list (3)
• 34-20 Show online user list (4)
• 34-21 Show online user list (5)
• 34-22 Show online user list (6)
• 34-23 Show online user list (7)
• 34-24 Analysis of client messaging ideas
• 34-25 Client message sending code implementation
• 34-26 Analysis of ideas for forwarding messages on the server side
• 34-27 Server-side message forwarding code implementation
• 34-28 Project summary
• Chapter35 Data structures and algorithms
• 35-1 basic introduction
• 35-2 Introduction to sparse arrays
• 35-3 Convert original array to sparse array
• 35-4 Convert sparse array to original array
• 35-5 Array simulation queue analysis
• 35-6 Array simulation queue implementation
• 35-7 Array simulates circular queue
• 35-8 Array simulation circular queue implementation
• 35-9 Basic introduction to singly linked lists
• 35-10 Adding and displaying singly linked lists
• 35-11 Orderly insertion into singly linked list
• 35-12 Deletion of singly linked list
• 35-13 Introduction to doubly linked list
• 35-14 Doubly linked list creation and output
• 35-15 Deletion of doubly linked list
• 35-16 Create and display circular linked lists
• 35-17 Deletion of circular linked list
• 35-18 Linked list job arrangement
• 35-19 Joseph problem analysis
• 35-20 joseph problem solving(1)
• 35-21 Joseph problem solving (2)
• 35-22 selection sort
• 35-23 Insertion sort analysis
• 35-24 Insertion sort implementation
• 35-25 Insertion sort summary
• 35-26 quicksort
• 35-27 stack
• 35-28 Push operations and traversal
• 35-29 Stack pop operation
• 35-30 Stack calculation expression (1)
• 35-31 Stack calculation expression (2)
• 35-32 Stack calculation expression (3)
• 35-33 Stack calculation expression (4)
• 35-34 Sorting speed comparison
• 35-35 Analysis of recursive mechanism
• 35-36 Notes on recursion
• 35-37 Maze backtracking problem (1)
• 35-38 Maze backtracking problem (2)
• 35-39 Hash table (hash) - 1
• 35-40 Hash table (hash)-2
• 35-41 Hash table (hash)-3
• 35-42 Hash table (hash) - 4
• 35-43 Three ways to traverse a binary tree
• 35-44 Installation of vscode plug-in
• 35-45 vscode shortcut keys
• 35-46 Conclusion