Effettua una nuova chiamata asincrona all'interno di una funzione di callback

Question

Vorrei utilizzare il Feed AJAX di Google API per recuperare più feed e visualizzarli su una pagina web.

Non riesco a utilizzare la classe FeedControl di Google perché desidero controllare il modo in cui gli elementi del feed vengono visualizzati. Questo mi lascia con la classe Feed di Google come unica opzione.

Ho capito che funziona con un singolo feed: fornire un url e una funzione di callback; elaborare i risultati del feed all'interno della funzione di callback.

La mia domanda: come posso recuperare più feed? Dovrei in qualche modo creare un nuovo oggetto google.feeds.feed all'interno della funzione di callback e fornirgli un nuovo url e ... la stessa funzione di callback (?)

Non ho mai studiato informatica, quindi questo tipo di ricorsione mi fa girare la testa. Chiunque può spiegare cosa devo fare?

Answer 1

Certo, puoi farlo in questo modo, ecco alcuni pseudocodici:

// 'feeds' is an array of the feed URLs
function grabFeeds(feeds) {
    var index;

    // We start with the first feed
    index = 0;

    // Kick off the process
    feedWorker();

    // Our "go get the next feed" function
    function feedWorker() {
        var feed;

        // Do we have any more?
        if (index < feeds.length) {
            // Yes, request it and bump our index
            // (You could combine these lines, but it's
            // clearer to keep them separate)
            feed = feeds[index];
            ++index;
            start_feed_download(feed, callback);
        }
    }

    // Our callback function
    function callback() {
        // ...do something with the result...

        // Kick of the next feed (feedWorker is defensive,
        // so we don't have to check index here)
        feedWorker();
    }
}

Non conosco l'API per i feed di Google, quindi la funzione segnaposto start_feed_download .

Quello che fa è avviare il processo di acquisizione dei feed tramite la funzione grabFeeds , che accetta una serie di feed. grabFeeds dà il via a feedWorker , che avvia la prima richiesta di feed e quindi restituisce immediatamente (quasi sicuramente prima che venga recuperato il primo feed). callback elabora il risultato, quindi chiede a feedWorker di dare il via alla successiva richiesta di feed (se presente).

La " magia " ecco che feedWorker e callback sono entrambi chiusure , quindi anche se grabFeeds è già tornato, le variabili index e feed continuano a vivere (in un oggetto chiamato "contesto di esecuzione") fino a quando qualcosa fa riferimento alle cose all'interno del contesto di esecuzione - nel nostro caso, fino a quando callback e feedWorker non sono più referenziato dalle cose di Google.

Answer 2

Sì, puoi farlo bene, assicurati che ogni volta che fai la ricorsione hai due casi (a) il caso base e (b) il caso ricorsivo.

Solo nel secondo caso la funzione si chiama da sola, assicurati di non farlo nel caso base altrimenti finirai con una ricorsione infinita. Ad esempio, in questa funzione fattoriale 0 è il caso base, tutto il resto è il caso ricorsivo

function fact(n) {
    if (n==0) { return 1; }
    else { return n * factorial(n-1) }
}

In alternativa, potresti farli uno alla volta, ad es. avvia il primo, quindi avvia il secondo, invece di dover attendere che uno si carichi completamente prima che inizi il caricamento del secondo.