Chapter 4 - Constants

Constants are an essential feature in programming, allowing developers to create values that remain unchanged throughout the execution of a program. This article explores what constants are, why they are useful, and how they can be implemented across multiple programming languages: Python, PHP, C++, Zig, and Go.

What is a Constant?

A constant is a fixed value that cannot be altered during the program's execution. Constants are typically used to represent values that are fundamental to the program, such as mathematical constants (π, e), configuration settings, or default values. By defining constants, you make your code more readable, maintainable, and less error-prone.

Why Use Constants?

Readability: Constants provide meaningful names for values, making the code easier to understand. For example, PI is more intuitive than 3.14159.
Maintainability: If a constant value needs to change, it can be updated in one place rather than throughout the code.
Error Prevention: Since constants cannot be modified, accidental changes to critical values are avoided.
Performance: Constants may allow compilers to optimize the program by knowing certain values are fixed.

Defining and Using Constants

Python

In Python, constants are typically defined using uppercase variable names. While Python does not enforce immutability for constants, it is a convention to treat such variables as constant values.

# Define constants
PI = 3.14159
GRAVITY = 9.81

# Use constants
area_of_circle = lambda radius: PI * radius ** 2
print(f"Area of circle: {area_of_circle(5)}")

While Python lacks a built-in mechanism to enforce immutability, you can use tools like typing.Final (introduced in Python 3.8) to indicate that a variable is constant.

from typing import Final

PI: Final = 3.14159
GRAVITY: Final = 9.81

PHP

PHP provides the define() function and the const keyword to declare constants.

// Using define()
define("PI", 3.14159);
define("GRAVITY", 9.81);

// Using const
const SPEED_OF_LIGHT = 299792458;

// Use constants
echo "The value of PI is: " . PI;

Constants in PHP are globally accessible and cannot be changed once defined.

C++

In C++, constants can be defined using the const keyword or constexpr for compile-time constants.

#include <iostream>

const double PI = 3.14159;
constexpr double GRAVITY = 9.81;

int main() {
    double radius = 5;
    double area = PI * radius * radius;
    std::cout << "Area of circle: " << area << std::endl;
    return 0;
}

const defines a value that cannot be modified after initialization.
constexpr guarantees the value is evaluated at compile time.

Zig

Zig emphasizes immutability by default, and constants are declared using the const keyword.

const std = @import("std");
const PI = 3.14159;
const GRAVITY = 9.81;

pub fn main() void {
    const radius = 5.0;
    const area = PI * radius * radius;
    std.debug.print("Area of circle: {f}\n", .{area});
}

Zig’s focus on safety and performance makes constants an integral part of the language.

Go

Go provides the const keyword to declare constants. Constants in Go can be of any basic type, such as numbers, strings, or booleans.

package main

import (
	"fmt"
)

const PI = 3.14159
const GRAVITY = 9.81

func main() {
	radius := 5.0
	area := PI * radius * radius
	fmt.Printf("Area of circle: %.2f\n", area)
}

Key features of constants in Go:

Constants are immutable once declared.
They are evaluated at compile time.
They can only hold values of simple types, making them highly efficient.

Best Practices for Using Constants

Naming Conventions: Use uppercase letters with underscores for readability (e.g., MAX_SPEED, DEFAULT_TIMEOUT).
Group Related Constants: Organize constants logically, such as grouping them in a class, namespace, module, or a dedicated constant block.
Documentation: Provide comments or documentation for constants to clarify their purpose.
Use Language Features: Leverage language-specific features like constexpr (C++), Final (Python), const (PHP/Zig/Go) to enforce immutability.
Avoid Magic Numbers: Replace hardcoded values with named constants to make the code self-explanatory.

When Not to Use Constants

While constants are valuable, overusing them can clutter your code. For example, using constants for values that are subject to frequent changes or are specific to a small section of code may be unnecessary. In such cases, consider using variables or configuration files.

Conclusion

Constants play a vital role in creating robust and maintainable programs. By understanding how to define and use constants effectively in Python, PHP, C++, Zig, and Go, you can write cleaner, more efficient code. Whether it’s a simple mathematical constant or a critical application setting, constants ensure your program’s values are safe, consistent, and easy to understand.

Last modified: 26 January 2025