"Ciao, Amico!"
"Ciao Bilaabo!"
"Sono felice di vederti. Oggi abbiamo una piccola ma molto istruttiva lezione. Oggi ti parlerò del linguaggio JavaScript."
"Una nuova lingua? Che interessante..."
"JavaScript è attualmente popolare grazie a Internet. Il fatto è che è l'unico linguaggio che tutti i browser possono eseguire. Se vuoi aggiungere animazione o logica alla tua pagina web, allora puoi farlo con JavaScript."
"È vero che JavaScript è il linguaggio più popolare?"
"Sì, ma sarebbe più esatto dire che è la 'seconda lingua' più popolare. I programmatori C++, Java, C# e PHP devono scrivere piccoli script in JavaScript per ravvivare le loro pagine web. Ma solo molte meno persone scrivere codice in JavaScript."
"Perché si chiama JavaScript? Sembra quasi Java."
"In realtà, inizialmente, si chiamava LiveScript, ma quando Java ha cominciato a diventare più popolare, è stato rinominato JavaScript."
"Java e JavaScript sono due linguaggi completamente diversi. Non confonderli."
"A differenza di Java, JavaScript non ha classi e non supporta la tipizzazione statica, il multithreading e molto altro. Java è come un ampio set di strumenti di costruzione, mentre JavaScript è più simile a un coltellino svizzero. JavaScript è progettato per risolvere piccoli compiti, ma Java è per risolvere compiti grandi e molto grandi."
"Ecco alcuni fatti su JavaScript:"
"Il primo fatto è che JavaScript ha funzioni, ma non classi"
"Semplicemente scrivi programmi usando diverse funzioni e basta. Ad esempio:"
function min(a, b)
{
return a
}public static int min(int a, int b)
{
return a
}
"Le nuove funzioni sono dichiarate usando «funzione <nome>».
"Un altro esempio:"
function min(a, b)
{
return a < b ? a: b;
}
function main()
{
var s = 3;
var t = 5;
var min = min(s, t);
}public static int min(int a, int b)
{
return a < b ? a : b;
}
public static void main()
{
int s = 3;
int t = 5;
int min = min(s,t);
}"Il secondo fatto è che JavaScript ha variabili, ma quelle variabili non hanno tipi"
"JavaScript è un linguaggio tipizzato dinamicamente. Ciò significa che le variabili in realtà non hanno tipi. A qualsiasi variabile può essere assegnato un valore di qualsiasi tipo (i valori hanno tipi). Ad esempio:"
function main()
{
var s = "Bender";
var k = 1;
var n = s.length;
}public static void main()
{
String s ="Bender";
int k = 1;
int n = s.length();
}"Ma la digitazione dinamica aumenta il rischio di errori di runtime:"
function main()
{
var s = "Bender";
var k = 1;
var n = k.length;
}public static void main()
{
String s ="Bender";
int k = 1;
int n = k.length();
}"Nell'esempio sopra, abbiamo usato la variabile k (un numero intero) invece di s (una stringa). In Java, l'errore verrebbe rilevato in fase di compilazione, ma in JavaScript non verrà rilevato fino a quando il codice sta correndo."
"Se vuoi dichiarare una variabile in JavaScript, devi scrivere «var <nome>». Non ci sono tipi di variabili e non ci sono tipi per metodi/funzioni o i loro argomenti."
"JavaScript ha pochissime regole rigide e molta anarchia."
"Puoi dichiarare una funzione con 5 argomenti e chiamarla con due: il resto sarà nullo. Puoi dichiarare una funzione con due argomenti e passarne cinque quando la chiami. Tre verranno semplicemente buttati via. C'è un controllo minimo su errori, errori di battitura e modifiche."
"Il terzo fatto è che JavaScript ha istruzioni if, for e while"
"JavaScript ha if, for e while. Questa è un'ottima notizia. Guarda questi esempi:"
function main()
{
var s = "Bender";
var result = "";
for(var i = 0; i < s.length; i++)
{
result += s[i] + "";
}
if(result.length > 10)
{
alert (result);
}
else
{
while(result.length <= 10)
{
result += " ";
}
alert(result);
}
}public static void main()
{
String s = "Bender";
char[] s2 = s.toCharArray();
String result = "";
for(int i = 0; i < s.length(); i++)
{
result += s2[i] + "";
}
if(result.length() > 10)
{
System.out.println(result);
}
else
{
while (result.length() <= 10)
{
result += " ";
}
System.out.println(result);
}
}"Sono piuttosto simili. Penso di poter capire come funziona il codice scritto in JavaScript."
"Il tuo ottimismo è buono."
"Il quarto fatto è che JavaScript supporta i blocchi try-catch-finally"
" JavaScript ha eccezioni ( Error ) e va bene. Non ha eccezioni controllate , solo eccezioni non controllate simili a RuntimeException . Il costrutto try-catch-finally funziona come in Java. Ad esempio:"
function main()
{
try
{
var s = null;
var n = s.length;
}
catch(e)
{
alert(e);
}
}public static void main()
{
try
{
String s = null;
int n = s.length();
}
catch(Exception e)
{
System.out.println(e);
}
}"Quando proviamo a ottenere la lunghezza della stringa, verrà generata un'eccezione poiché la variabile è nulla."
"Il quinto fatto è che JavaScript ha array"
"Buone notizie: JavaScript ha array. Cattive notizie: non ci sono elenchi o raccolte."
"Un'altra buona notizia è che gli array possono espandersi dinamicamente quando vengono aggiunti nuovi elementi e diminuire man mano che gli elementi vengono rimossi. È più simile a un ibrido tra un array e un elenco. "
Per esempio:
function main()
{
var m = [1, 3, 18, 45, 'c', "roma", null];
alert(m.length); // 7
m.push("end");
alert(m.length); // 8
for (var i = 0; i < m.length; i++)
{
alert(m[i]);
}
}public static void main()
{
List m = Arrays.asList(1, 3, 18, 45,'c', "roma", null);
System.out.println(m.size()); // 7
m.add("end");
System.out.println(m.size()); // 8
for (int i = 0; i < m.size(); i++)
{
System.out.println(m.get(i));
}
}"Cosa sono quelle parentesi quadre nella dichiarazione dell'array?"
"Questo è esattamente ciò che è una dichiarazione di array. Per dichiarare un array, devi scrivere parentesi quadre. Quindi elenchi gli elementi dell'array tra parentesi. Dichiari un array vuoto semplicemente con un paio di parentesi."
var m = [];"Il sesto fatto è che JavaScript ha oggetti"
"JavaScript ha oggetti. In effetti, tutto in JavaScript è un oggetto, anche i tipi primitivi. Ogni oggetto è rappresentato come un insieme di coppie chiave-valore. In parole povere, ogni oggetto JavaScript è equivalente a una HashMap in Java. Ecco un esempio di una dichiarazione di oggetto:"
function main()
{
var m = {
first_name : "Bill",
last_name: "Gates",
age: 54,
weight: 67,
children: ["Emma", "Catrin"],
wife: {
first_name : "Melinda",
last_name: "Gates",
age: 45,
}
};
alert(m.first_name); // Bill
alert(m.age); // 54
alert(m.wife.first_name); // Melinda
m.age = 45;
m.age++;
m["first_name"] = "Stive";
m["wife"] = null;public static void main()
{
HashMap m = new HashMap();
m.put("first_name", "Bill");
m.put("last_name", "Gates");
m.put("age", 54);
m.put("weight", 67);
String[] children = {"Emma", "Catrin"};
m.put("children", children);
HashMap wife = new HashMap();
wife.put("first_name", "Melinda");
wife.put("last_name", "Gates");
wife.put("age", 45);
m.put("wife", wife);
System.out.println(m.get("first_name"));
System.out.println(m.get("age"));
HashMap w = ((HashMap)m.get("wife"));
System.out.println(w.get("first_name")));
m.put("age", 45);
m.put("age", ((Integer)m.get("age")) + 1);
m.put("first_name", "Stive");
m.put("wife", null);"Per creare un nuovo oggetto, devi solo scrivere due parentesi graffe: «{}»."
"All'interno delle parentesi graffe, puoi specificare i dati dell'oggetto nel seguente formato: «chiave, due punti, valore, virgola»."
"È possibile accedere ai campi oggetto in due modi:"
m.age = 45;m[“age”] = 45;"Se il campo specificato non esiste, viene creato."
"La mia valvola di sfogo è sovraccarica o qualcosa del genere. Penso che dovremmo fare una pausa."
GO TO FULL VERSION