- Pilfunktioner forenkler syntaksen og indfanger leksikalsk værdien af `this`, i modsætning til normale funktioner.
- JavaScript bestemmer `dette` i klassiske funktioner ved hjælp af fire regler: eksplicit binding, implicit binding, binding med `ny` og standardbinding.
- Pilfunktioner er ideelle til callbacks og asynkron kode, men bør ikke bruges som metoder, der afhænger af `dette` eller som konstruktører.
- At mestre den kombinerede brug af normale funktioner, pilefunktioner og teknikker som call, apply og bind er nøglen til at skrive moderne og robust JavaScript.
At mestre pilefunktioner og opførslen af `this` i JavaScript er revolutionerende for dine udviklingsevner. Disse to emner kan virke forvirrende i starten, men når du først forstår dem, vil du begynde at bemærke fejl, du tidligere har overset, skrive tydeligere kode og have mindre problemer med kontekst.
I denne artikel vil vi se klart og tydeligt på, hvordan man skriver pilefunktioner, hvordan de adskiller sig fra almindelige funktioner, og hvordan dette påvirker `this` . Vi vil også dække nøglebegreber som `call`, `apply`, `bind`, brugen af `new`, de forskellige typer af `this`-binding, hvordan den opfører sig i klasser, events, callbacks, miljøer som React og Node.js, og hvornår det giver mening at bruge eller undgå pilefunktioner.
Grundlæggende syntaks for pilefunktioner
En pilefunktion skrives med symbolet => og er altid et funktionsudtryk , det vil sige, at den ikke deklareres med funktionsnavn(), men tildeles en variabel eller egenskab.
Den generelle form er nogenlunde sådan her: const myFunction = (param1, param2) => { /* code */ } . Ligesom en klassisk anonym funktion, men hvor ordet `function` erstattes med pilen => og parenteserne for parametrene og de krøllede parenteser for brødteksten bevares.
Det er vigtigt at forstå, at pilefunktioner ikke er funktionsdeklarationer : du kan ikke bruge dem, før du definerer dem, fordi de ikke er hoisted (der er ingen hoisting på samme måde som med `function name()`). De opfører sig altid som udtryk, der evalueres, når fortolkeren passerer over den linje.
Syntaksgenveje: kortere versioner af pilefunktioner
Når koden i funktionen er meget enkel, giver pilfunktioner mulighed for en mere kompakt og læsbar syntaks . Hvis brødteksten kun har én sætning, og denne sætning er et returnummer, kan flere ting udelades:
- Ordet kan fjernes funktion (Vi har faktisk allerede fjernet den).
- De kan fjernes Llaves {}.
- Ordet kan udelades afkast, ved hjælp af implicit retur.
For eksempel, i stedet for at skrive en sum som `const sum = function(a, b) { return a + b; }` , kan du med arrow lade den være `const sum = (a, b) => a + b;` . Resultatet er det samme, men koden er kortere og læses bedre, især i callbacks og array-metoder.
Parametre i pilefunktioner
Reglerne for parametre ændrer sig en smule med syntaksen, og det er vigtigt at forstå dem, fordi tåbelige fejl er almindelige i begyndelsen:
- En enkelt parameterDu kan fjerne parenteserne og skrive noget i retning af navn => `Hej ${navn}`Det er fuldt ud gyldigt og meget almindeligt.
- Nul parametreParenteserne er obligatoriske der, da du skal have noget før pilen: () => console.log('Ingen parametre').
- To eller flere parametreDu skal også bruge parenteser, for eksempel (a, b, c) => a * b * c.
I alle tilfælde, hvis funktionens brødtekst reduceres til et simpelt udtryk, kan du drage fordel af den implicitte return og eliminere parenteser og return , hvilket er meget praktisk i metoder som map, filter, reduce eller i små transformationsfunktioner.
Implicit retur og objektretur
Når pilfunktionen har et enkelt udtryk, returneres værdien af det udtryk automatisk, hvis du ikke bruger krøllede parenteser. Men når du vil returnere et literalobjekt, er der et vigtigt trick: du skal ombryde objektet i parenteser.
Hvis du skriver noget i retning af `const crearUsuario = (nombre, edad) => { nombre: nombre, edad: edad }` , fortolker JavaScript de krøllede parenteser som funktionens brødtekst, ikke som et objekt, der skal returneres, så det returnerer ikke noget (undefined). For at det kan virke, skal du skrive `const crearUsuario = (nombre, edad) => ({ nombre, edad })`.
Kort sagt, når din arrow-funktion skal returnere et objekt på en enkelt linje , skal du ombryde objektet i parenteser, så motoren forstår, at det er den returnerede værdi og ikke en kodeblok.
Vigtige forskelle mellem normale funktioner og pilefunktioner
Ud over syntaksen er det virkelig vigtigt til daglig brug, at pilefunktioner ikke opfører sig på samme måde som "normale" funktioner på flere kritiske områder : `dette`, argumenter, brug som metoder, konstruktører osv.
Håndtering af dette i normale funktioner
I en klassisk funktion afhænger værdien af `this` af, hvordan funktionen kaldes , ikke hvor den er defineret. Denne sondring er kilden til en stor del af forvirringen.
- Hvis du kalder en funktion som obj.metode()Inden for den metode peger dette på obj (implicit binding).
- Hvis du kalder en enkelt funktion, minFunktion(), uden et objekt foran, vil dette i ikke-strict tilstand være det globale objekt (vindue i browseren), og i strict tilstand vil det være udefineret.
- Hvis du bruger ny MinFunktion(), så vil dette være det nye objekt, der oprettes i MyFunction (binding med new).
- Hvis du bruger opkald, ansøg eller bindDu kan eksplicit angive, hvilket objekt du ønsker, at dette skal være.
Denne dynamiske natur gør `dette` meget kraftfuldt, men også meget nemt at inddrage i callbacks og asynkron kode, hvis man ikke er klar over, hvor hver funktion kaldes fra.
Leksikalsk håndtering af "dette" i pilefunktioner
Pilfunktioner ændrer reglerne fuldstændigt: de har ikke deres eget `this` . I stedet for at modtage et nyt `this` afhængigt af deres navn, registrerer de `this` fra det miljø, hvor de blev oprettet, hvilket kaldes et leksikalsk `this`.
Det betyder, at inden for en pilefunktion er `this` præcis den samme `this`, der var på det sted, hvor funktionen blev defineret . Den påvirkes ikke af, hvordan den kaldes, eller af `call/apply/bind`. Denne funktion er uvurderlig til håndtering af array-metoder, `setTimeout`, `setInterval`, promises og enhver situation, hvor du tidligere skulle jonglere med `self = this` eller `bind`.
De fire hovedregler for `dette` i JavaScript
For fuldt ud at forstå, hvorfor pilefunktioner er så nyttige, er det vigtigt at forstå, hvordan JavaScript bestemmer værdien af `this` i almindelige funktioner . Der er fire grundlæggende regler, der anvendes i denne prioriterede rækkefølge:
- Eksplicit binding: når du bruger call, apply eller bind til at løse dette.
- Implicit binding: når du kalder en metode som en egenskab for et objekt (obj.method()).
- Binding med nyt: når du kalder en funktion med new, og omdanner den til en konstruktør.
- Standardbinding: når ingen af ovenstående gælder (global eller udefineret afhængigt af tilstanden).
Pilfunktioner "omgår" dette system: de deltager ikke i disse regler, fordi de aldrig opretter deres eget `dette` . De arver blot det, der findes i den omgivende kode.
Eksplicit binding: kalde, anvende og binde
Normale funktioner giver dig mulighed for at gennemtvinge værdien af `this` ved hjælp af tre velkendte metoder: `call`, `apply` og `bind` . Disse er grundlæggende for at forstå den klassiske model og for at sammenligne den med funktionsmåden af pilefunktioner.
kald og anvend: udfør med brugerdefineret `this`
Både `call` og `apply` bruges til øjeblikkeligt at kalde en funktion med en specifik `this` . Forskellen ligger i, hvordan du sender argumenterne: `call` modtager dem én efter én, mens `apply` modtager et array.
Hvis du for eksempel har en funktion, der hilser med `this.name`, kan du kalde den funktion med forskellige objekter og genbruge logikken. Dette er meget almindeligt, når du vil dele funktioner mellem objekter uden at duplikere kode.
bind: opret en ny funktion med `this`
`bind` fungerer anderledes: i stedet for at udføre den med det samme, returnerer den en ny funktion, hvor `this` er "vedhæftet" til det objekt, du sender den til . Derudover kan du angive argumenter på forhånd (delvis anvendelse), så den resulterende funktion allerede leveres med nogle foruddefinerede parametre.
Det er meget nyttigt, når du vil sende metoder som callbacks uden at miste deres oprindelige kontekst , for eksempel i eventlistenere eller i setInterval, hvor `this` ofte er defekt.
En vigtig detalje er, at en funktion, der allerede er bundet med `bind`, ignorerer efterfølgende forsøg på at ændre `this` med `call` eller `apply` . Bindingen er permanent for den afledte funktion.
Implicit binding og tab af kontekst
Implicit binding opstår, når du kalder en funktion som en metode til et objekt ; det vil sige, at der er noget til venstre for prikken. I så fald bliver `dette` til det objekt.
Hvis du for eksempel har et restaurantobjekt med metoderne welcomeGuest og cookPizza, og du bruger restaurant.welcomeGuest() , peger denne metode på selve restauranten, hvilket giver dig adgang til egenskaber som navn eller placering.
Problemet starter, når du adskiller metoden fra objektet , for eksempel ved at sende det som et callback: `setInterval(this.tick, 1000)`. Når timeren udføres, er der ikke længere et objekt til venstre for tick'et. Den implicitte binding går tabt, og standardbindingen overtager, hvilket gør `this` global eller udefineret, og din kode fejler.
Den klassiske løsning var at bruge `bind(this) ` eller gemme en reference som `const self = this`. Nu om dage er pilefunktioner et perfekt valg til at løse dette tab af kontekst , fordi de arver det ydre `this` og ikke ændrer det, selv når det sendes som callbacks.
Konstruktører, nye og dette
Når du kalder en funktion med new , gør JavaScript automatisk flere ting for at behandle den som en konstruktør:
- Opret et nyt tomt objekt.
- Vincula Dette er et nyt objekt inden for funktionen.
- Tilpas prototypen af det nye objekt til konstruktørens prototype.
- Returner objektet, medmindre du eksplicit returnerer et andet objekt.
Takket være dette giver en konstruktør som `function Persona(nombre) { this.nombre = nombre; }` dig mulighed for at udføre `const p = new Persona('Ana');` og have et objekt med egenskaben `nombre`. Inde i konstruktøren refererer `this` til den nyoprettede instans.
Dette mønster bruges også til at designe mere komplekse strukturer, såsom en bankkonto med ind- og udbetalingsmetoder eller et køretøj med kørselsmetoder og egenskaber som årgang og model. I alle disse tilfælde er `dette` den konkrete instans, du arbejder med.
Meget vigtigt: pilfunktioner kan ikke bruges som konstruktører . De understøtter ikke brugen af `new`, og hvis du prøver, får du en fejl. Da de ikke har deres egen `this` eller `prototype`, passer de ikke ind i denne model.
Standardbinding og streng tilstand
Når hverken eksplicit, implicit eller ny binding gælder, vender JavaScript tilbage til standardbinding :
- I ikke-streng tilstand, Dette peger på det globale objekt (vindue i browser, globalt i Node.js).
- I streng tilstand ('brug streng'), Dette er udefineret i en normal funktion kaldet "en bareback".
Denne ændring af streng tilstand er meget gavnlig, fordi den forhindrer dig i at ændre det globale objekt ved et uheld, når du troede, du arbejdede med en anden kontekst. Mange almindelige fejl med `dette` kommer frem i lyset, når du aktiverer 'brug streng', netop fordi de holder op med at virke korrekt og hurtigt fejler.
En anden vigtig detalje er, at i browserens globale miljø bliver variabler deklareret med `var` egenskaber for det globale objekt . Så hvis du deklarerer `var globalName = 'User'`, kan du tilgå `window.globalName`. Dette blandes med `this` i ikke-strikte funktioner og fører til mærkelig (og til tider farlig) adfærd.
Arrow fungerer som en "game changer" for dette
Den store fordel ved pilfunktioner er, at de ikke opretter en ny `this` . I stedet indfanger de `this` fra det scope, hvor de oprettes. Kort sagt: `this` inde i en pilfunktion er den samme `this` som udenfor.
Dette løser mange klassiske problemer, hvor kontekst gik tabt, for eksempel i forEach callbacks, setTimeout, listeners og promises. Der er ikke længere behov for at binde til hvert internt callback eller at bære mellemliggende variabler som self eller that rundt for at bevare kontekst.
Et meget typisk eksempel er iterering gennem et array af medlemmer i et teamobjekt. Hvis du bruger en almindelig funktion i `forEach`, afbrydes `this` og peger ikke længere på teamobjektet. Hvis du bruger en pilefunktion i stedet, forbliver `this` værdien af den ydre metode , så du kan læse `this.name` uden overraskelser.
Global kontekst, objektmetoder og pilefunktioner
Pilfunktioner opfører sig forskelligt afhængigt af den kontekst, de er defineret i :
- Hvis de er defineret i det globale omfang, arver de dette globale objekt (vindue- eller modulobjekt afhængigt af miljøet).
- Hvis de er definerede inden for en normal metodeDe arver `dette` fra den metode, som normalt vil være det objekt, der kaldte den.
- Hvis du placerer en pil direkte som en metode for et objekt (myObj.method = () => {}), Sådan får du ikke objektetmen den eksterne denne (global eller modulets).
Dette sidste punkt er afgørende: det er ikke en god idé at bruge pilfunktioner som objektmetoder, når du er afhængig af `this` for at få adgang til objektets egenskaber . I disse tilfælde er det at foretrække at bruge klassisk funktionssyntaks i metoden, så `this` er objektet.
Derimod er det god praksis at bruge indlejrede pilefunktioner i normale metoder, når du ønsker tilbagekald, der respekterer `this` for den pågældende metode (for eksempel i `forEach`, `map`, `setTimeout`...).
ES6-klasser, this og arrow-funktioner
ES6-klasser er ikke meget mere end syntaktisk sukker oven på prototypen og konstruktørsystemet , men de hjælper med at strukturere koden bedre. Inden for en klasse opfører konstruktøren sig som en traditionel funktionskonstruktør: `this` peger på den nyoprettede instans.
Metoder defineret som `myMethod() { … }` bruger også `this` som instans, når de kaldes fra objektet. Men hvis du udtrækker metoden og gemmer den i en variabel uden binding, mister du konteksten igen, ligesom med enhver anden normal funktion.
En meget populær strategi er at definere nogle klassemetoder som egenskaber ved hjælp af `arrow function` , for eksempel `getInfoArrow = () => { … }`. Disse metoder er "bundet" til instansen fra det øjeblik, den oprettes, så selvom du sender dem som callbacks eller tager dem ud af kontekst, vil `this` stadig pege korrekt på objektet . Dette bruges i vid udstrækning i frameworks som React (med klassekomponenter) for at undgå at skulle binde hver eventhandler i konstruktøren.
DOM-hændelser, callbacks og typiske problemer med `this`
Når du i browseren tilføjer en eventlistener med `addEventListener` og sender en almindelig funktion, peger `this` i handleren på det DOM-element, der udløste eventet . Dette er nogle gange nyttigt, men andre gange bryder det konteksten for din klasse eller dit objekt.
Hvis du for eksempel i en Button-klasse bruger `this.element.addEventListener('click', this.handleClick)`, vil `this` i `handleClick` være DOM-elementet, ikke klasseinstansen, når hændelsen udløses. For at løse dette har du tre almindelige muligheder:
- Brug bind (dette) når man registrerer lytteren.
- Send en pilefunktion, der kalder this.handleClick(), og arver dermed this fra instansen.
- Definer handleClick som en egenskab med en arrow-funktion i klassen.
I array-tilbagekald (map, filter, forEach osv.) sker der noget lignende: hvis du sender en metode uden en binding, kan du miste kontekst. Igen er arrow-funktioner meget praktiske til at skrive interne tilbagekald, der ser den relevante `this` uden at skulle binde manuelt.
Asynkrone operationer, løfter og asynkron/afvent
Med async/await bevares værdien af dette helt naturligt inden for den asynkrone metode, så længe du bruger normale funktioner i klassemetoden.
Men når du kæder løfter sammen med `then` og `catch`, og du bruger almindelige funktioner inden for disse metoder, risikerer du at miste `this`-attributten for instansen. Derfor er det så almindeligt at skrive `.then(data => this.process(data))` og `.catch(error => this.handleError(error))` : pilefunktionerne sikrer, at `this` fortsætter med at pege på det oprindelige objekt.
Kort sagt, i moderne asynkron kode er pilefunktioner standardværktøjet til at opretholde kontekst uden at skulle kæde bindinger sammen overalt.
Hvornår er det passende at bruge pilefunktioner
Pilfunktioner fremstår især i disse tilfælde:
- Korte tilbagekald i array-metoder, løfter, timere osv.
- Små og enkle funktioner hvor du prioriterer korthed frem for muligheden for at genbruge dette.
- Situationer hvor Vil du have, at dette forbliver den fra det ydre miljø?, såsom inden for en klasse eller objektmetode.
- Klassekomponenter i React og lignende biblioteker, f.eks. undgå at skulle binde i konstruktøren for hver håndterer.
Derudover gør pilefunktioner i mere funktionel programmering (funktionskomposition, kurering, datatransformationer) koden meget mere læsbar og udtryksfuld, fordi de favoriserer rene og korte funktioner uden at skulle navngive dem.
Hvornår du IKKE bør bruge pilefunktioner
Der er også klare scenarier, hvor det ikke er en god idé at bruge pilefunktioner , og en klassisk funktion er at foretrække:
- Objektmetoder der afhænger af `this` for at få adgang til objektets egenskaber. Hvis du definerer metoden som `arrow`, vil `this` ikke være objektet, men den eksterne kontekst.
- BygherrerPilfunktioner kan ikke bruges med new, så de er ikke nyttige til at oprette instanser.
- Funktioner, der kræver arguments-objektet Pilfunktioner har ikke deres egne argumenter; hvis du har brug for dem, kan du bruge en normal funktion eller restparametre (…args).
- Rene forsyningsvirksomheder eller hjælpere kontekstuafhængig
Hjælpefunktioner (formatCurrency, calculateTax, små matematiske operationer) bør ikke afhænge af `this` . I disse tilfælde er det vigtigt, at de er rene, nemme at teste og ikke har nogen bivirkninger. Du kan skrive dem med `function` eller `arrow`, men undgå at stole på `this` overhovedet.
I funktionelle programmeringsmønstre anbefales det også, at funktioner ikke afhænger af kontekst. Jo mindre du bruger `dette` i denne type kode, desto mere forudsigelig og sammensættelig vil din kodebase være.
Dette i moderne miljøer: React og Node.js
I React med klassekomponenter er brugen af `this` afgørende for håndtering af state og props . Hændelseshandlere skal have adgang til `this.setState` og komponentens egenskaber. Hvis du ikke binder eller bruger pilefunktioner til disse handlere, vil du støde på `this undefined`-fejl, så snart brugeren klikker.
Derfor vil du i mange projekter se mønstre som handleChange = (event) => { … } og onClick={this.handleChange} . Disse pilefunktioner, defineret som klasseegenskaber, er automatisk bundet til instansen , hvilket undgår yderligere bindinger i konstruktøren og reducerer risikoen for kontekstfejl.
I Node.js er opførslen af `this` på modulniveau ikke den samme som i browseren . På filniveau peger `this` typisk på `module.exports` (i CommonJS) eller er udefineret i ES-moduler i stedet for det globale objekt. Dette påvirker, hvordan du forstår `this`, når du skriver genbrugelige biblioteker og moduler.
Under alle omstændigheder forbliver reglen den samme: pilfunktioner arver `this`-egenskaben fra det miljø, hvor de er defineret . I Node vil det være det modul eller den klasse, du er i, hvilket dikterer, hvordan du designer dine API'er, og hvordan du eksponerer metoder for andre filer.
Brug af JavaScript i miljøer som Appsmith
På platforme med lav kode/ingen kode som Appsmith kan du skrive JavaScript i næsten enhver widget-egenskab (tekst, farve, synlig, deaktiveret osv.) ved hjælp af udtryk omsluttet af krøllede parenteser {{ }}. Disse udtryk evalueres og returnerer altid en værdi: en streng, et tal, en boolsk værdi, et objekt osv.
Du kan også definere regulære funktioner, udtryk og pilefunktioner i JSObjects , som er blokke af JavaScript-kode med en `export default { … }`. Det er vigtigt at bemærke, at du på det øverste niveau af et JSObject definerer egenskaber og metoder som kommaseparerede nøgle-værdi-par, og at `this`-attributten for disse metoder opfører sig afhængigt af, om de er regulære funktioner eller pilefunktioner.
Som bedste praksis bruger JSObjects typisk almindelige funktioner som hovedmetoder (for at undgå forvirring med `this`) og indlejrede pilefunktioner i disse metoder som tilbagekald til filtre, kort, reduktioner osv. Dette mønster giver dig mulighed for at udnytte den kompakte syntaks i pile uden at komplicere kontekststyring.
Bedste fremgangsmåder til at mestre dette og pilefunktioner
For at få mest muligt ud af disse værktøjer uden at blive skør, er der en række retningslinjer, der er værd at lære:
- Vær tydelig med kontekstenHvis du er i tvivl, så brug bind- eller arrow-funktionerne til at gøre det klart, hvilken `dette` du vil bruge.
- Brug pilefunktioner til tilbagekald næsten altid, især i asynkron kode og array-metoder, for at undgå at miste det ydre `this`.
- Bland ikke stilarter unødvendigtHvis du bruger arrow-metoder til handlere i en klasse, skal du bevare dette mønster i hele komponenten for at sikre konsistens.
- Aktivér 'brug streng' Eller brug miljøer, der allerede anvender strict mode, så fejl med `this` udløses hurtigere.
- Undgå at stole på `dette` for nyttefunktionerJo renere de er, jo lettere er de at teste og genbruge.
En solid forståelse af, hvordan og hvornår man bruger pilefunktioner, og hvad deres leksikalske adfærd indebærer , sammen med de bindende regler for almindelige funktioner, sætter dig i en langt stærkere position til at skrive moderne JavaScript. Med øvelse vil du holde op med at se `dette` som en forræderisk fjende og i stedet se det som et kraftfuldt værktøj, som du nemt kan mestre i enhver kontekst, fra browseren til Node.js eller frameworks som React.
Index
- 1 Grundlæggende syntaks for pilefunktioner
- 2 Syntaksgenveje: kortere versioner af pilefunktioner
- 3 Parametre i pilefunktioner
- 4 Implicit retur og objektretur
- 5 Vigtige forskelle mellem normale funktioner og pilefunktioner
- 6 De fire hovedregler for `dette` i JavaScript
- 7 Eksplicit binding: kalde, anvende og binde
- 8 Implicit binding og tab af kontekst
- 9 Konstruktører, nye og dette
- 10 Standardbinding og streng tilstand
- 11 Arrow fungerer som en "game changer" for dette
- 12 Global kontekst, objektmetoder og pilefunktioner
- 13 ES6-klasser, this og arrow-funktioner
- 14 DOM-hændelser, callbacks og typiske problemer med `this`
- 15 Asynkrone operationer, løfter og asynkron/afvent
- 16 Hvornår er det passende at bruge pilefunktioner
- 17 Hvornår du IKKE bør bruge pilefunktioner
- 18 Dette i moderne miljøer: React og Node.js
- 19 Brug af JavaScript i miljøer som Appsmith
- 20 Bedste fremgangsmåder til at mestre dette og pilefunktioner