Anciënniteit van de operator

Operatorprioriteit is de volgorde waarin bewerkingen in complexe expressies worden uitgevoerd. Bewerkingen op hetzelfde niveau hebben dezelfde prioriteit. Berekeningen worden van links naar rechts uitgevoerd voor alle binaire bewerkingen, beginnend met de bewerkingen bovenaan de lijst en eindigend met de bewerkingen onderaan.

De anciënniteit van de exploitanten, van laag naar hoog, zal als volgt zijn:

Toewijzing =+=-=*=/=%==>>>=&=^=|=

Selectie op voorwaarde? :

Logische OF ||

Logisch EN&&

Bitsgewijze OF |

Bitwise exclusief^

Bitsgewijze AND&

Ongelijkheid!=

Gelijkheid/Ongelijkheid == !=

Vergelijking =

Beetjeverschuiving >>>

Optellen/aftrekken + -

Vermenigvuldigen/delen * / %

Ontkenning/complement/unair min/verhoging/verlaging! ~ - ++ --

Oproepen, parameters doorgeven () .

Gereserveerde trefwoorden in JavaScript.

JavaScript heeft een aantal gereserveerde trefwoorden. Er zijn drie typen woorden: gereserveerde woorden in JavaScript, gereserveerde woorden voor de toekomst en woorden die u moet vermijden voor gebruik. JavaScript-trefwoorden

breek vals in deze leegte

ga door voor een nieuwe ware tijd

verwijder functie null typeof met

anders als return var

JavaScript-trefwoorden voor toekomstig gebruik

case-debugger export super

catch standaard verlengt schakelaar

klasse eindelijk gooien

const enum importeren proberen

Woorden die u beter niet gebruikt, zijn woorden die al namen hebben van interne JavaScript-objecten of -functies. Dit omvat woorden als String of parseInt.

Als u een trefwoord uit de eerste twee categorieën gebruikt, resulteert dit in een compilatiefout wanneer uw programma wordt geladen. Het gebruik van gereserveerde woorden uit de derde lijst kan leiden tot problemen met wangedrag als u uw variabelen en originele primitieven met dezelfde naam in hetzelfde programma probeert te gebruiken. Het volgende programma zal bijvoorbeeld niet doen wat u wilt:

var text = new String("Dit is een stringobject");

In dit geval ontvangt u een foutmelding waarin staat dat String geen object is. Veel gebruiksscenario's voor een reeds bestaande identificatie zijn niet zo duidelijk.

Scripts. Scenario's maken.

JavaScript is een scripttaal die voornamelijk wordt gebruikt om interactieve elementen op webpagina's te creëren. Het kan worden gebruikt om menu's samen te stellen, ervoor te zorgen dat formulieren correct worden ingevuld, afbeeldingen te wijzigen of iets anders dat u op een webpagina kunt doen. Een blik op GoogleMaps of de Gmail-service van Google geeft je een idee van wat JavaScript vandaag de dag kan doen.

Omdat JavaScript momenteel de enige scripttaal is die door alle grote webbrowsers (Internet Explorer, Firefox, Netscape, Safari, Opera, Camino, etc.) wordt ondersteund, wordt het op grote schaal gebruikt.

JavaScript-code wordt doorgaans uitgevoerd door de webbrowser van de client, in welk geval dit client-side scripting wordt genoemd. Maar JavaScript-code kan ook op een webserver worden uitgevoerd om HTML-documenten te genereren, waardoor scripting op de server wordt geïmplementeerd. Hoewel het gebruik van JavaScript doorgaans beperkt blijft tot scripting aan de clientzijde, is het ook een zeer krachtige server-side taal.

Wanneer u JavaScript-code maakt, heeft u eigenlijk alleen maar een teksteditor en een webbrowser nodig. Kennis van HTML en CSS zal zeker een pluspunt zijn, en als je JavaScript-vaardigheden op een website wilt gebruiken, heb je ook een website nodig. Als je al een website hebt, dan is dat geweldig! Als dat niet het geval is, zijn er veel gratis servers die u kunt gebruiken om uw pagina's te hosten.

Wat de teksteditor betreft, heeft Windows de NotePad-editor. Hoewel dit voldoende zal zijn voor het bewerken van JavaScript, HTML en CSS, kan een krachtigere editor zoals EditPlus of een andere handiger zijn.

Welnu, nu kunnen we verder gaan met het maken van het JavaScript-script!

Eerst moet u leren hoe u JavaScript aan een HTML-pagina toevoegt. Dit kan op twee manieren worden gedaan: door Script-tags op de webpagina te plaatsen en de JavaScript-code binnen die tags te plaatsen, of door alle JavaScript-code in een afzonderlijk bestand te plaatsen en deze te koppelen met behulp van een Script-tag.

