JavaScript.CodeCompared.To/Go

Both console.log() and fmt.Println() append a trailing newline. Every Go program requires a package main declaration and a func main() entry point — the runner adds this boilerplate automatically.

Go uses fmt.Printf() with % format verbs instead of template literals. Common verbs: %s for strings, %d for integers, %f for floats, %v for any value, %T for the type, and %#v for Go syntax representation. Unlike JavaScript's template literals, fmt.Printf() does not add a trailing newline — the explicit \n is required.

fmt.Sprintf() builds a formatted string without printing it — the equivalent of using a template literal to construct a string before passing it elsewhere. It returns a string value. The %.2f verb formats a float with exactly two decimal places.

The %v verb formats any Go value in its default representation — structs as {3 4}, slices as [1 2 3]. %T prints the type name (main.Point, []int, bool). The %#v verb produces Go syntax output useful for debugging.

The := operator both declares a variable and assigns its initial value, inferring the type from the right-hand side. It is equivalent to JavaScript's let. On subsequent lines, plain = reassigns without redeclaring. In Go, all declared variables must be used — declaring a variable you never read is a compile error, unlike JavaScript.

Go's var keyword allows explicit type annotation: var name type. Type annotations are required when you want a different type than inference would give — for example, declaring a float64 variable initialized to 0 (which inference would make int). In practice, := with type inference is preferred when the type is obvious from context.

Go has no undefined. Every type has a zero value: 0 for numeric types, "" for strings, false for booleans, nil for pointers/slices/maps/channels/interfaces. Variables declared without an explicit initial value always start at their type's zero value. This eliminates an entire class of bugs where JavaScript code fails because a variable was read before being assigned.

Go's const values are computed at compile time and can only hold basic types (numbers, strings, booleans). Unlike JavaScript's const, which merely prevents reassignment of the binding, Go constants are true compile-time constants — they can be used in array sizes, type definitions, and other positions where only compile-time values are accepted. Go conventionally uses camelCase for constants, not SCREAMING_SNAKE_CASE.

Go supports multiple assignment in a single statement, which is especially useful for swapping values and for receiving multiple return values from functions. The right-hand side is evaluated fully before any assignment occurs, making a, b = b, a a correct swap without a temporary variable.

Go has no implicit type coercion. Mixing int and float64 in arithmetic is a compile error — one must be explicitly converted first. String-to-number and number-to-string conversions go through the strconv package. This strictness eliminates JavaScript's notorious coercion surprises ("1" + 1 === "11", [] + {} === "[object Object]", etc.).

Go uses backtick-delimited raw string literals (` + "`" + `...` + "`" + `) where backslash sequences are treated as literal characters. JavaScript uses String.raw or template literals for multiline strings. In Go, backtick strings can span multiple lines and are a common way to embed JSON, SQL, or other content with backslashes.

The + operator works for simple concatenation in both languages. For building strings in a loop, Go uses strings.Builder — appending with + in a loop creates a new allocation each iteration, just as in JavaScript. strings.Join() is the direct equivalent of JavaScript's Array.prototype.join() for joining a slice of strings.

Go's string operations live in the strings package as free functions rather than methods on a string value. The pattern is strings.FunctionName(str, args) rather than str.methodName(args). The third argument to strings.Replace() limits how many replacements to make; pass -1 to replace all occurrences (like JavaScript's replaceAll()).

strconv.Atoi() (ASCII to integer) parses a decimal string; it returns (int, error) — the caller must check the error, unlike JavaScript's parseInt() which returns NaN on failure. strconv.ParseFloat() takes a bit size (32 or 64) to control precision. The blank identifier _ discards the error when you are certain the input is valid.

Go strings are byte slices encoded as UTF-8. len(s) returns the byte count, not the character count — the same as JavaScript's str.length for ASCII strings but different for multi-byte characters like é (2 bytes in UTF-8). A range loop over a string automatically decodes UTF-8 runes (Unicode code points), similar to iterating with for...of in JavaScript.

JavaScript has a single number type (IEEE 754 64-bit float) that represents all numbers, plus BigInt for arbitrary precision. Go has separate integer types (int, int8, int16, int32, int64) and float types (float32, float64). Mixing them in arithmetic is a compile error — you must cast explicitly. The plain int type is 64-bit on most modern platforms.

