Understanding Go Interfaces vs TypeScript Interfaces: A Comparison

For developers working with both Go and TypeScript, understanding the differences between their interface implementations is crucial. While they share the same name and serve similar purposes, their behaviors and use cases differ significantly. Let’s explore these differences and learn when to use each.

The Basics of Interfaces

Interfaces provide a way to define contracts that types must fulfill. However, Go and TypeScript take different approaches to how these contracts are implemented.

Go Interfaces

Go interfaces are implemented implicitly. If a type has all the methods that an interface specifies, it automatically implements that interface. This is known as structural typing.

type Writer interface {
    Write([]byte) (int, error)
}

type FileWriter struct {}

// FileWriter implicitly implements Writer
func (f FileWriter) Write(data []byte) (int, error) {
    return len(data), nil
}

TypeScript Interfaces

TypeScript interfaces require explicit implementation using the implements keyword. This is known as nominal typing.

interface Writer {
    write(data: Uint8Array): number;
}

class FileWriter implements Writer {
    write(data: Uint8Array): number {
        return data.length;
    }
}

Key Differences

1. Implementation Approach

The most significant difference lies in how types implement interfaces:

Go’s Implicit Implementation

type Greeter interface {
    Greet() string
}

type Person struct {
    Name string
}

// Person automatically implements Greeter
func (p Person) Greet() string {
    return "Hello, " + p.Name
}

TypeScript’s Explicit Implementation

interface Greeter {
    greet(): string;
}

class Person implements Greeter {
    constructor(private name: string) {}
    
    greet(): string {
        return `Hello, ${this.name}`;
    }
}

2. Interface Composition

Both languages support interface composition, but with different syntaxes:

Go Interface Composition

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

TypeScript Interface Composition

interface Reader {
    read(data: Uint8Array): number;
}

interface Writer {
    write(data: Uint8Array): number;
}

interface ReadWriter extends Reader, Writer {}

3. Type Checking

Go’s type checking is done at runtime, while TypeScript’s is done at compile time:

Go Runtime Type Checking

func ProcessWriter(w interface{}) {
    writer, ok := w.(Writer)
    if !ok {
        fmt.Println("Not a writer")
        return
    }
    // Use writer
}

TypeScript Compile-Time Type Checking

function processWriter(w: Writer) {
    // TypeScript checks at compile time
    w.write(new Uint8Array([1, 2, 3]));
}

When to Use Each Approach

Use Go Interfaces When:

1. You need flexible, decoupled code that focuses on behavior rather than type hierarchies
2. You want to define interfaces based on what types can do rather than what they are
3. You’re working with small, focused interfaces (following the interface segregation principle)

Use TypeScript Interfaces When:

1. You need strict type checking at compile time
2. You want explicit contracts between classes and their behaviors
3. You’re working with object-oriented patterns that benefit from nominal typing

Best Practices

Go Interface Best Practices

1. Keep interfaces small (the single responsibility principle)
2. Define interfaces close to where they’re used
3. Accept interfaces, return concrete types

type DataProcessor interface {
    Process(data []byte) error
}

func NewFileProcessor() *FileProcessor {
    return &FileProcessor{}
}

func UseProcessor(p DataProcessor) error {
    return p.Process([]byte("data"))
}

TypeScript Interface Best Practices

1. Use interfaces for object shapes and contracts
2. Leverage TypeScript’s strong type system
3. Combine interfaces with generics for flexible, type-safe code

interface Repository<T> {
    find(id: string): Promise<T>;
    save(item: T): Promise<void>;
}

class UserRepository implements Repository<User> {
    async find(id: string): Promise<User> {
        // Implementation
    }
    
    async save(user: User): Promise<void> {
        // Implementation
    }
}

Common Pitfalls to Avoid

Go Pitfalls

1. Creating large interfaces that are difficult to implement
2. Not leveraging interface composition
3. Using interfaces when concrete types would be more appropriate

TypeScript Pitfalls

1. Over-engineering with too many interface hierarchies
2. Not taking advantage of TypeScript’s structural typing when appropriate
3. Creating unnecessary interfaces for simple object shapes

Conclusion

Understanding the differences between Go and TypeScript interfaces helps you make better architectural decisions in your projects. Go’s implicit interfaces promote loose coupling and focus on behavior, while TypeScript’s explicit interfaces provide strong type checking and clear contracts.

While both approaches have their merits, the choice between them often depends on your project’s requirements, team preferences, and the specific problems you’re trying to solve. By understanding these differences, you can leverage the strengths of each language’s interface system effectively.

whoami

Stefan

Stefan founded Ceos3c in 2016 and has spent a decade teaching cybersecurity, Linux, and web development through hands-on tutorials. He builds and ships real products while sharing his journey: ProofSwap.me, XPMetric.com, and EasyEarningsTracker.com. Find him on YouTube (youtube.com/stefanrows) and X (@StefanRows).

• ProofSwap Testimonial swaps for indie makers
• xpmetric Cookieless web analytics
• EasyEarningsTracker Income tracking for creators