Elk van deze methoden is volkomen acceptabel, maar ze hebben verschillende doeleinden. Als u een kleine code heeft die slechts op één pagina wordt gebruikt, is het plaatsen van deze code tussen Script-tags een goede oplossing. Als u echter een groot stuk code heeft dat op meerdere pagina's wordt gebruikt, is het wellicht beter om die JavaScript-code in een apart bestand te plaatsen en ernaar te linken. Dit wordt gedaan zodat u deze code niet elke keer hoeft te laden wanneer u verschillende pagina's bezoekt. De code wordt eenmalig gedownload en door de browser opgeslagen voor later gebruik. Dit is vergelijkbaar met de manier waarop Cascading Style Sheets (CSS) worden gebruikt.

Hieronder staan ​​voorbeelden van twee manieren om JavaScript-code op te nemen:

Scriptfuncties.

U kunt stukjes broncode als een functie verpakken en de functie indien nodig vanuit verschillende plaatsen in uw JavaScript-script aanroepen.

Functies worden doorgaans gedefinieerd in het hoofdgedeelte van een HTML-document, gemarkeerd met tags en. Zoals we al zeiden, moet de functie worden gedefinieerd voordat deze wordt aangeroepen. Door alle functiedefinities in de head-sectie van een HTML-document te plaatsen, zorgt u ervoor dat deze functies beschikbaar zijn wanneer het document wordt verwerkt.

Hieronder vindt u een algemeen overzicht van de functiedefinitie:

functienaam([parameter 1] [,parameter 2] [...,parameter N])

functie lichaamslijnen

Alle parameters worden per waarde aan de functie doorgegeven. Daarom kan de functie de inhoud van de variabelen die eraan worden doorgegeven als parameters niet wijzigen.

Met behulp van het return-trefwoord kan een functie een waarde retourneren.

Een operator is een of meer symbolen of trefwoorden die een soort berekening met een of meer waarden mogelijk maken. De waarden die zich links en rechts van de operator bevinden, worden operanden genoemd. Een operator met één operand wordt unair genoemd, met twee - binair, met drie - ternair.

Operators kunnen de typen van hun operanden indien nodig automatisch converteren. De vermenigvuldigingsoperator * verwacht bijvoorbeeld getallen, dus de uitdrukking "2" * "3" wordt als geldig beschouwd omdat de tolk een impliciete conversie van tekenreeks naar getal zal uitvoeren.

Voorrang van operator

Operatorprioriteit is een eigenschap van een operator die de volgorde beïnvloedt waarin deze wordt uitgevoerd in een expressie met verschillende operators, zonder expliciet de volgorde te specificeren waarin ze worden geëvalueerd. Verklaringen met een hogere prioriteit worden vóór instructies met een lagere prioriteit uitgevoerd.

In de kolom Operator geeft een weglatingsteken de locatie van de operanden ten opzichte van de operator aan.

Kolom A geeft de associativiteit van de operator weer. Associativiteit is de volgorde waarin operators met dezelfde prioriteit worden verwerkt. De aftrekkingsoperator heeft bijvoorbeeld associativiteit van links naar rechts, dus de volgende twee uitdrukkingen zijn gelijkwaardig:

X - y - z (x - y) - z

De toewijzingsoperator heeft associativiteit van rechts naar links, dus de volgende twee uitdrukkingen zijn gelijkwaardig:

W = x = y = z w = (x = (y = z))

Kolom O geeft het aantal operanden aan.

In de kolom Waardetypen worden de verwachte operandtypen vóór de pijl aangegeven, en het retourwaardetype na de pijl.

lval (afkorting van linkerwaarde) is een linkshandige uitdrukking. Dit is een historische term voor een uitdrukking die links van een toewijzingsoperator kan verschijnen. Linkshandige expressies zijn: variabelen, objecteigenschappen en array-elementen.

In de onderstaande tabel worden operators weergegeven in afnemende volgorde van prioriteit, met horizontale lijnen die groepen operators met verschillende prioriteitsniveaus scheiden.

Operator Operatortype A O Waardetypen

