Menos gritos en el código

La tradición de usar mayúsculas para las constantes proviene del lenguaje C, donde así se marcaban las llamadas macro constantes del preprocesador. Era útil distinguir de forma inequívoca el código para el parser del código para el preprocesador. PHP no necesita esta distinción ya que no tiene preprocesador. Por el contrario, el resaltado excesivo de las constantes es contraproducente. ¿Por qué debería una constante gritar y llamar la atención sobre sí misma, ser un elemento sobresaliente en el flujo del programa? No hay razón para ello.

Ejemplo de código real con constantes SCREAMING_SNAKE_CASE, que sobresalen agresivamente del código y también 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;
	}
}

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, por supuesto, se preocupa por la compatibilidad hacia atrás. Todas las constantes públicas siguen existiendo también en su forma original y sirven como alias para las constantes PascalCase preferidas. Existirán también en la próxima versión mayor y tendrán el indicador @deprecated.

Todas las constantes de clase recién añadidas ya están solo en la variante PascalCase. Nette no utiliza constantes globales.

Enumeraciones (Enums)

PHP 8.1 introduce los tipos enumerados, que algún día se usarán también en Nette. Anteriormente, los enums se imitaban mediante constantes. La propia documentación de PHP para los enum cases utiliza la notación PascalCase, al igual que PHP-FIG o la implementación experimental anterior SplEnum.

Las enumeraciones son básicamente azúcar sintáctico para las constantes, desde el punto de vista de PHP no hay diferencia entre un “caso de enum” y una constante de clase. Y por eso, combinar enums PascalCase y constantes SCREAMING_SNAKE_CASE parecería inconsistente, lo cual es otra razón para cambiar el estilo de escritura de las constantes.

¿Cómo cambiar su propio código?

Cada cambio cosmético siempre provoca mucha resistencia. Pero si intenta usar las constantes PascalCase durante un mes, estará encantado con ellas y no habrá vuelta atrás. Y querrá introducir la nueva notación también en su propio código. ¿Cómo hacerlo? La forma ideal es renombrar las constantes en PhpStorm usando la función Refactor > Rename. Instale también el plugin String Manipulation y asígnele en la configuración un atajo de teclado para Switch Case > To Pascal Case.

Luego bastará con colocar el cursor sobre la constante, presionar Ctrl-F6 (rename) y luego el atajo para To Pascal Case y PhpStorm cambiará la constante en todo el proyecto.

¡Feliz codificación!