Guida · Debug

Come risolvere gli errori degli script in Roblox Studio

Quando uno script di Roblox si rompe, Studio di solito scrive dove e perché nella finestra Output. In questa guida vediamo come leggere quel messaggio, cosa significano gli errori più comuni e come risolverli uno per uno, cosa controllare se lo script non funziona affatto senza dare errori, e una sequenza di passi che trova la causa invece di tirare a indovinare.

Aggiornato il 20 novembre 202621 min di letturaScritto da

In breve

Apri la finestra Output dal menu Window o dalla scheda Script, premi Play e clicca sul primo errore rosso. Studio apre lo script alla riga in cui si è fermato. Il messaggio dice cosa è andato storto: attempt to index nil with 'Humanoid' significa che il valore subito prima di .Humanoid era nil. Correggi il motivo per cui quel valore manca e avvia di nuovo il gioco.

  • Parti dal primo errore della lista. Gli errori sotto spesso sono solo sue conseguenze.
  • Gli errori comuni durante il gioco si riducono a tre cause: un valore è nil, un nome è scritto male o non si è ancora caricato, oppure il codice gira dal lato sbagliato (server o client).
  • Se non c'è alcun errore, di solito il codice semplicemente non è partito. Controlla il tipo di script, dove si trova nell'Explorer, la sua proprietà Enabled e se l'evento che aspetta scatta davvero.
  • Per sapere quanto vale davvero un valore alla riga che ti interessa, stampalo con print e un'etichetta oppure metti un breakpoint su quella riga.
In questa pagina
  1. Leggere l'Output
  2. Sequenza di debug
  3. Errori comuni
  4. Nessun errore, non succede nulla
  5. Strumenti di debug
  6. Con RoCode
  7. Domande frequenti
  8. Fonti e letture

Come aprire l'Output e leggere un errore

IllustrazioneL'esempio del kill brick della guida, accelerato: la riga rotta dà un errore, e dopo Stop, la correzione e un nuovo playtest la parte cade senza errori.

La finestra Output è il posto dove Roblox segnala gli errori degli script, gli avvisi del motore e tutto ciò che stampa il tuo codice. Non è sempre aperta, quindi aprila prima del test. Se non hai mai avviato uno script, la guida alla programmazione per principianti comincia proprio aprendo l'Output e stampando una prima riga da uno script.

  1. Apri l'Output dal menu Window di Studio o con il pulsante nella scheda Script.
  2. Cancella i messaggi vecchi con Ctrl+K (⌘K su Mac), così vedi solo questo test.
  3. Premi Play (F5) e fai ciò che rompe il gioco.
  4. Trova la prima riga rossa. Gli errori sono rossi. Gli avvisi, per esempio Infinite yield possible, sono in arancione.

Un errore durante il gioco nell'Output appare così. A seconda delle opzioni di visualizzazione dell'Output, ogni riga può avere anche l'ora, un'etichetta Client o Server e il nome dello script.

Output (esempio)
ServerScriptService.CoinPad:14: attempt to index nil with 'Coins'
Stack Begin
Script 'ServerScriptService.CoinPad', Line 14 - function award
Script 'ServerScriptService.CoinPad', Line 27
Stack End
  • ServerScriptService.CoinPad è la posizione dello script nell'Explorer: uno script chiamato CoinPad dentro ServerScriptService.
  • :14 è la riga in cui è avvenuto l'errore.
  • Il messaggio dopo il numero di riga dice cosa è andato storto. Ognuno è spiegato nell'elenco degli errori comuni qui sotto.
  • Lo stack tra Stack Begin e Stack End mostra le chiamate che hanno portato fin qui, partendo dall'ultima: la riga 14 dentro la funzione award, chiamata dalla riga 27.

Clicca su un errore rosso e Studio apre quello script con il cursore sulla riga giusta. In un test in solitaria i messaggi del server e del tuo client finiscono nello stesso Output: quelli del server sono segnati in verde, quelli del client in blu. I filtri in alto restringono l'elenco per tipo di messaggio (Error, Warning), per contesto (Client, Server) o per testo.

Una sequenza di debug che va bene per qualsiasi script