In Go, dividing two integers always produces an integer, truncating toward zero — there is no automatic promotion to float. This matches most other statically-typed languages and is a common source of bugs for JavaScript developers who expect 7 / 2 to equal 3.5. To get a float result, cast one operand to float64 first: float64(7) / 2.

Go's math package mirrors JavaScript's Math object for most operations. A key difference: math.Min() and math.Max() each take exactly two arguments — there is no variadic version. To find the minimum of a slice, use a loop. All math functions operate on float64; pass integer arguments with float64(n) if needed.

Go has both arrays ([5]int, fixed size, rare) and slices ([]int, dynamic, the idiomatic choice). Slices are the Go equivalent of JavaScript arrays. make([]int, length) creates a zero-filled slice of a given length. make([]int, length, capacity) also preallocates backing storage to avoid reallocations during growth.

append() returns a new (or possibly reallocated) slice — the result must always be assigned back. Unlike JavaScript's Array.push() which mutates in place, append() may allocate a new backing array if the current capacity is exceeded. append() accepts variadic elements, so append(sliceA, sliceB...) concatenates two slices (the ... unpacks the second slice).

Go's slice expression s[low:high] returns a sub-slice sharing the same underlying array (no copy), whereas JavaScript's Array.slice() always returns a new array. This means mutating the sub-slice also mutates the original. Go's standard library (Go 1.21+) includes a slices package with slices.Index() and slices.Contains().

Go's for ... range construct replaces JavaScript's for...of, forEach(), and index-based for loops for iterating slices. range yields two values: the index and a copy of the element. Use _ to discard whichever you don't need. Go has no built-in map(), filter(), or reduce() — these are idiomatic for loops in Go.

The sort package provides sort.Ints(), sort.Strings(), and sort.Float64s() for the common cases. For custom ordering, sort.Slice(s, func(i, j int) bool { ... }) takes a comparator function — similar to JavaScript's Array.sort() comparator but returning a boolean instead of a number. sort.Slice() sorts in place.

Go maps have typed keys and values — map[string]int maps string keys to integer values. Looking up a missing key returns the value type's zero value (0 for int) without error — similar to how accessing a missing property in a JavaScript object returns undefined. The two-value form value, ok := m[key] distinguishes "key present with zero value" from "key absent".

The comma-ok idiom (value, ok := map[key]) is Go's idiomatic way to distinguish a missing key from a key whose value happens to be the zero value. It appears throughout Go: type assertions, channel receives, and map lookups all use the same two-value pattern. The if with an init statement (if value, ok := ...; ok { ... }) scopes both variables to the if block.

for key, value := range map iterates all map entries. Critically, Go map iteration order is intentionally randomized — the specification does not define an order. If you need sorted output, collect the keys into a slice, sort the slice, and iterate the slice. This is a deliberate design choice to prevent code from depending on an ordering that could change between Go versions.

make(map[K]V, hint) preallocates internal hash table buckets for approximately hint entries, avoiding rehashing during growth. It is an optimization hint, not a size limit. strings.Fields() splits on any whitespace sequence — the equivalent of JavaScript's str.split(/\s+/).filter(Boolean). Note wordCount[word]++ works because the zero value for int is 0.

Go if requires no parentheses around the condition, and the braces are always required — even for a single-statement body. Both rules are enforced by the compiler and formatter. Omitting braces (as allowed in JavaScript) or adding unnecessary parentheses causes a compile error (the latter triggers gofmt to remove them).

Go's if statement supports an optional initialization statement before the condition, separated by a semicolon. Variables declared in the init statement are scoped to the entire if/else if/else chain. This pattern is idiomatic for function calls that return a (value, bool) or (value, error) pair — it keeps the scope of the result tight and avoids polluting the enclosing function's scope.

Go's switch does not fall through by default — no break statements needed. Multiple values can be listed in a single case separated by commas. To opt into fallthrough for a specific case, use the fallthrough keyword (rare in idiomatic Go). switch can also have no expression (equivalent to switch true), making it a cleaner alternative to a long if/else if chain.

