Domande frequenti e risposte sull'intervista JavaScript

Avere JavaScript nel tuo portfolio aumenta le possibilità di ottenere un ruolo di sviluppatore software. Detto questo, diamo un'occhiata alle domande frequenti dell'intervista JavaScript.

JavaScript è uno dei linguaggi più utilizzati nello sviluppo web. Ora è usato per sviluppare quasi ogni tipo di applicazione.

Prima di passare alle domande dell'intervista, vediamo i vantaggi dell'apprendimento di JavaScript.

JavaScript è un linguaggio di programmazione leggero, interpretato o compilato just-in-time. È uno dei linguaggi principali del world wide web. Conosci le altre due lingue principali di www. Faresti meglio a cercarli se non lo fai.

JavaScript è creato principalmente per il web. Ma non è solo per il web adesso. Con l'aiuto di ambienti come Node, Deno , ecc., possiamo eseguirlo su quasi tutte le piattaforme.

Diamo un'occhiata ad alcuni vantaggi di esso.

Vantaggi di JavaScript

1. Facile da iniziare. Puoi impararlo anche senza alcuna conoscenza di programmazione.
2. Grande comunità intorno ad esso. Otterrai tutto l'aiuto che desideri se sei bloccato ovunque.
3. Esistono molte librerie/framework create utilizzando JavaScript, che aiuta a sviluppare applicazioni più velocemente.
4. Possiamo sviluppare applicazioni frontend, backend, android, iOS, ecc., con JavaScript. Possiamo creare quasi ogni tipo di applicazione con esso. Ma è più robusto nello sviluppo web.

Quali sono i tipi di dati in JavaScript?

I tipi di dati vengono utilizzati per memorizzare diversi tipi di dati. I tipi di dati differiranno da un linguaggio di programmazione all'altro. In JavaScript, abbiamo 8 tipi di dati. Vediamoli uno per uno.

• Numero
• Corda
• Booleano
• Non definito
• Nullo
• BigInt
• Simbolo
• Oggetto

Tutti i tipi di dati tranne Object sono chiamati valori primitivi. E sono immutabili.

Quali sono i metodi integrati in JavaScript?

I metodi incorporati in JavaScript sono diversi per ogni tipo di dati. Possiamo accedere a questi metodi integrati utilizzando il rispettivo tipo di dati. Vediamo alcuni metodi incorporati per diversi tipi di dati e strutture di dati.

1. Numero
   • aFisso
   • accordare
   • …
2. Corda
   • toLowerCase
   • inizia con
   • graficoAt
   • …
3. Vettore
   • filtro
   • carta geografica
   • per ciascuno
   • …

Esistono molti metodi integrati per ogni tipo di dati. È possibile controllare i riferimenti per tutti i metodi integrati di diversi tipi di dati e strutture di dati.

Come creare un array in JavaScript?

Gli array sono una delle strutture dati fondamentali in JavaScript. Gli array possono contenere qualsiasi tipo di dati poiché JavaScript è dinamico. Vediamo come creare array in JavaScript.

Possiamo creare un array usando le parentesi quadre [] . È semplice e veloce creare oggetti

 // Empty array const arr = []; // Array with some random values const randomArr = [1, "One", true]; console.log(arr, randomArr);

Possiamo creare un array usando il costruttore di Array . Le persone usano raramente il costruttore per creare array in progetti generali.

 // Empty array const arr = new Array(); // Array with some random values const randomArr = new Array(1, "One", true); console.log(arr, randomArr);

Gli array JavaScript sono mutabili, cioè possiamo modificarli come vogliamo dopo averli creati.

Come creare un oggetto in JavaScript?

A parte l'array, l'oggetto è un'altra struttura dati di base in JavaScript. Gli oggetti utilizzano memorizzare le coppie chiave-valore. La chiave deve essere un valore immutabile, mentre il valore può essere qualsiasi cosa. Vediamo come creare oggetti in JavaScript.

Possiamo creare oggetti usando le parentesi graffe {} . È semplice e veloce creare oggetti.

 // Empty object const object = {}; // Object with some random values const randomObject = { 1: 2, one: "Two", true: false }; console.log(object, randomObject);

