Variables & Types
TypeScript:
let name: string = "john";
const age: number = 25;
let active: boolean = true;
let items: string[] = ["a", "b"];
Go:
var name string = "john"
const age int = 25
active := true
items := []string{"a", "b"}
Functions
TypeScript:
function add(a: number, b: number): number {
return a + b;
}
const multiply = (a: number, b: number): number => a * b;
Go:
func add(a int, b int) int {
return a + b
}
func multiply(a, b int) int {
return a * b
}
Error Handling
TypeScript:
try {
const result = riskyFunction();
} catch (error) {
console.log(error);
}
Go:
result, err := riskyFunction()
if err != nil {
log.Println(err)
}
HTTP Requests
TypeScript:
const response = await fetch("https://api.example.com/data");
const data = await response.json();
Go:
resp, err := http.Get("https://api.example.com/data")
if err != nil {
return err
}
defer resp.Body.Close()
var data interface{}
json.NewDecoder(resp.Body).Decode(&data)
Loops
TypeScript:
for (let i = 0; i < 10; i++) {}
items.forEach((item) => console.log(item));
for (const item of items) {
}
Go:
for i := 0; i < 10; i++ {}
for _, item := range items {
fmt.Println(item)
}
for i, item := range items {
fmt.Printf("%d: %s\n", i, item)
}
Objects/Structs
TypeScript:
interface User {
name: string;
age: number;
}
const user: User = { name: "john", age: 25 };
Go:
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
user := User{Name: "john", Age: 25}
JSON
TypeScript:
const jsonStr = JSON.stringify(obj);
const obj = JSON.parse(jsonStr);
Go:
jsonBytes, _ := json.Marshal(obj)
jsonStr := string(jsonBytes)
var obj MyStruct
json.Unmarshal([]byte(jsonStr), &obj)
Conditionals
TypeScript:
if (condition) {
} else if (other) {
} else {
}
const result = condition ? "yes" : "no";
Go:
if condition {
} else if other {
} else {
}
var result string
if condition {
result = "yes"
} else {
result = "no"
}
Arrays/Slices
TypeScript:
const items = [1, 2, 3];
items.push(4);
const filtered = items.filter((x) => x > 2);
const mapped = items.map((x) => x * 2);
Go:
items := []int{1, 2, 3}
items = append(items, 4)
var filtered []int
for _, x := range items {
if x > 2 {
filtered = append(filtered, x)
}
}
String Operations
TypeScript:
const text = `Hello ${name}`;
const parts = text.split(" ");
const joined = parts.join("-");
Go:
text := fmt.Sprintf("Hello %s", name)
parts := strings.Split(text, " ")
joined := strings.Join(parts, "-")
Async/Promises → Goroutines
TypeScript:
async function fetchData() {
const result = await someAsyncFunction();
return result;
}
Promise.all([fetch1(), fetch2()]);
Go:
func fetchData() (string, error) {
return someFunction()
}
ch := make(chan string, 2)
go func() { ch <- fetch1() }()
go func() { ch <- fetch2() }()
result1, result2 := <-ch, <-ch
Key Differences to Remember
No classes → Use structs and methods
No null/undefined → Use zero values and pointers
Explicit error handling → No try/catch, check err != nil
No generics (until Go 1.18+) → Interface{} or code generation
Package system → Import paths, not node_modules
Compiled → go build creates binary
Garbage collected but more explicit about memory
Goroutines instead of async/await