(…)	Groepering	afwezig	1	elke → elke
… . … … […] nieuw...()	Toegangsoperator Toegangsoperator nieuw (met lijst met argumenten)	van links naar rechts van links naar rechts afwezig	2 2 1	lval, lval → willekeurig lval, string of nummer → willekeurig constructor -> object
… () nieuw...	Een functie aanroepen nieuw (geen argumenten)	van links naar rechts van rechts naar links	1 1	functie → willekeurig constructor -> object
… ++ … --	Postfix-toename Postfix-verlaging	afwezig afwezig	1 1	lval → getal lval → getal
! … ~ … + … - … ++ … -- … verwijderen... soort... leegte...	Logisch NIET (inversie) Bitsgewijs NIET (inversie) Unair plus Unair min Voorvoegselverhoging Voorvoegsel verlagen Verwijdering Definieert het gegevenstype Retourneert een ongedefinieerde waarde	van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links	1 1 1 1 1 1 1 1 1	any → booleaans heel → heel nummer → nummer nummer → nummer lval → getal lval → getal lval → booleaans elke → tekenreeks elke → ongedefinieerd
… ** … … * … … / … … % …	Machtsverheffing Vermenigvuldiging Divisie Verdeling met rest	van rechts naar links van links naar rechts van links naar rechts van links naar rechts	2 2 2 2	nummer, nummer → nummer nummer, nummer → nummer nummer, nummer → nummer nummer, nummer → nummer
… + … … - … … + …	Toevoeging Aftrekken Aaneenschakeling	van links naar rechts van links naar rechts van links naar rechts	2 2 2	nummer, nummer → nummer nummer, nummer → nummer tekenreeks, tekenreeks → tekenreeks
… > … … >>> …	Verschuif bits naar links Verschuif bits naar rechts met behoud van teken Verschuif bits naar rechts zonder opvulling	van links naar rechts van links naar rechts van links naar rechts	2 2 2	heel, heel → heel heel, heel → heel heel, heel → heel
… < … … … … >= … ... in ... ... exemplaar van ...	Minder dan Kleiner dan of gelijk aan Meer dan Groter dan of gelijk aan Controle op de aanwezigheid van een woning Controleren of u tot dit type behoort	van links naar rechts van links naar rechts van links naar rechts van links naar rechts van links naar rechts van links naar rechts	2 2 2 2 2 2	getal, getal → boolean getal, getal → boolean getal, getal → boolean getal, getal → boolean string, object → boolean object, constructor → boolean
… == … … != … … === … … !== …	Gelijk aan Niet gelijk Strikt gelijk Strikt niet gelijk	van links naar rechts van links naar rechts van links naar rechts van links naar rechts	2 2 2 2	elke, elke → boolean elke, elke → boolean elke, elke → boolean elke, elke → boolean
… & …	Bitsgewijs EN	van links naar rechts	2	heel, heel → heel
… ^ …	Bitwise EXCLUSIEVE OF	van links naar rechts	2	heel, heel → heel
… | …	Toewijzing operatie Toewijzing operatie Toewijzing operatie	van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links van rechts naar links	2 2 2 2 2 2 2 2 2 2 2 2 2	lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke lval, elke → elke
opbrengst... opbrengst* ...	opbrengst opbrengst*	van rechts naar links van rechts naar links	1 1
... …	Verlenging	afwezig	1
… , …	Komma	van links naar rechts	2	elke, elke → elke

Expressies in JavaScript zijn combinaties operanden En exploitanten.

Operaties in expressies worden opeenvolgend uitgevoerd in overeenstemming met de prioriteitswaarde (hoe hoger de prioriteitswaarde, hoe hoger deze is). Het geretourneerde resultaat is niet altijd van hetzelfde type als het type gegevens dat wordt verwerkt. Bij vergelijkingsbewerkingen zijn bijvoorbeeld operanden van verschillende typen betrokken, maar het retourresultaat zal altijd van het booleaanse type zijn.

Rijst. 1. Expressiestructuur in JavaScript

Operanden zijn de gegevens die door het JavaScript-script worden verwerkt. De operanden kunnen eenvoudige of complexe gegevenstypen zijn, maar ook andere expressies.

Operators zijn taalsymbolen die verschillende bewerkingen op gegevens uitvoeren. Operators kunnen worden geschreven met leestekens of trefwoorden.

Afhankelijk van het aantal operanden worden de volgende typen operatoren onderscheiden:
unair - één operand is betrokken bij de bewerking;
binair - de bewerking omvat twee operanden;
ternair - combineert drie operanden.

De eenvoudigste vorm van een uitdrukking is een letterlijke vorm: iets dat naar zichzelf evalueert, bijvoorbeeld het getal 100, de tekenreeks "Hallo wereld". Een variabele kan ook een uitdrukking zijn, omdat deze resulteert in de waarde die eraan is toegewezen.

Expressies en operators in JavaScript 1. Rekenkundige operatoren

Rekenkundige operatoren zijn ontworpen om wiskundige bewerkingen uit te voeren. Ze werken op numerieke operanden (of variabelen die numerieke waarden opslaan), waardoor een numerieke waarde wordt geretourneerd.

Als een van de operanden een tekenreeks is, probeert de JavaScript-interpreter deze naar een numeriek type te converteren en vervolgens de juiste bewerking uit te voeren. Als typeconversie niet mogelijk is, is het resultaat NaN (geen getal).

Tabel 1. Rekenkundige operatoren Operator/Bewerking Beschrijving Prioriteit

+ Toevoeging	Voegt numerieke operanden toe. Als een van de operanden een string is, dan is het resultaat van de expressie een string.	12
- Aftrekken	Trekt de tweede operand af van de eerste.	12
- Unaire min	Converteert een positief getal naar een negatief getal en omgekeerd.	14
* Vermenigvuldiging	Vermenigvuldigt twee operanden.	13
/ Divisie	Deelt de eerste operand door de tweede. Het resultaat van de deling kan een geheel getal of een getal met drijvende komma zijn.	13
% Modulo-verdeling (rest van de verdeling)	Berekent de rest die resulteert uit een gehele deling van de eerste operand door de tweede. Geldt voor zowel gehele getallen als getallen met drijvende komma.	13

