Come funziona il callback in AngularJS chiama al servizio REST?

Question

Sto studiando AngularJS e REST. Un esempio di codice utilizza ripetutamente la parola callback in una funzione di autenticazione. La richiamata è una parola chiave in JavaScript o Angolare? O è callback solo una variabile personalizzata creata in questo codice? In che modo callback funziona nel codice qui sotto? Googling callback e AngularJS non producono risultati utilizzabili. The code for the AngularJS module in question can be read at this link, che contiene anche tutto il codice per l'app di esempio.

Ecco il codice del modulo stesso:

angular.module('auth', []).factory('auth', 

    function($rootScope, $http, $location) { 

     enter = function() { 
      if ($location.path() != auth.loginPath) { 
       auth.path = $location.path(); 
       if (!auth.authenticated) { 
        $location.path(auth.loginPath); 
       } 
      }     
     } 

     var auth = { 

      authenticated : false, 

      loginPath : '/login', 
      logoutPath : '/logout', 
      homePath : '/', 
      path : $location.path(), 

      authenticate : function(credentials, callback) { 

       var headers = credentials && credentials.username ? { 
        authorization : "Basic " 
          + btoa(credentials.username + ":" 
            + credentials.password) 
       } : {}; 

       $http.get('user', { 
        headers : headers 
       }).success(function(data) { 
        if (data.name) { 
         auth.authenticated = true; 
        } else { 
         auth.authenticated = false; 
        } 
        callback && callback(auth.authenticated); 
        $location.path(auth.path==auth.loginPath ? auth.homePath : auth.path); 
       }).error(function() { 
        auth.authenticated = false; 
        callback && callback(false); 
       }); 

      }, 

      clear : function() { 
       $location.path(auth.loginPath); 
       auth.authenticated = false; 
       $http.post(auth.logoutPath, {}).success(function() { 
        console.log("Logout succeeded"); 
       }).error(function(data) { 
        console.log("Logout failed"); 
       }); 
      }, 

      init : function(homePath, loginPath, logoutPath) { 

       auth.homePath = homePath; 
       auth.loginPath = loginPath; 
       auth.logoutPath = logoutPath; 

       auth.authenticate({}, function(authenticated) { 
        if (authenticated) { 
         $location.path(auth.path); 
        } 
       }) 

       // Guard route changes and switch to login page if unauthenticated 
       $rootScope.$on('$routeChangeStart', function() { 
        enter(); 
       }); 

      } 

     }; 

     return auth; 

    }); 

---

ULTERIORI INFORMAZIONI:

---

In base alla risposta di @ okonyk, sto compreso il codice da un modulo differente che chiama il funzione auth.authenticate():

$scope.login = function() { 
    auth.authenticate($scope.credentials, function(authenticated) { 
     if (authenticated) { 
      //do some stuff 
      $scope.error = false; 
     } else { 
      $scope.error = true; 
     } 
    }) 
} 

Quindi come funziona la chiamata da login() a auth.authenticate($scope.credentials, function(authenticated)? Il parametro function(authenticated) invia un valore booleano che determina la funzionalità all'interno di auth.authenticate()? Se è così, puoi essere esplicito? Posso metterlo insieme. Ad esempio, true potrebbe indicare di eseguire la richiamata, mentre false potrebbe indicare la nota per eseguire la richiamata, ma sarebbe utile farla spiegare. You can read the code in the sample app for the other module with the login() method by clicking on this link.

Answer 1

Here è abbastanza buona spiegazione:

Una funzione di callback, noto anche come una funzione di ordine superiore, è una funzione che viene passata ad un'altra funzione (chiamiamolo quest'altra funzione “otherFunction”) come parametro, e la funzione di callback è chiamata (o eseguita) all'interno dell'altraFunction. Una funzione di callback è essenzialmente un pattern (una soluzione consolidata per un problema comune) e, pertanto, l'utilizzo di una funzione di callback è anche noto come pattern di callback.

callback non è una parola chiave, il suo solo un nome del parametro che viene passato nella funzione, si può chiamare quello che vuoi (o callbackcb è abbastanza comune).

Cercherò di spiegarlo in esempio di super semplice funzione di generazione personalizzata di callback:

function useAsCallback(string){ 
    console.log("callback is being executed with passed parameter: " + string) 
} 

function main(param, callback){ 
    callback(param) 
} 

main(123456, useAsCallback) 

se si esegue questo, sarebbe stampare: callback is being executed with passed parameter: 123456

richiamata modello è comunemente utilizzato per gestire Comportamento asincrono JavaScript.

EDIT: esempio più specifico:

Parlando snippet di codice ... permette di dire si inietta la tua fabbrica in controller.

Ora avete il metodo auth.authenticate esposto. Devi passare due parametri (credentials, callback).

auth.authenticate({username: Joe, password: 123456}, function(authStatus){ 
    if(authStatus){ 
    console.log("Successfully authenticated") 
    }else{ 
    console.log("Access denied") 
    } 
}); 

abbiamo appena superato funzione anonima come parametro callback del nostro metodo auth.authenticate.

EDIT: responce a 'ULTERIORI':

Sembra che ci potrebbe essere qualche malinteso. Ti stai chiedendo:

è il parametro di funzione (autenticato) l'invio di un valore booleano che determina la funzionalità all'interno auth.authenticate()

Cosa è che, è tutto il contrario: auth.authenticate() passa il valore in funzione' (autenticato) ', che è funzione anonima. Succede a questo punto: callback && callback(auth.authenticated); - on .success o callback && callback(false); - su .error

Answer 2

scrivere Fondamentalmente qualcosa come

callback && callback(auth.authenticated); 

o

callback && callback(false); 

significa che se quel callback esiste e poi lo chiama.

semplice esempio:

function foo() { 
    console.log('foo'); 
    return 'Fighting foo!'; 
} 

foo && foo(); 

E 'solo un costrutto del linguaggio, uno strano e non una grande pratica per migliorare la leggibilità. Questo codice implica anche che il risultato della chiamata foo() dovrebbe essere valido ma questo non viene mai gestito. Vorrei usare una semplice dichiarazione if.