Rechargement de l'état actuel - rafraîchir les données

j'ai trouvé que c'était la façon la plus courte de rafraîchir avec l'ui-router:

$state.go($state.current, {}, {reload: true}); //second parameter is for $stateParams

mise à Jour pour les versions plus récentes:

$state.reload();

qui est un alias pour:

$state.transitionTo($state.current, $stateParams, { 
  reload: true, inherit: false, notify: true
});

Documentation: https://angular-ui.github.io/ui-router/site/#/api/ui.router.state.$état # methods_reload

ce serait la solution finale. (inspiré du billet de @Hollan_Risley)

'use strict';

angular.module('app')

.config(function($provide) {
    $provide.decorator('$state', function($delegate, $stateParams) {
        $delegate.forceReload = function() {
            return $delegate.go($delegate.current, $stateParams, {
                reload: true,
                inherit: false,
                notify: true
            });
        };
        return $delegate;
    });
});

maintenant, chaque fois que vous avez besoin de recharger, il suffit d'appeler:

$state.forceReload();

pour ionique cadre

$state.transitionTo($state.current, $state.$current.params, { reload: true, inherit: true, notify: true });//reload

$stateProvider.
  state('home', {
    url: '/',
    cache: false, //required

https://github.com/angular-ui/ui-router/issues/582

probablement l'approche la plus propre serait la suivante:

<a data-ui-sref="directory.organisations.details" data-ui-sref-opts="{reload: true}">Details State</a>

nous pouvons recharger L'État à partir du HTML seulement.

la réponse de @Holland Risley est maintenant disponible en tant qu'api dans le dernier ui-router.

$state.reload();

méthode qui force à recharger l'état actuel. Toutes les résolutions sont re-résolu, les contrôleurs de réintroduit, et les événements de recuit.

http://angular-ui.github.io/ui-router/site/#/api/ui.router.state.$état

$state.go($state.current, $stateParams, {reload: true, inherit: false});

$scope.reloadstat = function () { $state.go($state.current, {}, {reload: true}); };

si vous voulez recharger votre page entière, comme il semble, il suffit d'injecter $ window dans votre contrôleur et ensuite appeler

$window.location.href = '/';

mais si vous voulez seulement recharger votre vue actuelle, injecter $scope, $state et $stateParams (ce dernier juste au cas où vous avez besoin d'avoir quelques paramètres de changement dans cette prochaine recharge, quelque chose comme votre numéro de page), alors appelez cela dans n'importe quelle méthode de contrôleur:

$stateParams.page = 1;
$state.reload();

AngularJS v1.3.15 angular-ui-router v0.2.15

solution idiote qui fonctionne toujours.

$state.go("otherState").then(function(){
     $state.go("wantedState")
});

pour v1 angulaire.2.26, aucun des travaux ci-dessus. Un ng-click qui appelle les méthodes ci-dessus devra être cliqué deux fois pour faire le rechargement de l'état.

donc j'ai fini par émuler 2 clics en utilisant $timeout.

$provide.decorator('$state',
        ["$delegate", "$stateParams", '$timeout', function ($delegate, $stateParams, $timeout) {
            $delegate.forceReload = function () {
                var reload = function () {
                    $delegate.transitionTo($delegate.current, angular.copy($stateParams), {
                        reload: true,
                        inherit: true,
                        notify: true
                    })
                };
                reload();
                $timeout(reload, 100);
            };
            return $delegate;
        }]);

tout a échoué pour moi. La seule chose qui a fonctionné...est d'ajouter cache-view= "false" dans la vue que je veux recharger en allant vers elle.

de ce numéro https://github.com/angular-ui/ui-router/issues/582

je ne sais Pas pourquoi aucun de ces semblait fonctionner pour moi; celui qui l'a finalement fait, c'était:

$state.reload($state.current.name);

C'était avec un angle de 1.4.0

j'avais plusieurs vues emboîtées et le but était de recharger une seule avec du contenu. J'ai essayé différentes approches, mais la seule chose qui a fonctionné pour moi est:

//to reload
$stateParams.reload = !$stateParams.reload; //flip value of reload param
$state.go($state.current, $stateParams);

//state config
$stateProvider
  .state('app.dashboard', {
    url: '/',
    templateUrl: 'app/components/dashboard/dashboard.tmpl.html',
    controller: 'DashboardController',
    controllerAs: 'vm',
    params: {reload: false} //add reload param to a view you want to reload
  });

dans ce cas, seule la vue nécessaire serait rechargée et la mise en cache fonctionnerait toujours.

je sais qu'il y a eu un tas de réponses mais la meilleure façon que j'ai trouvé pour faire ceci sans causer un rafraîchissement pleine page est de créer un paramètre factice sur la route que je veux rafraîchir et puis quand j'appelle la route je passe dans un numéro aléatoire au paramétreur factice.

            .state("coverage.check.response", {
                params: { coverageResponse: null, coverageResponseId: 0, updater: 1 },
                views: {
                    "coverageResponse": {
                        templateUrl: "/Scripts/app/coverage/templates/coverageResponse.html",
                        controller: "coverageResponseController",
                        controllerAs: "vm"
                    }
                }
            })

et puis l'appel à cette route

$state.go("coverage.check.response", { coverageResponse: coverage, updater: Math.floor(Math.random() * 100000) + 1 });

fonctionne comme un charme et gère les résolutions.

vous pouvez utiliser la réponse de @Rohan https://stackoverflow.com/a/23609343/3297761

mais si vous voulez faire chaque controller reaload après un changement de vue, vous pouvez utiliser

myApp.config(function($ionicConfigProvider) { $ionicConfigProvider.views.maxCache(0); ... }

j'ai eu ce problème qui me démolissait la tête, mon routage est lu à partir d'un fichier JSON et ensuite introduit dans une directive. Je pouvais cliquer sur un État-ui mais je ne pouvais pas recharger la page. Une de mes collègues m'a montré un petit truc pour ça.

1. vos Données
2. dans votre configuration d'applications Créer un État de chargement
3. Enregistrer l'état que vous souhaitez aller dans le rootscope.
4. Réglez votre position sur "chargement" dans votre application.run
5. dans le contrôleur de chargement résolvez la promesse de routage et ensuite réglez l'emplacement sur votre cible prévue.

cela a fonctionné pour moi.

j'Espère que ça aide

si vous utilisez ionic v1, la solution ci-dessus ne fonctionnera pas car ionic a activé la mise en cache de template dans le cadre de $ionicConfigProvider.

travailler autour pour cela est un peu hacky - vous devez mettre cache à 0 dans ionic.anguleux.fichier js:

$ionicConfigProvider.views.maxCache(0);