PHP.CodeCompared.To/Go

Go is a compiled language with a main package and a main function as its entry point (the runner here adds that boilerplate for you). Output goes through the fmt package — fmt.Println writes its arguments and a trailing newline, so unlike PHP's echo you do not append \n. There is no <?php tag and no $ on variables.

Go is compiled ahead of time into a single self-contained native binary with no runtime to install — you ship one file, not a PHP interpreter plus source. The compiler is famously fast and strict: type errors, unused variables, and unused imports all stop the build. go run compiles and runs in one step for quick iteration.

Go's fmt.Printf uses the same C-style verbs PHP borrowed — %s, %d, %.2f — plus two you will use constantly: %v prints any value in a sensible default form (the everyday var_dump), and %T prints the value's static type. There is no string interpolation, so Printf or string concatenation is how you build output.

The := short declaration creates a variable and infers its type from the value — concise like PHP, but the type is then fixed permanently. There is no $ sigil. := only works inside functions and only for new names; at package level, or to declare without an initial value, you use var name string instead.

Go is statically typed: every variable has a type known at compile time, which you inspect with the %T verb rather than a runtime gettype. The defaults are int (machine word size), float64 for decimals, string, and bool. Sized variants (int32, uint8, float32) exist for when you need exact widths.

Go has no null for value types. A declared-but-unassigned variable holds its type's zero value: "" for strings, 0 for numbers, false for bools, nil for pointers, slices, and maps. This eliminates "undefined variable" surprises — a variable always has a usable, well-defined value the moment it exists.

Go never converts between types implicitly — not even int to float64. You convert with explicit T(value) syntax (float64(total)), and mixing types in an expression without it is a compile error. This is stricter than PHP's automatic juggling, and it means int / int truncates to an int just like in C.

A Go string is an immutable read-only sequence of bytes, so you cannot edit it in place as PHP lets you — you build a new string instead. Indexing yields a byte (a number), not a one-character string, so greeting[0] prints 72 unless you format it with %c. len counts bytes, which matters for multi-byte text (next).

Go strings are UTF-8 by default, and it distinguishes bytes from runes (Unicode code points). len counts bytes; utf8.RuneCountInString counts characters, the equivalent of mb_strlen. Ranging over a string with for ... range walks rune by rune, giving you the byte offset and the decoded character — no mb_ family of functions needed.

Go gathers string helpers into the strings package, so PHP's global strtoupper/str_replace/str_contains become strings.ToUpper/strings.ReplaceAll/strings.Contains. They are regular functions that take the string as the first argument (Go has no string methods). strings.Builder is the efficient way to assemble a string from many pieces.

Go's growable list is a slice — written []string{...}, with a fixed element type. You grow it with the built-in append, which returns a (possibly relocated) slice you must assign back: fruits = append(fruits, ...). Every element shares one type, so a slice cannot hold a mix of strings and ints the way a PHP array can.

Unlike C, Go has a real built-in map — but it is a separate type from a slice, with the key and value types in its declaration (map[string]int). Reading a missing key returns the value's zero value, so to distinguish "absent" from "zero" you use the comma-ok idiom value, ok := ages[key], where ok is a bool. Map iteration order is randomized on purpose.

Go's for ... range is the equivalent of foreach ($x as $k => $v), yielding the index/key and value for slices, maps, and strings. When you do not need the index you must explicitly discard it with the blank identifier _ — Go refuses to compile an unused variable, so you cannot just leave it named.

Until recently Go had no map/filter/reduce — the idiomatic way is an explicit for loop with append, which Go programmers consider clearer than chained callbacks. (Go 1.21+ adds a slices package, and generics make custom helpers possible, but the loop remains the everyday norm.) Pre-allocating with make([]int, 0, len) avoids repeated reallocation.

Go drops the parentheses around the condition but requires the braces, even for a one-line body. A distinctive feature: an if may begin with a short init statement (if x := f(); x > 0) whose variable is scoped to the if/else — perfect for the comma-ok and error-check patterns. There is no elseif keyword; you write else if.

