Funzioni integrate in JavaScript

Questo articolo spiega le funzioni integrate in JavaScript.

YouTube Video

Funzioni integrate in JavaScript

JavaScript offre una varietà di funzioni integrate, che sono strumenti potenti per creare programmi in modo efficiente. Qui spiegheremo in dettaglio le tipiche funzioni integrate in JavaScript.

Cosa sono le Funzioni integrate?

Le Funzioni integrate sono funzioni fornite di default in JavaScript. Queste funzioni sono progettate per eseguire compiti specifici in modo conciso. I programmatori non devono implementarle autonomamente, il che migliora la leggibilità e la manutenibilità del codice.

Funzioni integrate rappresentative

parseInt()

1// Convert string to integer
2console.log(parseInt("42"));      // Output: 42
3console.log(parseInt("42px"));    // Output: 42
4console.log(parseInt("0xF", 16)); // Output: 15
5console.log(parseInt("0xF"));     // Output: 15
6console.log(parseInt("px42"));    // Output: NaN

• parseInt() è una funzione che analizza una stringa e la converte in un numero intero. Se l'inizio della stringa contiene un numero, quella parte viene restituita come numero intero. È anche possibile specificare una base opzionale (radix).

• Se l'inizio della stringa non contiene un numero, restituisce NaN (Not-a-Number). Inoltre, se non viene specificata una base, quella di default è il decimale, ma se la stringa inizia con "0x", viene interpretata come esadecimale.

parseFloat()

1// Convert string to float
2console.log(parseFloat("3.14"));      // Output: 3.14
3console.log(parseFloat("3.14abc"));   // Output: 3.14
4console.log(parseFloat("42"));        // Output: 42

• parseFloat() analizza una stringa e la converte in un numero a virgola mobile. Viene utilizzato quando si gestiscono numeri che includono una virgola decimale.

• Come parseInt(), se l'inizio della stringa non è un numero, restituisce NaN. Si caratterizza per analizzare correttamente non solo la parte intera ma anche la parte decimale.

isNaN()

1console.log(isNaN(NaN));         // Output: true
2console.log(isNaN(42));          // Output: false
3console.log(isNaN("hello"));     // Output: true

• isNaN() determina se un valore dato è NaN. NaN (Not-a-Number) rappresenta un valore non valido come numero.

• isNaN() è valido anche per tipi di dati diversi dai numeri e, per esempio, restituisce true se una stringa non può essere convertita in un numero.

Number()

1console.log(Number("42"));        // Output: 42
2console.log(Number("3.14"));      // Output: 3.14
3console.log(Number("0xff"));      // Output: 255
4console.log(Number("abc"));       // Output: NaN
5
6console.log(parseFloat("3.14abc"));  // Output: 3.14
7console.log(Number("3.14abc"));      // Output: NaN

• Number() è una funzione che converte stringhe o altri tipi di dati in un numero. Restituisce NaN se viene fornita una stringa non numerica.

• A differenza di parseInt() o parseFloat(), Number() considera una conversione non valida e restituisce NaN se la stringa contiene caratteri non numerici.

String()

1console.log(String(42));           // Output: "42"
2console.log(String(3.14));         // Output: "3.14"
3console.log(String(true));         // Output: "true"
4console.log(String(null));         // Output: "null"
5console.log(String(undefined));    // Output: "undefined"

• String() è una funzione che converte numeri e altri tipi di dati in stringhe. String(42) restituisce la stringa "42".
• Se il valore da convertire è null o undefined, restituisce rispettivamente le stringhe "null" o "undefined".
• È utile per gestire vari tipi di dati, come numeri, booleani o oggetti, convertendoli in stringhe.

Array

1const arr = Array(3);
2console.log(arr); // Output: [ <3 empty items> ]
3
4const arr2 = Array(1, 2, 3);
5console.log(arr2); // Output: [1, 2, 3]

• Array è un costruttore usato per creare nuovi array.
• Se c'è un solo argomento, viene considerato come la lunghezza dell'array e viene creato un array vuoto.
• Se ci sono più argomenti, viene creato un array con quei valori come elementi.

Array.isArray()

1console.log(Array.isArray([1, 2, 3])); // Output: true
2console.log(Array.isArray("not an array")); // Output: false

• Array.isArray() è un metodo che determina se l'argomento è un array.
• Restituisce true se l'argomento è un array, altrimenti restituisce false.

isFinite()

1console.log(isFinite(42));         // Output: true
2console.log(isFinite(Infinity));   // Output: false
3console.log(isFinite(NaN));        // Output: false

• isFinite() determina se un determinato valore è finito. Restituisce true per numeri finiti e false in caso contrario (come per infinito o NaN).

• In JavaScript, Infinity e -Infinity rappresentano l'infinito e appartengono al tipo numero, ma isFinite() considera l'infinito come un valore non valido.

eval()

1let expression = "2 + 2";
2console.log(eval(expression));    // Output: 4
3
4console.log(eval("var x = 10; x * 2"));  // Output: 20

• eval() è una funzione che valuta ed esegue codice JavaScript fornito come stringa. Puoi eseguire dinamicamente codice JavaScript.

• eval() è molto potente, ma rappresenta un rischio per la sicurezza, quindi dovrebbe essere evitato nello sviluppo reale. Eseguire codice fornito esternamente tramite eval() può portare a comportamenti indesiderati e vulnerabilità di sicurezza.

encodeURI() / decodeURI()

1let url = "https://example.com/?name=John Doe&age=25";
2let encodedUrl = encodeURI(url);
3console.log(encodedUrl);
4// Output: https://example.com/?name=John%20Doe&age=25
5
6let decodedUrl = decodeURI(encodedUrl);
7console.log(decodedUrl);
8// Output: https://example.com/?name=John Doe&age=25

• encodeURI() è una funzione utilizzata per codificare (convertire) i caratteri che non possono essere utilizzati in un URL. D'altra parte, decodeURI() decodifica un URL codificato alla sua forma originale.

• La codifica è particolarmente importante quando si trattano caratteri speciali. Ad esempio, caratteri come spazi o & devono essere codificati per essere correttamente inclusi in un URL, quindi devono essere elaborati adeguatamente utilizzando encodeURI().

setTimeout() / setInterval()

 1// Execute a function after 2 seconds
 2setTimeout(() => {
 3    console.log("This runs after 2 seconds");
 4}, 2000);
 5
 6// Execute a function every 1 second
 7let intervalId = setInterval(() => {
 8    console.log("This runs every 1 second");
 9}, 1000);
10
11// Stop the interval after 5 seconds
12setTimeout(() => {
13    clearInterval(intervalId);
14}, 5000);

• setTimeout() è una funzione timer utilizzata per eseguire una funzione una sola volta dopo un tempo specificato. setInterval() esegue ripetutamente una funzione a intervalli specificati.

• setTimeout() e setInterval() vengono eseguiti in modo asincrono, richiamando la funzione dopo il tempo specificato. È anche possibile annullare le esecuzioni utilizzando clearTimeout() o clearInterval().

Riepilogo

Utilizzare le funzioni integrate di JavaScript ti consente di scrivere programmi più semplici ed efficienti. Le funzioni introdotte qui sono basilari e utili in varie situazioni.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video