Tirare a indovinare e cambiare più cose insieme è un modo lento di riparare uno script. Questa sequenza restringe il problema passo dopo passo, che ci sia un messaggio di errore o no.

  1. Riproduci il problema. Cancella l'Output, premi Play e fai esattamente ciò che rompe il gioco. Annota cosa ti aspettavi e cosa è successo invece.
  2. Prendi il primo errore. Leggi la prima riga rossa nuova: percorso dello script, numero di riga e messaggio. Se non c'è nessun errore, passa alla sezione script che girano senza errori.
  3. Vai alla riga. Clicca sull'errore. Leggi tutta la riga e chiediti quale valore può essere nil, scritto male o del tipo sbagliato.
  4. Controlla il valore, non indovinarlo. Aggiungi un print subito sopra la riga oppure mettici un breakpoint e guarda i valori nella finestra Watch. typeof(x) ti dice cosa hai: un numero, una stringa, una Instance o nil.
  5. Segui la traccia all'indietro. Se il valore è sbagliato, trova dove è stato impostato: un FindFirstChild che non ha trovato nulla, una funzione che non ha restituito nulla, un argomento che il codice chiamante non ha mai passato.
  6. Correggi la causa, una modifica alla volta. Sistema il nome, aspetta l'oggetto o sposta il codice sul lato giusto, poi avvia di nuovo il gioco. Non racchiudere la riga in un pcall per farla tacere: così il bug si nasconde, non si risolve.
  7. Verifica. Ripeti il passo 1. L'errore deve sparire e la funzione deve fare ciò che ti aspettavi. Se riguarda altri giocatori, prova anche in modalità Server & Clients con due client.
  8. Fai pulizia. Elimina o disattiva i print di debug, così il prossimo problema sarà facile da notare.

Errori comuni degli script Roblox e come risolverli

Ogni messaggio segue uno schema fisso in cui vengono inseriti i tuoi nomi, quindi il testo stesso dell'errore è il suggerimento migliore. I nomi tra virgolette qui sotto, per esempio 'Health' o "Workspace", sono esempi.

Errori comuni nell'Output. Scegli un messaggio per aprire la spiegazione completa.
Cosa scrive l'OutputCosa significaCome si risolve di solito
attempt to index nil with 'Health'Il valore prima di .Health era nil.Scopri perché è nil e controllalo con un if prima di usarlo.
Infinite yield possible on 'Players.YourName:WaitForChild("Character")'WaitForChild aspetta già da 5 secondi e l'oggetto non è mai comparso.Correggi il nome o il percorso, assicurati che qualcuno crei l'oggetto o aggiungi un timeout.
Bridge is not a valid member of Workspace "Workspace"Lì in questo momento non c'è un figlio o una proprietà con quel nome esatto.Confronta grafia e maiuscole con l'Explorer. Sul client usa WaitForChild.
attempt to call a nil valueHai chiamato qualcosa che non è una funzione.Controlla il nome della funzione e che sia dichiarata sopra la chiamata.
attempt to perform arithmetic (add) on Instance and numberCalcoli con qualcosa che non è un numero.Usa .Value sui value object e tonumber per il testo.
attempt to concatenate string with nil.. ha provato a unire del testo con nil o con un oggetto.Usa tostring(), .Name o l'interpolazione di stringhe.
Expected 'end' (to close 'function' at line 3), got <eof>Errore di sintassi. Lo script non viene eseguito affatto.Correggi ciò che è sottolineato in rosso nello Script Editor.
Requested module experienced an error while loadingIl ModuleScript stesso si è fermato con un errore mentre veniva eseguito.Correggi l'errore del modulo, che è mostrato poco sopra nell'Output.
Argument 1 missing or nilUna funzione di Roblox ha ricevuto nil dove le serve un valore.Risali a dove avrebbe dovuto arrivare quell'argomento.
FireServer can only be called from the clientIl RemoteEvent è stato chiamato dal lato sbagliato.Il server usa FireClient, i LocalScript usano FireServer.
Errore del data store 403, StudioAccessToApisNotAllowedStudio non ha il permesso di usare i data store di questo gioco.Pubblica il gioco e attiva Studio Access to API Services.

Ogni messaggio di questo elenco, e non solo, ha una propria pagina con ogni causa, il codice che la provoca e la correzione: vedi i messaggi di errore di Roblox Studio, per esempio attempt to index nil, Infinite yield possible e is not a valid member of (pagine in inglese).

attempt to index nil with 'X'

