fbpx
I migliori suggerimenti JavaScript per lo sviluppo web

I migliori suggerimenti JavaScript per lo sviluppo web

Stai cercando dei fantastici suggerimenti su JavaScript? Questo post delineerà una serie di suggerimenti JS divertenti ed efficaci per aiutarti a imparare uno dei linguaggi di programmazione più utilizzati su Internet.

Tratteremo i seguenti argomenti JavaScript;

  • ArrayMetodi in JS
  • Fare richieste API con JavaScript
  • Una panoramica dei cicli `for` in JavaScript
  • Introduzione a Node.js

Metodi array in JavaScript

L'array è uno dei componenti più importanti di JavaScript e di qualsiasi linguaggio di programmazione in generale. Spesso concepita erroneamente come il proprio tipo di dati, è in realtà un sottoinsieme del Object, insieme alle funzioni. In parole povere, un array è una struttura dati composta che può contenere una quantità illimitata di valori di qualsiasi tipo. Ciascuno dei valori è indicizzato numericamente (cioè ogni valore ha un numero, che designa la sua posizione nell'array). Ciò rende l'array estremamente flessibile per l'archiviazione e l'organizzazione dei dati. Gli array possono memorizzare stringhe, numeri, oggetti o anche altri array. Questo post fornirà una panoramica di alcuni dei metodi di array JavaScript incorporati più comunemente usati. È possibile utilizzare questi metodi o funzioni per manipolare e gestire i dati all'interno di un array.

I migliori suggerimenti JavaScript per lo sviluppo web

concat()

concat() Il metodo, abbreviazione di "concatena", ci consente di unire due array insieme:

var colori = ["nero", "bianco", "blu"];
var colors2 = ["verde", "giallo", "viola"];
 
document.write(colors.concat(colors2));
// output: "nero, bianco, blu, verde, giallo, viola"

 

Da solo, concat() non altererà l'array originale su cui è stato chiamato il metodo. chiamando colors produrrà comunque l'array originale con solo 3 valori. Per aggiornare l'array originale, dovresti chiamare il metodo sul on colors array, riassegnando la variabile:

Da solo, concat() non altererà l'array originale su cui chiami il metodo. chiamando colors produrrà comunque l'array originale con solo 3 valori. Per aggiornare l'array originale, dovresti chiamare il metodo sul call colors array, riassegnando la variabile:

colori = colori.concat(colori1); 

 

push()

Spesso vorrai solo aggiungere nuovi elementi alla fine di un array, che puoi usare con push() metodo per. Puoi inviare uno o più valori a un array nella stessa chiamata:

var colori = ["nero", "bianco", "blu"];
colori.push("verde", "giallo");
 
document.write(colori);
// output: "nero, bianco, blu, verde, giallo"

 

a differenza di concat(), push() effettua aggiorna l'array originale con i valori che hai inserito.

unshift()

Simile a push(), unshift() aggiungerà uno o più nuovi valori al inizio della matrice:

var colori = ["nero", "bianco", "blu"];
colori.unshift("verde");
 
document.write(colori);
// output: "verde, nero, bianco, blu"

 

pop()

pop() è l'inverso di push() metodo, in quanto "spunterà" o rimuoverà l'ultimo elemento di un array:

var colori = ["nero", "bianco", "blu"];
colori.pop();
 
document.write(colori);
// output: "nero, bianco" 

 

Dal pop() rimuove un elemento da un array, è comune memorizzare l'elemento rimosso in un'altra variabile per altri usi:

var lastItem = colori.pop();
 
document.write(lastItem);
// uscita: "blu"

 

shift()

Analogamente, shift() rimuoverà il primo elemento in un array:

var colori = ["nero", "bianco", "blu"];
colori.shift();
 
document.write(colori);
// output: "bianco, blu"; 

 

È inoltre possibile utilizzare shift() insieme alla memorizzazione dell'elemento rimosso in una nuova variabile:

var firstItem = colori.shift();
 
document.write(firstItem);
// output: "nero" 

 

reverse()

Come suggerisce il nome, il reverse() Il metodo invertirà l'ordine dei valori nell'array:

var myArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var reversedArray = myArray.reverse();
 
document.write(reversedArray);
// uscita: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

 

