Loops et tableaux | Documentation - Hub Création Roblox

Les tableaux peuvent être combinés avec des boucles, telles que pendant que et pour, pour répéter le même code pour chaque valeur indexée. Par exemple, téléporter chaque joueur dans un tableau à un nouvel endroit ou faire un tableau de parties prendre lancer.

Pour explorer le looping à travers les tableaux, créez un chemin de pont disparaissant où les parties sont placées dans un tableau et puis faites-le disparaître un par un.

Looping à travers un tableau

Pour le projet, trouvez ou créez un ensemble de trois parties pour les faire disparaître. Les parties doivent toutes être ancrées.

Créez trois parties. Nommez les parties dans l'ordre dans lequel elles doivent disparaître, Part1, Part2, Part3.
Dans ServerScriptService, insérez un nouveau script et créez un tableau pour stocker les pièces.
```
local pathArray = {
}
```

Sur une seule ligne, chaque fois, tapez le nom des parties dans l'ordre dans lequel elles devraient disparaître. En utilisant une nouvelle ligne pour chaque valeur, cela rend plus facile de lire.


local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

Utiliser un for Loop With an Array

Utilisez un for loop pour aller à travers l' array et contrôler la vitesse à laquelle les parties doivent disparaître dans l'ordre dans lequel les parties sont indexées dans l' matrice.

Pour contrôler la fréquence à laquelle une partie disparaît en secondes, créez une variable nommée VANISH_RATE . Pour tester, il est préférable de la garder à un petit nombre.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Constants sont des variables qui ne devraient pas être modifiées par tout autre code dans le script. Ils sont probablement需要调整 et sont placés au top du script en ALL_CAPS pour les rendre faciles à repérer.
Créer un for loop avec les suivre: Démarrer : partIndex = 1 , l'index de la première valeur dans l'matrice. Fin : 1> #pathArray1> , la taille de cet matrice.
```
for partIndex = 1, #pathArray  do

end
```

Il y a donc un délai avant que une partie disparaisse, dans le boucle, ajoutez un task.wait() à l'aide de VANISH_RATE.


for partIndex = 1, #pathArray  do
   task.wait(VANISH_RATE)
end

Pour obtenir qu'une partie disparaisse, créez une nouvelle variable nommée whichPart et définissez-la comme partsArray[partIndex]. Puis, pour disparaître cette partie, définissez sa propriété CanCollide à false et 1> Transparency » à 1.


for partIndex = 1, #pathArray  do
   task.wait(VANISH_RATE)
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = false
   whichPart.Transparency = 1
end

Vérifiez que certaines parties du chemin disparaissent au fil du temps.

Conseils de débogage

Si le pont ne disparaît pas, vérifiez les problèmes possibles ci-dessous : Problème : Les parties disparaissent trop rapidement ou sont toutes parties au commencer.

En fonction de la rapidité avec laquelle votre personnage se charge dans l'expérience, les premières parties peuvent déjà être invisibles. Pour y remédier, ajoutez un petit délai, tel que task.wait(2), au début du script.

Codage du deuxième boucle

En ce moment, les parties disparaissent pour toujours. Pour les faire réapparaître, créez une seconde pour la boucle qui se répétera à travers chaque partie et fera instantanément chaque pièce marchable.

Après le premier boucle, ajoutez un task.wait() pour créer un délai court avant que le chemin réapparaisse.


for partIndex = 1, #pathArray  do
	task.wait(VANISH_RATE)
	local whichPart = pathArray[partIndex]
	whichPart.CanCollide = false
	whichPart.Transparency = 1
end

task.wait(1)

Sur votre propre , essayez de codifier un deuxième pour l'itération qui rend le chemin réutilisable en changeant la propriété CanCollide de chaque partie en vrai et en transparence à 0. Une fois terminé, vérifiez votre travail contre le code ci-dessous.


-- Réinitialisez le chemin en faisant que toutes les parties soient à nouveau marchables
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Les parties non ancrées tomberont à travers la plaque de base lorsque CanCollide est faux. Si les parties ne réapparaissent pas et qu'il n'y a pas d'erreurs d'Output, ancre les parties et testez-les à nouveau.

Testez le projet pour confirmer qu'une fois toutes les parties disparues, elles retour.

Répéter avec un boucle while

Les parties disparaissent et réapparaissent, mais seulement une fois. Pour que le code se répète, imbriquez tout le code dans une boucle while.

Au bas du script, créez un nouveau while true do loop. Then, déplacez both for loops into the while loop.


while true do
   -- Faites disparaître une partie de l' array
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Attendez qu'une seconde avant de faire réapparaître le chemin
	task.wait(1)

	-- Réinitialisez le chemin en faisant que toutes les parties soient à nouveau marchables
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Vérifiez que lorsque toutes les parties disparaissent, elles réapparaissent.

Une version finale du projet peut être téléchargée.

Script script
local VANISH_RATE = 1.0

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

while true do
	-- Faites disparaître une partie de l' array
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Attendez qu'une seconde avant de faire réapparaître le chemin
	task.wait(1.0)

	-- Réinitialisez le chemin en faisant que toutes les parties soient à nouveau marchables
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Les tableaux et les ipairs()

ipairs() est utilisé avec tableaux . Le « i » dans ipairs() signifie « index ». ipairs() peut être utilisé pour répéter rapidement une opération sur beaucoup d'objets, comme, disons, un dossier plein de pièces.

Ceci sera démontré en ajoutant rapidement des particules à un dossier entier de pièces.

Dans l'espace de Workspace, créez un dossier nommé PartsFolder. Ajoutez autant de pièces que vous le souhaitez.
Dans ServerScriptService, créez un nouveau script et référez-vous au dossier.

Utilisez GetChildren() pour obtenir automatiquement une liste d'objets dans le dossier.


local partsFolder = workspace.PartsFolder

-- Obtient une liste d'arrays dans PartsFolder
local partsArray = partsFolder:GetChildren()

Utilisez in ipairs(ArrayToUse) avec le for loop pour passer par partsArray et ajouter des particules.

Script script
-- Obtient une liste d'arrays dans PartsFolder
local partsArray = partsFolder:GetChildren()

-- Ajoute des particules à chaque partie de l' matrice
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Testez le jeu et observez que les particules flottent de chaque partie dans le dossier.

Résumé

Les boucles peuvent être combinées avec des tableaux pour travailler avec n'importe quel nombre de valeurs rapidement. Si vous voulez avoir un contrôle exact sur ce qui se produit à quelques parties et dans quel ordre, un tableau doit être codé avec des valeurs spécifiques.

Pour travailler avec de nombreuses parties où l'ordre n'a pas d'importance, GetChildren() peut créer un tableau d'enfants d'un objet. En utilisant ipairs(), la liste peut être itérée rapidement sans connaître la taille de l'matrice.