Le Primitive in JavaScript

Tutti i linguaggi di programmazione hanno delle strutture dati predefinite e il più delle volte il modo in cui vengono impiegate varia da linguaggio a linguaggio. JavaScript, ad esempio, non prevede l'associazione diretta di una variabile e uno specifico tipo di valore. Questo comportamento permette di riassegnare quante volte si desidera i valori:

1let pippo = 69; // pippo è un numero
2pippo = "nice"; // pippo è una stringa
3pippo = true; // pippo è un booleano

Lo snippet di codice sopra è molto semplice: viene dichiarata una variabile nominata pippo alla quale viene associato un numero, dopo di che avviene una nuova associazione, stavolta viene associata una stringa (racchiusa tra apici) e infine viene riassociata nuovamente, stavolta ad un valore booleano (vero o falso). let non serve ripeterlo ogni volta, serve solo a dichiarare la variabile la prima volta.

Questo genere di assegnazione in altri linguaggi, come ad esempio C, sarebbe stato segnalato come errore, ma in JavaScript no.

JavaScript suddivide i valori in 7 differenti gruppi, chiamati primitive, e in oggetti (i quali verranno affrontati più avanti).

Nello specifico le primitive presenti sono:

• Boolean
• Null
• Undefined
• Number
• BigInt
• String
• Symbol

Boolean

I valori booleani possono avere solamente due valori: true o false. In JavaScript vengono impiegati principalmente per decidere quali sezioni di codice eseguire (if) o ripetere (while e for).

Prendono il nome dal matematico inglese George Boole, pioniere della matematica logica.

1if (condizione booleana) {
2  // Codice da eseguire se la condizione booleana è vera.
3}
4
5for (variabile di controllo; condizione booleana; contatore) {
6  // Codice da ripetere fintanto che la condizione booleana risulterà vera.
7}

Come per tutte le primitive JavaScript mette a disposizione un oggetto che ci permette di effettuare delle operazioni, nello specifico l'oggetto Boolean mette a disposizione due metodi che sono:

• toString(): trasforma il valore booleano in una stringa (true ► "true").
• valueOf(): restituisce il valore primitivo dell'oggetto Boolean.

Null

La primitiva Null ha solo un valore null. Rappresenta un valore volontariamente assente o per meglio dire rappresenta una referenza che punta, intenzionalmente, a un valore inesistente. Se utilizzato in una condizione booleana, il valore di null è false.

1if (null) {
2  // Questo pezzo di codice non verrà mai eseguito perché null è considerato falso.
3}

Undefined

Una variabile alla quale non è stato assegnato alcun valore è definita come undefined. Se null è considerato il rappresentante di un valore volontariamente mancante, undefined è sicuramente il rappresentante dei valori involontariamente mancanti.

Differenza tra Null e Undefined

undefined è un valore che viene assegnato automaticamente quando, ad esempio, ad una variabile non viene assegnato nulla o quando una funzione non restituisce qualcosa. null, invece, può essere assegnato ad una variabile e può essere restituito da una funzione.

Number

ECMAScript (o JavaScript per gli amici) ha due tipi numerici: Number e BigInt.

Il primo tra questi, Number, supporta valori in double-precision 64-bit binary format IEEE 754, i quali in pratica sono numeri che spaziano tra -(2 ^ 53 - 1) a (2 ^ 53 + 1). A differenza di altri linguaggi che prevedono una differenza di tipo tra numeri con la virgola (float) o interi (integer) per JavaScript è tutto racchiuso sotto Number. Oltre a ciò il tipo di dato supporta anche tre valori simbolici: +Infinity, -Infinity e NaN (Not a Number).

BigInt

BigInt è un tipo di dato numerico che rappresenta un numero intero nel formato di precisione arbitrario.

