go notes

arithmetic operators

mostly the same as js but go is strict about types. integer division truncates, no implicit coercion, and ++ is a statement not an expression.

console output

go's fmt package. more explicit than console.log but more powerful. three families — print, sprintf, fprintf — each for a different job.

data types & variables

go is statically typed. types are checked at compile time, not runtime. no undefined, no null surprises, no implicit coercion.

short variable declaration

the := operator. you'll use this 90% of the time inside functions. faster to write, type is inferred, but has rules that'll trip you up.

goroutines and concurrency

lightweight concurrent functions managed by the go runtime, not the os

conditions & conditionals

if/else works like js but no parentheses, braces are mandatory, and there's an init statement that doesn't exist in js at all.

looping

go has one loop keyword — for. no while, no do-while. but for is flexible enough to do everything. range is your best friend for collections.

switch

go's switch is cleaner than js. no break needed, multiple values per case, and the expressionless form is a better if/else chain replacement.

functions

functions are first-class in go. multiple returns, variadic args, functions as values, factory pattern. this is the foundation of every middleware pattern you'll write.

interfaces

interfaces define behavior, not data. implicit implementation — if your struct has the methods, it satisfies the interface automatically. no implements keyword.

structs

go's way of modeling data. no classes, no inheritance. just fields, methods, and embedding. think typescript types but compiled and strict.

arrays

fixed size, value type, rarely used directly in real go code. understand them because slices are built on top of them.

maps

go's key-value store. like js objects but typed, stricter, and with a comma ok pattern you'll use constantly to avoid silent bugs.

slices

go's dynamic arrays. reference type, built on top of arrays, three things under the hood. this is what you'll actually use day to day.

error handling

errors are values in go. no try/catch, no throwing. return them, check them, wrap them. explicit and impossible to accidentally ignore.

generics

write functions and structs that work for multiple types without repeating code or losing type safety. go 1.18+.

pointers & references

& gives you the address, * gives you the value. every &Todo{} and *User in your gin api was this. now the mechanics click.