Una pregunta sobre alcance y encapsulación.

Question

Tengo una pregunta genérica sobre el alcance y la encapsulación. Toma dos escenarios:

Escenario 1:

// a global application level constant
public static const IS_DEMO_MODE:Boolean = false;   

... // somewhere deep in the codebase

private function _myFunction():void
{
    if (IS_DEMO_MODE == true) {
      // If Demo Mode do not allow this function to complete
      return;       
    }
    else {
       // Function behaves normally
       // Code ...
    }

}

Escenario 2:

// a global application level constant
public static const IS_DEMO_MODE:Boolean = false;   

... // somewhere deep in the codebase

 // call the function and pass in the constant
_myFunction(IS_DEMO_MODE);


private function _myFunction(isDemoMode:Boolean):void
{
    if (isDemoMode == true) {
      // If Demo Mode do not allow this function to complete
      return;       
    }
    else {
       // Function behaves normally
       // Code ...
    }

}

Hablando funcionalmente, estos dos fragmentos de código hacen exactamente lo mismo. Estoy tratando de entender los puntos más finos del estilo de codificación y por qué una forma podría preferirse a la otra. Parece que el escenario 2 es mejor desde el punto de vista de la encapsulación. Pero el escenario 1 es más seguro que el booleano que está en el condicional proviene de un solo lugar, la constante global. No tiene que preocuparse por una llamada de función que, al recibir correctamente un parámetro, podría pasar el valor incorrecto. Pero el escenario 2 parece valer la pena porque elimina la dependencia de la constante y puede hacer que la función se comporte de forma más dinámica. Tiene alguna idea sobre esto? ¿Hay otras compensaciones que estoy pasando por alto?

El mismo concepto y pregunta aplicados a objetos y clases también. Pero solo presento el ejemplo en términos de una función para simplificar el ejemplo de código.

Answer 1

En el segundo enfoque, puede hacer que _myFunction viva en un módulo separado, sin dependencia del global, por lo que es más fácil de probar, reutilizar y le ayuda a controlar su gráfico de dependencia , que a menudo se convierte en un problema grave en grandes bases de código. Si inserta dependencias que podría evitar fácilmente, solo está empeorando el problema del gráfico de dependencias, y muy pocos beneficios potenciales podrían pagar por ESO.

De hecho, para obtener este tipo de ventajas, un gran patrón de dependencia es INYECTAR explícitamente un objeto que de otro modo crearía dependencias (generalmente indeseables e indeseadas) entre los módulos - vea here para empezar. Como fanático de las pruebas, el acoplamiento suelto y la reutilización, también me estoy convirtiendo gradualmente en un fanático de la inyección de dependencia, por lo que NO SOY QUE SOÑAR el acceso a una constante global en la que pasarla como un argumento es una alternativa obvia ...; ).

Answer 2

Se preferiría

2 si quisiera que la misma unidad de compilación se vinculara con ambas versiones (especialmente como una biblioteca compartida en una ruta fija global), o si ejecutó varias instancias en el mismo proceso. De lo contrario, si se encuentra en una situación en la que reconstruir todo desde la fuente no es un obstáculo, el # 1 es mejor.

Algunas cosas son realmente globales. Las constantes globales no son peligrosas en absoluto.