var x = 5, y = 8, z; z = x + y; // retourneer 13 z = x - y; // retourneer -3 z = - y; // retourneer -8 z = x * y; // retourneer 40 z = x / y; // retourneer 0,625 z = y% x; // return 3 2. Toewijzingsoperatoren

Toewijzingsoperatoren worden gebruikt om waarden aan variabelen toe te wijzen. Met gecombineerde operatoren kunt u de oorspronkelijke en daaropvolgende waarden in één variabele opslaan.

var a = 5; // wijs de numerieke waarde 5 toe aan variabele a var b = "hallo"; // sla de string hieronder op in variabele b var m = n = z = 10; // wijs aan de variabelen m, n, z de numerieke waarde 10 x += 10 toe; // gelijkwaardig aan x = x + 10; x-= 10; // gelijkwaardig aan x = x - 10; x*= 10; // gelijkwaardig aan x = x * 10; x /= 10; // gelijkwaardig aan x = x / 10; x%= 10; // gelijkwaardig aan x = x % 10; 3. Operatoren voor verhogen en verlagen

De verhogings- en verlagingsbewerkingen zijn unair en verhogen en verlagen de waarde van de operand met één. De operand kan een variabele, een array-element of een objecteigenschap zijn. Meestal worden dergelijke bewerkingen gebruikt om een ​​teller in een lus te verhogen.

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* zal als resultaat van berekeningen de waarde z = 12, x = 6 retourneren, d.w.z. de waarde van x wordt eerst met 1 verhoogd en vervolgens wordt de vermenigvuldigingsbewerking uitgevoerd */ s = y++ * 2; /* zal als resultaat van berekeningen de waarde s = 10, y = 6 retourneren, d.w.z. Eerst wordt de vermenigvuldigingsbewerking uitgevoerd en vervolgens wordt de met 1 verhoogde waarde opgeslagen in de variabele y */ k = --m * 2; // retourneer de waarde k = 8, m = 4 l = n-- * 2; // retourneer de waarde l = 10, n = 4 4. Vergelijkingsoperatoren

Vergelijkingsoperatoren worden gebruikt om operanden te vergelijken, het resultaat van de expressie kan een van de twee waarden zijn: waar of onwaar. Operanden kunnen niet alleen getallen zijn, maar ook tekenreeksen, logische waarden en objecten. Vergelijkingen kunnen echter alleen worden uitgevoerd op getallen en tekenreeksen, dus operanden die geen getallen of tekenreeksen zijn, worden geconverteerd.

Als beide operanden niet succesvol kunnen worden geconverteerd naar getallen of tekenreeksen, retourneren de operators altijd false .

Als beide operanden strings/getallen zijn of kunnen worden geconverteerd naar strings/getallen, worden ze vergeleken als strings/getallen.

Als de ene operand een tekenreeks is/wordt omgezet in een tekenreeks en de andere een getal is/wordt omgezet in een getal, dan zal de operator proberen de tekenreeks naar een getal te converteren en een getallenvergelijking uit te voeren. Als de string geen getal is, wordt deze geconverteerd naar NaN en is het resultaat van de vergelijking false .

Meestal worden vergelijkingsbewerkingen gebruikt bij het organiseren van vertakkingen in programma's.

Tabel 4. Vergelijkingsoperatoren Operator/Bewerking Beschrijving Prioriteit

== Gelijkheid	Test twee waarden voor dezelfde waarde, waardoor typeconversie mogelijk is. Retourneert waar als de operanden hetzelfde zijn, en onwaar als ze verschillend zijn.	9
!= Ongelijkheid	Retourneert waar als de operanden niet gelijk zijn	9
=== Identiteit	Test twee operanden op 'identiteit' met behulp van een strikte definitie van een overeenkomst. Retourneert waar als de operanden gelijk zijn zonder typeconversie.	9
!== Niet-identiteit	Voert identiteitsverificatie uit. Retourneert waar als de operanden niet gelijk zijn zonder typeconversie.	9
> Meer	Retourneert waar als de eerste operand groter is dan de tweede, en retourneert anders false.	10
>= Groter dan of gelijk aan	Retourneert waar als de eerste operand niet kleiner is dan de tweede, en retourneert anders false.	10
	Retourneert waar als de eerste operand kleiner is dan de tweede, en retourneert anders false.	10
	Retourneert waar als de eerste operand niet groter is dan de tweede, en retourneert anders false.	10

5 == "5"; // retourneer waar 5 != -5.0; // retourneer waar 5 === "5"; // return false false === false; // retourneer waar 1 !== waar; // retourneer waar 1 != waar; // retourneert false omdat true wordt geconverteerd naar 1 3 > -3; // retourneer waar 3 >= "4"; // return false 5. Logische operatoren

