¡Esta es una revisión vieja del documento!


Justificación

Una “promesa” o también llamada “futuro” es un objeto que actúa como proxy en los casos en los que no se puede retornar el verdadero valor ya que aun no se conoce pero no se puede bloquear la función esperando a que llegue. Es una forma de hacer las cosas en vez de usar las funciones de callback.

Voy a volver a explicarlo pero con un ejemplo: Al hacer una llamada Ajax con $http, la llamada a $http no retorna ningún valor ya que aun no tiene dicho valor pero tampoco se puede bloquear esperando a que llegue. Pues realmente el servicio $http si que retorna un valor. Esto que retorna es una promesa y como hemos dicho la promesa es un proxy que en un futuro contendrá el valor.

Ahora que quizás entiendas la buena idea de las promesas, pasemos a la parte negativa. La promesa tendrá en un futuro el valor pero, ¿como nos enteramos que ahora la promesa ya tiene el valor? Pues usando una función de /callback. ¿Como?!!, Pero no habíamos dicho que lo bueno de las promesas es evitar las funciones de callback.

Pirámide de la muerte

Excepto en un caso que ya veremos mas adelante, realmente no podemos evitar las funciones de callback pero si que podemos evitar lo que se llama la pirámide de la muerte (en ingles Pyramid of Doom)). La pirámide de la muerte se produce cuando dentro de una función de callback hacemos otra llamada asíncrona que a su vez tiene otra función de callback y dentro de esta nueva función de callback hacemos otra llamada asíncrona, y así sucesivamente.

Podemos ver como queda la pirámide de la muerte en el siguiente ejemplo.

Obtenemos el fichero json “fichero1.json” y leemos el valor de “importe” pero dentro volvemos a obtener el fichero “fichero2.json” y obtenemos el valor del importe que sumamos al primer importe, …..y así hasta 4 veces.

    $scope.importeTotal = 0;
    $scope.mensajeFinal = "";
    
    $http({method: 'GET',url: 'fichero1.json'}).success(function(data, status, headers, config) {
      $scope.importeTotal = $scope.importeTotal + data.importe;
      $http({method: 'GET',url: 'fichero2.json'}).success(function(data, status, headers, config) {
        $scope.importeTotal = $scope.importeTotal + data.importe;
        $http({method: 'GET',url: 'fichero3.json'}).success(function(data, status, headers, config) {
          $scope.importeTotal = $scope.importeTotal + data.importe;
          $http({method: 'GET',url: 'fichero4.json'}).success(function(data, status, headers, config) {
            $scope.importeTotal = $scope.importeTotal + data.importe;
            $scope.mensajeFinal = "Ya hemos finalizado la lista de cálculos";
          });
        });
      });
    });

Hemos quitado las funciones de error para que se vea mejor el ejemplo.

Vemos como estamos añadiendo funciones dentro de funciones lo que crea que el código esté cada vez mas identado lo que crea una forma de pirámide y da nombre al problema.

El problema de esto es que el código es poco modular, cada una de las funciones de callback está dentro de la anterior, haciendo que separarlas sea complejo.

Veamos ahora el mismo ejemplo usando promesas

    $scope.importeTotalPromesas = 0;
    $scope.mensajeFinalPromesas="";
    
    $http({ method: 'GET',url: 'fichero1.json'}).then(function(resultado) {
      $scope.importeTotalPromesas = $scope.importeTotalPromesas + resultado.data.importe;
      return $http({method: 'GET',url: 'fichero2.json'})
    }).then(function(resultado) {
      $scope.importeTotalPromesas = $scope.importeTotalPromesas + resultado.data.importe;
      return $http({method: 'GET',url: 'fichero3.json'})
    }).then(function(resultado) {
      $scope.importeTotalPromesas = $scope.importeTotalPromesas + resultado.data.importe;
      return $http({method: 'GET',url: 'fichero4.json'})
    }).then(function(resultado) {
      $scope.importeTotalPromesas = $scope.importeTotalPromesas + resultado.data.importe;
      $scope.mensajeFinalPromesas = "Ya hemos finalizado la lista de cálculos con promesas";
    })

Aunque aun no hemos explicado como funcionan las promesas vemos en este ejemplo que ahora no hay 4 funciones independiente y que no están anidadas por lo que es mas sencillo separarlas en funciones independiente.

Otras ventajas

Siempre que se habla de las promesas se explican que resuelven el problema de la pirámide de la muerte pero desde mi punto de vista tienen otras ventajas que las hacen también útiles:

API Unificado

Resueltos antes de llamar al controlador

Ejemplo

Referencias

unidades/06_promesas/01_justificacion.1408106067.txt.gz · Última modificación: 2014/08/15 14:34 por admin
Ir hasta arriba
CC Attribution-Share Alike 3.0 Unported
chimeric.de = chi`s home Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0