Go has only one loop keyword: for. It covers all three JavaScript loop styles: the C-style three-clause for, the condition-only for (equivalent to while), and the infinite for {} loop (equivalent to while(true)). There is no while, do...while, or until keyword. The for ... range form handles iteration over slices, maps, strings, and channels.

defer schedules a function call to execute when the surrounding function returns — whether by reaching the end, a return statement, or a panic. This is Go's primary mechanism for resource cleanup (closing files, releasing locks, etc.) and is cleaner than JavaScript's try/finally because the cleanup code appears immediately after the resource is opened, not at the bottom of the function. Multiple defer calls run in last-in-first-out order.

Go functions use func name(params) returnType syntax with types after parameter names. When multiple consecutive parameters share a type, they can be grouped: func add(a, b int). Go does not have default parameter values — use function overloads with different names or an options struct for optional parameters. All parameters are passed by value; to modify the caller's variable, pass a pointer.

Go functions can return multiple values as a first-class language feature — no wrapping in an array or object needed. The return types are listed in parentheses. Multiple return values are especially common for the (result, error) pattern: almost every function that can fail returns its result and an error as the second value. Ignoring the error with _ is allowed but a code smell.

Go variadic functions use ...Type for the last parameter. Inside the function, the parameter is a regular slice. Calling a variadic function with a slice uses the slice... syntax to unpack it — similar to JavaScript's spread operator. Only the last parameter can be variadic. The built-in append() and fmt.Println() are variadic functions.

Named return values serve as documentation and can be used with a bare return statement that returns the current values of all named results. They are especially useful in short functions or when the same variable needs to be assigned in multiple branches. Named return parameters are initialized to their zero values on function entry.

Go closures capture variables from the enclosing scope by reference, just like JavaScript closures. The func() int return type declares that makeCounter() returns a function that takes no arguments and returns an int. Functions are first-class values in Go: they can be assigned to variables, passed as arguments, and returned from other functions.

Function types in Go are written as func(paramTypes) returnType. A function parameter of type func(int) int accepts any function that takes an int and returns an int. Anonymous functions (function literals) are the Go equivalent of arrow functions, though they use func and full syntax rather than =>.

