if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
    fmt.Println("Bad")
    return true
}
return false

|
| ```go
// good: перед использованием данных следует проверить их длину
func decode(data []byte) bool {
    if len(data) == 6 {
        if data[0] == 'F' && data[1] == 'U' && data[2] == 'Z' && data[3] == 'Z' && data[4] == 'E' && data[5] == 'R' {
            fmt.Println("Good")
            return true
        }
    }
    return false
}

* 1.1.2 Обязательная проверка нулевого указателя
    * При работе с указателями необходимо проверять их на нулевое значение, особенно при выполнении операции Unmarshal для структур.

PackeyType    uint8
PackeyVersion uint8
Data          *Data

p.PackeyType = b[0]
p.PackeyVersion = b[1]

// Если длина равна 2, то Data не будет создана
if len(b) > 2 {
    p.Data = new(Data)
}
return nil

fmt.Printf("Stat: %v\n", packet.Data.Stat)

|
| ```go
func main() {
    packet := new(Packet)
    data := make([]byte, 2)

    if err := packet.UnmarshalBinary(data); err != nil {
        fmt.Println("Failed to unmarshal packet")
        return
    }

    if packet.Data == nil {
        return
    }

    fmt.Printf("Stat: %v\n", packet.Data.Stat)
}

* 1.1.3 Обязательная безопасность целых чисел
    * При выполнении операций с целыми числами необходимо ограничивать их длину, чтобы предотвратить возможные ошибки из-за внешних входных данных.

var numInt int32 = 0
numInt = numControlByUser + 1
// Неправильное ограничение длины приводит к переполнению целого числа
fmt.Printf("%d\n", numInt)
// Использование numInt может вызвать другие ошибки

|
| ```go
func overflow(numControlByUser int32) {
    var numInt int32 = 0
    numInt = numControlByUser + 1
    if numInt < 0 {
        fmt.Println("integer overflow")
        return
    }
    fmt.Println("integer ok")
}

func main() {
    overflow(2147483647)
}

* 1.1.4 Обязательная проверка распределения памяти с помощью make
    * Необходимо проверять длину внешних данных при использовании make для выделения памяти, чтобы избежать возможных ошибок.

size := lenControlByUser
// Проверка длины внешних данных для предотвращения паники
buffer := make([]byte, size)
copy(buffer, data)

|
| ```go
func parse(lenControlByUser int, data []byte) ([]byte, error) {
    size := lenControlByUser
    // Ограничение размера внешних данных в допустимом диапазоне
    if size > 64*1024*1024 {
        return nil, errors.New("value too large")
    }
    buffer := make([]byte, size)
    copy(buffer, data)
    return buffer, nil
}
``` Когда объект выбирается сборщиком мусора (GC) для удаления из памяти, runtime.SetFinalizer() не выполняется, даже если программа завершается нормально или происходит ошибка. Хотя циклические ссылки, основанные на указателях, могут быть правильно обработаны GC, невозможно определить порядок зависимостей finalizer, что приводит к невозможности вызова runtime.SetFinalizer(), в результате чего целевой объект не может стать доступным, и память не может быть восстановлена.

```go
// bad
func foo() {
    var a, b Data
    a.o = &b
    b.o = &a

    // Указательная циклическая ссылка, хотя SetFinalizer() нельзя вызвать нормально
    runtime.SetFinalizer(&a, func(d *Data) {
        fmt.Printf("a %p final.\n", d)
    })
    runtime.SetFinalizer(&b, func(d *Data) {
        fmt.Printf("b %p final.\n", d)
    })
}

func main() {
    for {
        foo()
        time.Sleep(time.Millisecond)
    }
}

// bad
func foo(c chan int) {
    defer close(c)
    err := processBusiness()
    if err != nil {
        c <- 0
        close(c) // Повторное освобождение канала
        return
    }
    c <- 1
}

// bad: Поток не имеет условий для завершения
func doWaiter(name string, second int) {
    for {
        time.Sleep(time.Duration(second) * time.Second)
        fmt.Println(name, " is ready!")
    }
}

// bad: Использование unsafe для работы с исходным указателем
func unsafePointer() {
    b := make([]byte, 1)
    foo := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(0xfffffffe)))
    fmt.Print(*foo + 1)
}

  // bad
  // Слайс используется как параметр функции, содержащий указатель на исходный массив
  func modify(array []int) {
      array[0] = 10 // Изменение элемента слайса влияет на исходные данные
  }
  
  func main() {
      array := []int{1, 2, 3, 4, 5}
  
      modify(array)
      fmt.Println(array) // output：[10 2 3 4 5]
  }

  // good
  // Массив используется как параметр функции вместо слайса
  func modify(array [5]int) {
    array[0] = 10
  }

  func main() {
      // Передача массива вместо слайса, обратите внимание на разницу между массивом и слайсом
      array := [5]int{1, 2, 3, 4, 5}
  
      modify(array)
      fmt.Println(array)
  }

// bad: Произвольное чтение файла
func handler(w http.ResponseWriter, r *http.Request) {
    path := r.URL.Query()["path"][0]

    // Чтение файла без фильтрации пути, что может привести к произвольному чтению файла
    data, _ := ioutil.ReadFile(path)
    w.Write(data)

    // Для внешних переданных имён файлов также требуется проверка на наличие ../ и других путей пересечения
    data, _ = ioutil.ReadFile(filepath.Join("/home/user/", path))
    w.Write(data)
}

