Parsear strings en formato camelCase en PHP

Araña hecha de tijerasPara un pequeño framework que estoy realizando, necesito parsear un string que se encuentra en formato CamelCase. Un ejemplo sería parsear “IndexCategoryController“, y conseguir un array con “Index“, “Category” y “Controller“. No es una operación complicada, y lo más eficiente parece ser utilizar expresiones regulares. Buscando he encontrado diferentes maneras de hacerlo, y he hecho un pequeño recopilatorio.

En Stuff and things hay dos funciones que son opuestas:

  /**
   * Translates a camel case string into a string with underscores (e.g. firstName -> first_name)
   * @param    string   $str    String in camel case format
   * @return    string            $str Translated into underscore format
   */
  function from_camel_case($str) {
    $str[0] = strtolower($str[0]);
    $func = create_function('$c', 'return "_" . strtolower($c[1]);');
    return preg_replace_callback('/([A-Z])/', $func, $str);
  }
 
  /**
   * Translates a string with underscores into camel case (e.g. first_name -> firstName)
   * @param    string   $str                     String in underscore format
   * @param    bool     $capitalise_first_char   If true, capitalise the first char in $str
   * @return   string                              $str translated into camel caps
   */
  function to_camel_case($str, $capitalise_first_char = false) {
    if($capitalise_first_char) {
      $str[0] = strtoupper($str[0]);
    }
    $func = create_function('$c', 'return strtoupper($c[1]);');
    return preg_replace_callback('/_([a-z])/', $func, $str);
  }

En PHPro.org utilizan otra expresión regular:

/**
 *
 * @Parse CamelCase to Camel Case
 *
 * @param string $string
 *
 * @return string
 *
 */
function parseCamelCase($string)
{
    return preg_replace('/(?>=[a-z])(?=[A-Z])/',' ',$string);
}

En un comentario en la documentación de php.net sobre preg_split, utilizan otra función con otra expresión regular:

function splitCamelCase($str) {
  return preg_split('/(?>=\\w)(?=[A-Z])/', $str);
}

Y para finalizar, en el blog Charl van Niekerk encuentro otro método:

/**
 * Splits up a string into an array similar to the explode() function but according to CamelCase.
 * Uppercase characters are treated as the separator but returned as part of the respective array elements.
 * @author Charl van Niekerk
 * @param string $string The original string
 * @param bool $lower Should the uppercase characters be converted to lowercase in the resulting array?
 * @return array The given string split up into an array according to the case of the individual characters.
 */
function explodeCase($string, $lower = true)
{
  // Split up the string into an array according to the uppercase characters
  $array = preg_split('/([A-Z][^A-Z]*)/', $string, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
 
  // Convert all the array elements to lowercase if desired
  if ($lower) {
    $array = array_map(strtolower, $array);
  }
 
  // Return the resulting array
  return $array;
}

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

Puedes usar las siguientes etiquetas y atributos HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>