Vanliga frågor och svar på JavaScript-intervjuer

Att ha JavaScript i din portfölj ökar chanserna att få en roll som mjukvaruutvecklare. Som sagt, låt oss kolla in de vanligaste JavaScript-intervjufrågorna.

JavaScript är ett av de mest använda språken inom webbutveckling. Det används för att utveckla nästan alla typer av applikationer nu.

Innan vi hoppar in på intervjufrågorna, låt oss se fördelarna med att lära oss JavaScript.

JavaScript är ett lätt, tolkat eller just-in-time kompilerat programmeringsspråk. Det är ett av världsnätets kärnspråk. Du kan de andra två kärnspråken på www. Det är bättre att söka efter dem om du inte gör det.

JavaScript är främst skapat för webben. Men det är inte bara för webben nu. Med hjälp av miljöer som Node, Deno, etc.., kan vi köra det på nästan vilken plattform som helst.

Låt oss kolla in några fördelar med det.

Fördelar med JavaScript

  • Lätt att komma igång med. Du kan lära dig det även utan någon kodningskunskap.
  • Stor gemenskap runt det. Du kommer att få all hjälp du vill ha om du har fastnat någonstans.
  • Det finns många bibliotek/ramverk som bygger med JavaScript, vilket hjälper till att utveckla applikationer snabbare.
  • Vi kan utveckla frontend, backend, android, iOS, etc.., applikationer med JavaScript. Vi kan skapa nästan alla typer av applikationer med den. Men det är mer robust i webbutveckling.
  • Vilka är datatyperna i JavaScript?

    Datatyperna används för att lagra olika typer av data. Datatyper kommer att skilja sig från ett programmeringsspråk till ett annat. I JavaScript har vi 8 datatyper. Låt oss se dem en efter en.

    • siffra
    • Sträng
    • Boolean
    • Odefinierad
    • Null
    • BigInt
    • Symbol
    • Objekt

    Alla datatyper utom Objekt kallas primitiva värden. Och de är oföränderliga.

    Vilka är de inbyggda metoderna i JavaScript?

    De inbyggda metoderna i JavaScript är olika för varje datatyp. Vi kan komma åt dessa inbyggda metoder med hjälp av respektive datatyp. Låt oss se några inbyggda metoder för olika datatyper och datastrukturer.

  • siffra
  • Sträng
    • till LowerCase
    • börjar med
    • diagramAt
  • Array
  • Det finns många inbyggda metoder för varje datatyp. Du kan kontrollera referenserna för alla inbyggda metoder för olika datatyper och datastrukturer.

    Hur skapar man en array i JavaScript?

    Arrayer är en av kärndatastrukturerna i JavaScript. Arrayer kan ha vilken typ av data som helst eftersom JavaScript är dynamiskt. Låt oss se hur man skapar arrayer i JavaScript.

    Vi kan skapa en array med hakparenteser[]. Det är enkelt och snabbt att skapa objekt

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

    Vi kan skapa en array med Array-konstruktorn. Människor använder sällan konstruktorn för att skapa arrayer i allmänna projekt.

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

    JavaScript-matriser är föränderliga, dvs vi kan modifiera dem som vi vill efter att ha skapat dem.

    Hur skapar man ett objekt i JavaScript?

    Bortsett från array är objektet en annan kärndatastruktur i JavaScript. Objekt använder lagra nyckel-värde-par. Nyckeln måste vara ett oföränderligt värde, medan värdet kan vara vad som helst. Låt oss se hur man skapar objekt i JavaScript.

    Vi kan skapa objekt med hjälp av parenteser {}. Det är enkelt och snabbt att skapa objekt.

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

    Vi kan skapa objekt med hjälp av Object constructor. Människor använder sällan detta i allmänna projekt.

    // 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);

    JavaScript-objekt är föränderliga, dvs vi kan modifiera dem efter att ha skapats, som du ser i det andra exemplet.

    Hur felsöker du JavaScript-kod?

    Att felsöka kod är inte okomplicerat. Och det är olika från ett programmeringsspråk till ett annat, ett projekt till ett annat, etc..; låt oss se de vanligaste sakerna som används för att felsöka JavaScript.

    1. Loggning

    Vi kan använda console.log-satserna på flera ställen i vår kod för att identifiera felet. Koden kommer att sluta köra nästa rader kod när det finns en bugg på föregående rad.

    Loggning är en av de gamla felsökningsmetoderna, som är ganska effektiv för små projekt. Det är en vanlig felsökningsteknik för alla programmeringsspråk.

    2. Utvecklarverktyg

    JavaScript används mest för att utveckla webbapplikationer. Så nästan alla webbläsare har utvecklarverktyg nu som hjälper till att felsöka JavaScript-koden.

    En av de mest använda felsökningsmetoderna är att ställa in brytpunkter i utvecklarverktygen. Brytpunkterna stoppar exekveringen av JavaScript och ger all information om exekveringen för tillfället.

    Vi kan ställa in flera brytpunkter runt den plats där vi får fel och se vad som orsakar det. Det är det mest effektiva sättet att felsöka JavaScript-webbapplikationer.

    3. IDE:er

    Vi kan använda IDE:erna för att felsöka JavaScript. VS Code stöder felsökning med brytpunkter. Felsökningsfunktionen kan skilja sig beroende på vilken IDE du använder. Men de flesta av IDE:erna kommer att ha den funktionen.

    Hur lägger man till JavaScript-kod i en HTML-fil?

    Vi kan lägga till JavaScript HTML-filen med hjälp av script-taggen. Du kan kontrollera exemplet nedan.

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

    Vad är cookies?

    Cookies är nyckel-värdepar som används för att lagra liten information. Informationen kan vara vad som helst. Vi kan ställa in utgångstiden för cookies, som kommer att raderas efter deras utgångstid. Dessa används ofta för att lagra användarnas information.

    Cookies kommer inte att rensas även om vi uppdaterar sidan tills vi tar bort dem eller de förfaller. Du kan kontrollera cookies för alla webbappar/webbsidor i vilken webbläsare som helst genom att öppna utvecklarverktygen.

    Vi kan läsa cookien i JavaScript med hjälp av document.cookie. Det kommer att returnera alla cookies som vi skapat.

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

    Det kommer att returnera en tom sträng om det inte finns några cookies.

    Vi kan skapa cookies genom att ställa in nyckel-värdeparet till document.cookien. Låt oss se ett exempel.

    document.cookie = "one=One;";

    I ovanstående syntax är en cookie-nyckel och One dess värde. Vi kan lägga till fler attribut till cookien som domän, sökväg, expires, etc..; var och en av dem ska separeras med semikolon (;). Alla attribut är valfria.

    Låt oss se ett exempel med attribut.

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

    I ovanstående kod har vi lagt till ett utgångsdatum och sökväg till cookien. Om utgångsdatumet inte anges kommer cookien att raderas efter sessionen. Standardsökvägen kommer att vara filsökvägen. Formatet för utgångsdatum ska anges i GMT.

    Låt oss se hur du skapar flera 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=/;";

    Cookies kommer inte att skrivas över om nyckeln eller sökvägen är annorlunda när du ställer in flera cookies. Om nyckeln och sökvägen är samma, kommer den att skriva över den föregående cookien. Kolla in exemplet nedan, som kommer att skriva över den tidigare inställda cookien.

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

    Vi har tagit bort utgångsdatumet från cookien och ändrat värdet.

    Använd utgångsdatumet ett framtida datum när du testar koden för att den ska fungera korrekt. Om du behåller samma datum den 31 januari 2023 även efter den 31 januari 2023 kommer cookies inte att skapas.

    Vi har sett hur man skapar och uppdaterar cookies. Låt oss se hur man tar bort cookies.

    Det är enkelt att ta bort cookies. Ändra bara utgångsdatumet för cookien till ett tidigare datum. Kontrollera exemplet nedan.

    // 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=/;";

    Du hittar inte den sista kakan i kakorna eftersom den raderas på den sista raden i koden. Det var allt för min cookies handledning.

    Vilka är de olika JavaScript-ramverken?

    Det finns många JavaScript-ramverk där ute. React, Vue, Angular, etc.., för UI-utveckling. Express, Koa, Nest, etc.., för utveckling på serversidan. NextJS, Gatsby, etc.., för statisk webbplatsgenerering. React Native, Ionic, etc.., för utveckling av mobilappar. Vi har nämnt några av JavaScript-ramverken här. Du kan hitta fler ramverk som kommer att ta mycket tid att utforska. Utforska när du behöver dem.

    Stängningar i JavaScript

    En stängning är en funktion buntad med dess lexikala omfattning och dess överordnade lexikala miljö. Med stängningar kan vi komma åt data om det yttre omfånget. Förslutningarna bildas när funktionerna skapas.

    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();

    Förslutningar används ofta i JavaScript-applikationer. Du kanske har använt dem tidigare utan att inse att de är stängningar. Det finns mycket mer än så här att lära sig om stängningarna. Se till att du har lärt dig detta koncept helt.

    Hissning i JavaScript

    Hoisting är en process i JavaScript där deklarationen av variabler, funktioner och klasser flyttas till toppen av scopet innan koden exekveras.

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

    Om du kör ovanstående kod kommer du inte att se något fel. Men på de flesta språk får du felet. Utdatan kommer att vara odefinierad eftersom hissning endast flyttar deklarationerna till toppen, och den kommer inte att initialiseras förrän rad nummer 3.

    Ändra var till let eller const enligt följande, och kör koden igen.

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

    Nu kommer du att få referensfelet som säger att vi inte kan komma åt variabeln innan vi initierar den.

    ReferenceError: Cannot access 'name' before initialization

    Så här introduceras let och const i ES6, som inte kan nås innan de initierats, som felet antyder. Detta beror på att variablerna som deklareras med let eller const kommer att vara i Temporal Dead Zone (TDZ) tills raden den har initierats. Vi kan inte komma åt variablerna från TDZ.

    Curry i JavaScript

    Currying är en teknik för att konvertera funktioner med många parametrar till färre parametrar med flera anropsbara. Med den kan vi konvertera en funktion anropbar add(a, b, c, d) till add(a)(b)(c)(d) callable. Låt oss se ett exempel på hur man gör det.

    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));

    Vi kan generalisera getCurryCallback funktionen som kommer att användas för olika funktioner för att konvertera till currying callables. Du kan hänvisa till JavaScript Info för mer information om det.

    Skillnad mellan dokument och fönster

    Fönstret är det översta objektet i webbläsaren. Den innehåller all information om webbläsarfönstret, som historik, plats, navigator, etc..; det är globalt tillgängligt i JavaScript. Vi kan använda det direkt i vår kod utan några importer. Vi kan komma åt egenskaperna och metoderna för fönsterobjektet utan fönster.

    Dokumentet är en del av ett fönsterobjekt. All HTML som laddas på webbsidan konverteras till dokumentobjektet. Dokumentobjektet hänvisar till det speciella HTMLDocument-elementet, som kommer att ha olika egenskaper och metoder som alla HTML-element.

    Fönstret objektet representerar webbläsarfönstret och dokumentet representerar HTML-dokumentet som laddas i det webbläsarfönstret.

    Skillnaden mellan klientsidan och serversidan

    Klientsidan hänvisar till slutanvändaren som använder applikationen. Serversidan hänvisar till webbservern där applikationen distribueras.

    I frontend-terminologin kan vi säga webbläsare på användarnas datorer som klientsida och molntjänster som serversida.

    Skillnaden mellan innerHTML och innerText

    Både innerHTML och innerText är egenskaperna hos HTML-element. Vi kan ändra innehållet i ett HTML-element med dessa egenskaper.

    Vi kan tilldela HTML-strängen till innerHTML en egenskap som återges som vanlig HTML. Kontrollera exemplet nedan.

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

    Lägg till ett element med id-titeln i din HTML och lägg till skriptet ovan i JavaScript-filen. Kör koden och se resultatet. Du kommer att adminvista.com i orange färg. Och om du inspekterar elementet kommer det att finnas inuti span-taggen. Så innerHTML kommer att ta HTML-strängen och rendera den som normal HTML.

    InnerTexten på andra sidan tar en normal sträng och renderar den som den är. Det kommer inte att rendera någon HTML som innerHTML. Ändra innerHTML till innerText i ovanstående kod och kontrollera utdata.

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

    Nu kommer du att se den exakta strängen som vi angav på webbsidan.

    Skillnaden mellan let och var

    Nyckelorden let och var används för att skapa variabler i JavaScript. Nyckelordet let introduceras i ES6.

    Leten är en block-scoped och var är funktion-scoped.

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

    Kör ovanstående kod. Du kommer att få ett felmeddelande på sista raden eftersom vi inte kan komma åt låt en utanför blocket eftersom det är block-scoped. Ändra nu till var och kör det igen.

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

    Du kommer inte att få något fel eftersom vi kan komma åt en variabel utanför blocket också. Låt oss nu ersätta blocket med en funktion.

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

    Du kommer att få ett referensfel om du kör ovanstående kod eftersom vi inte kan komma åt var a it utanför funktionen eftersom den är funktionsomfattad.

    Vi kan omdeklarera variablerna med var nyckelord men vi kan inte omdeklarera variablerna med let nyckelord. Låt oss se ett exempel.

    var a = "adminvista.com";
    var a = "Chandan";
    console.log(a);
    let a = "adminvista.com";
    let a = "Chandan";
    console.log(a);

    Den första kodbiten ger inget fel och värdet är a kommer att ändras till det senast tilldelade värdet. Den andra kodbiten kommer att ge ett fel eftersom vi inte kan omdeklarera variabler med let.

    Skillnaden mellan sessionslagring och lokal lagring

    Sessionslagringen och den lokala lagringen används för att lagra information på användarnas datorer som kan nås utan internet. Vi kan lagra nyckel-värdeparen i både sessionslagring och lokal lagring. Både nyckel och värde kommer att konverteras till strängar om du tillhandahåller någon annan datatyp eller datastruktur.

    Sessionslagringen kommer att rensas efter att sessionen är över (när webbläsaren är stängd). Platslagringen rensas inte förrän vi rensar den.

    Vi kan komma åt, uppdatera och ta bort sessionslagring och platslagring med sessionStorage- respektive localStorage-objekt.

    Vad är NaN i JavaScript?

    NaN förkortas som Not-a-Number. Det representerar att något inte är ett lagligt/giltigt nummer i JavaScript. Det finns vissa fall där vi kommer att få NaN som utdata som 0/0, odefinierad * 2, 1 + odefinierad, null * odefinierad etc..,

    Vad är Lexical scoping?

    Den lexikaliska räckvidden hänvisar till att få tillgång till variablerna från sina föräldrars räckvidd. Låt oss säga att vi har en funktion med två inre funktioner. Den innersta funktionen kan komma åt sina två överordnade funktioners omfångsvariabler. På liknande sätt kan funktionen på 2:a nivån komma åt det yttersta funktionsomfånget. Låt oss se det i ett exempel.

    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 använder en omfattningskedja för att hitta variabeln när vi kommer åt den någonstans i koden. Först kommer den att kontrollera variabeln i det aktuella omfånget, och sedan det överordnade omfånget till det globala omfånget.

    Vad passeras av värde och passeras av referens?

    Pass by value och pass by reference är två sätt att skicka argumenten till en funktion i JavaScript.

    Pass by value: den skapar en kopia av originaldata och skickar den till funktionen. Så när vi gjorde några ändringar i funktionen kommer det inte att påverka originaldata. Kontrollera exemplet nedan.

    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);

    Du kommer att se att det ursprungliga värdet på a-et inte ändras även om vi ändrade det inuti funktionen.

    Pass by reference: den skickar referensen för data till funktionen. Så när vi gjorde några ändringar i funktionen kommer den också att ändra originaldata.

    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);

    Du kommer att se att det ursprungliga värdet på arr ändras när vi ändrar det inuti funktionen.

    Obs: alla primitiva datatyper skickas av värde och icke-primitiva skickas genom referens.

    Vad är memoisering?

    Memoization är en teknik som lagrar de beräknade värdena i cacher och använder dem när vi behöver dem igen utan att beräkna dem igen. Det kommer att påskynda exekveringen av koden om beräkningen är mycket tung. Det finns en lagringsavvägning som inte är ett stort problem jämfört med tid.

    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));

    Det är ett enkelt exempel som visar memoisering. Här är det inte svårt att lägga till två siffror. Det är bara för demot.

    Vad är viloparametern?

    Restparametern används för att samla alla återstående parametrar i en funktion. Låt oss säga att vi har en funktion som accepterar minst 2 argument och som maximalt kan acceptera vilket antal parametrar som helst. Eftersom vi inte har det maximala antalet argument kan vi samla in de två första parametrarna med normala variabler och alla andra med restparametern med restoperatorn.

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

    Parametern rest kommer att vara en array av de tre sista argumenten i exemplet ovan. Med detta kan vi ha hur många parametrar som helst för en funktion.

    En funktion kan bara ha en viloparameter. Och restparametern ska vara den sista i parametrarnas ordning.

    Vad är objektdestrukturering?

    Objektdestrukturering används för att komma åt variablerna från objektet och tilldela dem till variabler med samma namn som objektnycklar. Låt oss se ett exempel.

    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);

    Vi kan ändra variablerna för destrukturerade variabler på samma rad enligt följande.

    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);

    Vad är array-destrukturering?

    Array-destrukturering används för att komma åt variablerna från arrayen och tilldela dem till variabler. Låt oss se ett exempel.

    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);

    Vad är händelsefångande och händelsebubblande?

    Händelsefångst och händelsebubbling är två sätt att sprida händelser i HTML DOM. Låt oss säga att det finns två HTML-element, det ena inuti det andra. Och en händelse inträffar på det inre elementet. Nu kommer händelseutbredningsläget att avgöra ordningen för dessa händelsers exekvering.

    Händelsebubbling: den kör händelsehanteraren på elementet först, sedan dess element, och sedan går det hela vägen upp till det översta elementet. Detta är standardbeteendet för alla händelser.

    Händelsefångst: vi måste specificera i händelse av att vi behöver använda den här typen av händelseutbredning. Vi kan specificera det när vi lägger till händelseavlyssnaren. Händelserna kommer att köras i följande ordning om vi har aktiverat händelsefångst.

  • Händelserna börjar köras från det översta elementet till målelementet till nedåt.
  • Händelsen på målelementet kommer att exekveras igen.
  • Den bubblande händelseutbredningen kommer igen att inträffa tills det översta elementet är uppe.
  • Vi kan stoppa händelseutbredningen genom att anropa event.stopPropogation en metod i händelsehanteraren.

    Vilka är löftena i JavaScript?

    Löftet objektet används för asynkrona operationer som kommer att slutföras i framtiden med ett framgångs- eller misslyckande.

    Ett löfte kan vara i ett av följande tillstånd.

  • väntar – när operationen fortfarande pågår.
  • uppfyllt – när operationen har slutförts framgångsrikt. Vi kommer att ha resultat (om några) i framgångsläget.
  • avvisad – när operationen är klar med ett misslyckande. Vi kommer att ha anledningen (felet) till varför det misslyckades.
  • Låt oss se två exempel på framgångs- och misslyckandefall.

    // 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);
      });

    Du kan ha mer än en sedan kedja vid behov. Tidigare returnerade data kommer att accepteras vid nästa återuppringning.

    Förklara de olika typerna av omfång i JavaScript

    Det finns två typer av omfång i JavaScript. Den globala räckvidden och den lokala räckvidden.

    Du kanske har hört talas om funktionen scope och block scope också. De är lokala scopes för var och let, const.

    Vad är självanropande funktioner?

    De självanropande funktionerna är namnlösa funktioner som kommer att exekveras direkt efter skapandet. Låt oss se några exempel.

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

    Vi kan till och med föra över argumenten till de självanropande funktionerna som du har sett i exemplet.

    Vad är pilfunktioner?

    Pilfunktionen är syntaktisk socker till normal funktion med vissa ändringar. De beter sig som vanliga funktioner i vanliga fall. Pilfunktioner kommer väl till pass när vi måste ha återuppringningar. Låt oss se dess syntax.

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

    Det finns vissa skillnader mellan pilens funktioner och normala funktioner.

    • Pilfunktioner har inte sin egen denna bindning. Det här nyckelordet i pilfunktionen hänvisar till dess överordnade omfattning detta.
    • Pilfunktioner kan inte användas som konstruktorfunktioner

    Vad är återuppringningar?

    En återuppringning är en funktion som skickas till en annan funktion som anropas i den funktionen. Att använda återuppringningar är en vanlig sak i JavaScript. Låt oss se ett exempel.

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

    Funktionen avslutad skickas som en återuppringning till provet. Den färdiga funktionen anropas med resultatet efter att någon åtgärd har utförts. Du kommer att se återuppringningsanvändningen mestadels i asynkrona operationer som löften, setTimeout, etc..,

    Vilka är de olika typerna av fel?

    Låt oss kontrollera några fel i JavaScript.

    ReferenceError: detta fel kommer att uppstå om variabeln som vi har tillgång till är tillgänglig.

    TypeError: JavaScript ger det här felet om felet inte matchar andra typer av fel. Det kommer också att inträffa när vi försöker utföra en åtgärd som inte är kompatibel med data.

    SyntaxError: det här felet uppstår om JavaScript-syntaxen inte är korrekt.

    Det finns några andra typer av fel också. Men det här är de vanligaste feltyperna i JavaScript.

    Vilka är de olika omfattningarna av variabler i JavaScript?

    Det finns två omfång av variabler i JavaScript. Variablerna som deklareras med nyckelordet var kommer att ha funktionsomfång, och variablerna som deklareras med let och const kommer att ha blockomfånget.

    Se den 17:e frågan för mer information om dessa variablers omfattning.

    Vad är escape-tecken i JavaScript?

    Omvänt snedstreck är flykttecken i JavaScript. Det används för att skriva ut vissa specialtecken som vi inte kan skriva ut i allmänhet. Låt oss säga att vi vill skriva ut apostrof (’) inuti en sträng vilket vi inte kan göra normalt eftersom strängen kommer att sluta vid den andra apostrof. I så fall använder vi escape-tecknet för att undvika att strängen avslutas vid den punkten.

    const message="Hi, I"m adminvista.com';
    console.log(message);

    Vi kan uppnå ovanstående utdata utan att använda escape-tecken genom att ersätta de yttre enkla apostroferna med dubbla apostroferna. Men det är bara ett exempel på hur man använder en flyktkaraktär. Det finns andra karaktärer för vilka vi definitivt behöver flyktkaraktär som n, t, etc..,

    Vad är BOM och DOM?

    Browser Object Model (BOM): alla webbläsare har BOM som representerar det aktuella webbläsarfönstret. Den innehåller vårt översta fönsterobjekt som används för att manipulera webbläsarfönstret.

    Document Object Model (DOM): webbläsare skapar DOM när HTML läses in i trädstrukturen. Vi kan manipulera HTML-elementen med DOM API.

    Vad är ett skärmobjekt?

    Skärmobjektet är en av egenskaperna hos det globala fönsterobjektet. Den innehåller olika egenskaper för skärmen där det aktuella webbläsarfönstret renderas. Några av egenskaperna är bredd, höjd, orientering, pixelDepth, etc.,

    Slutsats

    Det kan finnas uppföljningsfrågor för alla ovanstående frågor. Så du måste förbereda koncepten kring alla ovanstående frågor.

    Du kan också utforska några vanliga frågor och svar på Java-intervjuer.

    Lycka till med lärandet 🙂