Solutions to minimize strings and numbers in the code base

I'm obsessed by removing as much strings and numbers from the code as possible. It comes from the fear that they are magic, I don't want my code to trick me.
There are five solutions I can think of.

The first is moving the strings and numbers to a variable. This relieves the code from the responsibility to have the correct value.

The second solution is an environment variable. The code is still not responsible for the correct value, but it more specialized than a variable because the value is bound to the OS the application is running on.

For the other solutions the code is responsible for the correct value.

Global constant

const USER_TABLE = 'users';`

Global constants go against the object-oriented practices. But if you think about it environment variables are also a form of global constants, and they are used without any hesitation.

One of the reasons global constants are considered bad is because there is a perception it is hard to group them. I think namespacing is as beneficial for classes as for constants to do the grouping.

The main problem is that, like with functions, there is no mechanism to autoload files that contain constants. So you need to provide one yourself.

function loadConstants(string $path) {
  foreach (glob("$path/*.php") as $file) {
    require_once "$path/$file";
  }
}

Class constant

class Table 
{
   const USER = 'users'
}

Using a class constant is the more accepted solution when doing object-oriented programming.

An object-oriented purist will have a problem with having only constants in a class. Because a class should have state, mutable properties, and/or behaviours, methods.

Enum

enum Table : string
{
  case USER = 'users';
}

This is the object-oriented dream solution. An enum is a specialized class that is meant to contain constant like items. There are two types of enums, basic and backed. The biggest difference is that a backed enum item has a value and a basic enum doesn't.

I choose a backed enum for the example because the syntax is closest to the global constant and class constant syntax.
It does require more code to get the value.

echo TABLE_USER; // global constant
echo Table::USER; // class constant
echo Table::USER->value(); // enum

The benefit of a backed enum are the from and tryFrom methods. These are useful when the value comes from a variable.

var_dump(Table::from('users')); // creates Table::USER instance

The biggest drawback of a backed enum is that the value can only be a string or an integer.
To allow more types you need a basic enum with a method to return the value with the correct type.

enum Table
{
  case USER;

  public method get(): TableName
  {
    return match($this) {
      Table::USER => new TableName('users'),
    };
  }
}

This is a lot more code than for the other constants. But because the item definition is separated from the value, this opens more possibilities. And one of them is to return different value types for the same definition.

enum Table
{
  private const USERS = 'users'

  case USER;

  public method getTableName(): TableName
  {
    return match($this) {
      Table::USER => new TableName(Table::USERS),
    };
  }

  public method getString(): string
  {
    return match($this) {
      Table::USER => Table::USERS,
    };
  }
}

In this example you see how you can use a class constant in an enum to reduce the use of a string.

Conclusion

Check if it is possible to move the a string or a number out of the code. And if that is not possible use one of the constant types that fits best for your application.