├── .gitignore
└── README.md
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | # Вопросы для собеседования по Go
3 |
4 | :information_source: В этом репозитории содержаться вопросы и ответы с помощью которых вы можете подготовиться к собеседованию по Golang
5 |
6 | :iphone: Telegram-канал - [@golangquiz](https://t.me/golangquiz)
7 |
8 | :bar_chart: Вопросов - 14.
9 |
10 | :pencil: Вы можете добавить свой вопрос или обьяснение, исправить/дополнить существующий с помощью пул реквеста :)
11 |
12 | # Todo:
13 | - разделить вопросы по категориям
14 | - разделить вопросы по сложности
15 |
16 | # Список вопросов и ответов
17 |
18 |
19 | 1. Какие основные фичи GO?
20 |
21 | * Сильная статическая типизация - тип переменных не может быть изменен с течением времени, и они должны быть определены во время компиляции
22 | * Быстрое время компиляции
23 | * Встроенная конкурентность
24 | * Встроеный сборщик мусора
25 | * Компилируется в один бинарник - все, что вам нужно для запуска приложения. Очень полезно для управления версиями во время выполнения.
26 |
27 |
28 |
29 |
30 | 2. Что выведет код?
31 |
32 | ```golang
33 | package main
34 |
35 | import (
36 | "fmt"
37 | "sync"
38 | "time"
39 | )
40 |
41 | func main() {
42 | var wg sync.WaitGroup
43 |
44 | wg.Add(1)
45 | go func() {
46 | time.Sleep(time.Second * 2)
47 | fmt.Println("1")
48 | wg.Done()
49 | }()
50 |
51 | go func() {
52 | fmt.Println("2")
53 | }()
54 |
55 | wg.Wait()
56 | fmt.Println("3")
57 | }
58 | ````
59 |
60 |
61 | Ответ
62 | всегда 2 1 3
63 |
64 |
65 |
66 |
67 |
68 | 3. Что выведет код?
69 |
70 | ```golang
71 | package main
72 |
73 | import (
74 | "context"
75 | "fmt"
76 | "time"
77 | )
78 |
79 | func main() {
80 | timeout := 3 * time.Second
81 | ctx, cancel := context.WithTimeout(context.Background(), timeout)
82 | defer cancel()
83 |
84 | select {
85 | case <-time.After(1 * time.Second):
86 | fmt.Println("waited for 1 sec")
87 | case <-time.After(2 * time.Second):
88 | fmt.Println("waited for 2 sec")
89 | case <-time.After(3 * time.Second):
90 | fmt.Println("waited for 3 sec")
91 | case <-ctx.Done():
92 | fmt.Println(ctx.Err())
93 | }
94 | }
95 | ```
96 |
97 |
98 | Ответ
99 | waited for 1 sec
100 |
101 |
102 |
103 |
104 |
105 | 4. Что выведет код?
106 |
107 | ```golang
108 | package main
109 |
110 | import (
111 | "container/heap"
112 | "fmt"
113 | )
114 |
115 | type IntHeap []int
116 |
117 | func (h IntHeap) Len() int { return len(h) }
118 | func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
119 | func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
120 |
121 | func (h *IntHeap) Push(x interface{}) {
122 | *h = append(*h, x.(int))
123 | }
124 |
125 | func (h *IntHeap) Pop() interface{} {
126 | old := *h
127 | n := len(old)
128 | x := old[n-1]
129 | *h = old[0 : n-1]
130 | return x
131 | }
132 |
133 | func main() {
134 | h := &IntHeap{2, 1, 5}
135 | heap.Init(h)
136 | fmt.Printf("first: %d\n", (*h)[0])
137 | }
138 | ```
139 |
140 |
141 | Ответ
142 | first: 1
143 |
144 |
145 |
146 |
147 |
148 | 5. Что выведет код?
149 |
150 | ```golang
151 | package main
152 |
153 | import (
154 | "fmt"
155 | )
156 |
157 | func mod(a []int) {
158 | // Как и почему изменится вывод если раскомментировать строку ниже?
159 | // a = append(a, 125)
160 |
161 | for i := range a {
162 | a[i] = 5
163 | }
164 |
165 | fmt.Println(a)
166 | }
167 |
168 | func main() {
169 | sl := []int{1, 2, 3, 4}
170 | mod(sl)
171 | fmt.Println(sl)
172 | }
173 | ```
174 |
175 |
176 | Ответ
177 | [5 5 5 5]
178 | [5 5 5 5]
179 | если раскомментировать `a = append(a, 125)`
180 | [5 5 5 5 5]
181 | [1 2 3 4]
182 |
183 |
184 |
185 |
186 |
187 | 6. Что выведет код? (тема - defer)
188 |
189 | ```golang
190 | package main
191 |
192 | import (
193 | "fmt"
194 | )
195 |
196 | func main() {
197 | i := 0
198 | defer fmt.Println(i)
199 | i++
200 | return
201 | }
202 | ```
203 |
204 |
205 | Ответ
206 | 0
207 |
208 |
209 |
210 |
211 |
212 | 7. Что выведет код? (тема - defer)
213 |
214 | ```golang
215 | package main
216 |
217 | import (
218 | "fmt"
219 | )
220 |
221 | func main() {
222 | for i := 0; i < 5; i++ {
223 | defer func(i *int) {
224 | fmt.Printf("%v ", *i)
225 | }(&i)
226 | }
227 |
228 | }
229 | ```
230 |
231 |
232 | Ответ
233 | Зависит от версии компилятора.
234 |
235 | До версии 1.22 - 5 5 5 5 5
236 |
237 | Начиная с 1.22 - 4 3 2 1 0
238 |
239 |
240 |
241 |
242 |
243 | 8. Предположим, что x объявлен, а y не объявлен, какие пункты ниже верны?
244 |
245 | ```golang
246 | x, _ := f()
247 | x, _ = f()
248 | x, y := f()
249 | x, y = f()
250 | ```
251 |
252 |
253 | Ответ
254 | x, _ = f()
255 | x, y := f()
256 |
257 |
258 |
259 |
260 |
261 | 9. Что делает runtime.newobject()?
262 |
263 | Выделяет память в куче.
264 | https://golang.org/pkg/runtime/?m=all#newobject
265 |
266 |
267 |
268 |
269 |
270 | 10. Что такое $GOROOT и $GOPATH?
271 |
272 | $GOROOT каталог для стандартной библиотеки, включая исполняемые файлы и исходный код.
273 | $GOPATH каталго для внешних пакетов.
274 |
275 |
276 |
277 |
278 |
279 | 11. Что выведет код? (тема - slice)
280 |
281 | ```golang
282 | package main
283 |
284 | import (
285 | "fmt"
286 | )
287 |
288 | func main() {
289 | test1 := []int{1, 2, 3, 4, 5}
290 | test1 = test1[:3]
291 | test2 := test1[3:]
292 | fmt.Println(test2[:2])
293 | }
294 | ```
295 |
296 |
297 | Ответ
298 | [4 5]
299 |
300 |
301 |
302 |
303 |
304 |
305 | 12. Перечислите функции которые могу остановить выполнение текущей горутины
306 |
307 | runtime.Gosched
308 | runtime.gopark
309 | runtime.notesleep
310 | runtime.Goexit
311 |
312 |
313 |
314 |
315 | 13. Что выведет код?
316 |
317 | ```golang
318 | x := []int{1, 2}
319 | y := []int{3, 4}
320 | ref := x
321 | x = y
322 | fmt.Println(x, y, ref)
323 | ```
324 |
325 |
326 | Ответ
327 | [3 4] [3 4] [1 2]
328 |
329 |
330 |
331 |
332 |
333 | 14. Как скопировать slice?
334 |
335 | Следует воспользоваться встроенной функцией copy:
336 |
337 | ```golang
338 | x := []int{1, 2}
339 | y := []int{3, 4}
340 | ref := x
341 | copy(x, y)
342 | fmt.Println(x, y, ref)
343 | // Output: [3 4] [3 4] [3 4]
344 | ```
345 |
346 |
347 |
348 |
--------------------------------------------------------------------------------