Pousser Fonctions dans un Tableau - Boucle et de la Jonction?

À l'aide de Javascript j'ai besoin d'être en mesure de:

1: appuyez sur une certaine quantité de la même fonction (avec un paramètre différent de chaque) dans un tableau.

2: Ensuite, exécutez chaque fonction un par un (pour cet exemple juste d'une alerte du paramètre/numéro)

3: Après chaque fonction que j'ai besoin d'être en mesure d'ÉPISSAGE que la fonction de la matrice de

4: Vérifiez la Longueur du Tableau après à chaque fois - une Fois que le tableau est à nouveau vide - alerte l'utilisateur, il est complet

Maintenant j'ai l'impression d'être capable de faire des tâches 1, 2 et 4, mais je suis sturggling avec la façon d'épissure de la fonction de la matrice après l'exécution peut aider quelqu'un? Comme je ne peux pas supprimer la fonction, je ne suis jamais trouvé le "fait" alerte une fois que toutes les fonctions ont été appelés

Mon code javascript jusqu'à présent est:

//Create empty array
var array = [];

//Push functions into array - dynamic amount and could be any amount of functions
array.push(func(1));
array.push(func(2));
array.push(func(3));

//Call array manager function after pushing array
arrayManager();

//Array manager function to splice and detect when finished
function arrayManager() {
    if (array.length < 1) {
        alert("done");
    }
    else {
    //////////////////////////////////
    //<< THIS IS WHERE I DON'T KNOW HOW TO SPLICE THE ITEM FROM THE ARRAY
    //////////////////////////////////
    }
}

//Function for array objects - alert passed parameter
function func(num){
    alert(num);
}

qu'est-ce exactement que vous voulez accomplir? il y a peut être plus simple de le faire.
Avez-vous lu la jonction de la documentation?
aussi, la "longueur" de la propriété commence à 1 pas de zéro
Ce qui sur un tableau à n éléments?
Maintenant, vous n'êtes pas pousser toutes les fonctions dans le Tableau.

OriginalL'auteur Lauren Reynolds | 2012-09-24

14

Tout d'abord, vous ne pousse pas les fonctions dans le tableau à l'instant, vous exécutez la touche func place. Pour atteindre le pousser votre func devrait ressembler à ceci:
```
//Function for array objects - alert passed parameter
function func(num){
  return function(){
    alert(num);
  }
}
```
Maintenant, si vos fonctions sont synchrones, il vous suffit d'itérer sur le tableau
```
for(var i in arr){
  arr[i]();
}
console.log('done');
```
Si nous avons affaire à asynchrones fonctions alors qu'ils ont besoin d'avoir un rappel:
```
//Function for array objects - alert passed parameter
function func(num){
  return function(callback){
    alert(num);
    callback();
  }
}
```
Et ensuite vous pouvez soit utiliser un compteur pour s'exécuter en parallèle.
```
var count = arr.length;
for(var i in arr){
  arr[i](function(){
    if(--count === 0){
      console.log('Done');
    }
  });
}
```
Ou dans l'ordre:
```
function run(){
  var fn = arr.shift();
  if(!fn){
    console.log('Done');
  } else {
    fn(run);
  }
}
run();
```
Merci pour cette réponse! Bien sûr, la async itération doit appeler fn(run()) ou il s'arrête après le premier "run" (pun intended). Si je suis absent quelque chose, par tous les moyens, laissez-moi savoir pourquoi j'ai tort. 😀
Passons sur le fait... 🙂

OriginalL'auteur DeadAlready
1

Cela devrait faire ce que vous êtes à la recherche pour:
```
var next_func = array.splice(0, 1)[0]
```
"splice" prend au moins deux paramètres: le premier est l'indice de commencer à retirer à partir de, et le second est le nombre d'éléments à supprimer. Comme elle renvoie un nouveau tableau, pour obtenir exactement la fonction que vous obtenez la première valeur de l'épissage. Vous pouvez également ajouter autant de valeurs que vous souhaitez après ces deux premiers paramètres qui seront ajoutés au tableau à la place de ce que vous avez supprimé.

Cependant, je suis curieux de savoir pourquoi vous le faites de cette façon - même si je peux comprendre de faire quelque chose de manière conventionnelle comme un exercice intellectuel, si vous êtes nouveau à la programmation, je dirais qu'il y a une meilleure façon de le faire. Il n'y a pas besoin de supprimer des éléments de la matrice que vous utilisez les fonctions d'elle. Pour moi, cela aurait plus de sens pour exécuter chaque fonction à partir de la matrice, puis réglez "array = []" après la fin de la boucle. Toutefois, en fonction des circonstances, ce peut être encore le meilleur moyen de faire ce que vous faites, j'ai juste pensé que je donnerais un peu de nourriture pour la pensée.

Je suis très nouveau pour le javascript (et de codage en général en fait) donc je m'excuse si certaines de mes méthodes sembler étrange ou il y a beaucoup plus facile de façons de le faire. Fondamentalement, je suis à l'aide de javascript dans Titanium Appcelerator d'une application mobile dans l'app, l'utilisateur aura la peinture et le dessin gribouillis ou des croquis, à la fin de l'application que je puis avoir besoin pour être en mesure de télécharger tous créé des gribouillis sur un serveur. Mon idée sur la façon de le faire est d'ajouter à chaque doodle comme une fonction dans un tableau, en boucle par le biais de la matrice de téléchargement jusqu'à ce qu'elle est vide, et quand c'est vide de leur permettre de continuer - si cela a du sens?
Sons assez raisonnable sur le visage de celui-ci. Toutefois, si vous êtes le déchargement de toutes les fonctions à la fois, il n'y a vraiment pas besoin de s'embêter avec de l'épissage. Le principal avantage de quelque chose comme l'épissage dans un cas comme cela est si vous êtes exécution fonctions dans un peu de façon aléatoire. Si vous envisagez sur l'exécution de tous à la fois, je voudrais juste utiliser une boucle for pour passer et d'exécuter chacun d'eux, puis définissez le tableau à vide après la finition. Aussi, si vous êtes nouveau à l'javascript, assurez-vous de vérifier le MDN ressources Chris Francis liés - c'est un excellent moyen d'apprendre à propos de javascript.

OriginalL'auteur Bubbles

//Create empty array
var array = [];

//Push functions into array - dynamic amount and could be any amount of functions
array.push(function() { func(1); });
//if you call array.push(func(1)) the function is executed immediatly
//then null is stored in the array
array.push(function() { func(2); });
array.push(function() { func(3); });

//Call array manager function after pushing array
arrayManager();

//Array manager function to splice and detect when finished
function arrayManager() {
    while (array.length){
        var fnc=array.splice(0,1)[0]
        fnc();
    }
    alert ("done");            
}

//Function for array objects - alert passed parameter
function func(num){
    alert(num);
}

OriginalL'auteur

1

Est-ce que vous avez besoin?

1: appuyez sur une certaine quantité de la même fonction (avec un paramètre différent de chaque) dans un tableau.
```
function func(num){
    alert(num);
}

var k = [];
k.push({f:func, params:[1]});
k.push({f:func, params:[2]});
k.push({f:func, params:[3]});
```
2: Ensuite, exécutez chaque fonction un par un (pour cet exemple juste d'une alerte du paramètre/numéro)

3: Après chaque fonction que j'ai besoin d'être en mesure d'ÉPISSAGE que la fonction de la matrice de

4: Vérifiez la Longueur du Tableau après à chaque fois - une Fois que le tableau est à nouveau vide - alerte l'utilisateur, il est complet
```
while (k.length > 0) {
 k[0].f(k[0].params);
 k.shift();
}
alert("done");
```
OriginalL'auteur prashanth
0

http://jsfiddle.net/nZ459/1/

Si vous voulez pousser chaque fonction avec ses paramètres dans la manière que vous faites, vous aurez à intégrer la fonction comme ceci:
```
function wrapper(arg){
    return function(){
        console.log(arg);
    };
}


var ar = [];

console.log("pushing functions");

ar.push(wrapper(1));
ar.push(wrapper(2));
ar.push(wrapper('three'));

console.log("done pushing functions");

while (ar.length){
    var fn = ar.shift();
    console.log("calling ", fn);
    fn();
}
```
Alternativement, vous pourriez faire un wrapper générique qui prend une fonction et les arguments en paramètres, et retourne une fonction anonyme.

Pour répondre à votre question plus directement, de la façon la plus simple de courir à travers un tableau de la manière que vous le désir est comme ceci:
```
while (array.length){
    var item = array.shift();
    ...
}
```
OriginalL'auteur Shmiddty

Vous devez vous connecter pour publier un commentaire.