Indicizzare significa leggere qualcosa con il punto o con le parentesi quadre: part.Position, player.Character, list[1]. Questo errore dice che ciò che sta a sinistra era nil, e il nome tra virgolette è ciò che hai cercato di leggerci dentro. Quindi, sulla riga player.Character.Humanoid, l'errore attempt to index nil with 'Humanoid' significa che player.Character era nil. Se la chiave è un numero, il messaggio finisce con with number.

I motivi abituali per cui il valore era nil:

  • FindFirstChild, FindFirstChildOfClass o FindFirstAncestor non ha trovato nulla, perché il nome è diverso o l'oggetto non c'è ancora.
  • Players.LocalPlayer è stato usato in uno Script del server. Esiste solo nei LocalScript e nei ModuleScript che questi caricano con require; sul server è sempre nil. Usa invece il player fornito da PlayerAdded o dal gestore di un RemoteEvent.
  • player.Character è stato letto prima che il personaggio comparisse, o mentre sta rinascendo.
  • Una voce della tabella non è mai stata impostata, per esempio playerData[player] prima che i dati di quel giocatore si caricassero, oppure la funzione chiamata non ha restituito nulla.

Il caso classico è il kill brick. La versione rotta dà per scontato che tutto ciò che tocca la parte appartenga a un personaggio, ma per gli strumenti lasciati cadere, le parti non ancorate e gli accessori non è così.

Script in una Part in Workspace chiamato KillBrick
local part = script.Parent :: BasePart

part.Touched:Connect(function(hit: BasePart)
	-- Versione rotta:
	--   hit.Parent:FindFirstChild("Humanoid").Health = 0
	-- Se la parte che tocca non fa parte del corpo di un personaggio, FindFirstChild
	-- restituisce nil, e l'Output mostra:
	--   attempt to index nil with 'Health'

	-- Corretto: controlliamo ogni passo prima di usarlo
	local model = hit:FindFirstAncestorOfClass("Model")
	local humanoid = model and model:FindFirstChildOfClass("Humanoid")
	if humanoid then
		humanoid.Health = 0
	end
end)

Se scrivi hit.Parent.Humanoid, ottieni un messaggio diverso, Humanoid is not a valid member of ..., spiegato più sotto. FindFirstAncestorOfClass("Model") trova il personaggio anche quando la parte che tocca sta dentro un accessorio o uno strumento in mano al personaggio, quindi conta anche uno strumento in mano che sfiora il blocco.

Lo schema che risolve questo errore: ottieni il valore, controllalo e solo dopo usalo. Sul server FindFirstChild con un controllo if va bene per ciò che potrebbe benissimo non esserci. In un LocalScript usa WaitForChild per ciò che crea il server, perché potrebbe comparire dopo l'avvio dello script.

Infinite yield possible on ...

WaitForChild("Name") mette in pausa lo script finché non compare un figlio con quel nome. Se aspetta più di 5 secondi e non hai impostato un timeout, Roblox stampa questo avviso. È un avviso, non un errore: lo script sta ancora aspettando, e niente dopo quella riga verrà eseguito finché l'oggetto non compare, cosa che potrebbe non succedere mai. Le cause abituali:

  • Nome o genitore sbagliato. WaitForChild("leaderStats") non troverà mai la cartella leaderstats.
  • Nessuno crea l'oggetto: lo script del server che lo crea è disattivato, sta nel posto sbagliato o si è fermato prima con un errore. Cerca un errore precedente nell'Output.
  • Un LocalScript aspetta qualcosa in ServerStorage o ServerScriptService. Il loro contenuto non viene mai inviato ai giocatori, quindi l'attesa non finirà.
  • Stai aspettando una proprietà, non un figlio. L'esempio tipico è player:WaitForChild("Character"): Character è una proprietà di Player, non un oggetto al suo interno.
  • È attivo lo streaming delle istanze (Workspace.StreamingEnabled) e la parte è troppo lontana dal giocatore, quindi non è ancora stata inviata a quel client.
LocalScript in StarterPlayerScripts chiamato DeathMessage
local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Versione rotta:
--   local character = player:WaitForChild("Character")
-- Character è una proprietà di Player, non un figlio, quindi l'Output avvisa:
--   Infinite yield possible on 'Players.YourName:WaitForChild("Character")'