Met logische operatoren kunt u voorwaarden combineren die Booleaanse waarden retourneren. Meestal gebruikt in een if-voorwaardelijke instructie.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // retourneert true als x in het bereik van 0 tot 10 ligt! false; // return true 6. Bitsgewijze operatoren

Bitsgewijze operatoren werken op hun operanden als een 32-bits reeks van enen en nullen en retourneren een numerieke waarde die het resultaat van de bewerking vertegenwoordigt, geschreven in decimale notatie. Gehele getallen worden beschouwd als operanden; het fractionele deel van de operand wordt weggegooid. Bitsgewijze bewerkingen kunnen bijvoorbeeld worden gebruikt bij het versleutelen van gegevens, het werken met vlaggen en het afbakenen van toegangsrechten.

Tabel 6. Bitwise-operatoren Operator/Bewerking Beschrijving Prioriteit

& Bitsgewijze EN	Als beide bits 1 zijn, is de resulterende bit 1. Anders is het resultaat 0.	8
| Bitsgewijze OF	Als een van de operanden op positie een 1 bevat, zal het resultaat ook een 1 op die positie bevatten, anders is het resultaat op die positie 0.	6
^ Exclusief OF	Als er maar één waarde op een willekeurige positie een 1 bevat, dan zal het resultaat op die positie een 1 bevatten, anders is het resultaat op die positie 0.	7
~ Ontkenning	Voert een bitsgewijze negatiebewerking uit op de binaire representatie van de waarde van een expressie. Elke positie die een 1 bevat in de oorspronkelijke uitdrukking wordt vervangen door een 0. Elke positie die 0 bevat in de oorspronkelijke uitdrukking wordt 0 . Positieve getallen beginnen bij 0, negatieve getallen beginnen bij -1, dus ~ n == -(n+1) .	14
	De operator verschuift de bits van de eerste operand naar links met het aantal bitposities dat is ingesteld door de tweede operand. Nullen worden gebruikt om posities aan de rechterkant in te vullen. Retourneert een resultaat van hetzelfde type als de linkeroperand.	11
>> Bitsgewijs naar rechts verschuiven	De operator verschuift de bits van de eerste operand naar rechts met het aantal bitposities dat is ingesteld door de tweede operand. Cijfers die buiten het bereik zijn verschoven, worden verwijderd. Het meest significante bit (32e) wordt niet gewijzigd om het teken van het resultaat te behouden. Als de eerste operand positief is, worden de meest significante bits van het resultaat gevuld met nullen; als de eerste operand negatief is, worden de meest significante bits van het resultaat gevuld met enen. Een waarde één positie naar rechts verschuiven is gelijk aan delen door 2 (de rest weggooien), en twee posities naar rechts verschuiven is gelijk aan delen door 4, enz.	11
>>> Bitsgewijs naar rechts verschuiven zonder teken	De operator verschuift de bits van de eerste operand naar rechts met het aantal bitposities dat is ingesteld door de tweede operand. Nullen worden aan de linkerkant toegevoegd, ongeacht het teken van de eerste operand. Cijfers die buiten het bereik zijn verschoven, worden verwijderd.	11

var x = 9, y = 5, z = 2, s = -5, resultaat; // 9 is gelijk aan 1001, 5 is gelijk aan 0101 resultaat = x & y; // retourneert 1 (equivalent aan 0001) resultaat = x | j; // retourneert 13 (equivalent aan 1101) resultaat = x ^ y; // retourneert 12 (equivalent aan 1100) resultaat = ~ y; // retourneert -6 (equivalent aan 1100) resultaat = x > z; // retourneer 2 (equivalent aan 10) resultaat = s >>> z; // retourneert 1073741822 (equivalent aan 11111111111111111111111111110) 7. Stringoperatoren

Er zijn verschillende operators die op speciale manieren met tekenreeksen werken.

"1" + "10"; // retourneer "110" "1" + 10; // retourneert "110" 2 + 5 + "kleurpotloden"; // retourneert "7 kleurpotloden" "Kleurpotloden" + 2 + 5; // retourneert "25 kleurpotloden" "1" > "10"; // return false "10" 10 ? x * 2: x / 2; // retourneert x * 2 als x > 10, anders x / 2 9. Opmerkingen in JavaScript

Commentaar van één regel: u moet de commentaartekst vooraf laten gaan door de symbolen // .

De JavaScript-taal ondersteunt de principes van objectgeoriënteerd programmeren. Alle objecten die je in je werk tegenkomt, kun je in drie grote groepen verdelen:

1. Ingebouwde taalobjecten. Deze objecten zijn ontworpen om met specifieke gegevenstypen te werken of typische taken uit te voeren (bijvoorbeeld Math-, String-, Date-objecten, enz.). Voordat u ingebouwde objecten kunt gebruiken, is het vaak nodig om een ​​overeenkomstig exemplaar van dat object te maken (anders dan Math).

