Quando parliamo di debug, è importante capire cosa potrebbe andare storto e in quali situazioni potresti voler
eseguire il debug del codice o evitare errori e la cosa più ovvia
che può andare storto è che l'app si blocca o che stai ottenendo un messaggio
di errore. In fase di
sviluppo, questa è una casella rossa che si sovrappone alla tua app che abbiamo già visto in questo corso e questi messaggi di
errore sono ovviamente un chiaro segno che qualcosa non va nel tuo codice.
Più sottili di così sono errori logici. Nelle tue app, ad un certo punto avrai sicuramente dei
comportamenti che potrebbero non avere senso per te o dove qualcosa semplicemente non funziona come dovrebbe funzionare.
Non stai ricevendo un errore ma la tua app si sta comportando male, funziona
in modo
errato e in genere, hai qualche errore logico da qualche parte che lo sta causando.
E, ultimo ma non meno importante, hai la tua interfaccia utente, il tuo
stile, il tuo layout, l'esperienza utente che vuoi creare e forse è
fuori, forse lì hai qualcosa che semplicemente non sembra o si sente come dovrebbe apparire o sentire e questo è anche qualcosa
che può andare storto e che vuoi evitare. Ora esempi tipici di messaggi di errore o
cause di messaggi di errore sono errori di sintassi in cui hai semplicemente un refuso nel tuo codice o dove hai dimenticato
una parentesi graffa chiusa, qualcosa del genere ma anche semplicemente bug nel tuo codice, quindi
ad esempio una riga di codice dove usi un valore che in realtà non
hai mai impostato, quindi stai provando ad esempio a calcolare qualcosa con un valore indefinito o ad analizzare una stringa
che in realtà non è
definita, niente del genere, che in genere porta anche a errori. E poi hai un tipo speciale di errore e questi sono
inevitabili errori come mi piace chiamarli.
Ora ciò non significa che si tratta di errori che non puoi evitare perché non
sei abbastanza
bravo come sviluppatore, invece intendo errori che potrebbero derivare da te quando fai una richiesta di rete e gli utenti della
tua app non hanno una connessione di rete o che stai scrivendo nel filesystem e in qualche modo questo accesso è bloccato,
quindi non puoi essere sicuro che ciò non fallirà mai quando gli utenti usano la tua app perché non puoi controllare come stanno usando la
tua app o in quali circostanze stanno usando la tua app e per tali errori, puoi anche trovare strategie
in cui non puoi evitare l'errore ma dove puoi gestirlo. Ora, per errori logici, un tipico esempio potrebbe
essere il comportamento delle app indesiderato o imprevisto e, naturalmente, si desidera liberarsene, il comportamento dell'utente
imprevisto o non gestito in modo che gli utenti utilizzino l'app in un modo non intendevano usarli, quindi
quando testate la vostra app durante lo sviluppo,
volete essere davvero creativi e scoprire se gli utenti potrebbero entrare in punti
dove possono procedere o dove la vostra app non funziona correttamente, quindi forse gli utenti hanno seguito una certa sequenza
di passaggi che porta a un errore, a un errore logico, forse a un certo punto
manca qualche input e non stai verificando che questo input sia impostato e quindi con quello non impostato,
puoi causare un altro problema o andare in un altro errore, quindi
qualcosa del genere.
Ora, ultimo ma meno importante, se parliamo di stile, layout, ovviamente possiamo avere uno stile imprevisto o
sbagliato, quindi stiamo testando l'app e vediamo che non sembra nel modo in cui
dovrebbe o forse abbiamo solo risultati incoerenti dispositivi diversi, forse la
nostra app ha un bell'aspetto su iOS ma non su Android o, ultimo ma non meno importante, forse abbiamo un
layout che non funziona o si sente bene su determinati dispositivi o orientamenti.
Forse i nostri contenuti non si adattano allo schermo su dispositivi molto piccoli,
queste sono tutte cose che vogliamo anche escludere. Ora è quello che puoi fare il
debug, come fai il debug? Quali strumenti ottieni per il debug degli errori?
Ora lo strumento più ovvio che stai ricevendo e tuttavia lo strumento che molte persone trascurano o semplicemente non guardano affatto sono
i messaggi di errore, leggi
seriamente i messaggi di errore che stai ricevendo.
L'ho visto così spesso nei miei corsi che gli studenti ottengono qualche errore e semplicemente vanno Oh dio, ho un errore, screenshot
o copia e incolla nella sezione Domande e risposte e, a volte, gli errori possono essere davvero difficili da debug o
da capire o hai bisogno di esperienza per scoprire cosa è andato storto, ma ad essere sinceri,
spesso i messaggi di errore sono molto chiari su ciò che è andato storto o contengono persino una soluzione
su come risolvere l'errore.
E, ultimo ma non meno importante, semplicemente prendere un messaggio di errore e cercarlo su Google spesso ti porta molto lontano perché
è probabile che tu non sia il primo a riceverlo.
Ora supponiamo che non visualizzi un messaggio di errore ma la tua app non si sta comportando correttamente in
qualche punto o non sei sicuro che un valore sia impostato correttamente in alcune parti del codice.
Un modo molto semplice per esaminare il tuo codice, per farti un'idea dei valori con cui stai lavorando
nel codice è usare un buon vecchio registro della console. Ora il debug dei log della console non ha la migliore reputazione
e, in effetti, non è eccezionale se si esegue il debug di un problema
molto complesso, ma semplicemente farsi un'idea del flusso del codice o di alcuni dei valori con cui si sta lavorando , è
ottimo.
Puoi semplicemente scaricarlo nel tuo codice e quindi scoprire quale valore stai utilizzando a quale punto o come
qualcosa si comporta in una determinata situazione o se qualcosa viene eseguito affatto e
quindi, questo è sicuramente qualcosa che dovresti anche fare.
Ora, per problemi più complessi o se vuoi davvero scorrere il tuo codice passo dopo passo, usare il debugger e
i punti di interruzione di Chrome è un ottimo strumento ed è supportato da React Native, sia
quando usi expo sia quando stai non usando expo. Lì puoi davvero immergerti profondamente nel tuo codice e
avere un'idea di come funziona, esaminarlo passo dopo passo e esaminare il tuo codice mentre viene
eseguito.
Quindi diamo un'occhiata a queste cose ora.