local function onCharacterAdded(character: Model)
	-- Con un timeout WaitForChild restituisce nil invece di aspettare per sempre
	local humanoid = character:WaitForChild("Humanoid", 10)
	if not (humanoid and humanoid:IsA("Humanoid")) then
		warn(`[DeathMessage] no Humanoid in {character:GetFullName()} after 10 seconds`)
		return
	end
	humanoid.Died:Connect(function()
		print(`[DeathMessage] {player.Name} died`)
	end)
end

-- Gestiamo il personaggio che potrebbe già esistere, poi ogni rinascita
local current = player.Character
if current then
	onCharacterAdded(current)
end
player.CharacterAdded:Connect(onCharacterAdded)

Il numero passato come secondo argomento di WaitForChild è il timeout in secondi. Così lo script può segnalare il problema con warn e fermarsi in modo pulito, invece di restare bloccato in silenzio.

X is not a valid member of Y

Con il punto hai chiesto un figlio o una proprietà che in quel momento non esiste, per esempio workspace.Bridge quando in Workspace non c'è nessuna parte chiamata Bridge. Il messaggio riporta prima ciò che hai chiesto, poi la classe e il percorso completo dell'oggetto in cui hai cercato. Controlla tre cose:

  • La grafia e le maiuscole coincidono esattamente con l'Explorer. La cartella si chiama leaderstats, tutta minuscola, e humanoid non è Humanoid.
  • I nomi delle proprietà sono in inglese americano. part.Colour si ferma con Colour is not a valid member of Part "Workspace.Part"; la proprietà si chiama Color.
  • L'oggetto si è caricato. Sul client, gli oggetti creati dal server possono arrivare dopo l'avvio del LocalScript, quindi lì usa WaitForChild.
LocalScript in StarterPlayerScripts chiamato CoinsWatcher
local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Versione rotta:
--   local coins = player.leaderstats.Coins
-- leaderstats lo crea il server, e a questo client può arrivare dopo
-- l'avvio di questo script. Allora l'Output mostra:
--   leaderstats is not a valid member of Player "Players.YourName"

local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue -- il server crea Coins come IntValue

print(`[CoinsWatcher] starting coins: {coins.Value}`)
coins.Changed:Connect(function(newValue: number)
	print(`[CoinsWatcher] coins changed to {newValue}`)
end)

Qui serve uno script del server che crei leaderstats con un IntValue chiamato Coins, come nella guida alla classifica.

attempt to call a nil value

Il codice ha messo le parentesi dopo qualcosa che vale nil, quindi non c'era niente da eseguire. Le cause abituali:

  • Il nome della funzione è scritto male o ha maiuscole diverse. Il modulo dichiara Format.clock, ma il codice chiamante scrive Format.Clock(95).
  • Una local function viene chiamata su una riga sopra la sua dichiarazione. In quel momento il nome non esiste ancora, quindi sposta la dichiarazione più in alto.
  • Il ModuleScript non aggiunge mai la funzione alla tabella che restituisce.

Due messaggi simili indicano lo stesso errore. Chiamare con i due punti un metodo di tabella che non esiste dà attempt to call missing method 'Kill' of table. Un errore di battitura in un metodo di un oggetto Roblox, per esempio part:Destory(), dà Destory is not a valid member of Part "Workspace.Part".

attempt to perform arithmetic (add) on ...

Luau ha provato a fare un calcolo (add, sub, mul, div e così via) e uno dei due lati non era un numero. I nomi dei tipi alla fine del messaggio ti dicono quale caso hai:

  • on Instance and number: hai fatto il calcolo con un value object invece che con il suo numero. coins + 10 deve essere coins.Value + 10.
  • on nil and number: la variabile o la voce della tabella non è mai stata impostata. Dalle un valore iniziale o scrivi (x or 0) dove l'assenza di valore significa davvero zero.
  • on string and number: testo che non è un numero, spesso da un TextBox. Convertilo con tonumber(text) e controlla che il risultato non sia nil. Il testo che contiene un numero, per esempio "5", viene convertito automaticamente.

I confronti si rompono allo stesso modo, con attempt to compare nil < number. Luau riscrive a > b come b < a, quindi l'ordine nel messaggio può essere invertito rispetto al tuo codice.

Script in ServerScriptService chiamato CoinDrip
local Players = game:GetService("Players")

local REWARD = 5
local INTERVAL_SECONDS = 60

