02-Le Basi
02 - Le Basi
Setup
- creare una nuova cartella e aprirla con VSCode
- creare al suo interno una nuova cartella chamata `playground
- nella cartella creare un file
index.htmle uno `playground.js - nel file
index.htmlinserire il codice
<!DOCTYPE html>
<html>
<head>
<title>Playground</title>
<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-9ndCyUaIbzAi2FUVXJi0CjmCapSmO7SnpJef0486qhLnuZ2cdeRhO02iuK6FUUVM" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js" integrity="sha384-geWF76RCwLtnZ8qwWowPQNguL3RmwHVBC9FhGdlKrxdiJJigb/j/68SIy3Te4Bkz" crossorigin="anonymous"></script>
<script src="./playground.js"></script>
</head>
<body>
<div class="container text-center mt-5">
<h1>Playground Page</h1>
<h3>Apri l'inspector con F12 o con click destro -> Ispeziona</h3>
<h3>Poi vai su console</h3>
</div>
</body>
</html>
Per visualizzare i risultati nel browser fare click destro sulla cartella playground e premere Open With Five Server. Se tutto va bene dovrebbe aprirsi un terminale in basso in VSCode con i log del server avviato, e dovrebbe lanciarsi automaticamente Chrome.
Per chiudere il server fare click sul fulmine giallo in basso a destra di VSCode (o chiudere il terminale).
console.log()
Stampa nella console i valori passati come argomento.
Viene molto utilizzato a scopo di debug, i browser hanno strumenti più avanzati per eseguire debug ma stampare il valore di una variabile o una scritta è più veloce per semplici controlli.
E' buona cosa togliere i console.log quando non servono più o prima di andare in produzione.
console.log("hello World");
// -> hello World
Esistono anche altri metodi di console che hanno risultati simili ma vengono usati per scopi diversi:
console.info() // non c'è differenza nel browser, ma è utile in node.js se si
// vuole impostare il log level
console.warn() // viene usato per mostrare messaggi di avvertimento, di solito
// lo si vede spesso quando si usano metodi deprecati o ci si
// dimentica di settare delle impostazioni
console.error() // mostra gli errori veri e propri, viene chiamato in automatico
// quando si verificano errori non gestiti ma può essere usato
// manualmente quando si vuole avere una traccia più precisa di
// alcuni errori
Variablili
Come in qualsiasi altro linguaggio di programmazione si usano le variabili per salvare e dare un nome riconoscibile a delle informazioni (valori numerici, stringhe, oggetti, ecc). Questo permette di utilizzarli in diversi punti del codice e manipolarli con facilità.
Dichiarazione e assegnazione
link utile
Dichiarare una variabile significa segnalarne l'esistenza, le viene dato un nome.
Ci sono 3 keyword con cui si può dichiarare una variabile:
- var è il vecchio modo usato da sempre in JavaScript. E' sconsigliato ad oggi perché è più semplice commettere errori difficili da indagare (ad esempio si possono dichiarare più variabili con lo stesso nome)
- let corregge i problemi di var ed è il modo raccomandato ad oggi
- const permette di dichiarare variabili il cui valore non può essere cambiato dopo la prima assegnazione
var firstName;
let firstName;
Nei casi qui sopra le variabili sono state dichiarate senza assegnare un valore. Una variabile senza un valore assegnato è undefined.
Per assegnare un valore a una variabile si usa l'operatore \=. Può essere fatto assieme alla dichiarazione o anche in seguito.
le variabili dichiarate con const non possono essere dichiarate senza valore.
const firstName = "Mario";
Il valore di una variabile, se non è stata creata come const, può essere riassegnato più volte.
let firstName;
firstName = "Mario";
// oppure
let firstName = "Mario";
// riassegnazione
let count = 0;
count = 1;
count = 2;
I nomi delle variabili sono case-sensitive. Possono contenere numeri (ma non può iniziare con un numero), lettere e qualsiasi carattere che non sia un operatore (ad esempio = o -).
Non ci sono regole nel formato dei nomi, per convenzione però si usa il camel case, nello specifico lowerCamelCase: prima lettera minuscola e la prima lettera di ogni successiva parola in maiuscolo.
JavaScript è un linguaggio non tipizzato, questo significa che quando viene definita una variabile può contenere qualsiasi tipo di valore e il tipo di valore può cambiare nel tempo.
let myvariable = 1; // numeric value
myvariable = 'one'; // string value
myvariable = 1.1; // decimal value
myvariable = true; // Boolean value
myvariable = null; // null value
Tipi di variabile
Primitive
Sono il tipo più basso di dato.
| Data Type | Description |
|---|---|
| String | String is a textual content wrapped inside ' ' or " " or ` ` (tick sign). Example: 'Hello World!', "This is a string", etc. |
| Number | Number is a numeric value. Example: 100, 4521983, etc. |
| Boolean | Boolean is a logical data type that has only two values, true or false. |
| Null | A null value denotes an absense of value. Example: let str = null; |
| Undefined | undefined is the default value of a variable that has not been assigned any value. Example: In the variable declaration, var str;, there is no value assigned to str. So, the type of str can be check using typeof(str) which will return undefined. |
Strutturali
Sono strutture dati che contengono altri valori primitivi o strutturali.
| Data Type | Description |
|---|---|
| Object | An object holds multiple values in terms of properties and methods. Example: js<br>let person = { <br> firstName: "James", <br> lastName: "Bond", <br> age: 15<br> }; <br> |
| Date | The Date object represents date & time including days, months, years, hours, minutes, seconds, and milliseconds. Example: let today = new Date("25 July 2021"); |
| Array | An array stores multiple values using special syntax. Example: let nums = [1, 2, 3, 4]; |
Operatori
Aritmetici
| Operator | Description |
|---|---|
| + | Adds two numeric operands. |
| - | Subtract right operand from left operand |
| * | Multiply two numeric operands. |
| / | Divide left operand by right operand. |
| % | Modulus operator. Returns remainder of two operands. |
| ++ | Increment operator. Increase operand value by one. |
| -- | Decrement operator. Decrease value by one. |
let prezzoNetto = 50;
let sconto = 30;
let prezzoScontato = prezzoNetto - (prezzoNetto * sconto / 100);
let iva = 22;
let prezzoFinale = prezzoScontato + (prezzoScontato * iva /100);
Comparazione
| Operators | Description |
|---|---|
| == | Compares the equality of two operands without considering type. |
| === | Compares equality of two operands with type. |
| != | Compares inequality of two operands. |
| > | Returns a boolean value true if the left-side value is greater than the right-side value; otherwise, returns false. |
| < | Returns a boolean value true if the left-side value is less than the right-side value; otherwise, returns false. |
| >= | Returns a boolean value true if the left-side value is greater than or equal to the right-side value; otherwise, returns false. |
| <= | Returns a boolean value true if the left-side value is less than or equal to the right-side value; otherwise, returns false. |
let a = 5, b = 10, c = "5";
let x = a;
a == c; // returns true
a === c; // returns false
a == x; // returns true
a != b; // returns true
a > b; // returns false
a < b; // returns true
a >= b; // returns false
a <= b; // returns true
Il numero 0, false e una stringa vuota "" sono uguali se confrontati con ==, diversi se si usa ===
let a = 0, b = '', c = false;
a == b; // true
a === b; // false
a == c; // true
a === c; // false
b == c; // true
b === c; // false
Logici
Operatori booleani per combinare più condizioni.
| Operator | Description |
|---|---|
| && | && is known as AND operator. It checks whether two operands are non-zero or not (0, false, undefined, null or "" are considered as zero). It returns 1 if they are non-zero; otherwise, returns 0. |
| | | | is known as OR operator. It checks whether any one of the two operands is non-zero or not (0, false, undefined, null or "" is considered as zero). It returns 1 if any one of of them is non-zero; otherwise, returns 0. |
| ! | ! is known as NOT operator. It reverses the boolean result of the operand (or condition). !false returns true, and !true returns false. |
let a = 5, b = 10;
(a != b) && (a < b); // returns true
(a > b) || (a == b); // returns false
(a < b) || (a == b); // returns true
!(a < b); // returns false
!(a > b); // returns true
Funzioni
Permettono di racchiudere un blocco di codice e riutilizzarlo più volte.
La sintassi base è:
function <function-name>(arg1, arg2, arg3,...)
{
//write function code here
}
Definizione di una funzione
function greet() {
console.log('Hello World!')
}
greet();
Argomenti
function greet(name) {
console.log('Hello ' + name);
}
greet('Pippo'); // Hello Pippo
greet('Pluto'); // Hello Pluto
JavaScript non lancia errore se si chiama una funzione con più o meno parametri di quelli con cui è stata dichiarata. Nel caso se ne passino di più quelli extra semplicemente non vengono utilizzati, se se ne passano di meno gli argomenti non passati avranno valore undefined. Gli argomenti di una funzione vengono sempre assegnati nell'ordine in cui vengono passati.
function greet(firstName, lastName) {
console.log('Hello '+ firstName + ' ' + lastName);
}
greet('Mario', 'Rossi', 'Sig.') // Hello Mario Rossi
greet('Mario') // Hello Mario undefined
Return
Una funzione può tornare un valore usando la keyword return.
function sum(num1, num2) {
return num1 + num2;
}
let result = sum(2, 3); // 5
Return interrompe l'esecuzione della funzione, qualsiasi codice dopo l'esecuzione di return non verrà eseguito. Il risultato di una funzione senza return è undefined.
Altre varianti
Una funzione può essere assegnata a una variabile per essere usata in seguito o passata come argomento:
let double = function(num) {
return num * 2;
}
double(3); // 6
let numbers = [1, 2, 3, 4];
numbers.map(double); // [2, 4, 6, 8]
In alternativa, se si deve solo passare una funzione come argomento una volta, si possono utilizzare anche quelle che vengono chiamate anonymous functions. Ci sono due varianti:
let numbers = [1, 2, 3, 4];
numbers.map(function(num) {
return num * 2;
});
// oppure con una arrow function
numbers.map((num) => {
return num * 2;
})
Le arrow functions si possono scrivere in forme più abbreviate a seconda del numero di righe della funzione e del numero di argomenti.
La forma estesa è:
let sum = (a, b) => {
return a + b;
}
ma essendoci solo una operazione si può abbreviare in:
let sum = (a, b) => a + b;
in questo caso il return è implicito e le parentesi del blocco di istruzioni sono state rimosse.
Se invece c'è un solo argomento si possono omettere le parentesi tonde che lo racchiudono:
let double = (num) => {
return num * 2;
}
// diventa
let double = num => {
return num * 2;
}
// che applicando la regola precedente a sua volta si abbrevia in
let double = num => num * 2;
Quindi l'esempio di partenza si può abbreviare in:
let numbers = [1, 2, 3, 4];
numbers.map(num => num * 2); // sempre [2, 4, 6, 8]
if/else
Permette di eseguire un blocco di codice solo se una determinata condizione è soddisfatta. else è opzionale
if(boolean expression)
{
// code to be executed if condition is true
} else {
// code to be executed if condition is false
}
let score = 19;
let result;
if (score > 18) {
result = 'passato';
} else {
result = 'fallito';
}
console.log(`Hai ${result} l'esame`);
Operatore ternario
Esiste una forma abbreviata usata specialmente per assegnare un valore a una variabile:
let score = 19;
let result = score > 18 ? 'passato' : 'fallito';
console.log(`Hai ${result} l'esame`);
for loop
Permette di eseguire in modo ripetuto un blocco di codice.
for(initializer; condition; iteration)
{
// Code to be executed
}
La dichiarazione si compone di 3 parti:
- initializer: inizializza un contatore al valore iniziale
- condition: specifica la condizione da soddisfare per avviare la prossima esecuzione
- iteration: modifica il contatore tra le esecuzioni
for (let i = 0; i < 5; i++)
{
console.log(i);
}
Sono utilizzati specialmente per eseguire operazioni sugli array:
let arr = [2, 4, 6, 8, 10];
for (let i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
Proprio per questo motivo è stata creata una forma più compatta e sicura per eseguire loop su array (e su tutti i dati iterable): for...of
Fornisce direttamente il valore alla posizione dell'array come argomento al blocco di codice, senza aver bisogno di usare gli indici, e scorre l'intero array senza aver bisogno di controllarne la lunghezza.
let arr = [2, 4, 6, 8, 10];
for(let item of arr) {
console.log(item);
}
Diventa però un po' più complicato accedere all'indice nell'elemento nel caso ce ne sia bisogno:
let arr = [2, 4, 6, 8, 10];
for(let [index, item] of arr.entries()) {
console.log(index, item);
}
Esercizio 02-01
Sviluppare il codice che gestisce i calcoli di un carrello degli acquisti.
Caratteristiche:
- ogni elemento del carrello è un oggetto con questo formato:
let item = {
name: "nome dell'oggetto",
netPrice: 10, // prezzo netto
weight: 250, // peso dell'oggetto in grammi
discount: 10, // sconto applicato all'oggetto, può essere 0
quantity: 2 // numero di oggetti di questo tipo
}
- il carrello è costituito da un array di oggetti come sopra
- se il peso totale dell'ordine supera i 2kg c'è un costo di spedizione di 7€, sopra i 5 di 15€ e sopra i 10 sempre 20€
- a seconda che l'acquisto arrivi dall'Italia o dall'estero ai prezzi si applica il 22% di IVA
Obiettivi:
- stampare a console la lista degli articoli con il prezzo finale calcolato (sconto e iva)
- calcolare il prezzo totale degli articoli e stamparlo
- calcolare le spese di spedizione in base al peso e stamparle
- scrivere il codice in modo che controlli la sigla del paese di destinazione, se è IT applica il 22% di IVA, altrimenti 0
const cart = [
{
name: 'ssd',
netPrice: 95,
weight: 100,
discount: 5,
quantity: 2
},
{
name: 'motherboard',
netPrice: 270,
weight: 900,
discount: 0,
quantity: 1
},
{
name: 'ram',
netPrice: 120,
weight: 60,
discount: 10,
quantity: 2
},
{
name: 'processor',
netPrice: 400,
weight: 130,
discount: 0,
quantity: 1
},
{
name: 'power supply',
netPrice: 130,
weight: 1400,
discount: 15,
quantity: 1
},
{
name: 'cpu cooler',
netPrice: 170,
weight: 1000,
discount: 23,
quantity:1
},
{
name: 'gpu',
netPrice: 1600,
weight: 2500,
discount: 0,
quantity: 1
},
{
name: 'case',
netPrice: 130,
weight: 3500,
discount: 30,
quantity: 1
}
];