Course name reading

&times
Beneficiary: Jiangsu knowledge of the Computer Co., Ltd. Price reading
Alipay to pay
WeChat payment

After paying the success of the page automatically jump, please do not close the window in the payment process.

  • curriculum> Programming language / framework> Go language> Introduction to Go language programming
  • Introduction to Go language programming

  • By Baidu Open Cloud provides technical support
    Course catalog
    The first chapter: Introduction
    • 1 Course Introduction (free)
    • 4:29
    • 2 Trace (free)
    • 8:19
    • 3 language features and advantages and disadvantages (free)
    • 10:15
    • 4 development prospects (free)
    • 8:18
    • 5 learning suggestions (free)
    • 5:47
    The second chapter: building the development environment
    • 1 Course Introduction (free)
    • 1:24
    • 2 install SDK (free)
    • 3:44
    • 3 configuration environment variables (free)
    • 4:57
    • 4 development tools (free)
    • 4:50
    • 5 Windows to build the development environment demonstration (free)
    • 8:30
    • 6 Linux to build the development environment demonstration (free)
    • 5:59
    • 7 Mac to build the development environment demonstration (free)
    • 5:16
    The third chapter: NiuDao
    • 1 first Go program (free)
    • 5:30
    • 2 code simple instructions (free)
    • 11:26
    • 3 go program commonly used commands (free)
    • 2:19
    • 4 build go command description (free)
    • 7:56
    • 5 install go command description (free)
    • 6:40
    • 6 doc go command description (free)
    • 4:03
    • 7 other 3 commonly used commands (free)
    • 13:16
    The fourth chapter: program structure
    • 1 identifier (free)
    • 4:46
    • 2 statement (free)
    • 3:43
    • 3 variable (free)
    • 5:07
    • 4 assignment (free)
    • 18:14
    • 5 notes (free)
    • 3:38
    The fifth chapter: basic types
    • 1 integer (free)
    • 8:14
    • 2 floating point type (free)
    • 6:20
    • 3 string (free)
    • 11:19
    • 4 Boolean (free)
    • 3:05
    • 5 complex number (free)
    • 2:43
    The sixth chapter: Supplement
    • 1 constants (free)
    • 6:20
    • 2 batch declaration and iota keyword
    • 11:15
    • 3 scope of action
    • 5:34
    • 4 escape character
    • 11:05
    • 5 native string
    • 3:25
    • 6 arithmetic operation
    • 9:52
    • 7 arithmetic operations reminder
    • 3:40
    • 8 bit operation
    • 17:08
    • 9 comparison operation
    • 7:15
    • 10 logical operations
    • 4:46
    • 11 type conversion
    • 7:40
    • 12 declaration type
    • 6:53
    • 13 placeholders
    • 4:21
    • 14 pointer
    • 8:41
    • 15 pointer attention
    • 10:42
    The seventh chapter: compound type
    • 1 composite type introduction
    • 1:32
    • 2 array
    • 11:54
    • 3 access array elements
    • 6:05
    • 4 pointers and arrays
    • 5:17
    • 5 multidimensional array
    • 5:59
    • Comparison of 6 arrays
    • 6:16
    • 7 initialize an array of advanced syntax
    • 4:03
    • 8 slice
    • 6:49
    • 9 slice initialization
    • 14:11
    • 10 make function to create slices
    • 7:17
    • 11 slice does not support comparison
    • 2:51
    • 12 slice append element
    • 7:47
    • 13 copy section
    • 5:49
    • 14 slice supplement
    • 8:24
    • 15 mapping
    • 9:01
    • 16 initialization map
    • 6:03
    • 17 access mapping
    • 7:47
    • 18 mapping other operations
    • 8:10
    • 19 mapping of the rich value type
    • 8:31
    • 20 structure
    • 7:10
    • 21 declarations and access structures
    • 8:54
    • 22 initialization structure
    • 3:40
    • 23 structure support comparison
    • 2:51
    • 24 nested and anonymous access
    • 7:21
    • Use 25 pointer structure
    • 5:15
    The eighth chapter: the control structure
    • 1 condition judgment (free)
    • 12:14
    • 2 multi conditional branches (free)
    • 10:55
    • 3 cycle (free)
    • 17:47
    • 4 jump (free)
    • 10:40
    The ninth chapter: function
    • 1 function introduction
    • 12:15
    • Use 2 pointer
    • 8:33
    • 3 variable parameters
    • 7:33
    • 4 delay execution
    • 11:29
    • 5 function recursion
    • 8:34
    • 6 function is also type
    • 4:38
    • 7 anonymous function
    • 4:58
    The tenth chapter: method
    • 1 method declaration
    • 9:35
    • 2 pointers and methods
    • 6:54
    • 3 structure embedding and method
    • 14:16
    • 4 method expression
    • 4:26
    • 5 methods supplement
    • 10:00
    The eleventh chapter: Interface
    • 1 interface introduction
    • 7:39
    • 2 interface embedded
    • 9:32
    • 3 interface conversion
    • 4:23
    • 4 interface value
    • 6:10
    • 5 types of assertions (free)
    • 5:07
    • 6 types of branches
    • 4:51
    • 7 interface and pointer
    • 9:29
    • 8 interface as a function parameter and return value
    • 5:00
    • 9 error
    • 7:20
    The twelfth chapter: concurrent
    • 1 concurrent introduction
    • 4:56
    • 2 Go range
    • 10:48
    • 3 channel
    • 8:43
    • 4 no buffer channel
    • 9:30
    • 5 buffer channel
    • 10:42
    • 6 off channel
    • 6:31
    • 7 receive operation
    • 8:46
    • 8 pipe
    • 4:51
    • 9 one-way channel
    • 9:02
    • 10 multiplexing
    • 9:19
    • 11 panic
    • 6:47
    • 12 recovery
    • 8:49
    The thirteenth chapter: package
    • 1 bags
    • 3:04
    • 2 package declaration
    • 5:52
    • 3 package import
    • 15:11
    $100 Buy immediately Join a shopping cart
    • [course type]Technical course [difficulty level]senior [suitable for the crowd]All
    • [course introduction]
      Introduces the Go language related to the introduction and basic grammar, learn to develop the environment to build and use the Go language simple programming. This video tutorial is suitable for beginners Go language.
    • [course objectives]
      The first chapter mainly describes the development history and current situation of Go language, as well as the characteristics of the language itself, and it also shows the advantages and disadvantages of learning and using it. The second chapter describes how to set up a set of Go language development environment for learning test. The following chapters mainly explain the basic syntax of the Go language and some notes.
    • [Course Project]
      June years ago, the end of the course.

    The first chapter: Introduction
    From the current most fire Docker introduction to the Go language.
    Introduce the background of the Go language and the concept of absorbing the other language.
    This paper introduces the characteristics of Go language and its attractive advantages, as well as its deficiencies.
    This paper introduces the present development situation of Go language and the prospect of learning and using Go language.
    According to their own learning experience in the past, to the majority of Go language newcomers to provide some suggestions as a reference.

    The second chapter: building the development environment
    Go language development environment to build a simple description of the contents of the environment.
    Two Install SDK
    3:44
    A brief introduction to choose to install the SDK package, the need to download the corresponding Go language SDK version of the system according to the type and architecture of the system.
    This paper introduces the differences of Go language environment variable configuration in different systems.
    Four development tool
    4:50
    This paper introduces the commonly used support Go language programming development tools, to provide reference for Go scholars.
    Demonstrates how to build our own Go system under the Windows language development environment, including the SDK download and install, configure the system environment variables, install the Studio Code Visual editor.
    Deepin depth system using Go to build the Linux language development environment to explain the reference.
    The use of Go computer Mac language can also learn the video learn to build the Go language development environment.

    The third chapter: NiuDao
    One First Go program
    5:30
    First Go code simple pressure Yajing, compile and run the Go program is what an exciting thing.
    For our last class of the first paragraph of the code written in a simple note, including some attention, especially the novice often made a mistake, the left braces a new line from the new, which is not allowed in the Go language.
    SDK in the Go program is a regular use of the program, with a variety of functions, we first list a number of commonly used command options.
    Build go operation demonstration and precautions.
    Install go compiler generates a binary file or library files and stored in the corresponding directory.
    Using doc go can view a variety of documents, or directly use the godoc program to achieve web page view of the document manual.
    Run/get/fmt three common command instructions

    The fourth chapter: program structure
    One identifier
    4:46
    Identifier is the Go source code for a variety of objects for our convenient access and do a variety of operations, and a variety of symbols to form a Go program.
    Two statement
    3:43
    Declares the identifier of various types to call access and operation in a subsequent step of the preparation procedure.
    Three variable
    5:07
    The first course variables, need to pay attention to, and the other variable declaration syntax format language slightly different types of variables in the variable name, and initializes the zero value.
    Four assignment
    18:14
    Declare a variable may, we do not want to use the Go language automatic zero initialization statement, then you can use the assignment operation. Or use a variable to store a segment of the final result after a complex operation.
    Five Notes
    3:38
    It is generally recommended that you add comments to the package and functions, with the same package that you only need to add a comment to a source file.

    The fifth chapter: basic types
    One integer
    8:14
    Integer type is our most commonly used basic data types, in accordance with the occupied figures can be subdivided into a variety of specific types.
    Two float
    6:20
    Float64 provides a higher accuracy, the preparation of the program as far as possible to use the 64 bit float64 type.
    Three Character string
    11:19
    Go language string and other languages have the same, there are many wonderful places, especially confusing, need to pay attention to Go scholars.
    Four Boolean type
    3:05
    Used to judge the condition of true and false, only two kinds of values, true or false.
    Five complex
    2:43
    Mathematical disciplines, the general use of a relatively small.

    The sixth chapter: Supplement
    One constant
    6:20
    Constants are used to hold our constant values.
    Constants and variables can be declared using the small brackets (), the constant can also use the iota auto increment device declaration
    Three Scope of action
    5:34
    The identifier determines the access order and scope of the object represented by the identifier.
    Four escape character
    11:05
    Visualization can be achieved by using special characters and symbols of the escape character.
    Five Native string
    3:25
    Two reverse quotes ` input content can be as output, even in the face of the escape character.
    Each kind of basic data types support operations are not the same, a difference from other languages, does not support the integer increment and decrement prefix prefix, suffix suffix only increment and decrement, and separate statements, write code must go alone.
    And other programming language of a very large difference, the two element operator on both sides of the data type must be completely consistent with the specific data type, otherwise the error.
    Eight Bit operation
    17:08
    Bit operations to achieve binary representation of the operation of the operation.
    Compare the size of the two basic data types or whether they are equal, the result is a Boolean value true or false.
    Ten Logic operation
    4:46
    Returns a new Boolean value for the result of an expression to a Boolean value.
    Eleven Type conversion
    7:40
    Go language default does not support the implicit data type conversion, at this time to use the new data type to save the original type value, you can use the mandatory display conversion, but there may be faced with the problem of loss of accuracy.
    Twelve Declaration type
    6:53
    Declaration of a new type of packaging the original data type or structure, you can improve the code reuse and readability, reduce the complexity of the program, improve the efficiency of the development process.
    Thirteen placeholder
    4:21
    To underline _ placeholder ignore references need not return values in the expression.
    Fourteen Pointer
    8:41
    Go language to retain the C and C++ pointer, but there are similarities and differences.
    Fifteen Pointer note
    10:42
    Go language pointer is very powerful, but very safe, can not point to a constant or text, and does not support the C and C++ pointer arithmetic.

    The seventh chapter: compound type
    This chapter introduces the contents of the course, there are 4 kinds of composite types: arrays, sections, maps, and structures.
    Two array
    11:54
    Describes the array of several syntax, including the initialization.
    Array element values can be accessed by index index.
    By declaring a pointer to an array, you can also access the array, and the overhead is much smaller.
    Go language also supports multidimensional arrays, a simple introduction to the multidimensional array of declarations and initialization.
    Six Array comparison
    6:16
    The two arrays are equal, must be of the same array length, the same type of array, and the value of each element of the array. Otherwise not equal.
    When the array can be initialized directly to specify an index index of the value of the index.
    Eight Section
    6:49
    Second composite data types are introduced, as well as its declarative syntax.
    Slices directly refer to an array, which can only be initialized with an array of partial or full elements.
    Go language built-in make function can also create a slice, when you can specify the length and capacity of the creation, the other way of operation and the general statement of the same. Also demonstrates the difference with the general statement.
    Slice and array of one of the big difference is that the array of support is equal and unequal, and the slice does not support, otherwise directly reported to the wrong.
    Twelve Slice append element
    7:47
    The built-in append function can easily add elements to the slice, even if the storage capacity is not enough. In addition, sections can be automatically extended capacity.
    Thirteen Copy section
    5:49
    Built in copy function to support the function of copy slice, relatively less.
    Fourteen Slice supplement
    8:24
    Some additional instructions and precautions for slicing.
    Fifteen mapping
    9:01
    The mapping (map) type corresponds to the hash table of other programming languages or the concepts of dictionaries, associative arrays, etc. this section describes the syntax for declaring mappings and using make to create a mapping.
    Sixteen Initialization map
    6:03
    Two initialization methods are introduced.
    Seventeen Access mapping
    7:47
    Read mapping keys are similar to the internal array, slice method and.
    Eighteen Mapping other operations
    8:10
    The key to mapping support operations, depending on the value type, and can delete key on through the built-in delete function, len function can query the existing value of the total. Mapping does not support comparison.
    The value type of the map not only supports basic data types, arrays, sections, and even maps, but also includes structures, functions, interfaces, and our custom types.
    Twenty structural morphology
    7:10
    This paper introduces the definition of the structure and the syntax of the variable of the type of the structure.
    Support structure pointer variable or pointer variable. Through the dot can be directly read and write structure members value.
    Twenty-two Initialization structure
    3:40
    This paper introduces two methods of the nominal value of the initial structure.
    Twenty-three Structure support comparison
    2:51
    Each member must be the structure of the data types are supported, can use the comparison operation = = = and.
    Twenty-four Nested and anonymous access
    7:21
    Like inheritance to achieve access to nested anonymous structure members.
    Twenty-five Use the pointer structure
    5:15
    Structure can not contain itself, but can use the pointer to achieve linked list, tree, and other complex data structure.

    The eighth chapter: the control structure
    One Condition judgment
    12:14
    If-else if-else implementation conditions to determine the implementation of
    Go language of the switch is very flexible and powerful, no longer can only use a fixed value to do branch judgment, you can use the comparison operation and logic operation mixed composition of the statement.
    Three loop
    17:47
    Go language only for keyword do loop operation, there is no while and do-while.
    Four Jump
    10:40
    Call labels can achieve the code of the jump, especially in the face of multiple nested loop, if you want to jump out of the multi layer cycle, you can use break, continue and goto and tags.

    The ninth chapter: function
    This paper introduces some basic knowledge of Go language function.
    Pass the address to the pointer, can modify the argument variable values, while reducing the value of the huge resource overhead copy.
    Three Variable parameter
    7:33
    The variable parameter can be used when the transfer function is more than one of the same type parameters that are not known.
    Four Delayed execution
    11:29
    Defer used to delay the implementation of functions, mainly in order to release the creation of a variety of resources, such as open files, database connections, and so on.
    Five Recursive function
    8:34
    Function internal statement calling itself called function recursion.
    In the Go language, functions are also used as types, you can declare a function type variable or assign a value to a variable.
    Seven Anonymous function
    4:58
    Although the function declaration does not support nested new declaration functions, it supports nested declaration anonymous functions and calls.

    The tenth chapter: method
    One Method statement
    9:35
    Method is a function of the type binding, and the different types can have the same name as the method of the same name.
    When the method is declared, the receiver can still use the pointer to receive the original value so as to modify the original value or reduce the memory usage of the transmitted value.
    The structure of embedded anonymous structure members, called the outer structure type for the first check whether there is no outer method, such as from top to bottom to check whether there is a method of the same name anonymous structure, need to pay attention to multiple anonymous structure methods with the same name ambiguity type.
    Four Expression method
    4:26
    Method can also be directly assigned to a variable, call methods and call the function of the same way, just add a list of parameters can be.
    Five Supplement method
    10:00
    1 when the anonymous structure is used as a pointer type, just use the address code and the address to be used, and the remaining code is still. 2 any type of alias can be declared a method, not only the structure of the body type.

    The eleventh chapter: Interface
    Interface is a collection of multiple space methods, no member, you can store all types of data, only the type of implementation of all the methods in the interface, the implicit implementation of the interface.
    Interface support embedded other interfaces, we call this interface embedded, the outer interface is equal to have all the inner interface of all methods. The statement also mixed interface type and embedded Go language support routine.
    Interfaces with more methods can be converted into interfaces that are only common parts, and vice versa.
    Four Interface value
    6:10
    The interface value holds the name of the data type and the specific value. The key point: the empty interface can save any data type, so it is often used.
    Five Type Asserts
    5:07
    Check whether the interface type variable is a specific type, combined with the if condition to determine whether to execute the following statement.
    Six Type branch
    4:51
    Switch branch statement combined with type to achieve a more clear and distinct interface variables to determine the specific types of inspection.
    When the interface value method is called, the method of the type of the interface is modified by modifying the type of interface, and the receiver can be declared as a pointer type, and the interface value can be modified.
    The interface can also be used as a function of a specific type as a function of the parameter, the function can return the value of the interface.
    Nine error
    7:20
    Go language will be used as a type of error processing, use the error keyword to represent the error, its essence is to contain only one string () Error method of the interface.

    The twelfth chapter: concurrent
    Go language is mainly used Go process (goroutine) and channel (channel) to write concurrent programs, development efficiency and implementation efficiency are satisfactory, which is the biggest highlight of the Go language to attract people.
    Two Go Cheng
    10:48
    Go process is distinguished from other concepts, such as process, thread, and other concepts, which is the unit of the corresponding function. The initial allocation stack is much smaller than the process or thread.
    Three channel
    8:43
    Channel is a common means of communication between Go range.
    Four No buffer channel
    9:30
    No buffer channel is synchronized blocking, Go process must wait for the channel to receive and send operations before the end of the code can be executed.
    Five Buffer channel
    10:42
    Buffer channel, when the channel is empty, the receiver operation is blocked; when the channel is full, the transmission operation is blocked; other times are not blocked.
    Six Close channel
    6:31
    When we don't need to send data to the channel, we can use the close function to turn off the channel.
    Seven Receive operation
    8:46
    For the channel, in addition to the traditional receiver operating syntax, there is another kind of deformation of the receiver operating mode. At the same time, we can use for and range to realize the data in the channel.
    Eight The Conduit
    4:51
    The channels in turn are connected in series. Through the N channel can be connected in series Go n+1 connect operation.
    The one-way channel is mainly used for the function to limit the channel whether the channel is only allowed to receive or send operation.
    Ten Multiplexing
    9:19
    Using select statement to achieve multiplexing, when a channel to achieve the conditions immediately after the implementation of the case block. Random selection of a branch execution when multiple case branch conditions are satisfied.
    Eleven panic
    6:47
    Panic is run time error, the built-in panic function can cause panic.
    Twelve recovery
    8:49
    With the aid of defer delay execution statement and recover function, you can make the program from panic to restore the implementation of follow-up code.

    The thirteenth chapter: package
    One Baojianjie
    3:04
    Go language use the package to organize the management code structure, corresponding to the Java in the package, C# namespace, etc..
    The package can be composed of multiple source files, and each source file can only be declared to belong to a package.
    Three Package import
    15:11
    After the package import statement, you can call the package level can be exported to the global variables, constants, custom types or functions.

    All evaluationZero)
    Praise (Zero)
    Middle assessment (Zero)
    Bad ratingZero)
    Published evaluation
    Dongsong
    FourcurriculumTwenty-eight thousand three hundred and eighty-eightStudent
    Has more than 9 years of experience in Linux operations, and served as senior R & D engineers, maintenance engineers, maintenance managers, architects maintenance duties, experienced website development, games, and education service industry, good system architecture, like the study of new technology and maintenance program development, the pursuit of perfection.

    Reference knowledge base

    Recommend courses for you

  • Linux rookie article
  • Lecturer: Dong SongFiveClass hour
  • Linux entry
  • Lecturer: Dong SongTwenty-sevenClass hour
  • Linux enterprise combat articles
  • Lecturer: Dong SongThreeClass hour