Para menos gritos en el código

La tradición de usar mayúsculas para las constantes proviene del lenguaje C, donde las llamadas macro constantes del preprocesador se denotaban como tales. Era útil no pasar por alto la distinción entre código del analizador sintáctico y código del preprocesador. PHP no necesita esta distinción ya que no tiene preprocesador. Por otro lado, enfatizar demasiado las constantes es contraproducente. ¿Por qué debería una constante gritar y llamar la atención sobre sí misma, ser un elemento prominente en el flujo del programa? No hay ninguna razón para ello.

Ejemplo de código real con constantes SCREAMING_SNAKE_CASE que destacan agresivamente en el código y además son más difíciles de leer:

foreach (self::SYMBOL_TO_NAME as $symbol => $name) {
	$idx = self::ACTION_BASE[$state] + $symbol;
	if (($idx >= 0 && $idx < count(self::ACTION) && self::ACTION_CHECK[$idx] === $symbol
			|| $state < self::YY_2_TBLSTATE
			&& ($idx = self::ACTION_BASE[$state + self::NUM_NON_LEAF_STATES] + $symbol) >= 0
			&& $idx < count(self::ACTION) && self::ACTION_CHECK[$idx] === $symbol)
		&& self::ACTION[$idx] !== self::UNEXPECTED_TOKEN_RULE
		&& self::ACTION[$idx] !== self::DEFAULT_ACTION
		&& $symbol === 0
	) {
		return true;
	}
}

Un ejemplo del mismo código con constantes PascalCase, que parece mucho más compacto:

foreach (self::SymbolToName as $symbol => $name) {
	$idx = self::ActionBase[$state] + $symbol;
	if (($idx >= 0 && $idx < count(self::Action) && self::ActionCheck[$idx] === $symbol
			|| $state < self::Yy2Tblstate
			&& ($idx = self::ActionBase[$state + self::NumNonLeafStates] + $symbol) >= 0
			&& $idx < count(self::Action) && self::ActionCheck[$idx] === $symbol)
		&& self::Action[$idx] !== self::UnexpectedTokenRule
		&& self::Action[$idx] !== self::DefaultAction
		&& $symbol === 0
	) {
		return true;
	}
}

Compatibilidad

Nette es, por supuesto, cuidadoso con la compatibilidad hacia atrás. Todas las constantes públicas permanecen en su forma original y sirven como alias para las constantes PascalCase preferidas. Seguirán existiendo en la próxima versión principal y tendrán la bandera @deprecated.

Todas las constantes de clase añadidas recientemente están ahora sólo en la variante PascalCase. Las constantes globales no son utilizadas por Nette.

Enumeraciones

PHP 8.1 viene con enumeraciones, que serán usadas en Nette también. Las enumeraciones reemplazarán la solución anterior que usaba constantes. Aún no existe un estándar de codificación sobre cómo escribir enumeraciones, la organización PHP-FIG ha fallado por mucho tiempo en este aspecto y presenta recomendaciones con muchos años de retraso. La propia documentación de PHP es una guía. Para “enum cases”, usa exclusivamente la notación PascalCase, y esto también se aplica a la anterior implementación experimental SplEnum.

Combinar enumeraciones PascalCase con constantes SCREAMING_SNAKE_CASE se vería inconsistente, así que esta es también una razón para cambiar el estilo de escribir constantes.

*Nota técnica: las enumeraciones son azúcar sintáctico para las constantes, desde el punto de vista de PHP no hay diferencia entre “enum case” y constante de clase.

¿Cómo cambiar el código propio?

Cualquier cambio cosmético siempre causará mucho resentimiento. Pero si pruebas a usar las constantes PascalCase durante un mes, estarás encantado con ellas y no habrá vuelta atrás. Y también querrá introducir la nueva notación en su propio código. ¿Cómo hacerlo? Lo ideal es renombrar las constantes en PhpStorm utilizando la función Refactor > Rename. Además, instala el plugin String Manipulation y asígnale un acceso directo en la configuración de Switch Case > To Pascal Case.

Entonces todo lo que tienes que hacer es colocar el cursor sobre la constante, pulsar Ctrl-F6 (renombrar) y luego el acceso directo para To Pascal Case y PhpStorm cambiará la constante en todo el proyecto.

¡Feliz codificación!