Совет для новичка Go

Question

Я начал учиться идти сегодня. В частности, я читал документацию, http://blog.go-lang.org и http://golang-book.com.

Какой лучший способ выучить язык, чем практиковать его? Я написал небольшую программу в Go, которая дает изменения клиенту, используя наименьшее количество монет. Прочитав ранних руководств, похоже, есть несколько способов сделать то же самое в Go.

Например:

• Можно ли объявить несколько переменных в одном операторе вар?
• Должны ли вы объявлять переменные с помощью var или вывести тип с помощью: = okay?
• При объявлении кусочка монет лучше всего объявить их локально в функции?

---

package main 

import "fmt" 

func main() { 
    fmt.Printf("%v", change(158)) 
} 

func change(value int) []int { 
    var (
     change []int 
     coins = []int{ 100, 50, 20, 10, 5, 2, 1 } 
    ) 

    for value > 0 { 
     for i := 0; i < len(coins); i++ { 
      if coins[i] <= value { 
       change = append(change, coins[i]) 
       value -= coins[i] 
       break 
      } 
     } 
    } 

    return change 
} 

Большое спасибо!

Answer 1

Некоторые вещи - это всего лишь вопрос стиля. Также подумайте, что произойдет, если вас попросят расширить функцию, например, поддерживать несколько валют как часть денежного пакета. Например, я написал бы свой change функцию как метод на валюту:

package main 

import "fmt" 

type Currency struct { 
    Name string 
    Notes []int 
    Coins []int 
} 

var ukCurrency = Currency{ 
    Name: "UK Sterling", 
    Notes: []int{5000, 2000, 1000, 500}, 
    Coins: []int{100, 50, 20, 10, 5, 2, 1}, 
} 

var usCurrency = Currency{ 
    Name: "US Dollar", 
    Notes: []int{10000, 5000, 2000, 1000, 500, 100}, 
    Coins: []int{25, 10, 5, 1}, 
} 

func (c *Currency) Change(amount int) []int { 
    var change []int 
    for _, note := range c.Notes { 
     for note <= amount { 
      change = append(change, note) 
      amount -= note 
     } 
     if amount == 0 { 
      break 
     } 
    } 
    for _, coin := range c.Coins { 
     for coin <= amount { 
      change = append(change, coin) 
      amount -= coin 
     } 
     if amount == 0 { 
      break 
     } 
    } 
    return change 
} 

func main() { 
    for _, currency := range []Currency{ukCurrency, usCurrency} { 
     fmt.Println(currency.Name, currency.Change(158)) 
     fmt.Println(currency.Name, currency.Change(4747)) 
    } 
} 

Выход:

UK Sterling [100 50 5 2 1] 
UK Sterling [2000 2000 500 100 100 20 20 5 2] 
US Dollar [100 25 25 5 1 1 1] 
US Dollar [2000 2000 500 100 100 25 10 10 1 1] 

В самом стиле, я бы пересмотреть ваши функции изменения в:

package main 

import "fmt" 

var coins = []int{100, 50, 20, 10, 5, 2, 1} 

func change(amount int) []int { 
    var change []int 
    for _, coin := range coins { 
     for coin <= amount { 
      change = append(change, coin) 
      amount -= coin 
     } 
     if amount == 0 { 
      break 
     } 
    } 
    return change 
} 

func main() { 
    fmt.Println(change(158)) 
} 

Answer 2

• Можно ли объявить несколько переменных в одном выражении var?

да

• Если вы объявляете переменные, используя вар, или выводя тип с помощью: = нормально?

Оба приемлемы. Правило большого пальца состоит в том, что если вам нужно инициализировать переменную со значением, используйте: = if not then use var.

• При объявлении кусочка монет, лучше ли объявить их локально в функции?

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

Answer 3

• Можно ли объявить несколько переменных в одном выражении var?

Да, хотя в моем личном опыте я никогда не видел его в локальном масштабе. Синтаксис var (...) традиционно зарезервирован для объявлений верхнего уровня (хотя я никогда не видел этого в каких-либо руководствах по стилю, это просто мое наблюдение).

• Должны ли вы объявлять переменные с помощью var или вывести тип, используя: = okay?

Обычно := в порядке. Обычно вы хотите использовать var с явным типом, когда тип либо не является очевидным, либо вы хотите, чтобы переменная была чем-то иным, чем очевидным, или даже принудительно приводила к типу.