Un BigInt si crea facendo seguire la lettera n ad un numero intero (es. 2n). La peculiarità dei BigInt, rispetto a Number, è che permettono di operare con numeri che vanno oltre al numero intero sicuro massimo (9.007.199.254.740.991 o ~9 quadrilioni).

Si possono utilizzare gli operatori più comuni come +, -, *, ** (elevazione a potenza) e % (modulo o resto della divisione), come con i Number e sempre come quest'ultimi si comportano i BigInt con gli operatori booleani come ||, && e !.

String

In ogni linguaggio di programmazione, una stringa è una sequenza di caratteri usati per rappresentare un testo.

In JavaScript una stringa può essere delimitata da apici singoli ', apici doppi " e backtick o accenti gravi ` e come tutte le altre primitive JavaScript mette a disposizione un oggetto che permette di effettuare operazioni di mutazione o per controllarne, ad esempio, la lunghezza (numero di caratteri presenti).

1// Proprietà `length` dell'oggetto `String`
2const stringa = "Sono una stringa";
3console.log(stringa.length); // Valore atteso: 16
4
5// Metodo `chartAt()` dell'oggetto `String`
6console.log(stringa.charAt(1)); // Valore atteso: o

Differenza tra apici

Come menzionato qualche paragrafo più in su, le stringhe possono essere delimitate da apici singoli, doppi e accenti gravi, ma qual è la differenza? Con gli accenti gravi possiamo evitare di concatenare le stringhe utilizzando il simbolo + e possiamo andare a capo, cosa che con gli apici non è possibile. Le stringhe tra accenti gravi sono chiamate template literals o template strings, i quali permettono l'inserimento di un'espressione attraverso l'uso della sostituzione.

1const userName = "Manuel";
2const stringaConcatenata = "Ciao " + userName + "!"; // Valore atteso: Ciao Manuel!
3const templateString = `Ciao ${userName}!`; // Valore atteso: Ciao Manuel!

Symbol

Un Symbol è una primitiva unica e immutabile. La funzione Symbol viene invocata in fase di runtime da JavaScript, la quale creerà dinamicamente un valore anonimo e univoco. Il valore generato spesso viene utilizzato come chiave negli oggetti.

I benefit di usare Symbol come chiave sta nel fatto che se lo stesso frammento di codice viene utilizzato in vari programmi, si possono utilizzare gli stessi nome di chiave in codici diversi evitando quindi problemi di duplicazione.

1let persona = {
2  nome: "Manuel",
3};
4
5// creazione Symbol
6let id = Symbol("id");
7
8// aggiunta Symbol come chiave
9person[id] = 12;

Se lo snippet qui sopra venisse riciclato altrove, il programmatore è libero di usare nuovamente id come chiave senza andare in conflitto con quanto scritto.

In altri linguaggi di programmazione Symbol può essere chiamato atoms.

L'immutabilità delle primitive

Tutte le primitive, ad esclusione degli oggetti, i quali non rientrano nelle primitive elencate finora, sono immutabili, ciò significa che il loro valore non può essere modificato direttamente, ma solo attraverso gli oggetti che JavaScript ci mette a disposizione per ogni primitiva, come ad esempio Number, String, Boolean, ecc. (notare la lettera maiuscola iniziale, non l'ho messa a caso).

Quindi:

1const stringa = "Gatto";
2stringa[0] = "g";
3console.log(stringa); // Valore atteso: gatto

Il codice qui sopra cerca di modificare la prima lettera della stringa "Gatto" facendola passare da G maiuscola a g minuscola e quindi il valore che ci aspettiamo in console è "gatto" con la g minuscola. Eh no... la stringa è una primitiva che gode del vincolo di immutabilità e quindi non c'è niente da fare, la stringa rimarrà "Gatto" con la g maiuscola.

Per completezza includo di seguito il codice per ottenere il risultato sperato:

1const stringa = "Gatto";
2const stringa2 = stringa.charAt(0).toLowerCase() + name.slice(1);
3console.log(stringa2); // Valore atteso: gatto