2. Externe standaardobjecten. Ontworpen voor interactie met standaard interface-elementen en browserfuncties. Dit zijn objecten zoals venster, document en gebeurtenis. Alle externe objecten zijn overal in het script beschikbaar en vereisen geen instantiatie.

3. Aangepaste objecten. Ze zijn door de ontwikkelaar gemaakt voor een aantal specifieke behoeften. Het maken van uw eigen objecten vereist bepaalde vaardigheden en ontwikkelingservaring.

Elk object bevat eigenschappen en methoden. Een eigenschap van een object is een soort kwantitatieve of kwalitatieve parameter die de kenmerken van het object bepaalt. Een objectmethode specificeert een actie die dit object kan uitvoeren. Als we de programmering negeren en een gewoon persoon als een object beschouwen, dan zullen de eigenschappen ervan ‘lengte’, ‘gewicht’, ‘oogkleur’ zijn, en de methoden ervan zullen ‘eten’, ‘drinken’, ‘lopen’, enz. zijn.

U kunt toegang krijgen tot een eigenschap of methode door de naam en het objectexemplaar op te geven:

object.eigenschap

object.methode()

Met deze notatie (met behulp van een punt) kunt u op unieke wijze een exemplaar van een object identificeren waarvan u de eigenschappen en methoden wilt gebruiken. In de praktijk worden eigenschappen op dezelfde manier gebruikt als reguliere variabelen, en worden methoden gebruikt als reguliere functies. Houd er rekening mee dat de naam van de methode altijd tussen haakjes moet eindigen, zelfs als u geen parameters aan de methode doorgeeft. Bijvoorbeeld:

// de tolk zal de open() METHODE aanroepen

// de tolk zoekt naar de open PROPERTY,

// zal het niet vinden en zal een foutmelding geven

8. Speciale operators in JavaScript.

?: Hiermee kunt u een eenvoudige "als...dan...anders" doen

Evalueert twee expressies en retourneert het resultaat van de tweede expressie.

verwijderen Hiermee kunt u een eigenschap van een object of element op een specifieke index in een array verwijderen.

nieuw Hiermee kunt u een exemplaar maken van een door de gebruiker gedefinieerd objecttype of een van de ingebouwde objecttypen.

dit trefwoord kunt u gebruiken om naar het huidige object te verwijzen.

typeof Geeft een tekenreeks terug die het type van de niet-geëvalueerde operand aangeeft.

void De void-operator definieert een expressie die wordt geëvalueerd zonder een waarde terug te geven.

9. Operatorprioriteit in JavaScript.

Anciënniteit van de operator

Operatorprioriteit is de volgorde waarin bewerkingen in complexe expressies worden uitgevoerd. Bewerkingen op hetzelfde niveau hebben dezelfde prioriteit. Berekeningen worden van links naar rechts uitgevoerd voor alle binaire bewerkingen, beginnend met de bewerkingen bovenaan de lijst en eindigend met de bewerkingen onderaan.

De anciënniteit van de exploitanten, van laag naar hoog, zal als volgt zijn:

Toewijzing =+=-=*=/=%==>>>=&=^=|=

Selectie op voorwaarde? :

Logische OF ||

Logisch EN &&

Bitsgewijze OF |

Bitwise exclusief^

Bitsgewijs EN &

Ongelijkheid!=

Gelijkheid/Ongelijkheid == !=

Vergelijking =

Bitverschuiving > >>>

Optellen/aftrekken + -

Vermenigvuldigen/delen * / %

Ontkenning/complement/unair min/verhoging/verlaging! ~ - ++ --

Oproepen, parameters doorgeven () .

Wiskundige bewerkingen zijn een van de meest fundamentele en universele functies van elke programmeertaal. In JavaScript worden getallen vaak gebruikt bij algemene taken, zoals het bepalen van de grootte van een browservenster, het berekenen van de uiteindelijke prijs van een geldtransactie of de afstand tussen elementen in een websitedocument.

Je hoeft niet goed te zijn in wiskunde om een ​​goede ontwikkelaar te zijn, maar het is wel belangrijk om te weten welke soorten bewerkingen beschikbaar zijn in JavaScript en hoe je deze kunt gebruiken om praktische taken uit te voeren.

In tegenstelling tot andere programmeertalen heeft JavaScript slechts één numeriek gegevenstype; het maakt geen onderscheid tussen gehele getallen en floats.

Deze tutorial behandelt rekenkundige operatoren, toewijzingsoperatoren en de volgorde van bewerkingen met numerieke JavaScript-gegevens.

Rekenkundige operatoren

Rekenkundige operatoren zijn symbolen die wiskundige bewerkingen definiëren en een resultaat opleveren. In 3 + 7 = 10 definieert het symbool + bijvoorbeeld de syntaxis voor de optelbewerking.

Veel JavaScript-operatoren zijn u bekend uit de basiswiskunde, maar er zijn ook verschillende aanvullende operatoren.

Alle rekenkundige operatoren in JavaScript worden in de volgende tabel weergegeven.