local function addCoins(player: Player, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		-- Scriviamo perché non è successo nulla, invece di restare in silenzio
		warn(`[CoinDrip] {player.Name} has no leaderstats.Coins yet`)
		return
	end

	-- Versione rotta:
	--   coins = coins + amount
	-- coins è l'oggetto IntValue, non il suo numero, quindi l'Output mostra:
	--   attempt to perform arithmetic (add) on Instance and number
	coins.Value += amount
end

-- Ogni minuto diamo qualche moneta a ogni giocatore sul server
while true do
	task.wait(INTERVAL_SECONDS)
	for _, player in Players:GetPlayers() do
		addCoins(player, REWARD)
	end
end

attempt to concatenate string with nil

L'operatore .. unisce solo stringhe e numeri. Non puoi unirlo con nil, e nemmeno con un oggetto: "Hi " .. player dà attempt to concatenate string with Instance. Usa player.Name, racchiudi il valore in tostring() oppure usa l'interpolazione di stringhe con i backtick, print(`Coins: {coins}`), che stampa nil invece di fermare lo script.

Expected 'end' e altri errori di sintassi

I messaggi che iniziano con Expected sono errori di sintassi: il codice non è Luau valido, Roblox non riesce a compilarlo e non viene eseguita nessuna riga di quello script, nemmeno quelle sopra l'errore. Lo Script Editor li sottolinea in rosso già mentre scrivi, quindi puoi correggerli prima di premere Play.

  • Expected 'end' (to close 'function' at line 3), got <eof>: il function, if, for o while che inizia alla riga 3 non ha il suo end. Il numero di riga prima del messaggio spesso indica la fine del file, quindi guarda la riga citata tra parentesi.
  • Expected 'then' when parsing if statement, got '=': un = singolo nella condizione. Per confrontare serve ==.
  • Expected ')' (to close '(' at line 1), got 'local': una parentesi non è mai stata chiusa.
  • Expected <eof>, got 'end': un end di troppo.

Con un'indentazione ordinata un end mancante o in più si nota subito, perché ogni blocco sta allo stesso livello dell'end che lo chiude.

Requested module experienced an error while loading

Il primo require() di un ModuleScript esegue il suo codice. Se il modulo si ferma con un errore durante l'esecuzione, lo script che lo ha caricato riceve questo messaggio. Il vero problema è l'errore del modulo stesso, una o due righe più su nell'Output: correggi quello. Due messaggi simili:

  • Module code did not return exactly one value: il modulo non finisce con un return. Un ModuleScript deve restituire un valore, non nil, di solito la sua tabella.
  • Requested module was required recursively: due moduli si caricano a vicenda. Sposta la parte comune in un terzo modulo caricato da entrambi.
ModuleScript in ReplicatedStorage chiamato Format
local Format = {}

-- Trasforma un numero di secondi in minuti e secondi: 95 diventa "1:35"
function Format.clock(seconds: number): string
	local whole = math.max(0, math.floor(seconds))
	return string.format("%d:%02d", whole // 60, whole % 60)
end

-- Il modulo deve restituire la sua tabella alla fine. Senza questa riga ogni
-- require di questo modulo si ferma con: Module code did not return exactly one value
return Format

Uno script lo carica con local Format = require(ReplicatedStorage:WaitForChild("Format")) e poi chiama Format.clock(95). Se scrivi Format.Clock(95), ottieni l'errore attempt to call a nil value.

Argument 1 missing or nil

Una funzione di Roblox ha ricevuto nil in un argomento che le serve, e il numero dice quale. workspace:FindFirstChild(itemName) si ferma così quando itemName è nil. Il bug raramente sta su quella riga. Sta dove il valore sarebbe dovuto arrivare: una variabile scritta male, un attributo mai impostato o un argomento del RemoteEvent che il client non ha inviato. Gli argomenti dei RemoteEvent arrivano dal dispositivo del giocatore, quindi il server deve controllarli prima di usarli. Come farlo lo mostra la guida ai RemoteEvent.

FireServer can only be called from the client

Un RemoteEvent ha una direzione. Un LocalScript chiama FireServer, e uno Script del server ascolta con OnServerEvent. Uno Script del server chiama FireClient o FireAllClients, e i LocalScript ascoltano con OnClientEvent. Chiamare il metodo dal lato sbagliato dà questo errore o quello speculare, FireClient can only be called from the server. Di solito la correzione è spostare il codice in uno script del tipo giusto: vedi Script, LocalScript e ModuleScript (in inglese).

Errore 403 del data store in Studio

Le chiamate ai data store in Studio falliscono con il codice di errore 403 (StudioAccessToApisNotAllowed) finché non le permetti. Pubblica il place, apri File, Experience Settings, Security, attiva Enable Studio Access to API Services e salva. Da quel momento Studio usa gli stessi data store del gioco live, quindi Roblox consiglia di farlo in una copia di prova separata, non in un gioco a cui si sta già giocando. Racchiudi ogni chiamata ai data store in un pcall, perché queste chiamate possono fallire per motivi esterni al tuo codice. Come salvare in sicurezza è spiegato nel tutorial su DataStore.

Lo script gira senza errori ma non fa nulla

Uno script silenzioso di solito non è proprio partito, sta ancora aspettando qualcosa o è partito dal lato sbagliato. Prima di cambiare il codice, metti come prima riga print(script:GetFullName(), "started") e avvia il gioco. Se quella riga non compare mai nell'Output, il problema è dove si trova lo script o come è configurato, non cosa c'è scritto dentro.

Perché uno script può non fare nulla senza dare errori
Cosa controllareCosa va stortoCome risolvere
Tipo e posizione dello scriptUn LocalScript parte solo se lo metti in StarterPlayerScripts, StarterCharacterScripts, StarterGui, StarterPack o ReplicatedFirst (dai contenitori Starter parte come copia del giocatore). Se lo metti in Workspace, ServerScriptService o ReplicatedStorage, non partirà mai. Uno Script con il RunContext predefinito parte solo in Workspace o ServerScriptService.Spostalo o usa un altro tipo di script. Il codice dell'interfaccia e dei controlli va in un LocalScript, le regole del gioco vanno in uno Script in ServerScriptService.
EnabledUno script con la casella Enabled deselezionata non parte.Selezionalo e spunta Enabled nella finestra Properties.
RunContextIl RunContext di uno Script decide dove parte. Legacy, il valore predefinito, parte sul server da Workspace o ServerScriptService. Server parte sul server, Client parte sul dispositivo di ogni giocatore, per esempio da ReplicatedStorage.Impostalo consapevolmente. La documentazione di Roblox consiglia di mettere gli Script Client in ReplicatedStorage o ReplicatedFirst, e i LocalScript nei contenitori Starter.
L'evento non scattaTouched scatta solo con un movimento fisico, serve che almeno una delle due parti non sia ancorata, e serve CanTouch su entrambe. PlayerAdded non scatta per i giocatori che erano già sul server quando ti sei collegato all'evento. Il gestore di un RemoteEvent non parte se l'altro lato non attiva mai l'evento.Metti un print dentro il gestore per sapere con certezza se parte, poi correggi ciò che dovrebbe attivarlo.
Codice dopo un ciclo o un'attesaLe righe sotto un ciclo while true do non vengono mai eseguite, perché il ciclo non finisce. Nemmeno le righe sotto un WaitForChild che non trova mai l'oggetto.Collega gli eventi prima del ciclo o avvia il ciclo con task.spawn. Dai un timeout alle attese.
Un controllo che esce in silenzioUna protezione come if not coins then return end ferma la funzione senza dire nulla quando l'oggetto manca.Aggiungi un warn con i dettagli prima del return.
Filtri dell'OutputL'Output si può filtrare per tipo di messaggio, per Client o Server e per testo. Un filtro dimenticato può nascondere proprio l'errore che cerchi.Azzera i filtri e svuota il campo di ricerca.
Lo vedi solo tuLa modifica l'ha fatta un LocalScript, quindi la vede solo quel giocatore. Il server e gli altri giocatori non la vedono.Fai la modifica sul server. Vedi dove girano gli script (in inglese).

Sul caso di PlayerAdded cascano in molti, perché nei test di Studio entri quasi subito dopo l'avvio del server. Se qualcosa sopra la riga con Connect aspetta, per esempio un WaitForChild, un task.wait o il require di un modulo che aspetta, potresti entrare prima che il collegamento esista. Gestisci sia i giocatori nuovi sia quelli già entrati:

Script in ServerScriptService chiamato Welcome
local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	print(`[Welcome] {player.Name} joined`)
end

Players.PlayerAdded:Connect(onPlayerAdded)

-- Per i giocatori che erano già qui quando è stata eseguita la riga sopra,
-- PlayerAdded in questo script non scatterà, quindi li gestiamo adesso
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Strumenti di debug in Roblox Studio

print scrive una riga nell'Output, e warn scrive un avviso. È il modo più veloce per rispondere alle domande "è partito?" e "quanto vale questo valore?". Un print(x) nudo poi è difficile da ritrovare, quindi aggiungi un'etichetta e i dettagli importanti. typeof(x) mostra che tipo di valore è: un numero, una stringa, una Instance o nil, e GetFullName() mostra quale oggetto hai esattamente.

Script in ServerScriptService chiamato ShopDebug
local Players = game:GetService("Players")

local DEBUG = true -- metti false quando hai finito
local TAG = "[ShopServer]"

local function debugPrint(...: any)
	if DEBUG then
		print(TAG, ...)
	end
end

Players.PlayerAdded:Connect(function(player: Player)
	debugPrint("joined:", player.Name, player.UserId)

	local leaderstats = player:WaitForChild("leaderstats", 10)
	if not leaderstats then
		warn(TAG, "no leaderstats for", player.Name, "after 10 seconds")
		return
	end

	local coins = leaderstats:FindFirstChild("Coins")
	-- typeof e ClassName mostrano cosa è davvero il valore
	debugPrint("Coins is", typeof(coins), if coins then coins.ClassName else "missing")
end)

Il campo di ricerca dell'Output filtra per testo, quindi un'etichetta fissa come [ShopServer] ti permette di mostrare solo le righe di quel sistema. Se devi sapere come il codice è arrivato a una riga, debug.traceback() restituisce lo stack di chiamate attuale come stringa.

Breakpoint ed esecuzione passo passo

Un breakpoint mette in pausa il gioco su una riga, così puoi esaminare tutto in quel momento. Nello Script Editor clicca nel margine a destra del numero di riga (compare un cerchio rosso), poi avvia un playtest. Quando l'esecuzione arriva a quella riga il gioco va in pausa, e una freccia gialla indica la riga successiva. Per avanzare nel codice si usano i pulsanti dell'esecuzione passo passo:

  • Step Over (F10) esegue la riga attuale e si ferma sulla successiva.
  • Step Into (F11) entra nella funzione chiamata su quella riga.
  • Step Out (Shift+F11) porta a termine la funzione attuale e si ferma nel codice che l'ha chiamata.
  • Resume Scripts prosegue fino al breakpoint successivo.

Il clic destro sul margine offre altri due tipi utili. Un breakpoint condizionale mette in pausa solo quando un'espressione come amount < 0 è vera. Un Logpoint stampa un messaggio nell'Output senza pausa, così puoi registrare un valore senza modificare lo script.

Watch e Call Stack

Mentre il gioco è in pausa, passa il mouse su una variabile nello Script Editor per vederne il valore. La finestra Watch, nella scheda Variables, mostra tutte le variabili visibili, e nella scheda My Watches puoi scrivere qualsiasi espressione, per esempio coins.Value + amount, e vederne il valore attuale. La finestra Call Stack mostra quale funzione ha chiamato quale per arrivare alla riga in pausa. Entrambe si aprono dalla scheda Script o dal menu Window.

Script Analysis e modalità strict

Lo Script Editor sottolinea i problemi già mentre scrivi, e la finestra Script Analysis, che si apre con il pulsante Analysis nella scheda Script, mostra errori e avvisi di tutti gli script. Cattura errori di sintassi e nomi sconosciuti prima di premere Play. Se metti --!strict come prima riga di uno script, si attiva il controllo dei tipi strict di Luau, che segnala anche errori di battitura nelle proprietà, tipi di argomenti sbagliati e valori che potrebbero essere nil. Però non vede il gioco in esecuzione: una parte che manca in Workspace la mostra solo l'Output.

Command bar

La command bar (nella scheda Script o con Ctrl+9, ⌘9 su Mac) esegue Luau all'istante. Mentre il gioco è avviato, è un modo veloce per fare una domanda: print(workspace:FindFirstChild("Bridge")) ti dice se quella parte esiste, e print(#game:GetService("Players"):GetPlayers()) conta i giocatori. In modalità modifica il codice della command bar cambia davvero il tuo place, quindi fai attenzione a tutto ciò che sposta o elimina oggetti.

Developer Console nel gioco live

L'Output di Studio funziona solo in Studio. Nel gioco live premi F9 o scrivi /console in chat per aprire la Developer Console. Il suo Log mostra l'output del tuo dispositivo, e l'output del server se sei il proprietario del gioco o un membro del gruppo con il permesso di modificarlo.

Anche l'Assistant integrato di Roblox può aiutare con un singolo messaggio: la guida di Roblox stessa consiglia di incollare l'errore dall'Output e chiedere all'Assistant di analizzarlo. Se l'Assistant ha smesso di rispondere o dice che hai raggiunto un limite, vedi limiti ed errori dell'Assistant.

Correggere gli errori con RoCode

RoCode è un agente IA indipendente per Roblox Studio: descrivi il problema nella chat web, e il plugin per Studio legge e modifica il place che hai aperto. Con gli errori può occuparsi dei passi di lettura della sequenza qui sopra, basandosi sul playtest che hai già avviato.

Tu scrivi

Ho premuto Play e cliccare sul pulsante del negozio non fa nulla. L'Output mostra attempt to index nil with 'Coins'. Trova la causa e correggila.

RoCode fa
  • Legge l'Output di Studio con il suo strumento Check Output, comprese le righe Server e Client del tuo ultimo playtest, anche dopo che hai premuto Stop
  • Apre lo script dell'errore con Read Script e legge il codice attorno a quella riga, e con Search Scripts può trovare dove avrebbe dovuto essere creato il valore mancante
  • Fa una modifica mirata con Edit Script, una ricerca e sostituzione esatta in quello script, poi esegue Check Script, che compila lo script dentro Studio (non controlla i tipi, non esegue un linter e non esegue il tuo codice)
  • Invia le modifiche a Studio a blocchi, e ogni blocco è un punto di annullamento nella cronologia di Studio

Premi di nuovo Play e clicca sul pulsante del negozio per verificare tu stesso la correzione: con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.15 o successivo il suo personaggio di prova può premere i pulsanti sullo schermo, ma controlla solo ciò che ha deciso di testare, e un controllo di compilazione non ti dice se la logica del gioco è corretta. La lettura degli errori fa parte di ogni build: il ciclo di build, controllo e test per un gioco intero ripete questo controllo dopo ogni sistema. Come RoCode si collega a Studio.

Domande frequenti

Perché uno script di Roblox non funziona anche se non ci sono errori?

Di solito lo script non è proprio partito (tipo di script o contenitore sbagliato, o Enabled disattivato), sta ancora aspettando qualcosa, oppure l'evento che ascolta non scatta mai. Un print sulla prima riga ti dice qual è il caso. Vedi la checklist qui sopra.

Cosa significa "attempt to index nil" in Roblox?

Il valore prima del punto o dei due punti era nil, quindi Roblox non ha potuto guardarci dentro. Sulla riga player.Character.Humanoid, l'errore attempt to index nil with 'Humanoid' significa che player.Character era nil: non esiste o non si è ancora caricato. Controlla il valore con un if prima di usarlo, e in un LocalScript aspetta gli oggetti creati dal server con WaitForChild. Altri dettagli sulle cause.

Cosa significa "infinite yield possible" in Roblox?

WaitForChild aspetta da più di 5 secondi un figlio che non è mai comparso, e continua ad aspettare. Spesso il nome o il genitore è sbagliato, oppure nessuno crea l'oggetto. Altri dettagli sulle cause.

Perché la finestra Output è vuota o non compare?

Aprila dal menu Window o dalla scheda Script. Se è aperta ma resta vuota durante il test, azzera i filtri e il campo di ricerca, poi controlla che gli script che dovrebbero stampare qualcosa partano davvero.

Roblox ha un controllo degli errori negli script?

Sì, è integrato in Studio: lo Script Editor sottolinea i problemi mentre scrivi, e la finestra Script Analysis li mostra in elenco. Trovano errori di sintassi e di tipo, ma non oggetti mancanti né logica di gioco sbagliata: quelli si vedono solo quando il codice è in esecuzione.

Devo racchiudere il codice in un pcall per evitare gli errori?

Solo le chiamate che possono fallire per motivi esterni al tuo codice, per esempio le richieste ai data store, HTTP o MarketplaceService. Se racchiudi in un pcall un errore con nil, il messaggio sparisce, ma la funzione continua a non funzionare.

Come vedo gli errori degli script nel gioco live?

Premi F9 nel gioco o scrivi /console in chat per aprire la Developer Console. Mostra gli errori del tuo dispositivo, e quelli del server se sei il proprietario del gioco o un membro del gruppo che può modificarlo.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.