Work with variables as if they were objects

This article is a personal opinion and I am not trying to speak out about anything.

One of the things I like most about languages ​​like Ruby or JavaScript is that their variables are objects, I find the code much more readable in some aspects, other times not so much.

An example would be.

# Ruby Program for length method.
str = "Hello, world!"
puts str.length # prints 13 to the console

While in PHP it is

$str = 'Hello, world!';
echo strlen($str);

That said, from my point of view the Ruby or JavaScript form is more readable because it would be the variable that is the subject and the method would be the predicate.

PHP does not support this way of writing code and that is why I have created a class that allows it to be done, but the purpose of the class is only for playing, it is not intended for use in production as it may have performance problems.

<?php namespace Scalar;

use Exception;
use ReflectionFunction;

class Scalar {

  /**
   * @var mixed
   * Value that can only be scalar.
   */
  private $Scalar;

  /**
   * Constructor: Initializes the Scalar object.
   * @param mixed $Scalar
   * @throws Exception if the value is not scalar.
   */
  public function __construct($Scalar) {
    if (!is_scalar($Scalar)) {
      throw new Exception('It\'s not a scalar value');
    }
    $this->Scalar = $Scalar;
  }

  /**
   * Magic method: Dynamically calls a PHP function with the scalar value.
   * Supports named parameters if provided as an associative array.
   * @param string $method The name of the function to call.
   * @param array $arguments Additional arguments for the function.
   * @return mixed The result of the function call.
   * @throws Exception if the function does not exist.
   */
  public function __call($method, $arguments) {
    if (!function_exists($method)) {
      throw new Exception('The function called ' . $method . ' doesn\'t exist');
    }

    // Verificar si los argumentos son asociativos (named parameters)
    if (!empty($arguments) && array_keys($arguments) !== range(0, count($arguments) - 1)) {
      $refFunc = new ReflectionFunction($method);
      $params = $refFunc->getParameters();

      $mappedArgs = [];
      foreach ($params as $param) {
        $name = $param->getName();
        if (isset($arguments[$name])) {
          // Asignar el valor proporcionado
          $mappedArgs[] = $arguments[$name];
        } elseif ($name === 'data') {
          // Insertar $this->Scalar si el parámetro es 'data'
          $mappedArgs[] = $this->Scalar;
        } elseif ($param->isDefaultValueAvailable()) {
          // Usar el valor predeterminado si está disponible
          $mappedArgs[] = $param->getDefaultValue();
        } else {
          // Parámetro requerido sin valor proporcionado
          throw new Exception("Missing required parameter: $name for function $method");
        }
      }

      return $refFunc->invokeArgs($mappedArgs);
    } else {
      // Llamada con argumentos posicionales (por defecto, insertar scalar al inicio)
      array_unshift($arguments, $this->Scalar);
      return call_user_func_array($method, $arguments);
    }
  }

  /**
   * Get the scalar value.
   * @return mixed
   */
  public function getScalar() {
    return $this->Scalar;
  }
}

It is also important to keep in mind that for it to work well it is necessary to use the functionality of writing the variables with their name in front

<?PHP $data = new CustomerData(
    name: $input['name'],
    email: $input['email'],
    age: $input['age'],
);

An example of using the class with a single parameter function and a function with multiple parameters:

<?PHP try {
    $a = 'hola mundo';
    $a_object = new Scalar($a);

    // Llamar a la función hash con named parameters
    $result = $a_object->hash(algo: 'sha256', binary: true);
    echo $result; // Hash binario de 'hola mundo'

    // Llamar a otras funciones
    echo $a_object->strlen(); // Devuelve 10 (longitud de 'hola mundo')
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

The above is the detailed content of Work with variables as if they were objects. For more information, please follow other related articles on the PHP Chinese website!