retourner un booléen après la promesse a été résolu/rejeté?

J'ai une fonction qui fonctionne tout à fait bien. Je veux juste retourner true ou false selon la promesse.

 //I want this function to return a simple true or false!!!
function isAppOnline() {
            var is_connected = connectivityMonitor.isInternetConnected();
            is_connected.then(function(result) {
                console.log('INTERNET_CHECK_API : app online');//works fine
                return true;//this is not being returned
            }, function(error) {
                console.log('INTERNET_CHECK_API : app offline');//works fine
                return false;//this is not being returned
            });
        }

Mais lorsque j'appelle cette fonction,

is_online = isAppOnline();

is_online est toujours undefined . Pourquoi la fonction n'est pas en mesure de retourner une valeur booléenne simple?

Mise à jour :

C'est ce que je suis en train de faire :
Je veux simplement ouvrir une popup qui indique à l'utilisateur qu'il est en mode hors connexion. Je suis l'appel de la fonction isAppOnline périodiquement après 10secs. Cette fonction est déjà à l'aide d'une promesse dans mes usines . Je ne veux pas compliquer les choses, mais c'est important pour moi que cette fonction renvoie un booléen, donc, sur cette base,je peux prendre mes mesures en conséquence.

Basé sur votre montage, vous pourriez bande de cette même fenêtre, logique dans son propre contrôleur, probablement une bonne idée de toute façon. Ce contrôleur peut s'asseoir avec d'autres contenus statiques entre les pages, est votre nav dans son propre contrôleur, il pourrait vivre à un niveau similaire dans l'application? ensuite, vous n'aurez qu'à utiliser la même promesse, dans un seul endroit, et en plus c'est plus modulaire. Seule une cause de préoccupation. Il est plus vérifiable. vous pouvez même le mettre dans une directive et il suffit de coller dans votre point de vue où vous le souhaitez.
ce code est pour tous les contrôleurs. 🙂

OriginalL'auteur HIRA THAKUR | 2015-10-20

6

EDIT: Pour ES2017
Si votre eu de la chance d'âmes, qui se met à utiliser ES2017 ensuite, vous pouvez utiliser la nouvelle attendent/async mots-clés. Ils sont assez brillants et vous permettent d'écrire du code asynchrone qui lit synchrone. (Il est encore des promesses sous le capot, juste unboxing).
```
function isOnline() {
    return Promise.resolve(true);
}

async function Main() {
    const online = await isOnline();

  console.log(online);
}

Main();
```
fidle

Parce qu'il est asynchrone. Votre isAppOnline méthode retourne avant votre promesse est résolu.

Je présume est de faire une certaine forme de l'appel AJAX pour vérifier la connectivité réseau donc il faudra attendre pour elle de répondre. JavaScript est mono-thread, si ce thread verrouillé en place d'attente pour la demande afin de répondre, de sorte qu'il pourrait être synchrone de l'ensemble de votre JavaScript met en pause jusqu'à ce qu'elle retourne. Pas bonne.

Donc, si vous voulez l'appelant de isAppOnline de connaître le résultat que vous avez des options. Soit en passant un appel de retour ou le retour à la promesse (meilleure option)
```
function isAppOnline(cb) {
    var is_connected = connectivityMonitor.isInternetConnected();
    is_connected.then(function(result) {
        console.log('INTERNET_CHECK_API : app online');//works fine
        cb(true);
    }, function(error) {
        console.log('INTERNET_CHECK_API : app offline');//works fine
        cb(false);
    });
}

//better option
function isAppOnline() {
    return connectivityMonitor.isInternetConnected().then(function(result) {
        console.log('INTERNET_CHECK_API : app online');//works fine
        return true;
    }, function(error) {
        console.log('INTERNET_CHECK_API : app offline');//works fine
        return false;
    });
}

//used as
isAppOnline().then(function (isOnline) {
    console.log('Is it online?', isOnline);
});
```
Impossible de lire la propriété", puis " undefined
Oh, qui, à la seconde? Je dois ajouter, sans voir le reste de votre code spécifique de cette mise en œuvre n'a pas été testé. Toutefois, le principe fonctionne très bien, j'ai utilisé cette méthode personnellement dans presque tous angulaire application ive a travaillé sur. Le retour promet de méthodes qui utilisent des .then() est parfaitement à la chaîne de mesure.
yup,le second. eh bien, je cherchais quelque chose de plus simple . Je savais que je pouvais ajouter une promesse, mais ensuite c'est la raison pourquoi j'ai posé la question. Promesse après promesse après promesse .. n'est pas là quelque chose de plus simple. De toute façon thx.
Jain Note le retour ajoutés avant is_connected
Réponse d'édition. JayeshJain. Si vous avez d'avoir à faire la promesse après promesse dans imbriqués promesse chaînes, qui ont inceptually enchaînés à partir des promesses qui n'ont pas encore été créé, vous devrez peut-être reconsidérer votre structure de l'application.