Go's switch is much closer to PHP 8's match than to C's: each case does not fall through, so no break is needed, and a case can list several values (case 2, 3). Unlike match it is a statement, not an expression, so you assign a result inside it. A bare switch {} with boolean cases is Go's clean replacement for a long if/else if chain.

Go has a single loop keyword, for, which covers every case. The three-clause form is the classic counter; a one-clause form (for condition) is the while loop; and a bare for {} loops forever until you break. There is no separate while or do/while — one construct does it all.

Go deliberately omits the ? : ternary operator — the designers considered it a readability hazard. You write an explicit if/else, declaring the variable first with var and assigning in each branch. It is more verbose than PHP's one-liner, but it is the only way, and it keeps every conditional in the same uniform shape.

A Go function uses func, and — unlike PHP — the type comes after each parameter name, with the return type after the parameter list. When consecutive parameters share a type you write it once (a, b int). Types are mandatory; there is no dynamic fallback. A function whose name starts with a capital letter is exported from its package (see Gotchas).

Go functions can return several values natively — the signature lists the return types in parentheses, and the caller receives them as separate variables, no array packing/unpacking like PHP's [$q, $r] = .... This is not a niche feature: it is the foundation of Go's error handling, where functions return (result, error) as a pair.

Go's variadic parameter is numbers ...int (the ... follows the type), and inside the function it is an ordinary slice you range over. To pass an existing slice as the arguments you append ... after it at the call site — sum(values...) — mirroring PHP's sum(...$values) spread, just with the dots on the other side.

Go closures capture surrounding variables automatically — there is no use ($factor) clause to maintain. A function literal func(n int) int { ... } is a first-class value you assign, pass, and return. It closes over the live variable, so later changes to factor are visible inside the closure.

Go's defer schedules a call to run when the surrounding function returns, no matter how — the cleanup half of PHP's try/finally, but written right next to the resource it pairs with. Deferred calls run in last-in-first-out order, making defer file.Close() the idiomatic way to guarantee cleanup immediately after acquiring a resource.

Go has no classes; a struct is a typed bundle of fields. You create one as a plain value with a composite literal (no new keyword needed), naming fields for clarity. Note the fields are capitalized — in Go, an uppercase initial letter makes a name exported (public) and lowercase makes it package-private; there is no public/private keyword.

A method is a function with a receiver declared before its name — func (r Rectangle) Area() attaches Area to Rectangle. The receiver r is Go's explicit version of PHP's implicit $this. Methods live outside the struct body, so a type's data and its behavior are declared separately, often even in different files.

Because Go passes everything by value, a method that modifies its struct must use a pointer receiver (*Account) — a value receiver would mutate a copy and lose the change. This is the explicit machinery behind PHP's automatic object-mutation. Conveniently, Go takes the address for you when you call account.Deposit() on an addressable value.

Go has no inheritance. Instead you embed one struct in another: writing Animal with no field name inside Dog promotes Animal's fields and methods so dog.Describe() works directly. This is composition, not an is-a hierarchy — there is no overriding and no parent::, just a has-a relationship that forwards calls.

Go has no constructors and no default field values — a struct literal that omits a field gets that field's zero value. The idiom is a package-level NewX factory function that builds and returns a fully initialized value, which is where you apply defaults and validation. Calling code uses NewUser("Alice") rather than a new keyword.

Go interfaces are satisfied implicitly: any type that has the required methods is a Speaker, with no implements declaration. This structural typing decouples implementations from interfaces — you can define an interface a third-party type already satisfies. It is duck typing checked at compile time: "if it has Speak(), it speaks."

any (an alias for the empty interface interface{}) is Go's mixed — it holds a value of any type. To act on what is inside you use a type switch, switch v := value.(type), where each case binds v to the concrete type. This is the type-safe replacement for PHP's is_int/is_string ladder, recovering the static type in each branch.

Go's fmt.Stringer interface — a single String() string method — is the counterpart to PHP's __toString. Implement it and the fmt package calls it automatically wherever the value is printed. It is satisfied implicitly, like every Go interface, so you simply add the method and printing "just works".

Go has no exceptions for ordinary failures. A function that can fail returns an error as its last value, and the caller checks if err != nil right at the call site. The error is a plain value you can inspect, wrap, or pass on — there is no stack-unwinding throw. This explicit, repetitive checking is Go's defining trade-off: nothing fails silently.