// bad: Произвольная запись файла
func unzip(f string) {
    r, _ := zip.OpenReader(f)
    for _, f := range r.File {
        p, _ := filepath.Abs(f.Name)
        // Запись файла без проверки имени сжатого файла, что может привести к ../ и другим путям пересечения, произвольной записи файла
        ioutil.WriteFile(p, []byte("present"), 0640)
    }
}

// good: Проверка имени сжатого файла на наличие .. и других признаков пересечения путей, предотвращение произвольной записи
func unzipGood(f string) bool {
    r, err := zip.OpenReader(f)
    if err != nil {
        fmt.Println("read zip file fail")
        return false
    }
    for _, f := range r.File {
        if !strings.Contains(f.Name, "..") {
            p, _ := filepath.Abs(f.Name)
            ioutil.WriteFile(p, []byte("present"), 0640)
        } else {
            return false
        }
    }
    return true
}

ioutil.WriteFile(p, []byte("present"), 0640)

if checkIllegal(cmdName) { // 检查传给sh的命令是否有特殊字符
    return // 存在特殊字符直接return
}

cmd := exec.Command("sh", "-c", cmdName)
output, _ := cmd.CombinedOutput()
fmt.Println(string(output))

// good
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
        w.Write([]byte("This is an example server.\n"))
    })

    // 服务器配置证书与 приватным ключом
    log.Fatal(http.ListenAndServeTLS(":443", "yourCert.pem", "yourKey.pem", nil))
}

// bad
import (
    "crypto/tls"
    "net/http"
)

func doAuthReq(authReq *http.Request) *http.Response {
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr}
    res, _ := client.Do(authReq)
    return res
}

// good
import (
    "crypto/tls"
    "net/http"
)

func doAuthReq(authReq *http.Request) *http.Response {
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: false},
    }
    client := &http.Client{Transport: tr}
    res, _ := client.Do(authReq)
    return res
}

// bad
func serve() {
    http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()
        user := r.Form.Get("user")
        pw := r.Form.Get("password")

        log.Printf("Registering new user %s with password %s.\n", user, pw)
    })
    http.ListenAndServe(":80", nil)
}

// good
func serve1() {
    http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()
        user := r.Form.Get("user")
        pw := r.Form.Get("password")

        log.Printf("Registering new user %s.\n", user)

        // ...
        use(pw)
    })
    http.ListenAndServe(":80", nil)
}

defer func () {
    if r := recover(); r != nil {
        fmt.Println("Recovered in start()")
    }
}()

Это похоже на язык Go.

if validateVariable(x) {
    var tmpl = `<!DOCTYPE html><html><body>
        <form action="/" method="post">
        First name:<br>
        <input type="text" name="name" value="">
        <input type="submit" value="Submit">
        </form><p>` + x + ` </p></body></html>`
    t := template.New("main")
    t, _ = t.Parse(tmpl)
    t.Execute(w, "Hello")
} else {
    // ...
}

Здесь создаётся функция `handler`, которая принимает два аргумента: `w` и `r`. В функции происходит парсинг формы запроса, а затем вызывается функция `validateVariable`, которая проверяет значение переменной `x` на соответствие определённым условиям. Если проверка проходит успешно, то формируется HTML-код с формой и значением переменной `x`, который затем обрабатывается шаблонизатором.

В результате выполнения этого кода будет сформирована HTML-страница с формой, в которую пользователь сможет ввести своё имя. После отправки формы это имя будет выведено на экран. **1.9.2**

*Нельзя выполнять операции записи в map одновременно.*

Это может привести к сбою программы и аварийному завершению работы. Рекомендуется использовать блокировку для защиты данных.

```go
// bad
func main() {
    m := make(map[int]int)
    // одновременное чтение и запись
    go func() {
        for {
            _ = m[1]
        }
    }()
    go func() {
        for {
            m[2] = 1
        }
    }()
    select {}
}

// good
var count int

func Count(lock *sync.Mutex) {
    lock.Lock() // блокировка записи
    count++
    fmt.Println(count)
    lock.Unlock() // снятие блокировки записи, любой вызов Lock() или RLock() должен сопровождаться вызовом Unlock() или RUnlock()
}

func main() {
    lock := &sync.Mutex{}
    for i := 0; i < 10; i++ {
        go Count(lock) // передача указателя на блокировку предотвращает несоответствие блокировок внутри функции и снаружи
    }
    for {
        lock.Lock()
        c := count
        lock.Unlock()
        runtime.Gosched() // передача управления другим горутинам
        if c > 10 {
            break
        }
    }
}

// good
import (
    "sync"
    "sync/atomic"
)

func main() {
    type Map map[string]string
    var m atomic.Value
    m.Store(make(Map))
    var mu sync.Mutex // используется только для записи
    read := func(key string) (val string) {
        m1 := m.Load().(Map)
        return m1[key]
    }
    insert := func(key, val string) {
        mu.Lock() // синхронизация с потенциальной операцией записи
        defer mu.Unlock()
        m1 := m.Load().(Map) // загрузка текущих данных
        m2 := make(Map)      // создание нового значения
        for k, v := range m1 {
            m2[k] = v
        }
        m2[key] = val
        m.Store(m2) // замена текущего объекта новым
    }
    _, _ = read, insert
}