Go has the same closure-in-loop trap: a closure captures the loop variable itself, not its value at the time of capture. The fix in Go is the same as the pre-let JavaScript fix: copy the value into a new variable inside the loop body. As of Go 1.22, for range loops create a new variable per iteration (like JavaScript's let), eliminating the trap for for ... range — but classic three-clause for loops still share the variable.

Go has no classes — structs with methods fill that role. Structs are defined with type Name struct { ... } and instantiated as values (not objects on the heap by default). %+v in fmt.Printf() prints field names alongside values, useful for debugging. Exported fields start with an uppercase letter; unexported fields start with lowercase and are only accessible within the same package.

A Go method is a function with a receiver: func (r Rectangle) MethodName() ReturnType. The receiver r is similar to this in JavaScript, but it is a copy of the value, not a reference. Methods can be defined on any named type — not just structs — and the definition can appear anywhere in the same package, not just adjacent to the type.

A value receiver (func (c Counter)) operates on a copy — mutations are not visible to the caller. A pointer receiver (func (c *Counter)) operates on the original value and allows mutation. This is unlike JavaScript, where object methods always receive a reference. Use pointer receivers when the method needs to mutate the struct, or when copying the struct would be expensive. Go automatically takes the address when calling a pointer receiver on an addressable value.

Go has no inheritance. Instead, embedding a type (type Dog struct { Animal; ... }) promotes the embedded type's fields and methods to the outer struct — dog.Speak() works even though Speak() is defined on Animal. This is composition, not inheritance: there is no subtype relationship. Dog is not an Animal and cannot be used where an Animal is expected — only interfaces enable polymorphism.

Go interfaces are satisfied implicitly — a type implements an interface by having the required methods, with no implements declaration. This is like JavaScript's duck typing, but verified at compile time rather than runtime. If a type has all the methods in the interface, it satisfies the interface — even if the type was written before the interface was defined. This allows interfaces to be defined close to where they are used, not close to where types are defined.

Any type that implements String() string satisfies the fmt.Stringer interface. The fmt package automatically uses String() when formatting a value with %v, %s, or fmt.Println(). This is the Go equivalent of JavaScript's toString() — override it to control how a type appears in output.

any (alias for interface{}, added in Go 1.18) is the empty interface — every type implements it, since it requires no methods. It is the Go equivalent of TypeScript's any or JavaScript's untyped values. To recover the concrete type from an any, use a type assertion (value.(int)) or a type switch. Using any loses compile-time type safety — prefer it only at API boundaries.

A type switch (switch value.(type)) dispatches on the runtime type of an interface value — the Go equivalent of a chain of typeof/instanceof checks. Inside each case, the variable has the concrete type. For a single-type check without a switch, use a type assertion: number, ok := value.(int) — if ok is false, the value is not an int.

Go has no exceptions. Functions that can fail return an error as the last return value. Callers must check the error before using the result — if err != nil is the pervasive Go idiom. This makes all error paths explicit and visible in function signatures. Unlike JavaScript's throw, errors do not propagate automatically — if you don't check, the error is silently ignored.

fmt.Errorf() with the %w verb wraps an error — adding context while preserving the original error for inspection. errors.Is() checks whether any error in the wrap chain matches a sentinel error value. errors.As() extracts a specific error type from the chain. This is Go's equivalent of JavaScript's Error({ cause }) pattern for error chaining.

panic() is for programmer errors and invariant violations — situations that "should never happen" in correct code. It is not the normal error-handling mechanism. recover(), called inside a deferred function, can catch a panic and resume normal execution. Most Go code never uses recover() — it is mainly used in server frameworks to prevent one bad request from crashing the whole server. Normal, expected errors (file not found, invalid input) use the (value, error) return pattern instead.

The go keyword before a function call launches it as a goroutine — a lightweight thread managed by the Go runtime. Goroutines are truly concurrent (multiple CPU cores) unlike JavaScript's single-threaded event loop. A goroutine starts at ~2 KB of stack (growing as needed) and a modern program can run millions simultaneously. sync.WaitGroup coordinates completion, similar to Promise.all().

Channels provide typed conduits for communication between goroutines. make(chan int) creates an unbuffered channel — a send blocks until a receiver is ready and vice versa, synchronizing the two goroutines. make(chan int, 10) creates a buffered channel with capacity 10 — sends don't block until the buffer is full. Closing a channel signals to receivers that no more values will arrive; a for ... range loop over a channel exits when the channel is closed.

select blocks until one of its cases can proceed, then executes that case — similar to Promise.race(). If multiple cases are ready, one is chosen at random. A default case makes the select non-blocking. time.After(d) returns a channel that receives a value after duration d — the idiomatic way to implement timeouts.

Because goroutines run truly in parallel on multiple CPU cores, shared mutable state requires synchronization. Without a mutex, concurrent increments produce a data race — the final count could be anything less than 1000. sync.Mutex ensures only one goroutine modifies the value at a time. The defer counter.mutex.Unlock() pattern ensures the lock is always released even if the function panics. The sync/atomic package offers lighter-weight primitives for simple counters.

Go imports are package paths (strings). Standard library packages are short paths like "fmt" and "path/filepath". Third-party packages use module paths like "github.com/user/repo/pkg". Go requires every imported package to be used — an unused import is a compile error. The package name used in code is the last segment of the path: "path/filepath" is used as filepath.Join().

Go uses capitalization to control visibility. A name starting with an uppercase letter is exported (visible outside the package); a lowercase name is unexported (package-private). This replaces JavaScript's explicit export keyword. There is no private, protected, or public keyword — the single capitalization rule covers all cases. Fields, methods, functions, types, and constants all follow the same rule.

go.mod is Go's equivalent of package.json: it declares the module path, Go version requirement, and dependencies. go get package@version adds a dependency (like npm install). Dependencies are downloaded to a local cache (~/go/pkg/mod), not a per-project node_modules directory. The go.sum file records cryptographic hashes of every dependency — the equivalent of package-lock.json.

Every Go package can define one or more init() functions, which run automatically when the package is loaded — before main() starts. They are used for one-time setup: registering drivers, validating configuration, initializing lookup tables. Unlike JavaScript's module-level code, init() cannot be called directly and does not accept parameters or return values. Multiple init() functions in the same file run in declaration order.