OriginalL'auteur ste2425

Promesse fonctionne différemment avec de simples énoncés, parce qu'ils pourraient revenir plus tard, de sorte que vous pourriez avoir besoin de repenser le déroulement de votre programme afin de gérer les différents états initial et final.

function isAppOnline() {
    var is_connected = connectivityMonitor.isInternetConnected();
    return is_connected.then(function(result) { //add return here to return the whole promise
        console.log('INTERNET_CHECK_API : app online');//works fine
        return; //this will resolve the promise returned
    }, function(error) {
        console.log('INTERNET_CHECK_API : app offline');//works fine
        $q.reject(); //this will reject the promise returned
    });
}

Que vous devrez gérer changer d'état à votre appel contrôleur (peut-être fausse pour un court moment, puis se tourna vers le vrai, etc). Vous pourriez envisager d'utiliser un temps de chargement de l'état pour prévenir les aiguillant les utilisateurs.

is_online = false;
isLoading = true;

isAppOnline().then(function() {
    is_online = true;
}, function() {
    is_online = false;
})
.finally(function(){
    isLoading = false;
});

OriginalL'auteur Icycool

0

Votre question indique un profond besoin pour la poursuite de l'exploration de Javascript asynchrone de traitement. Je vous recommande la lecture: Comment puis-je retourner la réponse d'un appel asynchrone?

Il existe des astuces que vous pouvez mettre en œuvre pour forcer une méthode pour revenir en mode synchrone, mais angulaire est construit d'une manière qui honore les promesses presque partout. Si vous pouviez nous donner un peu plus de contexte sur ce que vous essayez d'accomplir, nous pouvons être en mesure pour vous aider à écrire votre code dans une manière qui profite de la promesse elle-même.

bien sûr... je vais ajouter quelques points de plus qui explique ce que je suis en train de réaliser.

OriginalL'auteur David Boskovic
-1

Vous pouvez essayer la chose suivante (code non testé, puisque vous n'avez pas à fournir un travail de script):
```
function isAppOnline() {
    var defer = $q.defer();

    var is_connected = connectivityMonitor.isInternetConnected();
    is_connected.then(function(result) {
        console.log('INTERNET_CHECK_API : app online');//works fine
        defer.resolve(true);
    }, function(error) {
        console.log('INTERNET_CHECK_API : app offline');//works fine
        defer.resolve(false);
    });

    return defer.promise;
}
```
Et de l'appeler comme ceci:
```
var is_online = false;
isAppOnline().then(function(data){
    is_online = data;
});
```
Ou, passer le is_connected objet directement, que de vous faire une meilleure gestion des erreurs:
```
function isAppOnline() {
    var defer = $q.defer();

    var is_connected = connectivityMonitor.isInternetConnected();
    is_connected.then(function(result) {
        console.log('INTERNET_CHECK_API : app online');//works fine
        defer.resolve(is_connected);
    }, function(error) {
        console.log('INTERNET_CHECK_API : app offline');//works fine
        defer.reject();
    });

    return defer.promise;
}
```
Veuillez vous référer à ma réponse ou ste2425 sur le retour d'une promesse plutôt que de créer un nouveau reporté.
Bien que la façon dont il est prêt pour un plus complexe objet de retour, dans le cas où vous voulez faire quelque chose comme ceci: var result = { isConnected: is_connected, ...}. Dans mon expérience, il est préférable de le faire de cette façon parce que votre application se développe, vous avez souvent besoin de le faire de toute façon, à un certain point, afin de mieux au début.
Nope. Le cas où vous avez vraiment besoin de créer un différé est lorsque le cœur de la fonction ne retourne pas une promesse, comme $timeout. En fait, la création d'un reportés lorsqu'une promesse peut être renvoyé est défini comme l'un des promesse-antipatterns.
Alors, comment vous résoudre ajoutant à une promesse de résultat (juste par curiosité)?
Ok, merci pour l'information.

OriginalL'auteur Spikee

Vous devez vous connecter pour publier un commentaire.