Jak działa wywołanie zwrotne w wywołaniu AngularJS do usługi REST?

Question

Studiuję AngularJS i REST. Próbka kodu wielokrotnie używa słowa callback w funkcji uwierzytelniania. Czy wywołanie zwrotne jest słowem kluczowym w języku JavaScript lub Angular? Czy jest to tylko niestandardowa zmienna utworzona w tym kodzie? Jak działa callback w poniższym kodzie? Googling callback i AngularJS nie przynoszą użytecznych rezultatów. The code for the AngularJS module in question can be read at this link, który zawiera również cały kod przykładowej aplikacji.

Oto kod moduł sam:

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; 

    }); 

---

DODATKOWE INFORMACJE:

---

oparciu o użytkownika @ okonyk odpowiedzi, jestem w tym kod z innego modułu, który wywołuje Funkcja auth.authenticate():

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

Jak działa połączenie z login() do auth.authenticate($scope.credentials, function(authenticated)? Czy parametr function(authenticated) wysyła wartość boolowską, która określa funkcjonalność wewnątrz auth.authenticate()? Jeśli tak, czy możesz wyrazić się jasno? Mogę to połączyć. Na przykład prawda może wskazywać na wywołanie zwrotne, podczas gdy wartość false może wskazywać notatkę, aby wykonać wywołanie zwrotne, ale pomoże to wyjaśnić. 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 jest dość dobre wyjaśnienie:

Funkcja zwrotna, znany również jako funkcja wyższego rzędu, to funkcja, która jest przekazywana do innej funkcji (nazwijmy tę drugą funkcję „otherFunction”) jako parametr, a funkcja wywołania zwrotnego jest wywoływana (lub wykonywana) wewnątrz innej funkcji. Funkcja wywołania zwrotnego jest zasadniczo wzorcem (ustalonym rozwiązaniem wspólnego problemu), a zatem użycie funkcji wywołania zwrotnego jest również znane jako wzorzec wywołania zwrotnego.

callback nie jest słowem kluczowym, to tylko nazwa parametru, który jest przekazywany do funkcji, można nazwać to, co chcesz (callback lub cb jest dość powszechne).

Postaram się to wyjaśnić na przykładzie bardzo uproszczonym funkcji zwyczaj budowania callback:

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

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

main(123456, useAsCallback) 

jeśli uruchomić to, byłoby wydrukować: callback is being executed with passed parameter: 123456

oddzwaniania wzór jest powszechnie używany do obsługi Zachowanie asynchroniczne JavaScript.

EDIT: bardziej konkretny przykład:

Mówiąc o fragmencie kodu ... powiedzmy będziesz wprowadzić swoją fabrykę w kontrolerze.

Teraz masz odkrytą metodę auth.authenticate. Musisz podać dwa parametry: (credentials, callback).

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

Właśnie przeszedł funkcję anonimową jako parametr naszego auth.authenticate metody callback.

EDIT: responce do 'Dodatkowe informacje':

Wygląda na to, że może być jakieś nieporozumienie. Pytasz:

Czy funkcja (uwierzytelnione) parametr wysyłania wartość logiczną, która określa funkcjonalność wewnątrz auth.authenticate()

rzeczą jest to, że jest całkowitym przeciwieństwem: auth.authenticate() przechodzi wartość do funkcji” (uwierzytelniony) ", który jest funkcją anonimową. Zdarza się w tym momencie: callback && callback(auth.authenticated); - na .success lub callback && callback(false); - na .error

Answer 2

zasadzie pisząc coś

callback && callback(auth.authenticated); 

lub

callback && callback(false); 

oznacza, że ​​jeśli callback istnieje i wtedy nazywa.

prosty przykład:

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

foo && foo(); 

To jest tylko konstruktem język, dziwne i nie jedna wielka praktyka dla czytelności. Ten kod oznacza również, że wynik wywołania foo() powinien być prawidłowy, ale nigdy nie jest obsługiwany. Użyłbym prostej instrukcji if.