Exploitant	Syntaxis	Voorbeeld	Definitie
Toevoeging	+	x+y	Som van x en y
Aftrekken	—	x - y	Verschil tussen x en y
Vermenigvuldiging	*	x*y	Afgeleide van x en y
Divisie	/	x/j	Quotiënt van x en y
Module	%	x % j	Rest x/y
Machtsverheffing	**	x**y	x tot de macht y
Verhogen	++	x++	x plus één
Verlagen	—	X-	x min één

Optellen en aftrekken

Operators voor optellen en aftrekken zijn beschikbaar in JavaScript en kunnen worden gebruikt om de som en het verschil van numerieke waarden te vinden. JavaScript heeft een ingebouwde rekenmachine en wiskundige bewerkingen kunnen rechtstreeks in de console worden uitgevoerd.

Met het plusteken kunt u cijfers toevoegen, bijvoorbeeld:

Naast bewerkingen met priemgetallen kunt u met JavaScript getallen aan variabelen toewijzen en er berekeningen op uitvoeren. Je kunt bijvoorbeeld numerieke waarden toekennen aan de variabelen x en y, en het resultaat in z zetten.

// Wijs waarden toe aan x en y
laat x = 10;
laat y = 20;
// Voeg x en y toe en wijs de som toe aan z
laat z = x + y;
console.log(z);
30

// Wijs waarden toe aan x en y
laat x = 10;
laat y = 20;
// Trek x af van y en wijs het verschil toe aan z
laat z = y - x;
console.log(z);
10

// Wijs waarden toe aan x en y
stel x = -5,2;
laat y = 2,5;
// Trek y af van x en wijs het verschil toe aan z
laat z = x - y;
console.log(z);
-7.7

Een interessante functie in JavaScript waarmee u rekening moet houden en die u moet kennen, is het resultaat van het toevoegen van een getal en een tekenreeks. We weten dat 1 + 1 gelijk moet zijn aan 2, maar deze vergelijking zal een onverwacht resultaat opleveren.

laat x = 1 + "1";
console.log(x);
type x;
11
"snaar"

In plaats van getallen toe te voegen, converteert JavaScript de volledige expressie naar tekenreeksen en voegt deze aan elkaar. Het is belangrijk om voorzichtig te zijn met dynamisch typen in JavaScript, omdat dit ongewenste resultaten kan opleveren.

Optellen en aftrekken in JavaScript worden vaak gebruikt om door de navigatiebalk te scrollen.

functie scrollToId() (
const navHoogte = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);

In dit geval scrollt het paneel 60 pixels vanaf de id.

Vermenigvuldigen en delen

JavaScript-operatoren voor vermenigvuldiging en deling worden gebruikt om de afgeleide en het quotiënt van numerieke waarden te vinden.

Het sterretje is de vermenigvuldigingsoperator.

// Wijs waarden toe aan x en y
stel x = 20;
laat y = 5;
// Vermenigvuldig x met y om het product te krijgen
laat z = x * y;
console.log(z);
100

Vermenigvuldiging kan worden gebruikt om de prijs van een artikel te berekenen nadat de omzetbelasting is geheven.

const-prijs = 26,5; // Prijs van het artikel vóór belasting
const belastingtarief = 0,082; // 8,2% belastingtarief
// Bereken het totaal na belastingen tot op twee decimalen
laat totalePrijs = prijs + (prijs * belastingtarief);
totaalprijs.naarvast(2);
console.log("Totaal:", totaalprijs);
Totaal: 28,67

Slash is de divisieoperator.

// Wijs waarden toe aan x en y
stel x = 20;
laat y = 5;
// Verdeel y in x om het citaat te krijgen
laat z = x / y;
console.log(z);
4

Delen is vooral handig bij het berekenen van de tijd, zoals het berekenen van het aantal uren of het percentage correct op een toets.

Aantalmodulus

Modulus is een andere rekenkundige operator, minder populair dan de vorige. Vertegenwoordigd door het %-symbool. Het retourneert de rest wanneer het eerste getal wordt gedeeld door het tweede.

We weten bijvoorbeeld dat 9 deelbaar is door 3 zonder rest:

Met de getalmodulus kunt u bepalen of een getal even of oneven is, bijvoorbeeld:

// Initialiseer functie om te testen of een getal even is
const isEven = x => (
// Als de rest na delen door twee 0 is, retourneer dan waar
als (x % 2 === 0) (
retourneer waar;
}
// Als het getal oneven is, retourneert u false
retour vals;
}
// Test het nummer
isEven(12);
WAAR

In dit voorbeeld is 12 deelbaar door 2, dus het is een even getal.

Bij het programmeren wordt de getalmodulus vaak gebruikt in combinatie met voorwaardelijke instructies.

Machtsverheffing

Machtsverheffing is een van de nieuwste operators in JavaScript. De syntaxis voor machtsverheffen is twee sterretjes op rij (**).

10 tot de vijfde macht (10^5) wordt bijvoorbeeld als volgt geschreven:

10 ** 5;
100000

De bewerking 10**5 heeft hetzelfde resultaat als 10*10, 5 keer herhaald.

10 * 10 * 10 * 10 * 10;

Deze bewerking kan ook worden geschreven met de methode Math.pow().

Wiskunde.pow(10, 5);
100000

Het gebruik van de machtsverheffingsoperator is een snelle manier om de macht van een bepaald getal te bepalen, maar zoals altijd is het bij het kiezen tussen een methode en een operator belangrijk om consistent te zijn en in dezelfde stijl te coderen.

Verhogen en verlagen

De operatoren voor verhogen en verlagen verhogen of verlagen de numerieke waarde van een variabele met één. Ze worden weergegeven door twee plustekens (++) of twee mintekens (-) en worden vaak in lussen gebruikt.

Houd er rekening mee dat de operatoren voor verhogen en verlagen alleen met variabelen kunnen worden gebruikt. Als u ze probeert te gebruiken met priemgetallen, resulteert dit in een fout.

7++
Uncaught ReferenceError: Ongeldige expressie aan de linkerkant in postfix-bewerking

De operatoren voor verhogen en verlagen kunnen worden geclassificeerd als operatoren voor prefix en postfix, afhankelijk van waar de operator is geplaatst ten opzichte van de variabele.

De voorvoegseltoename wordt geschreven als ++x.

//Stel een variabele in
laat x = 7;

laat voorvoegsel = ++x;
console.log(voorvoegsel);
8

De waarde van x is met 1 toegenomen. De postfix-toename wordt geschreven als y++.

//Stel een variabele in
laat y = 7;
// Gebruik de bewerking voor het verhogen van het voorvoegsel
laat achtervoegsel = y++;
console.log(postfix);
7

De postfix-bewerking heeft de waarde niet verhoogd. Deze waarde wordt pas verhoogd als de expressie is geëvalueerd. Om dit te doen, moet u de bewerking twee keer uitvoeren:

laat y = 7;
y++;
y++;
console.log(y);
8

Meestal worden deze operators in lussen aangetroffen. In deze for-lus wordt de for-instructie 10 keer uitgevoerd, beginnend bij 0.

// Voer tien keer een lus uit
voor (laat i = 0; i< 10; i++) {
console.log(i);
}
0
1
2
3
4
5
6
7
8
9

In dit voorbeeld wordt de lus herhaald met behulp van de increment-operator.

Simpel gezegd: x++ kan worden gezien als een afkorting van x = x + 1, en x kan worden gezien als een afkorting van x = x – 1.

Toewijzingsoperatoren

Een van de meest gebruikte operators is de toewijzingsoperator, die we al in deze tutorial hebben gezien. Het wordt weergegeven door een gelijkteken (=). Het =-symbool wordt gebruikt om de waarde aan de rechterkant toe te wijzen aan de variabele aan de linkerkant.

// Wijs 27 toe aan de leeftijdsvariabele
laat leeftijd = 27;

Naast de standaard toewijzingsoperator heeft JavaScript samengestelde toewijzingsoperatoren, die de rekenkundige operator combineren met de =-operator.

De add-operator begint bijvoorbeeld met de oorspronkelijke waarde en voegt er een nieuwe waarde aan toe.

// Wijs 27 toe aan de leeftijdsvariabele
laat leeftijd = 27;
leeftijd += 3;
console.log(leeftijd);
30

In wezen is leeftijd += 3 hetzelfde als leeftijd = leeftijd + 3.

Alle rekenkundige operatoren kunnen worden gecombineerd met een toewijzingsoperator. Hieronder vindt u een referentietabel met toewijzingsoperatoren in JavaScript.

Samengestelde toewijzingsoperatoren worden vaak gebruikt in lussen, zoals verhogingen en verlagingen.

Voorrang van operator

Operatoren worden uitgevoerd in volgorde van prioriteit, net als in de gewone wiskunde.

Vermenigvuldigen heeft bijvoorbeeld een hogere prioriteit dan optellen.

// Vermenigvuldig eerst 3 met 5 en tel er dan 10 bij op
10 + 3 * 5;
25

Als u eerst een optelbewerking moet uitvoeren, plaats deze dan tussen haakjes; dergelijke bewerkingen hebben altijd de hoogste prioriteit.

// Tel eerst 10 en 3 op en vermenigvuldig vervolgens met 5
(10 + 3) * 5;
65

Hieronder vindt u een tabel met de prioriteit van rekenkundige operatoren in JavaScript. Voor het verhogen en verlagen heeft het postfix een hogere prioriteit dan het prefix.

Verhogen/verlagen, vermenigvuldigen/delen en optellen/aftrekken hebben hetzelfde prioriteitsniveau.

Niet alleen rekenkundige operatoren hebben prioriteit, maar ook toewijzingsoperatoren, logische operatoren, voorwaardelijke operatoren, enz. U kunt de volledige lijst bekijken.

Tags: