How to pass an array of setting values across multiple classes, efficiently - php

Question

I have a settings array of config values that don't change and need to use these values in various classes.
$settings = ['foo' => 'bar', 'license_id' => '12345'];
Currently, I am using a static class and anytime I need a config value inside a class I do this:
$this->global_config = MyClass::get_global_config_array();
if ( $this->global_config['license_id'] ) do this . . .
Is there another way than using a global, dependency injection, or a singleton class? I make a lot of calls to MyClass::get_global_config_array() and was looking for a way to be more efficient.
FYI: I am new to OOP, but not procedural.
class Settings() {
public static function global_config_array() {
$settings = ['foo' => 'bar', 'license_id' => '12345'];
return $settings;
}
}
class Render_Setup_Page() {
public function __construct() {
$this->global_settings = Settings::global_config_array();
}
public function check_license() {
if ( $this->global_settings['license_id'] ) do this . . .
}
}
class Render_Profile_page() {
public function __construct() {
$this->global_settings = Settings::global_config_array();
}
public function user_info() {
ret 'first name: ' . $this->global_settings['foo'] );
}
}
UPDATE:
To add more content to this request. I am building a WordPress plugin that has plugin settings that are divided into three types: static, dynamic, and the theme customizer.
I merge the three into a global settings array and pass the array around to several functions. Having them in a single array it eliminates a lot of calls for data. Especially in a theme template.
Based on the suggestion from #miken32 to use trait, I have come up with the following example:
trait Global_Settings {
private array $static = [
"foo" => "bar",
"license_id" => "12345"
];
private array $dynamic = [
'plugin_build' => '73686572726965206',
'plugin_version' => '1.0.0',
'plugin_prefix' => 'xyx',
];
private array $customizer = [
'plugin_123' => 'hello',
'plugin_456' => 'there',
];
private function get_static_settings() {
return $this->static;
}
private function get_dynamic_settings() {
return $this->dynamic;
}
private function get_customizer_settings() {
return $this->customizer;
}
private function global_settings() {
return array_merge(
$this->static,
$this->dynamic,
$this->customizer,
);
}
}
class Do_Something {
use Global_Settings;
public function render_something() {
error_log( print_r($this->get_dynamic_settings(), TRUE) );
error_log( print_r($this->get_static_settings(), TRUE) );
error_log( print_r($this->get_customizer_settings(), TRUE) );
error_log( print_r($this->global_settings(), TRUE) );
// Get a specific settings array.
$output = 'Your' . $this->get_dynamic_settings['foo'] . ' license is: ' . $this->get_dynamic_settings['license_id'];
// Or get all of them at once.
extract( $this->global_settings );
$output = $plugin_123 . ' your' . $foo . ' license is: ' . $license_id . ' for version ' . $plugin_version;
return $output;
}
}
$obj = new Do_Something();
$obj->render_something();
My follow up question is how to assign the results from another class that has a settings array to the $static property in the trait Global_Settings?
class Static_Array {
public array() {
return [
"foo" => "bar",
"license_id" => "12345"
];
}
}

Answer 1

If these values really are fixed, you could have the classes import a trait that holds the settings and also incorporates any common functionality you need.
trait HasSettings
{
private array $settings = ["foo" => "bar", "license_id" => "12345"];
private function hasLicense(): bool
{
return !empty($this->settings["license_id"]);
}
private function getFoo(): string
{
return $this->settings["foo"] ?? "";
}
}
class Render_Setup_Page
{
use HasSettings;
public function __construct()
{
// do stuff
}
public function check_license()
{
if ( $this->hasLicense()) {
// do stuff
}
}
}
class Render_Profile_page
{
use HasSettings;
public function __construct()
{
// do stuff
}
public function user_info()
{
// don't ever echo from a class method
return 'first name: ' . $this->getFoo();
}
}
Providing methods to access these values is a good idea, but you also have access to the private array via $this->settings.