reverse() non altererà l'array originale. Dovrai memorizzare l'array invertito in una nuova variabile. In alternativa è possibile riassegnarlo alla variabile originale per mantenere le modifiche invertite.

join()

join() Il metodo array unirà tutti i valori nell'array in una stringa, quindi restituirà la stringa:

var colori = ["nero", "bianco", "blu", "verde"];
console.log(colors.join());
// output: nero, bianco, blu, verde 

 

C'è un parametro opzionale "separatore" che può essere incluso con join(). Questo parametro indica un carattere (o un insieme di caratteri) per separare ciascun valore nella stringa. L'esempio seguente separerà ogni valore con una virgola seguita da uno spazio vuoto:

var colori = ["nero", "bianco", "blu", "verde"];
console.log(colors.join(', ');
// output: nero, bianco, blu, verde 

 

join() non modificherà l'array originale. Dovrai assegnare la modifica a una variabile per salvarla.

var colorList = colors.join(', ');
console.log(listacolori);
// output: nero, bianco, blu, verde
 
console.log(colori);
// output: ["nero", "bianco", "blu", "verde"]
// cioè ancora l'array originale

 

sort()

sort() ordinerà i valori di un array in ordine alfanumerico. sort() effettua aggiorna l'array originale:

var arr1 = [4, 9, 3, 2, 1];
arr1.sort();
console.log(arr1);
// uscita: [1, 2, 3, 4, 9]

 

sort() ordina solo i valori nel momento in cui chiami il metodo. Dovrai richiamarlo di nuovo per riordinare se aggiungi o modifichi i valori nell'array.

indexOf()

indexOf() restituirà il valore dell'indice di un termine di ricerca fornito come parametro stringa al metodo:

var colori = ["nero", "bianco", "blu", "verde"];
colori.indexOf('bianco');
// restituisce 1

 

Se non c'è una corrispondenza di indice per il searchValue parametro, indexOf() sarà di ritorno -1:

var colori = ["nero", "bianco", "blu", "verde"];
colori.indexOf('arancione');
// restituisce -1

 

indexOf() fa distinzione tra maiuscole e minuscole:

colori.indexOf('Blu');
// restituisce -1

 

C'è anche un optional fromIndex parametro. Indica da quale valore di indice dovrebbe iniziare la ricerca. Se non fornito, la ricerca inizia da index 0 di default:

var names = ["Michele", "Giovanni", "Sarah", "Michele", "Matteo"];
nomi.indexOf('Michele', 2);
// restituisce 3 

 

slice()

slice() Il metodo restituirà una "fetta" dell'array, indicata da parametri opzionali per i punti di inizio e fine. slice() lascia l'array originale non modificato:

slice() Il metodo restituirà una "fetta" dell'array. Puoi indicare i punti di inizio e di fine tramite i suoi parametri opzionali. slice() lascia l'array originale non modificato:

var colors = ["nero", "bianco", "blu", "verde", "viola", "arancione"];
var colori2 = colori.slice(2, 5);
console.log(colori2);
// output: ["blu", "verde", "viola"]
 
var colori3 = colori.fetta(1);
console.log(colori3);
// output: ["bianco", "blu", "verde", "viola", "arancione"];
 
console.log(colori);
// output: ["nero", "bianco", "blu", "verde", "viola", "arancione"]; 

 

filter()

filter() è in qualche modo simile al slice() metodo. La differenza principale è che crea un nuovo array in base a determinate condizioni. Ogni valore nell'array che passa una condizione viene "filtrato" nel nuovo array. La condizione per il filtraggio viene impostata tramite la funzione di callback:

var someWords = ["facile", "difficile", "crittografia", "società", "totale", "fastidioso", "complessità"];
 
funzione checkSize(w) {
    ritorno w.lunghezza > 5;
}
 
var bigWords = someWords.filter(checkSize);
console.log(bigWords);
// output: ["crittografia", "società", "fastidioso", "complessità"] 

 

L'esempio sopra usa il checkSize() funzione di callback per filtrare le parole di lunghezza inferiore a 6 caratteri. Mette anche tutti i valori rimanenti in un nuovo array chiamato bigWords.

every()

every() array controllerà se ogni valore nell'array supera una condizione o meno. La condizione qui viene fornita anche tramite una funzione di callback. Se è passato, il metodo tornerà true, se non lo fa, tornerà false:

num var = [20, 31, 18, 500];
 
funzione maggioredi10 (valore) {
    valore restituito > 10;
}
 
console.log(nums.every(greerThan10));
// output: vero

 

L'esempio sopra verifica se ogni valore in nums array è maggiore di 10, tornando true.

isArray()

Come suggerisce il nome, .isArray() controllerà se un valore passato ad esso è un array o meno:

Array.isArray(['blu', 'giallo' 'verde']); // restituisce vero
Array.isArray(3); // restituisce false
Array.isArray('ciao'); // restituisce false

 

findIndex()

findIndex() è quasi l'opposto di indexOf() metodo. Restituirà l'indice del primo valore in un array che soddisfa una condizione. La condizione viene impostata tramite una funzione di callback. Se non viene trovato alcun valore che soddisfi la condizione, la funzione restituisce -1.

var colors = ['nero', 'blu', 'giallo', 'verde', 'viola'];
 
funzione maggiorediFive(e) {
    restituisce e.lunghezza > 5;
}
 
var indexOfLargeValue = colors.findIndex(greerThanFive);
console.log(indexOfLargeValue);
// uscita: 2

 

forEach()

forEach() Il metodo eseguirà una funzione di callback su ogni valore nell'array su cui è chiamato il metodo. Questo è utile per aggiungere valori equamente a ciascun indice in un array, così come per molte altre applicazioni. Tuttavia, questo non modificherà l'array originale, quindi i nuovi valori dovranno essere salvati in un'altra variabile:

num var = [1, 2, 3, 5, 8, 13];
var numsUpdated = [];
 
funzione aggiungiDue(e) {
    e += 2;
    numsUpdated.push(e);
}
 
nums.forEach(addTwo);
console.log(numsUpdated);
// uscita: [3, 4, 5, 7, 10, 15]

 

Questo è simile all'uso di a for loop per iterare su un array, con una sintassi leggermente più semplice.

includes()

Puoi usare includes() per verificare se un certo array contiene un dato un valore o meno. Se l'array lo fa, tornerà true, se non lo fa tornerà false.

var colors = ['nero', 'blu', 'giallo', 'verde', 'viola'];
 
console.log(colors.includes('blu'));
// output: vero
 
console.log(colors.includes('rosso'));
// output: falso

 

C'è un secondo parametro opzionale, fromIndex. Questo indicherà da dove iniziare la ricerca:

var colors = ['nero', 'blu', 'giallo', 'verde', 'viola'];
 
console.log(colors.includes('blue', 2));
// output: falso
 
console.log(colors.includes('blue', 1));
// output: vero

 

lastIndexOf()

Simile a indexOf(), lastIndexOf() troverà l'ultima istanza di un dato valore in un array, al contrario della prima. Il metodo inizierà la sua ricerca dalla fine dell'array e proseguirà fino all'inizio finché non verrà trovata una corrispondenza adatta. Se non viene trovata alcuna corrispondenza, il metodo tornerà -1:

var food = ['sushi', 'pizza', 'cheeseburger', 'sushi', 'pasta'];
 
console.log(food.lastIndexOf('sushi'));
// uscita: 3
 
console.log(food.lastIndexOf('burrito'));
// uscita: -1

 

.toString()

.toString() è in qualche modo simile al .join() metodo, in quanto entrambi possono restituire l'indice completo dei valori come stringa. toString() è un metodo molto più semplice. Non ha parametri facoltativi per specificare i caratteri "separatori" da inserire tra ciascun valore. Tutti i valori in un array saranno semplicemente separati da una virgola (senza spazi). Questo può essere positivo o negativo, a seconda dell'applicazione.

Fare richieste API con JavaScript

Uno dei componenti, se non il più importante, dell'interazione con i servizi di terze parti è la comunicazione con le loro API. In piedi per Application Programming Interface, questo è il modo principale in cui diversi siti Web, applicazioni e servizi Web possono comunicare tra loro, ricevendo e inviando dati avanti e indietro. Questo tutorial servirà come introduzione di base alla connessione a un'API Web tramite JavaScript e alla possibilità di ricevere o leggere GET richieste che restituiscono dati in JSON (o Notazione oggetto JavaScript) formato. Questo tutorial presuppone una conoscenza di base degli oggetti JavaScript e dell'accesso alle proprietà, ma è destinato a persone senza esperienza precedente nell'utilizzo delle API.

Introduzione

Per questo tutorial, esamineremo il API Ghibli, che è stato creato per introdurre le persone all'uso delle interfacce di programmazione delle applicazioni (oltre che per gli appassionati dei film dello Studio Ghibli).

L'API è suddivisa in 5 diversi moduli o componenti per diverse classi di dati relativi a Studio Ghibli (Film, Persone, Luoghi, Specie e Veicoli). Ciascuno di questi componenti è più formalmente indicato come an endpoint. Quando si effettua una chiamata all'endpoint tramite GET (o un altro metodo simile, come fetch), l'endpoint restituirà una matrice di dati specifici per quella categoria, in formato JSON. Ad esempio, l'endpoint per Film sarebbe simile a questo:

Richieste API con JavaScript

Prenderemo l'endpoint per i film (disponibile qui), effettuare una chiamata tramite GET, poi log varie parti dei dati al console.

// Crea un nuovo XMLHttpRequest e salvalo in una variabile
var ricevere = nuovi XMLHttpRequest();
 
// Indica l'endpoint che vorremmo aprire, tramite il metodo `GET`
ricevere.aprire('OTTENERE', 'https://ghibliapi.herokuapp.com/films', vero);
 
// Esegue il codice all'interno della funzione una volta caricato l'endpoint
ricevere.caricare = function () {
 
  // Analizza i dati in entrata in formato JSON  
  var in arrivo = JSON.parse(questo.risposta);
  
  // Usa il metodo dell'array .map per scorrere ogni indice nei Films
  // endpoint, quindi accedi a data di uscita, titolo e Rotten Tomatoes 
  // punteggio da ciascuno, registrandoli sulla console con alcuni addizionali
  // formattazione
  in arrivo.carta geografica(attraverso => {
      consolle.ceppo(attraverso.data di rilascio + " : " + attraverso.titolo + " -- (" +  attraverso.punteggio_rt + "% su pomodori marci)");
    });
};
 
// Invia la richiesta effettiva, per eseguire la funzione assegnata a 
// `ricevi.onload`
ricevere.inviare();    

L'inserimento del codice sopra nella console del browser o l'esecuzione come file JavaScript collegato a una pagina Web dovrebbe restituire quanto segue:

Richieste API con JavaScript

…dove mostriamo l'anno di uscita, il nome del film e la sua valutazione complessiva su Rotten Tomatoes (insieme ad alcune formattazioni aggiuntive per una migliore leggibilità)

La chiamata API spiegata

Le note documentate all'interno dello script sopra dovrebbero rendere esplicativa la maggior parte della chiamata API, ma la manipolazione dei dati all'interno receive.onload merita ulteriori dettagli.

.map() l'array è usato per scorrere ogni singolo indice all'interno dell'endpoint Film (cioè ogni film). UN for loop potrebbe essere usato anche qui, sebbene .map() fa la stessa cosa con molto meno codice. .map() accetta una funzione di callback (scritta qui nella sintassi ES6). Il codice all'interno della funzione di callback viene eseguito per ogni elemento nell'endpoint, recuperando la sua data di rilascio (films.release_date), titolo (films.title) e punteggio su Rotten Tomatoes (films.rt_score).

Per semplicità, a console.log messaggio viene utilizzato per ogni elemento, ma questi dati possono essere facilmente aggiunti agli elementi HTML della pagina o ordinati ulteriormente con altri metodi di matrice (es. filtrare solo i film degli anni '1980). Sebbene ci sia molto di più per lavorare con i servizi API, questa è una panoramica di alto livello dei meccanismi di recupero dei dati dagli endpoint di un'API.

Una panoramica dei cicli `for` in JavaScript

Una panoramica dei cicli `for` in JavaScript

Un principio fondamentale della programmazione del computer è l'adagio di vecchia data di "DRY", o "Don't Repeat Yourself". Ogni volta che ti ritrovi a riscrivere lo stesso codice più e più volte, è probabile che ci sia un modo migliore per rifattorizzare, senza la necessità di righe duplicate dello stesso codice. Uno dei modi migliori per farlo è tramite i loop. Esistono diversi tipi di loop, tutti presenti in varie forme in tutti i linguaggi di programmazione. In questo post, daremo un'occhiata a una delle forme più comuni e utili di loop, il for ciclo continuo.

Un esempio di base

Come introduzione per mostrare dove i loop sono molto utili, supponiamo che tu voglia stampare "Hello World" sul Sviluppatori JavaScript consolle. Senza l'uso di un ciclo, dovresti scrivere qualcosa lungo quanto segue:

console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo"); console.log("Ciao mondo");

 

Questo è estremamente noioso e inefficiente. Le 10 righe di codice precedenti possono essere drasticamente semplificate con solo le seguenti 3 righe:

for (var i = 0; i < 10; i++) { console.log("Hello World"); }

 

L'esempio sopra è noto come a known for loop, una delle forme più comuni e utili di loop.

for anello

Ci sono diversi componenti che vanno nella scrittura a for loop: il contatore o l'espressione iniziale, la condizione, l'espressione di incremento e il codice da eseguire all'interno del ciclo. Analizzeremo il nostro esempio sopra della creazione di un ciclo che stampa "Hello World" sulla console 10 volte.

Tutti for i loop iniziano con la parola chiave for, seguito da una serie di parentesi, quindi seguite da parentesi. Il codice da eseguire è posto all'interno delle parentesi. La struttura dello scheletro di a for ciclo può essere visto come:

for (contatore; condizione; incremento) { // Il codice da eseguire va qui }

 

Il contatore deve essere impostato come variabile; nella programmazione questo è spesso impostato come i, anche se potrebbe essere x, n o qualsiasi nome di variabile consentito dalla lingua. Questo dice al ciclo il suo valore iniziale, in questo caso, 0.

La parte successiva del ciclo dice a JavaScript la condizione: in questo caso, esegui il ciclo finché il valore di i è inferiore a 10. Non appena il ciclo raggiunge 10, si fermerà. Suo estremamente importante avere un set condizionale prima di provare a eseguire il tuo ciclo, altrimenti ti ritroverai con un ciclo infinito, che finirà per sovraccaricare e mandare in crash il tuo browser.

L'ultima parte del ciclo tra parentesi è l'incremento: i++. i++ è una scorciatoia in JavaScript per i += 1 or i = i + 1. In altre parole, aggiunge 1 al valore di i ogni volta che viene eseguito il ciclo. Questo è anche un componente cruciale del ciclo, poiché se non incrementasse effettivamente non verrà terminato.

Qualunque sia il codice inserito all'interno delle parentesi verrà eseguito attraverso ogni iterazione del ciclo. Se desideri avere una sorta di indicazione di quale iterazione si trova il ciclo ogni volta che viene eseguito, puoi semplicemente aggiungere la variabile contatore da includere nel codice che dovrebbe essere restituito ogni volta (cioè il codice eseguito all'interno delle parentesi ):

for (var i = 1; i <= 10; i++){ console.log("Il ciclo è ora in iterazione " + i); }

 

Il codice sopra, quando eseguito, stamperà:

Il ciclo è ora all'iterazione 1 Il ciclo è ora all'iterazione 2 Il ciclo è ora all'iterazione 3 Il ciclo è ora all'iterazione 4 Il ciclo è ora all'iterazione 5 Il ciclo è ora all'iterazione 6 Il ciclo è ora all'iterazione 7 il ciclo è ora all'iterazione 8 Il ciclo è ora all'iterazione 9 Il ciclo è ora all'iterazione 10

Introduzione a Node.js

Introduzione a Node.js

Lo sviluppo di JavaScript ha fatto molta strada da quando è stato introdotto per la prima volta nel 1995, dal co-fondatore di Mozilla Brendan Eich. Originariamente utilizzato come linguaggio di scripting lato client, JavaScript ha esteso il suo utilizzo ad applicazioni ben oltre le sue intenzioni originali. La lingua non è più utilizzata esclusivamente sul lato client. Con l'introduzione di Node.js, JavaScript viene ora utilizzato anche sul lato server, sostituendo la necessità di altri linguaggi di back-end come PHP, Python o Ruby.

Più che una semplice novità, sempre più sviluppatori e aziende stanno adottando JavaScript sul back-end, consentendo di svolgere tutto il lavoro di sviluppo in un'unica lingua. Per avere un'idea migliore del motivo per cui questo sta diventando una tendenza in crescita, questo post darà un'occhiata a cosa Node.js è, e per cosa è meglio usarlo.

Una spiegazione di Node.js

Node.js è un framework o una libreria JavaScript sviluppato per essere in grado di utilizzare JavaScript come linguaggio di scripting lato server primario. Non è un nuovo linguaggio, semplicemente un sottoinsieme di codice scritto per il linguaggio JavaScript. Creato originariamente da Ryan Dahl nel 2009, è basato sul motore JavaScript V8 di Google Chrome, che di per sé è stato sviluppato per offrire prestazioni migliori rispetto ad altri motori JavaScript esistenti. Node.js è completamente open source, funziona su tutti i sistemi operativi e viene costantemente migliorato dalla grande comunità di sviluppatori che circonda il progetto.

Poiché è destinato specificamente all'uso di backend, Node.js viene fornito con una varietà di moduli per gestire attività comuni per le quali si utilizzerebbe un linguaggio di scripting lato server. Questo può accelerare immensamente il processo di sviluppo, astraendo caratteristiche comuni che altrimenti dovresti scrivere da zero.

Le caratteristiche di base di Node.js

Ecco alcune delle caratteristiche fondamentali di Node.js che si separano dagli altri script quadri:

Programmazione asincrona basata su eventi

Le API utilizzate come parte del framework Node.js sono totalmente asincrone, altrimenti note come non bloccanti. Ciò equivale a Node.js che non deve mai attendere un'API specifica per inviare dati senza passare a un'altra attività. Node.js passerà a un'altra API, tenendo traccia dei dati che è ancora in attesa di ricevere da altre API.

Alte prestazioni

Node.js è estremamente veloce rispetto ad altre alternative lato server, essendo stato costruito sul motore V8 di Google Chrome. A seconda delle versioni confrontate, Node.js ha superato PHP e Python nei test di benchmark.

Evita il buffering

Le applicazioni Node.js emettono sempre i dati in blocchi, per evitare il buffering.

Scalabile

Node.js è stato sviluppato per essere utilizzato sia per piccoli progetti che per grandi sistemi aziendali. Node.js utilizza un modello a thread singolo per consentire eventi asincroni, mentre i linguaggi server comuni utilizzano un numero limitato di thread per gestire le richieste di dati. Ciò significa in definitiva che Node.js può gestire un numero maggiore di richieste del server contemporaneamente rispetto a una configurazione server più tipica come Apache HTTP.

Node.js in pratica

Node.js viene utilizzato per una vasta gamma di usi, da progetti open source o piccole startup, alle aziende Fortune 500. Un breve elenco di aziende che utilizzano Node.js include PayPal, Uber, Microsoft, eBay e GoDaddy.

A cosa serve Node.jss

Alcuni degli usi in cui Node.js brilla davvero includono applicazioni legate a I/0, come messaggistica chat, servizi di streaming di dati come video live, applicazioni Data Intensive Real-Time (DIRT), applicazioni Web a pagina singola e applicazioni che utilizzano un molte API basate su JSON.

Conclusione

Ci auguriamo che tu abbia trovato alcuni suggerimenti utili da questo articolo che puoi utilizzare con il tuo prossimo progetto Javascript. Sentiti libero di pubblicare il tuo feedback e suggerimenti JS tramite la sezione commenti qui sotto.

Potresti anche voler dare un'occhiata a questa fantastica risorsa che confronta JavaScript contro PHP.

angelo frisina luce solare media

Autore Bio

Angelo è coinvolto nel mondo creativo dell'IT da oltre 20 anni. Ha creato il suo primo sito Web nel 1998 utilizzando Dreamweaver, Flash e Photoshop. Ha ampliato le sue conoscenze e competenze imparando una gamma più ampia di abilità di programmazione, come HTML/CSS, Flash ActionScript e XML.

Angelo ha completato la formazione formale con il programma CIW (Certified Internet Webmasters) a Sydney in Australia, apprendendo i fondamenti fondamentali del networking di computer e come si relaziona con l'infrastruttura del world wide web.

Oltre a gestire Sunlight Media, Angelo ama scrivere contenuti informativi relativi allo sviluppo di app e web, marketing digitale e altri argomenti relativi alla tecnologia.