Fonctions de rappel Javascript et récursivité

C'est une sorte de casse-tête question, étant donné que le code fonctionne parfaitement bien, il irrite juste mon sens de l'esthétique très légèrement. Je suis passant à Débordement de Pile parce que mon propre cerveau est de ne pas en moi.

Voici un extrait de code qui ressemble à une adresse à l'aide de Google Maps API JS et place un marqueur sur une carte. Cependant, parfois, la première recherche échoue, je tiens donc à répéter le processus avec une adresse différente.

geocoder.getLatLng(item.mapstring, function(point) {
    if (!point) {
        geocoder.getLatLng(item.backup_mapstring, function(point) {
            if (!point) return;
            map.setCenter(point, 13);
            map.setZoom(7);
            map.addOverlay(new GMarker(point));
        })
        return;
    }
    map.setCenter(point, 13);
    map.setZoom(7);
    map.addOverlay(new GMarker(point));
})

(Le deuxième paramètre à getLatLng est une fonction de rappel.)

Bien sûr, vous pouvez voir que les trois lignes du centre et de zoom de la carte et ajouter le marqueur sont dupliqués, une fois dans le primaire de rappel et une fois dans le "repli de rappel" (ha, ha). Pouvez-vous trouver un moyen pour exprimer tout ça, sans aucune redondance? Vous gagnez des points de bonus, et mon adulation, si votre solution fonctionne pour un nombre arbitraire de sauvegarde de la carte des chaînes.

source d'informationauteur lawrence

21

Autres réponses sont bonnes, mais ici, c'est une option de plus. Cela vous permet de garder la même forme que vous avez commencé avec, mais utilise l'astuce de donner un nom à votre fonction lambda de sorte que vous pouvez vous référer à elle de manière récursive:
```
mapstrings = ['mapstring1', 'mapstring2', 'mapstring3'];

geocoder.getLatLng(mapstrings.shift(), function lambda(point) {
   if(point) {
        //success
        map.setCenter(point, 13);
        map.setZoom(7);
        map.addOverlay(new GMarker(point));
    }
    else if(mapstrings.length > 0) {
        //Previous mapstring failed... try next mapstring
        geocoder.getLatLng(mapstrings.shift(), lambda);
    }
    else {
        //Take special action if no mapstring succeeds?
    }
})
```
La première fois le symbole "lambda" est utilisée, elle consiste à introduire une nouvelle fonction nom littéral. La deuxième fois qu'il est utilisé, il est une référence récursive.

fonction de désignation littérale fonctionne dans Chrome, et je suppose que ça fonctionne dans la plupart des navigateurs modernes, mais je ne l'ai pas testé et je ne sais pas pour les anciens navigateurs.
8

Il est extrêmement agréable de la méthode pour la réalisation de la récursivité dans les constructions de langage qui ne sont pas explicitement le soutien de la récursivité appelé combinateur de point fixe. La plus connue est la Y Combinator.

Voici le Y combinator pour une fonction à un paramètre dans le code Javascript:
```
function Y(le, a) {
    return function (f) {
        return f(f);
    }(function (f) {
        return le(function (x) {
            return f(f)(x);
        }, a);
    });
}
```
Cela ressemble un peu effrayant, mais vous n'avez qu'à écrire qu'une seule fois. À l'aide de c'est en fait assez simple. Fondamentalement, vous prenez votre original lambda d'un paramètre, et vous transformer en une nouvelle fonction de deux paramètres - le premier paramètre est maintenant la réelle expression lambda que vous pouvez faire l'appel récursif, le deuxième paramètre est le premier paramètre (point) que vous souhaitez utiliser.

C'est comment vous pouvez l'utiliser dans votre exemple. Notez que je suis en utilisant mapstrings comme une liste de chaînes à regarder vers le haut et le menu de fonction serait destructive supprimer un élément à partir de la tête.
```
geocoder.getLatLng(pop(mapstrings), Y(
  function(getLatLongCallback, point)
  {
    if (!point)
    {
      if (length(mapstrings) > 0)
        geocoder.getLatLng(pop(mapstrings), getLatLongCallback);
      return;
    }

    map.setCenter(point, 13);
    map.setZoom(7);
    map.addOverlay(new GMarker(point));
  });
```

Yep, facteur d'une fonction 🙂

geocoder.getLatLng(item.mapstring, function(point) {
    if (!point) {
        geocoder.getLatLng(item.backup_mapstring, function(point) {
                if (point) {
                    setPoint(point);
                }
        })
        return;
    }

    function setPoint(point) {
        map.setCenter(point, 13);
        map.setZoom(7);
        map.addOverlay(new GMarker(point));
    }

    setPoint(point);
});

Comment à ce sujet?

function place_point(mapstrings,idx)
{
    if(idx>=mapstrings.length) return;
    geocoder.getLatLng(mapstrings[idx],
                       function(point)
                       {
                           if(!point)
                           {
                               place_point(mapstrings,idx+1);
                               return;
                           }
                           map.setCenter(point, 13);
                           map.setZoom(7);
                           map.addOverlay(new GMarker(point));
                       });
}

Comme beaucoup de sauvegarde de chaînes que vous voulez. Il vous suffit d'appeler avec un 0 comme deuxième argument, la première fois.

Vous devez vous connecter pour publier un commentaire.