Introduzione

Questo corso ti insegna i concetti fondamentali della programmazione, validi in qualsiasi linguaggio: Python, JavaScript, Java, C, e tutti gli altri. Imparare questi concetti una volta significa poterli applicare ovunque.

Useremo JavaScript per gli esempi, perché gira direttamente nel browser e puoi eseguirlo subito cliccando "Provalo tu". Ma le idee — variabili, cicli, funzioni — sono universali.

Cosa imparerai
Come memorizzare e manipolare dati (variabili, tipi)
Come prendere decisioni (condizioni)
Come ripetere operazioni (cicli)
Come organizzare il codice (funzioni, scope)
Come i computer rappresentano i numeri (binario, esadecimale)

💡 Non serve installare nulla: ogni esempio è eseguibile nel browser. Clicca "Provalo tu ▶", modifica il codice e guarda subito il risultato.

Cos'è programmare

Programmare significa scrivere una serie di istruzioni precise che il computer esegue una dopo l'altra. Un programma è come una ricetta: una sequenza di passi per ottenere un risultato.

Il computer è velocissimo ma "stupido": fa esattamente ciò che gli dici, anche se è sbagliato. Il lavoro del programmatore è tradurre un problema in passi così chiari che una macchina possa eseguirli.

L'algoritmo: il cuore della programmazione

Un algoritmo è la sequenza di passi per risolvere un problema, indipendente dal linguaggio. Esempio — fare un tè:

Riempi il bollitore d'acqua
Accendi il bollitore
Aspetta che l'acqua bolla
Metti la bustina nella tazza
Versa l'acqua

JS — il tuo primo programma

<!DOCTYPE html>
<html>
<body>
<script>
// Un programma esegue le istruzioni in ordine, dall'alto in basso
document.write("<h2>Ciao, mondo!</h2>");
document.write("<p>Questo è il mio primo programma.</p>");
document.write("<p>2 + 2 fa " + (2 + 2) + "</p>");
</script>
</body>
</html>

💡 "Hello, World!" è tradizionalmente il primo programma che si scrive in ogni linguaggio: serve a verificare che tutto funzioni.

Variabili

Una variabile è un contenitore con un nome che memorizza un valore. Puoi pensarla come una scatola etichettata: l'etichetta è il nome, il contenuto è il valore (che può cambiare).

JS — dichiarare e usare variabili

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
// Dichiarazione di variabili con 'let'
let nome = "Marco";
let eta = 25;
let altezza = 1.78;

// Le variabili possono cambiare valore
eta = eta + 1;  // ora vale 26

let testo = "";
testo += "Nome: " + nome + "\n";
testo += "Età: " + eta + "\n";
testo += "Altezza: " + altezza + " m\n";

document.getElementById("out").textContent = testo;
</script>
</body>
</html>

📋 Regole per i nomi delle variabili: usa nomi descrittivi (eta meglio di x), niente spazi, non iniziare con un numero, attenzione a maiuscole/minuscole (Nome ≠ nome).

Costanti

Una costante è come una variabile, ma il suo valore non può cambiare dopo essere stato assegnato. Si usano per valori fissi: π, il numero massimo di tentativi, l'aliquota IVA.

JS — costanti con const

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
const PI = 3.14159;
const IVA = 0.22;

let raggio = 5;
let area = PI * raggio * raggio;

let prezzoNetto = 100;
let prezzoConIva = prezzoNetto * (1 + IVA);

let out = "Area del cerchio (r=5): " + area.toFixed(2) + "\n";
out += "Prezzo con IVA: " + prezzoConIva.toFixed(2) + " €\n\n";