Например, допустим, что у вас есть переменная, a, и вы хотите создать повторяющуюся переменную, b. Иногда вы можете напомнить читателю, что тип a, а не просто делать b := a.

В качестве примера «отличного от очевидного» случая представьте, что вы хотите 16-битовое значение с плавающей запятой. Вы могли бы сделать что-либо из следующего, но некоторые считают, что второй уборщик:

a := float16(1) 
var a float16 = 1 

Наконец, использовать var где вы только объявляющий, не назначая переменной (например, использовать его значение по умолчанию, или назначить его позже):

`var a int` 

• при объявлении ломтик монет, это лучше, чтобы объявить их локально в функции?

Это зависит главным образом от двух факторов: логически ли оно связано с функцией и достаточно ли оно громоздким, если оно объявлено локально?

Очевидно, что если одно и то же значение используется в других функциях, вы можете захотеть объявить его глобально. Иногда, даже если он используется только в одной функции, он все же имеет более логичный смысл объявить его глобально (например, если он похож на параметр поведения общего пакета, например, сколько байтов используется для локального хранилища или что-то типа того).

Даже если он логически связан с локальной функцией, если это очень долго значение, объявляя его локально может засорять код значительно, который был бы уважительная причина объявить глобально:

функ MyFunc () {

// Do некоторый материал

mySlice: = [] строка { "1", "2", "3", "4", "5", "6", "7", «8», «9», «10», «11», «12», «13», «14», «15», «16», «17», «18», «19», «20 «21», «22», «23», «24», «25», «26», «27», «28», «29», «30», «31», «32», «33», «34», «35», «36», «37», «38», «39», «40», «41», «42», «43», «44», «45 "," 46 "," 47 "," 48 "," 49 "," 50 "," 51 "," 52 "," 53 "," 54 "," 55 "," 56 "," 57 "," 58 " , «59», «60», «61», «62», «63», «64», «65», «66», «67», «68», «69», «70», 71 "," 72 "," 73 "," 74 "," 75 "," 76 "," 77 "," 78 "," 79 "," 80 "," 81 "," 82 "," 83 " , «84», «85», «86», «87», «88», «89», «90», «91», «92», «93», «94», «95», 96 "," 97 "," 98 "," 99 "," 100 "," 101 "," 102 "," 103 "," 104 "," 105 "," 106 "," 107 "," 108 " , «109», «110», «111», «112», «113», «114», «115», «116», «117», «118», «119», «120», 121 "," 122 "," 123 "," 124 "," 125 "," 126 "," 127 "," 128 "," 129 "," 130 "," 131 "," 132 "," 133 " «134», «135», «136», «137», «138», «139», «140», «141», «142», «143», «144», «145», 146 "," 147 "," 148 "," 149 "," 150 "," 151 "," 152 "," 153 "," 154 "," 155 "," 156 "," 157 "," 158 " , «159», «160», «161», «162», «163», «164», «165», «166», «167», «168», «169», «170», 171 «,« 172 »,« 173 »,« 174 »,« 175 »,« 176 »,« 177 »,« 178 »,« 179 »,« 180 »,« 181 »,« 182 »,« 183 », «188», «181», «181», 196" , "197", "198", "199", "200",}

// Делайте некоторые другие вещи.

}

(Обратите внимание, что я не писал, что в качестве блока кода, потому что он не был бы обернута вокруг иначе, и не было бы передать, насколько уродлив, что может быть.)

Answer 4

Лучший совет, который я могу вам дать: Прочитайте исходный код встроенных пакетов. Исходный код поможет вам значительно. Особенно при чтении некоторых удобных функций: что они делают, чтобы облегчить мою жизнь? Также обратите внимание на любые файлы, которые заканчиваются на «_test.go», поскольку они будут иметь примеры, не содержащиеся в документации.

Можно ли объявить несколько переменных в одном выражении var?

Да, если они связаны.

Следует ли объявлять переменные с помощью var или вывести тип, используя: = okay? При объявлении кусочка монет, лучше ли объявить их

Либо работает. Просто будьте последовательны. Иногда приходится использовать var предварительно объявить переменную, если функция уже заявляет один из переменных, которые вы используете:

func Foo() (err error) { 
    ... 
    var n int 
    if n, err = something.Read(buf); err != nil { 
     return 
    } 
    .... 
} 

А иногда имя переменной не достаточно, чтобы передать то, что вы делаете.

При объявлении кусочка монет, лучше ли объявить их локально в функции?

Если это постоянная величина, объявите ее снаружи.