A sentinel error is just a package-level value made with errors.New. To add context while preserving the original you wrap it with fmt.Errorf("...: %w", err), then test the chain with errors.Is (compare to a sentinel) or errors.As (extract a typed error). This wrapping replaces PHP's exception hierarchy and catch (SpecificType) with composable values.

Go does have panic and recover, which resemble throw/catch — but they are reserved for truly unrecoverable situations (programmer bugs, impossible states), not routine error handling. recover only works inside a deferred function. Idiomatic Go returns error values for anything a caller might reasonably handle, and panics rarely.

A goroutine is a function call prefixed with go — it runs concurrently on a lightweight, runtime-scheduled thread (you can launch hundreds of thousands). This is Go's signature feature and the opposite of PHP's strictly synchronous, per-request model. Because goroutines run independently, you need a way to coordinate them, which is what channels provide.

A channel is a typed pipe that goroutines use to communicate and synchronize: ch <- v sends, <-ch receives, and a receive blocks until a value is ready. Go's motto is "don't communicate by sharing memory; share memory by communicating" — channels let concurrent code hand off values safely instead of locking shared state. PHP has no equivalent in its core.

When you fan out work to many goroutines and just need to wait for all of them, a sync.WaitGroup is the tool: Add counts the tasks, each goroutine calls Done (via defer) when finished, and Wait blocks until the count reaches zero. It replaces the implicit "the loop finished" guarantee PHP gives you for free with concurrent, explicit coordination.

Go has no enum keyword. The idiom is a named integer type plus a const block using iota — a counter that starts at 0 and increments on each line, so you list the names and the values fill in automatically. It is more type-safe than bare constants (a Status is distinct from an int) but, like C, it carries no string name by default.

To give an iota enum a readable name, implement the String() method on the type — the same Stringer interface used for any value. Here a slice indexed by the enum maps each value to its label, and because fmt calls String() automatically, printing the enum shows "Hearts" instead of 0. PHP's backed enums bundle this name in for you; in Go you wire it up once.

Go marshals JSON to and from structs, not loose maps. json.Marshal turns a struct into bytes and json.Unmarshal fills one in (note the & — it writes through a pointer). The backtick struct tags (`json:"name"`) map struct fields to JSON keys, since exported Go fields are capitalized but JSON keys usually are not. This gives you typed, validated decoding instead of PHP's untyped associative array.

The sort package sorts in place like PHP's sort. For built-in types there are helpers (sort.Ints, sort.Strings); for anything custom, sort.Slice takes a less function that returns whether element i should come before j — a boolean, not a three-way spaceship as in usort. (Go 1.21+ adds the generic slices.Sort as a newer alternative.)

Because Go never coerces between strings and numbers, conversions are explicit calls in the strconv package: Atoi (string→int), Itoa (int→string), and ParseFloat. The parsing functions return a value and an error — there is no silent (int) cast that turns "abc" into 0; a bad input gives you an error you are expected to check.

Go treats an unused local variable or an unused import as a hard compile error, not a warning — a deliberate choice to keep code clean. This surprises everyone coming from PHP. The escape hatch is the blank identifier _, which explicitly discards a value you are required to receive (like the error from a function) but do not intend to use.

A declared-but-uninitialized map is nil. Reading from it is safe (you get the zero value), but writing to a nil map panics at runtime — there is no auto-creation as in PHP, where writing to $counts["a"] springs the array into being. Always initialize a map with make(map[...]...) or a literal before writing to it.

Go has no public/private keywords. Visibility is governed entirely by the first letter's case: a capitalized name (Size, Secret) is exported and visible to other packages, while a lowercase name (secret) is private to its own package. This applies to every identifier — types, functions, struct fields, methods — so naming is a deliberate API decision, not an afterthought.

Like C and unlike PHP, dividing two ints in Go yields an int: 7 / 2 is 3, the remainder discarded. Convert an operand to float64 for a real quotient. There is no automatic promotion to floating point and no intdiv function — the plain / already is integer division when both sides are integers.