Are Method Names Capitalized In Golang

Go Programming

As a programmer who has recently delved into Golang, I’ve come across the question of whether method names are capitalized. It’s an important aspect of the language’s syntax, and understanding it can make a big difference in the readability and maintainability of your code.

Method Names in Golang

Unlike some other programming languages, Golang has a unique convention for method names. In Golang, method names are capitalized if they are intended to be exported from a package. This means that if you want a method to be accessible from outside of the package where it is defined, you should capitalize its name.

For example, let’s say we have a type called Person and we want to have a method called GetAge that returns the person’s age. To make this method accessible from another package, we would capitalize the method name like this:

func (p *Person) GetAge() int {
    return p.age

On the other hand, if we have a method that is only intended to be used within the package where it is defined, we would not capitalize the method name. This is known as an unexported method.

Here’s an example of an unexported method:

func (p *Person) calculateBirthYear() int {
    return currentYear - p.age

Personal Insights

Understanding these conventions took some getting used to, especially coming from other languages where the convention might be different. However, I’ve come to appreciate this approach as it makes it very clear which methods are meant to be part of the public API of a package and which ones are internal implementation details.

It’s also worth noting that while Golang enforces this convention, it doesn’t restrict you from using unexported methods across different files within the same package. This can be a powerful way to organize your code and keep the public API clean and focused.


In conclusion, Golang’s approach to method names is unique and serves a clear purpose in distinguishing between exported and unexported methods. By adhering to this convention, you can enhance the clarity and usability of your code, making it easier for both yourself and others to understand and maintain.