// Se provi a cambiare una costante ottieni un errore:
try {
  PI = 4;
} catch (e) {
  out += "Errore: non puoi modificare una costante!";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

💡 Convenzione: i nomi delle costanti si scrivono spesso in MAIUSCOLO (PI, MAX_TENTATIVI) per distinguerle dalle variabili.

Tipi di dati

Ogni valore in un programma ha un tipo, che ne determina la natura e le operazioni possibili.

Tipo	Descrizione	Esempio
Intero (int)	Numeri senza decimali	`42`, `-7`
Decimale (float)	Numeri con virgola	`3.14`
Stringa (string)	Testo	`"ciao"`
Booleano (bool)	Vero o falso	`true`, `false`
Array	Lista di valori	`[1, 2, 3]`
Null / undefined	Assenza di valore	`null`

JS — scoprire il tipo con typeof

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let intero   = 42;
let decimale = 3.14;
let testo    = "programmazione";
let vero     = true;
let lista    = [1, 2, 3];

let out = "";
out += intero   + " → " + typeof intero   + "\n";
out += decimale + " → " + typeof decimale + "\n";
out += testo    + " → " + typeof testo    + "\n";
out += vero     + " → " + typeof vero     + "\n";
out += lista    + " → " + typeof lista    + " (array)\n";

document.getElementById("out").textContent = out;
</script>
</body>
</html>

Type Casting (conversione di tipo)

Il type casting è la conversione di un valore da un tipo a un altro. È fondamentale, ad esempio, quando leggi un numero da un campo di testo: arriva come stringa e devi convertirlo in numero per fare calcoli.

JS — conversioni tra tipi

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

// Stringa → Numero
let testo = "42";
let numero = Number(testo);   // oppure parseInt(testo)
out += testo + " + 8 (come stringhe) = " + (testo + 8) + "\n";
out += numero + " + 8 (come numeri)  = " + (numero + 8) + "\n\n";

// Numero → Stringa
let n = 100;
let s = String(n);
out += "Tipo di String(100): " + typeof s + "\n\n";

// Stringa → Decimale
out += 'parseFloat("3.14") = ' + parseFloat("3.14") + "\n";

// Booleano da numero
out += "Boolean(0) = " + Boolean(0) + "\n";
out += "Boolean(5) = " + Boolean(5) + "\n";

document.getElementById("out").textContent = out;
</script>
</body>
</html>

⚠️ Un errore classico: "5" + 3 dà "53" (concatenazione di stringhe), non 8. Converti sempre in numero prima di fare calcoli!

Operatori

Gli operatori eseguono operazioni su valori e variabili.

Categoria	Operatori
Aritmetici	`+ - * / %` (modulo) `**` (potenza)
Confronto	`== === != < > <= >=`
Logici	`&&` (AND) `\|\|` (OR) `!` (NOT)
Assegnazione	`= += -= *= /=`

JS — operatori in azione

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let a = 17, b = 5;
let out = "";

out += "a = " + a + ", b = " + b + "\n\n";
out += "Somma:        a + b = " + (a + b) + "\n";
out += "Differenza:   a - b = " + (a - b) + "\n";
out += "Prodotto:     a * b = " + (a * b) + "\n";
out += "Divisione:    a / b = " + (a / b).toFixed(2) + "\n";
out += "Resto (mod):  a % b = " + (a % b) + "\n";
out += "Potenza:      a ** 2 = " + (a ** 2) + "\n\n";

out += "Confronti:\n";
out += "a > b?  " + (a > b) + "\n";
out += "a == b? " + (a == b) + "\n\n";

out += "Logici:\n";
out += "(a > 10) && (b < 10) = " + ((a > 10) && (b < 10)) + "\n";
out += "(a < 10) || (b < 10) = " + ((a < 10) || (b < 10)) + "\n";

document.getElementById("out").textContent = out;
</script>
</body>
</html>

🔑 L'operatore modulo % dà il resto della divisione. È utilissimo: n % 2 == 0 verifica se un numero è pari.

Commenti

I commenti sono note nel codice ignorate dal computer ma lette dagli umani. Servono a spiegare perché il codice fa qualcosa, non solo cosa fa.

JS — commenti su una riga e su più righe

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
// Questo è un commento su una sola riga

/*
  Questo è un commento
  su più righe.
  Utile per spiegazioni lunghe.
*/

let prezzo = 50;
let sconto = 0.2;  // 20% di sconto applicato ai saldi

// Calcola il prezzo finale dopo lo sconto
let finale = prezzo * (1 - sconto);

document.getElementById("out").textContent =
  "Prezzo finale: " + finale + " €";
</script>
</body>
</html>

💡 Buon codice si commenta da solo con nomi chiari. Usa i commenti per spiegare le decisioni difficili, non per ripetere l'ovvio.

Condizioni (if)

Le condizioni permettono al programma di prendere decisioni: esegui un blocco di codice solo se una condizione è vera.

if (condizione) { ... } else if (altra) { ... } else { ... }

JS — if / else if / else

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

function valuta(voto) {
  if (voto >= 90) {
    return "Eccellente! 🏆";
  } else if (voto >= 60) {
    return "Promosso ✅";
  } else {
    return "Bocciato ❌";
  }
}

let voti = [95, 72, 45, 60, 88];
for (let v of voti) {
  out += "Voto " + v + " → " + valuta(v) + "\n";
}

// Operatore ternario: forma compatta di if/else
let numero = 7;
let parita = (numero % 2 === 0) ? "pari" : "dispari";
out += "\n" + numero + " è " + parita;

document.getElementById("out").textContent = out;
</script>
</body>
</html>

Cicli (loop)

I cicli ripetono un blocco di codice più volte, evitando di riscriverlo. Sono uno strumento potentissimo: con poche righe puoi elaborare migliaia di dati.

Ciclo	Quando usarlo
for	Quando sai quante volte ripetere
while	Quando ripeti finché una condizione è vera
for...of	Per scorrere gli elementi di un array

JS — i tre tipi di ciclo

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

// Ciclo FOR: conta da 1 a 5
out += "FOR: ";
for (let i = 1; i <= 5; i++) {
  out += i + " ";
}

// Ciclo WHILE: dimezza finché > 1
out += "\n\nWHILE: ";
let n = 100;
while (n > 1) {
  out += n + " ";
  n = Math.floor(n / 2);
}

// Ciclo FOR...OF: scorre un array
out += "\n\nFOR...OF: ";
let frutti = ["🍎", "🍌", "🍊", "🍇"];
for (let f of frutti) {
  out += f + " ";
}

// Tabellina del 7 con un ciclo
out += "\n\nTabellina del 7:\n";
for (let i = 1; i <= 10; i++) {
  out += "7 x " + i + " = " + (7 * i) + "\n";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

⚠️ Attento ai cicli infiniti: se la condizione di un while non diventa mai falsa, il programma si blocca. Assicurati sempre che qualcosa cambi a ogni iterazione.

Array

Un array è una lista ordinata di valori, accessibili tramite un indice numerico che parte da 0.

JS — creare e manipolare array

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

// Creazione
let numeri = [10, 20, 30, 40, 50];

// Accesso per indice (parte da 0!)
out += "Primo elemento (indice 0): " + numeri[0] + "\n";
out += "Terzo elemento (indice 2): " + numeri[2] + "\n";
out += "Lunghezza array: " + numeri.length + "\n\n";

// Aggiungere e rimuovere
numeri.push(60);          // aggiunge in fondo
numeri.unshift(5);        // aggiunge all'inizio
out += "Dopo push e unshift: [" + numeri + "]\n\n";

// Scorrere e calcolare la somma
let somma = 0;
for (let n of numeri) somma += n;
out += "Somma di tutti: " + somma + "\n";
out += "Media: " + (somma / numeri.length) + "\n\n";

// Trovare il massimo
out += "Massimo: " + Math.max(...numeri) + "\n";
out += "Minimo: " + Math.min(...numeri);

document.getElementById("out").textContent = out;
</script>
</body>
</html>

🔢 L'indice parte da 0! In un array di 5 elementi, gli indici validi vanno da 0 a 4. Accedere a numeri[5] dà undefined.

Stringhe

Una stringa è una sequenza di caratteri (testo). I linguaggi offrono molti metodi per manipolarle: cercare, sostituire, dividere, cambiare maiuscole/minuscole.

JS — operazioni sulle stringhe

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let frase = "Imparare a Programmare";
let out = "";

out += "Stringa: \"" + frase + "\"\n\n";
out += "Lunghezza: " + frase.length + " caratteri\n";
out += "Maiuscolo: " + frase.toUpperCase() + "\n";
out += "Minuscolo: " + frase.toLowerCase() + "\n";
out += "Primo carattere: " + frase[0] + "\n";
out += "Contiene 'Program'? " + frase.includes("Program") + "\n";
out += "Sostituzione: " + frase.replace("Programmare", "Pensare") + "\n\n";

// Dividere una stringa in parole
let parole = frase.split(" ");
out += "Parole: " + parole.length + " → [" + parole + "]\n\n";

// Invertire una stringa
let invertita = frase.split("").reverse().join("");
out += "Invertita: " + invertita;

document.getElementById("out").textContent = out;
</script>
</body>
</html>

Funzioni

Una funzione è un blocco di codice riutilizzabile con un nome. Riceve dati in ingresso (parametri), esegue operazioni e può restituire un risultato (return). Le funzioni evitano la ripetizione e organizzano il codice.

function nome(parametri) { ... return risultato; }

JS — definire e chiamare funzioni

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

// Funzione con due parametri che restituisce un valore
function somma(a, b) {
  return a + b;
}

// Funzione che calcola l'area di un rettangolo
function areaRettangolo(base, altezza) {
  return base * altezza;
}

// Funzione che dice se un numero è primo
function isPrimo(n) {
  if (n < 2) return false;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) return false;
  }
  return true;
}