Possiamo creare oggetti usando il costruttore di Object . Le persone lo usano raramente in progetti generali.

 // Empty object const object = new Object(); // Object with some random values const randomObject = new Object(); randomObject[1] = 2; randomObject["one"] = "Two"; randomObject[true] = false; console.log(object, randomObject);

Gli oggetti JavaScript sono mutabili, cioè possiamo modificarli dopo averli creati, come si vede nel secondo esempio.

Come si esegue il debug del codice JavaScript?

Il debug del codice non è semplice. Ed è diverso da un linguaggio di programmazione all'altro, da un progetto all'altro, ecc.; vediamo le cose comuni usate per eseguire il debug di JavaScript.

#1. Registrazione

Possiamo utilizzare le istruzioni console.log in più punti del nostro codice per identificare il bug. Il codice interromperà l'esecuzione delle successive righe di codice quando c'è un bug nella riga precedente.

La registrazione è uno dei vecchi metodi di debug, che è praticamente efficace per piccoli progetti. È una tecnica di debug comune per qualsiasi linguaggio di programmazione.

#2. Strumenti di sviluppo

JavaScript è utilizzato principalmente per lo sviluppo di applicazioni web. Quindi, quasi tutti i browser ora dispongono di strumenti per sviluppatori che aiutano a eseguire il debug del codice JavaScript.

Uno dei metodi di debug più utilizzati è l'impostazione dei punti di interruzione negli strumenti di sviluppo. I punti di interruzione interrompono l'esecuzione di JavaScript e forniscono tutte le informazioni sull'esecuzione al momento.

Possiamo impostare più punti di interruzione nel punto in cui riceviamo errori e vedere cosa lo sta causando. È il modo più efficace per eseguire il debug delle applicazioni Web JavaScript.

#3. IDE

Possiamo usare gli IDE per eseguire il debug di JavaScript. VS Code supporta il debug con punti di interruzione. La funzionalità di debug può variare in base all'IDE che stai utilizzando. Ma la maggior parte degli IDE avrà questa caratteristica.

Come aggiungere codice JavaScript in un file HTML?

Possiamo aggiungere il file HTML JavaScript usando il tag script . Puoi controllare l'esempio qui sotto.

 <!DOCTYPE html> <html lang="en"> <head> <title>Geekflare</title> </head> <body> <h1>Geekflare</h1> <script> // JavaScript code goes here console.log("This is JavaScript code"); </script> </body> </html>

Cosa sono i cookie?

I cookie sono coppie chiave-valore utilizzate per memorizzare piccole informazioni. Le informazioni possono essere qualsiasi cosa. Possiamo impostare il tempo di scadenza dei cookie, che verranno cancellati dopo il loro tempo di scadenza. Questi sono ampiamente utilizzati per memorizzare le informazioni degli utenti.

I cookie non verranno cancellati anche se aggiorniamo la pagina fino a quando non li eliminiamo o scadono. Puoi controllare i cookie di qualsiasi app Web/pagina Web in qualsiasi browser aprendo gli strumenti per sviluppatori.

Come leggere un cookie?

Possiamo leggere il cookie in JavaScript usando document.cookie . Restituirà tutti i cookie che abbiamo creato.

 console.log("All cookies", document.cookie);

Restituirà una stringa vuota se non ci sono cookie.

Come creare ed eliminare un cookie?

Possiamo creare i cookie impostando la coppia chiave-valore su document.cookie . Vediamo un esempio.

 document.cookie = "one=One;";

Nella sintassi di cui sopra, la chiave di one cookie e One è il suo valore. Possiamo aggiungere ulteriori attributi al cookie come dominio, percorso, scadenza, ecc.; ognuno di essi deve essere separato da un punto e virgola (;) . Tutti gli attributi sono facoltativi.

Vediamo un esempio con gli attributi.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;";

Nel codice sopra, abbiamo aggiunto una data di scadenza e un percorso al cookie. Se non viene fornita la data di scadenza, il cookie verrà eliminato dopo la sessione. Il percorso predefinito sarà il percorso del file. Il formato della data di scadenza deve essere in GMT.

Vediamo come creare più cookie.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;";

I cookie non verranno sovrascritti se la chiave o il percorso è diverso durante l'impostazione di più cookie. Se la chiave e il percorso sono gli stessi, sovrascriverà il cookie precedente. Dai un'occhiata all'esempio seguente, che sovrascriverà il cookie impostato in precedenza.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "one=Two;path=/;";

