Golang data One (strings, arrays and arrays pointers)

This is a creation in Article, where the information may have evolved or changed.

Introduce the data from the go language in the following ways

1. Listen to the string 2. Listen to the array 3. Listen to the slice 4. Listen to the dictionary 5. Listen to the structure

String

characters in the Go language A string is made up of a set of immutable byte (byte) sequences from the source file to see itself as a composite structure

String.go listen to the type listen to stringstruct listen to the struct listen {Listen to listen to hear Str listen to the unsafe. Pointer Listen, listen, listen, listen, Len, listen to int}

Each byte in the string is the head pointer of a Unicode character string stored in UTF-8 encoding that points to the beginning of the byte array but no null or a '/s ' End flag. The representations are simple with double quotation marks ("") or anti-quotation marks ("') whose difference is

1. Escape characters between double quotes are escaped and the escape character between the anti-quotes remains the same

2. Anti-quote support is written across lines and double quotes are not allowed

{Listen and listen to println ("Hello\tgo") listen to//output Hello Listen listen to go listen to listen to hear println (' Hello\tgo ') listen listen//Output Hello\tgo} {Listen and listen to println (listen to "Hello, listen, listen, go")//syntax listen to the error: Listen to unexpected listen to the semicolon or listen to newline, listen to expecting listen to or listen to the comma listen to listen to listen to the println (' Hello, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, listen, listen, listen, hear, listen, go. Output Hello Listen listen to listen go

The default value for the string described in the previous type of section is "" Instead of nil, such as

var listen to Stringprintln (listen to s listen = = listen to listen to) listen to//TRUEPRINTLN (listen to s listen = = listen to nil listen) listen to//invalid hear operation: listen to s listen = = Listen to nil listen ( Mismatched listen to types listen to string listen and hear nil)

Go string Support "+, + =, = =,! =, <, >" Six operators

The go string allows you to access the byte array (non-character) with an index number but not the address of the element such as

{Listen, listen, hear, listen to and listen to the "Hello" listen and listen to println (A[0]) listen and listen listen/listen/output listen to hear/hear println (&a[1) listen to listen to listen to hear Cannot listen to the listening address of the a[1]}

The go string allows you to return substrings (starting and ending index numbers) in the syntax of a slice, such as

var listen a listen = Listen to "0123456" Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, listen, hear, hear, listen, listen, listen, listen, listen, hear, listen, hear, hear, listen, heard, println, hear, hear, hear and hear.//0,1,2println (A[1:3) Listen and listen to//1,2println (a[3:]) listen and hear//3,4,5,6

In daily development, there will often be scenes that traverse strings such as

{Listen and listen to a listen = listen to "Go language" listen to listen to hear for listening to listen to i:=0;i hear < listen to Len (a) listen to listen to listen to hear hear hear hear listen listen to listen to listen to listening and listening listen to hear listen to hear listening, listening and hearing. Printf ("%d: listen to [%c]\n", listen to I, listen to a[i]) listen and listen to hear for listen I, listen to V listen: = Listen to the range listen to a{Listen listen listen listen listen hear listen To listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, . Printf ("%d: listen to [%c]\n, listen to I, listen to V) listen to listen} output listen to listen 0: Listen [g]1: Listen [o]2: Listen [è]3: Listen [ˉ]4: Listen [-]5: Listen [è]6: Listen [¨]7: Listen [] 0: Listen [g]1: Listen [o]2: Listen []5: Listen]

In the go language, the bottom of the string uses a byte array that cannot be changed, so there is only one byte at a time when the byte is polled, and the Chinese character is 3 bytes. Rune uses the method of calculating the length of a string differently than the byte method, such as

println (UTF8. Runecountinstring (a)) listen/listen to the results for listening 4println (Len (a)) listen//Listen to the results for listening 8

So if you want to get the kind of results you expect, you need to first convert the string A to rune slices and then use the built-in Len functions such as:

{Listen and hear r: = Listen to []rune (a) listen to hear for i:= listen to 0;i listen to < listen to Len (r); i++{Listen, listen, listen and listen to the FMT. Printf ("%d: listen [%c]\n, listen I, listen to r[i]) listen and Hear}}

So in the case of traversing or processing the string if it exists in Chinese, try to use the Rune method to handle it.

Transformation

As mentioned earlier, you cannot modify the original string if you need to convert the string to []byte or []rune], and then convert back such as

{Listen and listen to Var listen to a listen = listen to "Hello Listen go" Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, listen, hear, hear, listen, hear, hear, listen, hear, hear, listen, hear, hear, listen, listen, hear a[1 ] Listen = Listen to listen to hear listen//cannot listen listen to hear hear listen to hear hear assign hear listen to hear hear listen to listen to hear a[1]}{listen to listen to heard the listen to listen to hear the "Hello Listen go" listen to listening to listen to the BS listen to hear: = Hear []byte (a) Listen listen Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, hear, hear, hear, hear, listen, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, hear, listen, hear, hear, hear, hear, hear, hear, hear, hear, hear S2 listen: = Listen to String (BS) listen to listen to the RS listen : = Listen []rune (a) listen and listen ... Listen to listen to S3 listen: = Listen to String (RS)}

The go language supports string concatenation with the "+" operator, but each splicing requires re-allocating memory. If you construct a long string frequently, the performance impact will be large, such as

Func listen to Test1 () string{listen to the Var listen to listen to the B listen and hear for the i:= listen to hear for listening to listen to listen to listening to the listen to the listening < listening listen to listen to hear the listening and listening to listen to listen to listen to hear the listen listen to listening and hearing listen Func Listen to Benchmark_test1 (b listen to *testing. b) {Listen to listen to i:= listen to 0;i listen < listen to B. N Listen to i++{listen listen listen to listen to hear test1 () Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen. Output # Listen to go listen to test listen str1_b_ Test.go listen to-bench= "Test1" Listen to-benchmembenchmark_test1-2 listen to listen to listen to listen to hear 5000 listen listen to listen to hear 227539 listen to hear 530338 listen to ns/op listen to listen to listen to hear 999 listen to the B/OP

A common improvement is to pre-allocate enough memory space and then use strings. The Join function counts the length of all parameters and completes the memory allocation operation once to improve the code above

Func Listen test () string{listen to listen to hear s listen: = Listen to make ([]string,1000) listen to hear for i:= listen to listen to listen to the 0;i listen to listen to the 1000 listen to listening to listen to listening to hear "listen to listen to hear" a "listen to hear Listen and listen and listen to the return strings. Join (S, "")}func listen to Benchmark_test (b listen to *testing. b) {Listen to listen to i:= listen to 0;i listen < listen to B. N Listen i++{Listen listen to listen to listen to listen to hear} output # Listen to go listen to test-V listen to B_test.go listen to the-bench= "Test1" Listen to-benchmembenchmark_ Test1-2 listen to listen to listen to listen to listen to listen to 200000 listen to hear 10765 listen to listen to listen to ns/op listen to hear 2048 listen to listen to hear b/op listen to hear listen to listen to hear 2 hear allocs/op

FMT can be used in daily development. The sprintf function to format and stitch fewer string operations such as

{Listen to listen to a listen: = Listen to 10010 listen and listen as listen: = Listen to FMT. Sprintf ("%d", a) listen and listen to the FMT. Printf ("%t Listen, listen to%v\n", As,as)}

Array

An array is a built-in (build-in) type is a set of data types that hold a collection of data of the same type, which is determined by the length of the stored element type and array, even if the element type is the same but the length of different arrays is not of the same type. Array initialization after the length is fixed cannot modify the array also supports the logical judgment operator "= =", "=" is defined as follows

{Listen to listen to the Var listen to a listen to [10]int listen to listen to the Var listen to B listen to [20]int listen to listen to println (a listen = listen to B) listen to//invalid listen to Operation: Listen to a listen = = Listen to B listen to (mismatched listen to types listen to [10] int listen and listen [20]int)}

Array initialization relatively flexible subscript index value starting from 0 supports initializing by index location The default value is given to the uninitialized array compiler.

{Listen and listen to the Var hear a[4] Listen int Listen hear listen listen listen listen listen listen to hear//element initialized to 0 Listen listen B listen to: = Listen [4] Listen to listen to listen to hear listen to hear hear//int{0,1 elements will be initialized to 0 listen listen c listen: = Listen to [4] listen to int{0, Listen to 2: Listen to 3} Listen and hear listen//can specify the index location initialization Listen Listen D listen: = Listen to [...] int{0,1,2} listen and hear listen//compiler determines the length of an array based on the number of initialization values listen to listen to e listen to: = Listen to [...] Int{1, listen, listen, listen and listen.//Support index location initialization but the array length is irrelevant listen listen listen, listen, listen, hear, hear, listen to, listen to, listen to, listen to, listen to, hear, and listen to the "Listen and hear". Listen listen listen to listen to listen to D listen: = Listen to [...] Listen, hear, listen, hear, listen, listen, hear and hear.//composite data type array can omit element initialization type label listen and listen, listen and listen. {"A", 1}, listen and listen to listen to listening and hearing {"B", 2}, listen and Listen}}

When defining a multidimensional array, only the first dimension of the array allows the use of "..."

{Listen and listen to the x listen: = Listen to [2]int{2,2} listen to listen to a listen: = Listen to [2][2]int{{1,2},{2,2}} Listen listen to listen to B listen to: = Listen to [...] [2]int{{2,3},{2,2},{3,3}} Listen listen c listen: = Listen to [...] [2] [2]int{{Listen {2,3},{2,2} listen to},{{3,3},{4,4}}}

The length of the array is computed regardless of whether the built-in Len or cap returns the lengths of the first dimension, such as

{Listen and listen to the FMT. PRINTLN (x, listen to Len (x), listen to cap (x)) listen and listen and listen and listen to the FMT. Println (A, listen to Len (a), listen to cap (x)) listen and listen to the FMT. Println (b, listen to Len (b), listen to cap (x)) listen and listen to the FMT. Println (c, listen to Len (c), listen to cap (x))} Output [2 Listen 2] Listen to 2 listen to 2[[1 listen to 2] listen to [2 listen to 2]] listen to 2 listen to 2[[2 3] Listen [2 listen 2] listen to [3 listen 3]] Listen to 3 listen to the 3] listen [2 hear 2] [3 hear 3] Listen 2 Listen 2

Array Pointers & pointers arrays

Arrays can hold pointers in addition to specific types of data such as

{Listen to listen to x, listen to Y listen: = Listen to 10, listen to 20 listen to listen to a listen: = Listen to [...] *int{&x, listen to &y} listen and hear//pointer array listen and listen to listen to the P listen: = Listen to the &a listen to listen to hear listen listen to hear listen to listen to hear listening

Array replication

The go language array is a value (non-reference) type so the entire array data is copied during assignment and parameter passing, such as:

Func Listen to test (x listen to [2]int) {Listen to listen to the FMT. Printf ("x:= Listen to%p,%v\n", listen to &x, listen to x)}func listen to main () {Listen and listen to a listen: = Listen [2] listen to the int{1, listen to the 2} listen to listen to listen to listen to the listening and hearing (a) Listen listen listen to listen to listen and hear Full copy in the process of the communication listen and listen to the Var listen b listen to [2]int listen listen listen to listen to listen to listen to hear heard hear hear hear listen listening to listen to hear hear listen listen//assignment process completely copy listen to hear the FMT. Printf ("a:= Listen to%p,%v\n", listen to &a, listen to a) listen and listen to the FMT. Printf ("b:= Listen to%p,%v\n", listen to &b, listen to B) Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, hear, hear, hear, hear, Listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, listen, hear, hear, listen, listen, listen, listen, listen, listen, hear, listen, listen, listen, listen, listen, listen, listen, listen, Listen to 0xc42000a370,[1 listen 2]

Learn from: Rain marks <go Learning notes >

Discussion study: 675020908

This article from "learned in the text, about the ceremony" blog, reproduced please contact the author!