out += "somma(3, 4) = " + somma(3, 4) + "\n";
out += "areaRettangolo(5, 8) = " + areaRettangolo(5, 8) + "\n\n";

out += "Numeri primi da 1 a 20: ";
for (let i = 1; i <= 20; i++) {
  if (isPrimo(i)) out += i + " ";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

💡 Una buona funzione fa una cosa sola e la fa bene. Se una funzione diventa troppo lunga, probabilmente va divisa in più funzioni.

Ricorsione

La ricorsione è quando una funzione chiama se stessa. È utile per problemi che si possono dividere in sotto-problemi più piccoli dello stesso tipo. Ogni funzione ricorsiva ha bisogno di un caso base che ferma la ricorsione.

JS — fattoriale e Fibonacci ricorsivi

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

// Fattoriale: n! = n * (n-1) * ... * 1
function fattoriale(n) {
  if (n <= 1) return 1;        // caso base
  return n * fattoriale(n - 1); // chiamata ricorsiva
}

// Fibonacci: ogni numero è la somma dei due precedenti
function fib(n) {
  if (n < 2) return n;          // casi base: fib(0)=0, fib(1)=1
  return fib(n - 1) + fib(n - 2);
}

out += "Fattoriali:\n";
for (let i = 1; i <= 6; i++) {
  out += i + "! = " + fattoriale(i) + "\n";
}

out += "\nSequenza di Fibonacci:\n";
for (let i = 0; i < 10; i++) {
  out += fib(i) + " ";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

⚠️ Senza un caso base corretto, la ricorsione non si ferma mai e il programma va in errore ("stack overflow"). È l'equivalente ricorsivo del ciclo infinito.

Scope (visibilità)

Lo scope è la regione del codice in cui una variabile è accessibile. Una variabile dichiarata dentro una funzione (locale) non esiste fuori da essa; una dichiarata fuori (globale) è visibile ovunque.

JS — scope locale e globale

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "";

let globale = "Sono visibile ovunque";  // scope globale

function esempio() {
  let locale = "Esisto solo qui dentro"; // scope locale
  out += "Dentro la funzione:\n";
  out += "  globale: " + globale + "\n";
  out += "  locale:  " + locale + "\n";
}

esempio();

out += "\nFuori dalla funzione:\n";
out += "  globale: " + globale + "\n";

// Provare ad accedere a 'locale' qui darebbe errore
try {
  out += "  locale: " + locale;
} catch (e) {
  out += "  locale: ERRORE - non è definita qui!";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

🔒 Limitare lo scope è una buona pratica: meno variabili globali = meno errori e codice più facile da capire e mantenere.

Input e Output

Un programma comunica con l'esterno tramite input (dati che riceve) e output (risultati che produce). Vediamo un esempio interattivo con un campo di input.

JS — input dell'utente e output

<!DOCTYPE html>
<html>
<head>
  <style>
    body { font-family: Arial; padding: 20px; }
    input { padding: 8px; font-size: 1rem; width: 200px; }
    button { padding: 8px 16px; background: #4f46e5; color: #fff; border: none; border-radius: 4px; cursor: pointer; }
    #risultato { margin-top: 16px; font-size: 1.2rem; font-weight: bold; color: #0d9488; }
  </style>
</head>
<body>

<h3>Convertitore Celsius → Fahrenheit</h3>
<input type="number" id="celsius" placeholder="Gradi Celsius" value="25">
<button onclick="converti()">Converti</button>
<div id="risultato"></div>

<script>
function converti() {
  // INPUT: legge il valore dal campo
  let c = Number(document.getElementById("celsius").value);

  // ELABORAZIONE: formula di conversione
  let f = c * 9/5 + 32;

  // OUTPUT: mostra il risultato
  document.getElementById("risultato").textContent =
    c + "°C = " + f + "°F";
}
converti();
</script>
</body>
</html>

⌨️ Ogni programma segue lo schema Input → Elaborazione → Output: riceve dati, li elabora secondo un algoritmo, e produce un risultato.

Bit e Byte

Al livello più basso, i computer conoscono solo due stati: 0 e 1 (acceso/spento). Un singolo 0 o 1 è un bit. Otto bit formano un byte.

Unità	Valore
1 bit	0 o 1
1 byte	8 bit (256 combinazioni: 0-255)
1 KB (kilobyte)	1.024 byte
1 MB (megabyte)	1.024 KB
1 GB (gigabyte)	1.024 MB

JS — quante combinazioni con N bit?

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "Con N bit puoi rappresentare 2^N valori:\n\n";

for (let bit = 1; bit <= 8; bit++) {
  let combinazioni = 2 ** bit;
  out += bit + " bit → " + combinazioni + " combinazioni";
  if (bit === 8) out += "  (un byte: 0-255)";
  out += "\n";
}

out += "\nEsempio: con 1 byte (8 bit) puoi rappresentare\n";
out += "un numero da 0 a 255, oppure un carattere (codice ASCII).";

document.getElementById("out").textContent = out;
</script>
</body>
</html>

Numeri binari

Il sistema binario (base 2) usa solo le cifre 0 e 1. È il linguaggio nativo dei computer. Ogni posizione vale una potenza di 2.

1011 (binario) = 1·8 + 0·4 + 1·2 + 1·1 = 8 + 2 + 1 = 11 (decimale)

JS — convertire decimale ↔ binario

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "Decimale → Binario:\n\n";

for (let n of [2, 5, 8, 10, 16, 42, 255]) {
  // toString(2) converte in binario
  let bin = n.toString(2);
  out += n + " = " + bin.padStart(8, "0") + " (binario)\n";
}

out += "\nBinario → Decimale:\n\n";
for (let b of ["0001", "0101", "1010", "1111", "11111111"]) {
  // parseInt con base 2
  let dec = parseInt(b, 2);
  out += b + " = " + dec + " (decimale)\n";
}

document.getElementById("out").textContent = out;
</script>
</body>
</html>

💡 Per convertire da decimale a binario a mano: dividi ripetutamente per 2 e leggi i resti dal basso verso l'alto.

Numeri esadecimali

Il sistema esadecimale (base 16) usa 16 simboli: 0-9 e A-F (dove A=10, B=11, ... F=15). È compatto e molto usato in informatica, per esempio nei colori (#FF5733) e negli indirizzi di memoria.

Decimale	Binario	Esadecimale
10	1010	A
15	1111	F
255	11111111	FF

JS — esadecimale e colori RGB

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<div id="colore" style="margin-top:12px;padding:20px;color:#fff;font-weight:bold;border-radius:8px"></div>
<script>
let out = "Decimale → Esadecimale:\n\n";
for (let n of [10, 15, 16, 255, 4096]) {
  out += n + " = " + n.toString(16).toUpperCase() + " (hex)\n";
}

// Un colore in esadecimale: #RRGGBB
let r = 255, g = 87, b = 51;
let hex = "#" +
  r.toString(16).padStart(2,"0") +
  g.toString(16).padStart(2,"0") +
  b.toString(16).padStart(2,"0");

out += "\nColore RGB(" + r + ", " + g + ", " + b + ")\n";
out += "in esadecimale = " + hex.toUpperCase();

let div = document.getElementById("colore");
div.style.background = hex;
div.textContent = "Questo è il colore " + hex.toUpperCase();

document.getElementById("out").textContent = out;
</script>
</body>
</html>

Algebra booleana

L'algebra booleana lavora con due soli valori: vero (1) e falso (0). È il fondamento della logica dei computer. Le operazioni base sono AND, OR e NOT.

A	B	A AND B	A OR B	NOT A
0	0	0	0	1
0	1	0	1	1
1	0	0	1	0
1	1	1	1	0

JS — tabelle di verità generate dal codice

<!DOCTYPE html>
<html>
<body>
<pre id="out"></pre>
<script>
let out = "Tabella di verità completa:\n\n";
out += "A  B | AND  OR  XOR | NOT A\n";
out += "---------------------------\n";

for (let a = 0; a <= 1; a++) {
  for (let b = 0; b <= 1; b++) {
    let and = a && b;
    let or  = a || b;
    let xor = a ^ b;          // OR esclusivo
    let notA = a ? 0 : 1;
    out += a + "  " + b + " |  " + and + "    " + or +
           "    " + xor + "  |   " + notA + "\n";
  }
}

out += "\nAND: vero solo se ENTRAMBI veri\n";
out += "OR:  vero se ALMENO UNO vero\n";
out += "XOR: vero se DIVERSI tra loro\n";
out += "NOT: inverte il valore";

document.getElementById("out").textContent = out;
</script>
</body>
</html>

🔌 Questi operatori logici sono realizzati fisicamente nei processori da minuscoli circuiti chiamati porte logiche (logic gate). Milioni di esse compongono una CPU.

Esercizi pratici

🏆 Esercizio 1 — FizzBuzz

Scrivi un ciclo da 1 a 30 che stampi: "Fizz" se il numero è divisibile per 3, "Buzz" se divisibile per 5, "FizzBuzz" se divisibile per entrambi, altrimenti il numero stesso. (Usa l'operatore modulo %.)

🏆 Esercizio 2 — Conta le vocali

Scrivi una funzione che riceva una stringa e restituisca quante vocali contiene. Testala con "programmazione". (Suggerimento: scorri i caratteri con un ciclo e controlla con un if.)

🏆 Esercizio 3 — Massimo di un array

Senza usare Math.max, scrivi una funzione che trovi il valore più grande in un array di numeri, usando un ciclo e una variabile che tiene traccia del massimo trovato finora.

🏆 Esercizio 4 — Convertitore binario

Scrivi una funzione che converta un numero decimale in binario senza usare toString(2), applicando il metodo delle divisioni successive per 2.

E ora?

Complimenti! Hai imparato i concetti fondamentali della programmazione, validi in ogni linguaggio. Ora hai le basi per scegliere e imparare un linguaggio specifico molto più velocemente.

Cosa hai imparato:

Variabili, costanti e tipi di dati
Operatori e type casting
Condizioni e cicli (il controllo di flusso)
Array e stringhe
Funzioni, ricorsione e scope
Input/output e struttura di un programma
Bit, byte, numeri binari ed esadecimali
Algebra booleana e logica

Il passo successivo? Scegli il tuo primo linguaggio. Consiglio Python (semplice e leggibile) o JavaScript (gira nel browser) per iniziare.

Vai al corso Python →Vai al corso JavaScript →Vai al corso DSA →Torna ai Corsi

Introduzione alla Programmazione

Introduzione

Cos'è programmare

L'algoritmo: il cuore della programmazione

Variabili

Costanti

Tipi di dati

Type Casting (conversione di tipo)

Operatori

Commenti

Condizioni (if)

Cicli (loop)

Array

Stringhe

Funzioni

Ricorsione

Scope (visibilità)

Input e Output

Bit e Byte

Numeri binari

Numeri esadecimali

Algebra booleana

Esercizi pratici

E ora?