Abbiamo rimosso la data di scadenza dal cookie e modificato il valore.

Usa la data di scadenza come data futura quando stai testando il codice affinché funzioni correttamente. Se mantieni la stessa data del 31 gennaio 2023 anche dopo il 31 gennaio 2023 , i cookie non verranno creati.

Abbiamo visto come creare e aggiornare i cookie. Vediamo come eliminare i cookie.

Eliminare i cookie è facile. Basta modificare la data di scadenza del cookie in qualsiasi data passata. Controlla l'esempio qui sotto.

 // Creating cookies document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;"; // Deleting the last cookie document.cookie = "three=Three;expires=Jan 1 2023;path=/;";

Non troverai l'ultimo cookie nei cookie poiché viene eliminato nell'ultima riga del codice. Questo è tutto per il tutorial sui cookie minimi.

Quali sono i diversi framework JavaScript?

Ci sono molti framework JavaScript là fuori. React, Vue, Angular, ecc., per lo sviluppo dell'interfaccia utente. Express, Koa, Nest, ecc., per lo sviluppo lato server. NextJS, Gatsby, ecc., per la generazione di siti statici. React Native, Ionic, ecc., per lo sviluppo di app mobile. Abbiamo menzionato alcuni dei framework JavaScript qui. Puoi trovare più framework che richiederanno molto tempo per essere esplorati. Esplora quando ne hai bisogno.

Chiusure in JavaScript

Una chiusura è una funzione in bundle con il suo ambito lessicale e il suo ambiente lessicale genitore. Con le chiusure, possiamo accedere ai dati dell'ambito esterno. Le chiusure si formano quando vengono create le funzioni.

 function outer() { const a = 1; function inner() { // We can access all the data from the outer function scope here // The data will be available even if we execute this function outside the outer function // as inners' closure formed while creating it console.log("Accessing a inside inner", a); } return inner; } const innerFn = outer(); innerFn();

Le chiusure sono ampiamente utilizzate nelle applicazioni JavaScript. Potresti averli usati prima senza renderti conto che sono chiusure. C'è molto di più da imparare sulle chiusure. Assicurati di aver appreso completamente questo concetto.

Sollevamento in JavaScript

Il sollevamento è un processo in JavaScript in cui la dichiarazione di variabili, funzioni e classi si sposta all'inizio dell'ambito prima di eseguire il codice.

 // Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` var name = "Geekflare";

Se esegui il codice precedente, non vedrai alcun errore. Ma nella maggior parte delle lingue, riceverai l'errore. L'output sarà undefined poiché il sollevamento sposta solo le dichiarazioni in alto e non lo inizializzerà fino alla riga numero 3.

Modificare var in let o const come segue ed eseguire nuovamente il codice.

 // Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` const name = "Geekflare";

Ora otterrai l'errore di riferimento che dice che non possiamo accedere alla variabile prima di inizializzarla.

 ReferenceError: Cannot access 'name' before initialization

Quindi, qui let e const vengono introdotti in ES6, a cui non è possibile accedere prima dell'inizializzazione, come suggerisce l'errore. Questo perché le variabili dichiarate con let o const saranno in Temporal Dead Zone (TDZ) fino a quando la riga non sarà inizializzata. Non possiamo accedere alle variabili da TDZ.

Curry in JavaScript

Il currying è una tecnica per convertire funzioni con molti parametri in meno parametri con più callable. Con esso, possiamo convertire una funzione callable add(a, b, c, d) in add(a)(b)(c)(d) callable. Vediamo un esempio di come farlo.

 function getCurryCallback(callback) { return function (a) { return function (b) { return function (c) { return function (d) { return callback(a, b, c, d); }; }; }; }; } function add(a, b, c, d) { return a + b + c + d; } const curriedAdd = getCurryCallback(add); // Calling the curriedAdd console.log(curriedAdd(1)(2)(3)(4));

Possiamo generalizzare la funzione getCurryCallback che verrà utilizzata per diverse funzioni da convertire in callable di currying. Puoi fare riferimento a Informazioni JavaScript per maggiori dettagli su di esso.

Differenza tra documento e finestra

La window è l'oggetto più in alto nel browser. Contiene tutte le informazioni sulla finestra del browser, come cronologia, posizione, navigatore, ecc.; è disponibile a livello globale in JavaScript. Possiamo usarlo direttamente nel nostro codice senza alcuna importazione. Possiamo accedere alle proprietà e ai metodi dell'oggetto window senza window.

Il document è la parte dell'oggetto window . Tutto il codice HTML caricato nella pagina Web viene convertito nell'oggetto documento. L'oggetto documento si riferisce allo speciale elemento HTMLDocument, che avrà proprietà e metodi diversi come tutti gli elementi HTML.

La window l'oggetto rappresenta la finestra del browser e il document rappresenta il documento HTML caricato in quella finestra del browser.

Differenza tra lato client e lato server

Il lato client si riferisce all'utente finale che utilizza l'applicazione. Il lato server si riferisce al server Web in cui è distribuita l'applicazione.

Nella terminologia del frontend, possiamo dire browser sui computer degli utenti come lato client e servizi cloud come lato server.

Differenza tra innerHTML e innerText

Sia innerHTML che innerText sono le proprietà degli elementi HTML. Possiamo cambiare il contenuto di un elemento HTML usando queste proprietà.

Possiamo assegnare la stringa HTML a innerHTML una proprietà resa come un normale HTML. Controlla l'esempio qui sotto.

 const titleEl = document.getElementById("title"); titleEl.innerHTML = '<span style="color:orange;">Geekflare</span>';

Aggiungi un elemento con il title id al tuo HTML e aggiungi lo script sopra al file JavaScript. Eseguire il codice e vedere l'output. Potrai Geekflare in colore arancione. E se controlli l'elemento, sarà all'interno del tag span . Quindi innerHTML prenderà la stringa HTML e la renderà come normale HTML.

L' innerText dall'altra parte prenderà una stringa normale e la visualizzerà così com'è. Non eseguirà il rendering di alcun codice HTML come innerHTML . Cambia innerHTML in innerText nel codice precedente e controlla l'output.

 const titleEl = document.getElementById("title"); titleEl.innerText = '<span style="color:orange;">Geekflare</span>';

Ora vedrai la stringa esatta che abbiamo fornito sulla pagina web.

Differenza tra let e var

Le parole chiave let e var vengono utilizzate per creare variabili in JavaScript. La parola chiave let è stata introdotta in ES6.

let un ambito di blocco e var ha un ambito di funzione.

 { let a = 2; console.log("Inside block", a); } console.log("Outside block", a);

Esegui il codice sopra. Riceverai un errore nell'ultima riga in quanto non possiamo accedere let a al di fuori del blocco perché è con ambito di blocco. Ora cambialo in var ed eseguilo di nuovo.

 { var a = 2; console.log("Inside block", a); } console.log("Outside block", a);

Non riceverai alcun errore poiché possiamo accedere anche alla variabile a al di fuori del blocco. Ora sostituiamo il blocco con una funzione.

 function sample() { var a = 2; console.log("Inside function", a); } sample(); console.log("Outside function", a);

Riceverai un errore di riferimento se esegui il codice precedente poiché non possiamo accedere var a esso al di fuori della funzione perché è nell'ambito della funzione.

Possiamo ridichiarare le variabili usando la parola chiave var ma non possiamo ridichiarare le variabili usando la parola chiave let . Vediamo un esempio.

 var a = "Geekflare"; var a = "Chandan"; console.log(a);

 let a = "Geekflare"; let a = "Chandan"; console.log(a);

Il primo pezzo di codice non genera alcun errore e il valore è a verrà modificato nell'ultimo valore assegnato. Il secondo pezzo di codice genererà un errore poiché non possiamo ridichiarare le variabili usando let .

Differenza tra archiviazione della sessione e archiviazione locale

L'archiviazione della sessione e l'archiviazione locale vengono utilizzate per archiviare informazioni sui computer degli utenti a cui è possibile accedere senza Internet. Possiamo archiviare le coppie chiave-valore sia nell'archiviazione della sessione che nell'archiviazione locale. Sia la chiave che il valore verranno convertiti in stringhe se fornisci qualsiasi altro tipo di dati o struttura di dati.

La memorizzazione della sessione verrà cancellata al termine della sessione (alla chiusura del browser). L'archiviazione della posizione non verrà cancellata finché non la cancelleremo.

Possiamo accedere, aggiornare ed eliminare l'archiviazione della sessione e l'archiviazione della posizione rispettivamente con gli oggetti sessionStorage e localStorage .

Cos'è NaN in JavaScript?

Il NaN è abbreviato come Not-a-Number . Rappresenta che qualcosa non è un numero legale/valido in JavaScript. Ci sono alcuni casi in cui otterremo NaN come output come 0/0 , undefined * 2 , 1 + undefined , null * undefined ecc..,

Cos'è l'ambito lessicale?

L'ambito lessicale si riferisce all'accesso alle variabili dall'ambito dei suoi genitori. Diciamo che abbiamo una funzione con due funzioni interne. La funzione più interna può accedere alle variabili di ambito delle sue due funzioni padre. Allo stesso modo, la funzione di 2° livello può accedere all'ambito della funzione più esterna. Vediamolo in un esempio.

 function outermost() { let a = 1; console.log(a); function middle() { let b = 2; // `a` are accessible here console.log(a, b); function innermost() { let c = 3; // both `a` and `b` are accessible here console.log(a, b, c); } innermost(); } middle(); } outermost();

JavaScript utilizza una catena di ambito per trovare la variabile quando vi accediamo da qualche parte nel codice. Innanzitutto, controllerà la variabile nell'ambito corrente, quindi l'ambito padre fino all'ambito globale.

Cosa viene passato per valore e passato per riferimento?

Il passaggio per valore e il passaggio per riferimento sono due modi per passare gli argomenti a una funzione in JavaScript.

Passa per valore: crea una copia dei dati originali e la passa alla funzione. Quindi, quando abbiamo apportato modifiche alla funzione, non influirà sui dati originali. Controlla l'esempio qui sotto.

 function sample(a) { // changing the value of `a` a = 5; console.log("Inside function", a); } let a = 3; sample(a); console.log("Outside function", a);

Vedrai che il valore originale di a non è cambiato anche se lo abbiamo cambiato all'interno della funzione.

Passa per riferimento: passa il riferimento dei dati alla funzione. Quindi, quando abbiamo apportato modifiche alla funzione, verranno modificati anche i dati originali.

 function sample(arr) { // adding a new value to the array arr.push(3); console.log("Inside function", arr); } let arr = [1, 2]; sample(arr); console.log("Outside function", arr);

Vedrai che il valore originale di arr viene modificato quando lo cambiamo all'interno della funzione.

Nota: tutti i tipi di dati primitivi vengono passati per valore e quelli non primitivi vengono passati per riferimento.

Cos'è la memoizzazione?

La memoizzazione è una tecnica che memorizza i valori calcolati nelle cache e li usa quando ne abbiamo bisogno di nuovo senza calcolarli di nuovo. Accelererà l'esecuzione del codice se il calcolo è molto pesante. C'è un compromesso di archiviazione che non è un grosso problema rispetto al tempo.

 const memo = {}; function add(a, b) { const key = `${a}-${b}`; // checking whether we computed the value already or not if (memo[key]) { console.log("Not computing again"); return memo[key]; } // adding the newly computed value to cache // here cache is a simple global object memo[key] = a + b; return memo[key]; } console.log(add(1, 2)); console.log(add(2, 3)); console.log(add(1, 2));

È un semplice esempio che dimostra la memoizzazione. Qui, l'aggiunta di due numeri non è un calcolo pesante. È solo per la demo.

Qual è il parametro resto?

Il parametro rest viene utilizzato per raccogliere tutti i parametri rimanenti in una funzione. Supponiamo di avere una funzione che accetterà un minimo di 2 argomenti e può accettare qualsiasi numero di parametri al massimo. Non avendo il numero massimo di argomenti, possiamo raccogliere i primi 2 parametri con variabili normali e tutti gli altri con il parametro rest utilizzando l' operatore rest .

 function sample(a, b, ...rest) { console.log("Rest parameter", rest); } sample(1, 2, 3, 4, 5);

Il parametro rest sarà un array degli ultimi tre argomenti nell'esempio precedente. Con questo, possiamo avere qualsiasi numero di parametri per una funzione.

Una funzione può avere un solo parametro rest. E il parametro resto dovrebbe essere l'ultimo nell'ordine dei parametri.

Cos'è la destrutturazione degli oggetti?

La destrutturazione dell'oggetto viene utilizzata per accedere alle variabili dall'oggetto e assegnarle a variabili con gli stessi nomi delle chiavi dell'oggetto. Vediamo un esempio.

 const object = { a: 1, b: 2, c: 3 }; // Object destructuring const { a, b, c } = object; // Now, a, b, c will be used as normal variables console.log(a, b, c);

Possiamo cambiare le variabili delle variabili destrutturate nella stessa riga come segue.

 const object = { a: 1, b: 2, c: 3 }; // Changing the names of `a` and `b` const { a: changedA, b: changedB, c } = object; // Now, changedA, changedB, c will be used as normal variables console.log(changedA, changedB, c);

Cos'è la destrutturazione dell'array?

La destrutturazione dell'array viene utilizzata per accedere alle variabili dall'array e assegnarle alle variabili. Vediamo un esempio.

 const array = [1, 2, 3]; // Array destructuring // It's based on the index of the array const [a, b, c] = array; // Now, we can use a, b, c as normal variables console.log(a, b, c);

Cosa sono l'event capture e l'event bubbling?

L' acquisizione di eventi e il bubbling di eventi sono due modi di propagazione di eventi in HTML DOM. Diciamo che ci sono due elementi HTML, uno dentro l'altro. E un evento si verifica sull'elemento interno. Ora, la modalità di propagazione degli eventi deciderà l'ordine di esecuzione di questi eventi.

Bubbling dell'evento: esegue prima il gestore dell'evento sull'elemento, poi il suo elemento e poi arriva fino all'elemento più in alto. Questo è il comportamento predefinito di tutti gli eventi.

Cattura di eventi: dobbiamo specificare nell'evento che dobbiamo utilizzare questo tipo di propagazione di eventi. Possiamo specificarlo durante l'aggiunta del listener di eventi. Gli eventi verranno eseguiti nel seguente ordine se l'acquisizione degli eventi è abilitata.

1. L'esecuzione degli eventi inizia dall'elemento più in alto fino all'elemento di destinazione verso il basso.
2. L'evento sull'elemento di destinazione verrà eseguito nuovamente.
3. La propagazione dell'evento di bubbling si verificherà nuovamente fino a quando l'elemento più in alto non sarà attivo.

Possiamo fermare la propagazione dell'evento chiamando event.stopPropogation un metodo nel gestore dell'evento.

Quali sono le promesse in JavaScript?

L'oggetto Promise viene utilizzato per le operazioni asincrone che verranno completate in futuro con uno stato di esito positivo o negativo.

Una Promise può trovarsi in uno dei seguenti stati.

1. pending – quando l'operazione è ancora in corso.
2. fulfilled - quando l'operazione è stata completata con successo. Avremo risultati (se presenti) nello stato di successo.
3. rejected - quando l'operazione viene completata con un errore. Avremo il motivo (errore) per cui non è riuscito.

Vediamo due esempi di casi di successo e fallimento.

 // Promise which will complete successfully const successPromise = new Promise((resolve, reject) => { setTimeout(() => { resolve({ message: "Completed successfully" }); }, 300); }); successPromise .then((data) => { console.log(data); }) .catch((error) => { console.log(error); }); // Promise which will complete with failure state const failurePromise = new Promise((resolve, reject) => { setTimeout(() => { reject(new Error("Failing the promise for testing")); }, 300); }); failurePromise .then((data) => { console.log(data); }) .catch((error) => { console.log(error); });

Puoi averne più di uno then concatenare se necessario. I dati restituiti in precedenza verranno accettati nella richiamata then .

Spiegare i diversi tipi di ambito in JavaScript

Esistono due tipi di ambito in JavaScript. L' ambito globale e l'ambito locale .

Potresti aver sentito parlare anche dell'ambito della funzione e dell'ambito del blocco. Sono ambiti locali rispettivamente per var e let , const .

Cosa sono le funzioni autoinvocanti?

Le funzioni autoinvocanti sono funzioni senza nome che verranno eseguite immediatamente dopo la creazione. Vediamo alcuni esempi.

 // Without any parameters (function sayHello() { console.log("Hello, World!"); })(); // With parameters (function add(a, b) { console.log("Sum", a + b); })(1, 2);

Possiamo anche passare gli argomenti alle funzioni autoinvocanti come hai visto nell'esempio.

Cosa sono le funzioni freccia?

La funzione freccia è lo zucchero sintattico alla funzione normale con alcune modifiche. Si comportano come normali funzioni nei casi d'uso generali. Le funzioni freccia sono utili quando dobbiamo avere callback. Vediamone la sintassi.

 // arrow functions will return by default if it doesn't have any brackets let add = (a, b) => a + b; console.log(add(1, 2));

Ci sono alcune differenze tra le funzioni della freccia e le funzioni normali.

• Le funzioni freccia non hanno this associazione. La parola chiave this all'interno della funzione freccia fa riferimento all'ambito genitore this .
• Le funzioni freccia non possono essere utilizzate come funzioni di costruzione

Cosa sono i callback?

Un callback è una funzione che viene passata a un'altra funzione che viene richiamata all'interno di tale funzione. L'uso dei callback è una cosa comune in JavaScript. Vediamo un esempio.

 function sample(a, b, callback) { const result = a + b; callback(result); } function finished(result) { console.log("Finished with", result); } sample(1, 2, finished);

La funzione finished viene passata come callback al sample . La funzione finished viene richiamata con il risultato dopo aver eseguito un'azione. Vedrai l'utilizzo dei callback principalmente in operazioni asincrone come promesse, setTimeout, ecc.,

Quali sono i diversi tipi di errori?

Controlliamo alcuni errori in JavaScript.

ReferenceError : questo errore si verificherà se la variabile a cui stiamo accedendo è disponibile.

TypeError: JavaScript genererà questo errore se l'errore non corrisponde ad altri tipi di errori. Si verificherà anche quando tentiamo di eseguire un'azione che non è compatibile con i dati.

SyntaxError: questo errore si verifica se la sintassi JavaScript non è corretta.

Ci sono anche altri tipi di errori. Ma questi sono i tipi di errore comuni in JavaScript.

Quali sono i diversi ambiti delle variabili in JavaScript?

Esistono due ambiti di variabili in JavaScript. Le variabili dichiarate utilizzando la parola chiave var avranno l'ambito della funzione e le variabili dichiarate con let e const avranno l' ambito del blocco .

Fare riferimento alla diciassettesima domanda per maggiori dettagli sull'ambito di queste variabili.

Cosa sono i caratteri di escape in JavaScript?

La barra rovesciata è il carattere di escape in JavaScript. È usato per stampare alcuni caratteri speciali che non possiamo stampare in generale. Diciamo che vogliamo stampare l' apostrophe (') all'interno di una stringa che non possiamo fare normalmente poiché la stringa finirà al secondo apostrofo. In tal caso, utilizzeremo il carattere di escape per evitare di terminare la stringa in quel punto.

 const message = 'Hi, I\'m Geekflare'; console.log(message);

Possiamo ottenere l'output di cui sopra senza utilizzare il carattere di escape sostituendo i singoli apostrofi esterni con doppi apostrofi. Ma è solo un esempio di come usare un carattere escape. Ci sono altri caratteri per i quali abbiamo sicuramente bisogno di caratteri di escape come \n , \t , \\ etc..,

Cosa sono BOM e DOM?

Browser Object Model (BOM): tutti i browser hanno BOM che rappresenta la finestra corrente del browser. Contiene il nostro oggetto finestra più in alto che viene utilizzato per manipolare la finestra del browser.

Document Object Model (DOM): i browser creano il DOM quando l'HTML viene caricato nella struttura ad albero. Possiamo manipolare gli elementi HTML utilizzando l'API DOM.

Cos'è un oggetto schermo?

L'oggetto schermo è una delle proprietà dell'oggetto finestra globale. Contiene diverse proprietà dello schermo su cui viene visualizzata la finestra del browser corrente. Alcune delle proprietà sono larghezza , altezza , orientamento , pixelDepth , ecc.

Conclusione

Potrebbero esserci domande di follow-up per tutte le domande precedenti. Quindi, devi preparare i concetti attorno a tutte le domande di cui sopra.

Puoi anche esplorare alcune domande e risposte di interviste Java frequenti.

Buon apprendimento