Operații aritmetice în JavaScript. Operații în JavaScript Js modulo diviziune
După ce am vorbit despre priorități, asociativitate și alte probleme minore, putem începe să discutăm despre operatorii înșiși. Această secțiune oferă descrieri ale operatorilor aritmetici:
Adăugare (+)
Operatorul plus adaugă operanzi numerici sau realizează concatenarea șirurilor. Dacă unul dintre operanzi este un șir, celălalt operand este convertit într-un șir și se realizează concatenarea. Operanzii obiectului sunt convertiți în numere sau șiruri de caractere, care pot fi adăugate sau concatenate. Conversia se face folosind metodele valueOf() și/sau toString().
Scădere (−)
Când minus este folosit ca operator binar, acesta scade al doilea operand din primul. Dacă sunt specificați operanzi non-numerici, încearcă să-i convertească în numere.
Înmulțire (*)
Operatorul * își înmulțește cei doi operanzi. Încearcă să convertească operanzi non-numerici în numere.
Diviziune (/)
Operatorul / împarte primul operand la al doilea. Încercările de a converti operanzi non-numerici în numere. Cei obișnuiți cu limbaje de programare care fac distincția între numere întregi și numere reale se pot aștepta să obțină un rezultat întreg la împărțirea unui număr întreg la altul.
Cu toate acestea, în JavaScript, toate numerele sunt reale, astfel încât toate diviziunile produc un rezultat în virgulă mobilă. Operația 5/2 dă 2,5, nu 2. Împărțirea la zero dă plus sau minute infinit ca rezultat, iar 0/0 dă NaN.
Diviziune modul (%)
Operatorul % calculează restul obținut atunci când primul operand este un întreg împărțit la al doilea. Dacă sunt dați operanzi non-numerici, operatorul încearcă să-i convertească în numere. Semnul rezultatului se potrivește cu semnul primului operand. De exemplu, 5% 2 dă 1.
Operatorul de divizare modulo este de obicei folosit cu operanzi întregi, dar funcționează și pentru valori reale. De exemplu, -4,3% 2,1 dă un rezultat de -0,1.
Minus unar (−)
Când minus este folosit ca operator unar înaintea unui singur operand, efectuează o operație de schimbare a semnului unar. Cu alte cuvinte, transformă o valoare pozitivă într-o valoare negativă și invers. Dacă operandul nu este un număr, acest operator încearcă să-l convertească într-un număr.
Plus unar (+)
Pentru simetrie cu operatorul unar minus, JavaScript are și un operator unar plus. Puteți folosi acest operator pentru a specifica în mod explicit semnul literalelor numerice dacă credeți că acest lucru va face textul programului mai ușor de înțeles:
var profit = +1000000;
Într-un astfel de cod, operatorul plus nu face nimic; rezultatul muncii sale este sensul argumentului său.
Cu toate acestea, convertește argumentele non-numerice în numere. Dacă argumentul nu poate fi convertit, NaN este returnat.
Creștere (++)
Acest operator incrementează (adică mărește cu unu) singurul său operand, care trebuie să fie o variabilă, un element de matrice sau o proprietate de obiect. Dacă valoarea acestei variabile, element de matrice sau proprietate nu este un număr, operatorul încearcă mai întâi să o convertească într-un număr. Comportamentul exact al acestui operator depinde de poziția sa față de operand. Dacă îl puneți înaintea operandului (operatorul de creștere a prefixului), atunci 1 este adăugat la operand, iar rezultatul este valoarea incrementată a operandului. Dacă este plasat după operand (operatorul de increment postfix), atunci se adaugă 1 la operand, dar rezultatul este valoarea originală a operandului. Dacă valoarea care este incrementată nu este un număr, aceasta este convertită într-un număr în timpul procesului de calcul.
De exemplu, următorul cod setează variabilele i și j la 2:
i = 1;
j = ++i;
Și acesta setează i la 2 și j la 1:
i = 1;
j = i++;
Acest operatorîn ambele forme, este cel mai adesea folosit pentru a incrementa contorul care controlează bucla.
Rețineți că nu puteți introduce o nouă linie între un operator de increment de prefix sau postfix și operandul său precedent, deoarece punctele și virgulă sunt inserate automat în JavaScript. Dacă faceți acest lucru, JavaScript va trata operandul ca pe o instrucțiune completă și va introduce un punct și virgulă după el.
Scădere (−−)
Acest operator decrește (adică scade cu 1) operandul său numeric unic, care poate fi o variabilă, un element de matrice sau o proprietate de obiect. Dacă valoarea acestei variabile, element sau proprietate nu este un număr, operatorul încearcă mai întâi să o convertească într-un număr. Ca și în cazul operatorului ++, comportamentul exact al operatorului - depinde de poziția sa față de operandul său. Când este plasat înaintea unui operand, acesta decrește operandul și returnează valoarea decrementată. După operand, acesta decrește operandul, dar returnează valoarea inițială.
Dacă sunteți nou în JavaScript, jargon precum „module bundlers vs. module loaders”, „Webpack vs. Browserify” și „AMD vs. CommonJS” poate fi confuz.
Sistemul de module JavaScript poate fi intimidant, dar înțelegerea acestuia este vitală pentru dezvoltatori.
În acest articol voi încerca să explic totul în cuvinte simple(cu mai multe exemple de cod). Sper că veți găsi acest articol util.
Notă: Pentru comoditate, articolul va fi împărțit în două părți. În prima parte, ne vom uita la ce module sunt și de ce le folosim. În a doua parte ne vom uita diverse moduri combinând module într-un singur întreg.
Poate cineva să explice ce module sunt din nou?
La fel ca capitolele de carte, modulele sunt pur și simplu grupuri de cuvinte (sau cod, după caz).
Modulele bune sunt autosuficiente funcţionalitate, astfel încât acestea să poată fi adăugate, mutate sau îndepărtate după cum este necesar, fără a întrerupe întregul sistem.
De ce să folosiți module?
De fapt, modulele au multe avantaje. Cele mai importante, după părerea mea, sunt următoarele:
- Asistență convenabilă (capacitate de întreținere): Prin definiție, un modul este autonom. Un modul bine conceput își propune să reducă dependențele unor părți ale bazei de cod pe cât posibil, astfel încât să se poată dezvolta și să se îmbunătățească independent unul de celălalt. Actualizarea unui modul este mult mai ușoară atunci când este separat de alte părți ale codului Revenind la cartea noastră, de exemplu, dacă doriți să faceți o mică modificare într-un capitol și implică modificări în altă secțiune a cărții dvs. va fi un coșmar. Prin urmare, capitolul trebuie scris în așa fel încât atunci când faceți modificări, să nu afecteze alte capitole.
- Spații de nume:ÎN Variabile JavaScript care sunt în afara funcțiilor de nivel superior sunt considerate globale (toată lumea le poate accesa). Prin urmare, „poluarea spațiului de nume” este foarte comună, în cazul în care codul complet neînrudit este legat de variabile globale evitați poluarea spațiului de nume global prin crearea de spații private pentru variabilele noastre.
- Reutilizabilitate: Să fim sinceri. Cu toții am copiat cod în proiecte noi pe care le-am scris înainte. De exemplu, să ne imaginăm că ați copiat în proiect nou unele metode de ajutor din proiectul anterior Ok, dar dacă găsești cele mai multe cale bună scrieți această parte, va trebui să vă amintiți toate locurile în care a apărut acest cod pentru a-l actualiza. Aceasta este cu siguranță o pierdere uriașă de timp. Ar fi mult mai ușor să scrieți un modul și să-l reutilizați din nou și din nou.
Cum pot fi integrate modulele?
Există multe moduri de a integra module în programele dumneavoastră. Să ne uităm la unele dintre ele:
Model „Modul”
Modelul Module este folosit pentru a emula conceptul de clase (deoarece JavaScript nu a suportat în mod nativ clase), astfel încât putem stoca metode (variabile) publice și private în interiorul unui singur obiect, la fel ca clasele în alte limbi precum Java sau Python . Acest lucru ne permite să creăm un API public și să oferim posibilitatea de a accesa metode publice, în timp ce variabilele și metodele private sunt încapsulate într-o închidere.
Există mai multe moduri de a implementa modelul Module. În primul exemplu voi folosi închideri anonime. Punerea codului într-o funcție anonimă ne va ajuta să ne atingem obiectivul. (Rețineți că în JavaScript, funcțiile sunt singura modalitate de a crea un domeniu nou).
Exemplul 1: Închideri anonime
(funcție () ( // Păstrăm aceste variabile private în acest domeniu de închidere var myGrades = ; var average = function() ( var total = myGrades.reduce(function(accumulator, item) ( return acumulator + item), 0); return "Nota medie este " + total / myGrades.length + " ) var failing = function())( var failingGrades = myGrades.filter(function(item) (retur item).< 70;}); return "You failed " + failingGrades.length + " times."; } console.log(failing()); }());
În acest fel, funcția noastră anonimă are propriul domeniu de aplicare sau „închidere” și o putem executa imediat. Această metodă ne permite să ascundem variabilele din domeniul părinte (global).
Ceea ce este cu adevărat frumos la această abordare este că puteți utiliza variabile locale în interiorul acestei funcții și nu vă fie teamă de a suprascrie accidental variabilele globale cu același nume. Dar încă aveți acces la variabile globale, de exemplu, ca aceasta:
Var global = "Bună ziua, sunt o variabilă globală:)"; (funcție () ( // Păstrăm aceste variabile private în acest domeniu de închidere var myGrades = ; var average = function() ( var total = myGrades.reduce(function(accumulator, item) ( return acumulator + item), 0); return "Nota medie este " + total / myGrades.length + " ) var failing = function())( var failingGrades = myGrades.filter(function(item) (retur item).< 70;}); return "You failed " + failingGrades.length + " times."; } console.log(failing()); console.log(global); }()); // "You failed 2 times." // "Hello, I am a global variable:)"
Exemplul 2: Import global
O altă abordare populară pe care o folosesc bibliotecile precum jQuery este importul global. Este similar cu închiderile pe care tocmai le-am văzut, doar că acum trecem variabile globale ca parametri.
(funcție (globalVariable) ( // Păstrați aceste variabile private în acest domeniu de închidere var privateFunction = function() ( console.log ("Shhhh, asta este privat!"); ) // Expune metodele de mai jos prin interfața globalVariable în timp ce / / ascunde implementarea metodei în // blocul function() globalVariable.each = function(colecție, iterator) ( if (Array.isArray(colecție)) ( for (var i = 0; i< collection.length; i++) { iterator(collection[i], i, collection); } } else { for (var key in collection) { iterator(collection, key, collection); } } }; globalVariable.filter = function(collection, test) { var filtered = ; globalVariable.each(collection, function(item) { if (test(item)) { filtered.push(item); } }); return filtered; }; globalVariable.map = function(collection, iterator) { var mapped = ; globalUtils.each(collection, function(value, key, collection) { mapped.push(iterator(value)); }); return mapped; }; globalVariable.reduce = function(collection, iterator, accumulator) { var startingValueMissing = accumulator === undefined; globalVariable.each(collection, function(item) { if(startingValueMissing) { accumulator = item; startingValueMissing = false; } else { accumulator = iterator(accumulator, item); } }); return accumulator; }; }(globalVariable));
În acest exemplu, GlobalVariable este singura variabilă globală. Avantajul acestei abordări este că declari toate variabilele globale în avans, ceea ce face ca codul tău să fie transparent pentru alții.
Exemplul 3: Interfața obiectului
O altă abordare a creării modulelor este utilizarea interfețelor autonome, bazate pe obiecte, ca aceasta:
Var myGradesCalculate = (funcție () ( // Păstrați această variabilă privată în acest domeniu de închidere var myGrades = ; // Expune aceste funcții printr-o interfață în timp ce ascunde // implementarea modulului în blocul function() return ( medie: funcție () ( var total = myGrades.reduce(function(acumulator, item) ( return acumulator + item; ), 0); return"Nota medie este " + total / myGrades.length + "."; ), eșuând: funcție () ( var failingGrades = myGrades.filter(function(element) ( return item< 70; }); return "You failed " + failingGrades.length + " times."; } } })(); myGradesCalculate.failing(); // "You failed 2 times." myGradesCalculate.average(); // "Your average grade is 70.33333333333333."
După cum probabil ați observat, această abordare ne permite să decidem ce variabile (metode) dorim să facem private (de exemplu, notele mele ), și care sunt publice prin plasarea lor în obiectul returnat (de exemplu, medie Şi eșuând ).
Exemplul 4: Model de modul drop-down
Acest exemplu este foarte similar cu cel anterior, cu excepția faptului că toate metodele și variabilele rămân private până când sunt dezvăluite în mod explicit.
Var myGradesCalculate = (funcție () ( // Păstrați această variabilă privată în acest domeniu de închidere var myGrades = ; var average = function() ( var total = myGrades.reduce(function(acumulator, item) ( return acumulator + item; ), ), 0); returnare"Nota medie este " + total / myGrades.length + " );< 70; }); return "You failed " + failingGrades.length + " times."; }; // Explicitly reveal public pointers to the private functions // that we want to reveal publicly return { average: average, failing: failing } })(); myGradesCalculate.failing(); // "You failed 2 times." myGradesCalculate.average(); // "Your average grade is 70.33333333333333."
Aceasta poate părea o mulțime de informații, dar este doar vârful aisbergului când vine vorba de modele de module. Iată câteva resurse utile pe care l-am găsit în timpul cercetărilor mele:
- de Addy Osmani: acesta este o comoară de detalii și conținut impresionant de scurt;
- Adequately Good de Ben Cherry: o prezentare generală utilă cu exemple de utilizare avansată a modelului Module;
- Blogul lui Carl Danley: prezentare generală a modelului Module și resurse pentru alte modele JavaScript;
CommonJS și AMD
Toate abordările de mai sus au un singur lucru proprietate generală: Toți creează o variabilă globală în care plasează codul funcției, creând astfel un spațiu de nume privat și utilizând domeniul de aplicare al închiderii.
Deși fiecare dintre aceste abordări este eficientă în felul său, ele au și dezavantajele lor.
În calitate de dezvoltator, trebuie să cunoașteți ordinea corectă pentru încărcarea fișierelor. De exemplu, să presupunem că utilizați Backbone în proiectul dvs., deci includeți scriptul Backbone printr-o etichetă în fișierul dvs. Deoarece Backbone depinde direct de Underscore.js, nu puteți include scriptul Backbone.js înainte de Underscore.js.
Gestionarea dependențelor ca dezvoltator poate fi uneori o durere de cap.
Un alt dezavantaj este că încă pot apărea conflicte în spațiul de nume. De exemplu, este posibil să aveți două module cu același nume sau două versiuni ale aceluiași modul și aveți nevoie de ambele.
Acest lucru ridică o întrebare interesantă: putem accesa interfața modulului nu prin sfera globală?
Din fericire, răspunsul este da.
Există două abordări populare și bine implementate: CommonJS și AMD.
CommonJS
CommonJS este un grup de dezvoltatori voluntari care proiectează și implementează API-uri JavaScript pentru declararea modulelor.
Modulul CommonJS este un fragment Cod JavaScript conceput pentru utilizare repetată. Exportă obiecte speciale, făcându-le disponibile altor module, astfel încât acestea să le poată include în dependențele lor. Dacă ați programat în Node.js, acest lucru vă va fi foarte familiar.
Cu CommonJS, fiecare fișier JavaScript stochează un modul în contextul său unic (la fel ca închiderile). În acest spațiu folosim obiectul modul.exporturi pentru a exporta module și cere pentru a le conecta.
Definiția modulului CommonJS ar putea arăta astfel:
Funcția myModule() ( this.hello = function() ( return „bună ziua!”; ) this.goodbye = function() ( return „la revedere!”; ) ) module.exports = myModule;
Folosim un obiect special modul și plasați un link către funcția noastră în modul.exporturi . Acest lucru permite CommonJS să știe că dorim să expunem modulul, astfel încât alte fișiere să-l poată folosi.
După aceea, când cineva dorește să folosească noastre myModule, el îl va putea conecta fără probleme după cum urmează:
Var myModule = require("myModule"); var myModuleInstance = new myModule(); myModuleInstance.hello(); // "Buna ziua!" myModuleInstance.la revedere(); // "La revedere!"
U această abordare Există două avantaje evidente față de abordările discutate mai devreme:
- Fără poluare globală a spațiului de nume;
- Să ne explicăm dependențele;
În plus, sintaxa este foarte compactă, îmi place foarte mult.
Trebuie remarcat faptul că CommonJS folosește server-în primul rând abordarea și modulele sunt încărcate sincron. Acest lucru este important pentru că dacă mai avem trei module pe care trebuie să le conectăm, le va încărca unul după altul.
Acest lucru funcționează excelent pe server acum, dar, din păcate, face dificilă scrierea JavaScript bazată pe browser. Este nevoie de mult mai mult pentru a primi un modul de pe Internet decât pentru a primi un modul de la hard disk. În timp ce scriptul încarcă modulul, browserul este blocat și nu poți face nimic până nu se termină de încărcat. Se comportă astfel deoarece firul JavaScript este oprit în timp ce codul se încarcă (vă voi spune cum putem rezolva această problemă în a doua parte a articolului, când ne uităm la construirea modulelor . Pe în acest moment asta e tot ce trebuie sa stim).
AMD
CommonJS este grozav, dar ce se întâmplă dacă trebuie să încărcăm module asincron? Răspunsul la această întrebare este „Asynchronous Module Definition” sau pur și simplu AMD.
Define(["myModule", "myOtherModule"], function(myModule, myOtherModule) ( console.log(myModule.hello()); ));
Funcția de definire a modulului ia ca prim argument o matrice de dependențe. Aceste dependențe sunt încărcate în fundal (neblocare) și apelează funcția de apel invers care a fost transmisă ca al doilea argument.
În continuare, funcția de apel invers ia ca argumente dependențele deja încărcate și vă permite să le utilizați. În cele din urmă, dependențele în sine trebuie definite folosind cuvânt cheie defini .
De exemplu, myModule ar putea arata asa:
Define(, function() ( return ( salut: function() ( console.log ("bună ziua"); ), la revedere: function() ( console.log ("la revedere"); ) ); ));
Deci hai să trecem peste asta din nou. Spre deosebire de CommonJS, AMD implementează o abordare bazată pe browser împreună cu comportamentul asincron (rețineți că mulți oameni susțin că încărcare dinamică fișierele nu este propice pentru executarea codului dvs. Vom vorbi mai multe despre asta în următoarea parte a articolului nostru, dedicată asamblarii modulelor).
Pe lângă asincronie, AMD are un alt avantaj. Modulele AMD pot fi funcții, constructori, șiruri de caractere, JSON și alte tipuri, în timp ce CommonJS acceptă doar obiecte ca module.
În dezavantaj, AMD nu este compatibil cu io, sistem de fișiereși alte caracteristici de pe partea serverului care sunt disponibile prin CommonJS. Și sintaxa funcției de declarare a modulului este verbosă în comparație cu simplă cere .
UMD
Pentru proiectele care necesită suport atât pentru funcțiile AMD, cât și pentru CommonJS, există un alt format. Universal Module Definition, sau pur și simplu UMD.
În esență, UMD oferă posibilitatea de a utiliza oricare dintre cele două metode de mai sus, plus că acceptă definirea modulelor printr-o variabilă globală. Ca rezultat, modulele UMD pot rula atât pe client, cât și pe server.
Un exemplu rapid despre cum funcționează UMD:
(funcție (rădăcină, fabrică) ( if (typeof define === "funcție" && define.amd) ( // AMD define(["myModule", "myOtherModule"], fabrică); ) else if (tip de exporturi == = "obiect") ( // CommonJS module.exports = factory(require("myModule"), require("myOtherModule")); ) else ( // Browser globals (Notă: rădăcina este fereastra) root.returnExports = factory( root.myModule, root.myOtherModule) )(this, function (myModule, myOtherModule) ( // Funcția de metode notHelloOrGoodbye())(); // O funcție de metodă privată hello())(); deoarece „s returned (vezi mai jos) funcția goodbye())(; // O metodă publică deoarece este returnată (vezi mai jos) // Expuse public methods return ( hello: hello, goodbye: goodbye )));
JS nativ
Uf. Mai ești prin preajmă? Te-am pierdut în pădurea asta? Amenda! Pentru că avem un alt tip de definiție de modul.
După cum probabil ați observat mai sus, niciunul dintre module nu era JavaScript nativ. În schimb, am simulat un sistem de module folosind fie modelul Module, CommonJS, fie AMD.
Din fericire, oamenii inteligenți de la TC39 (organismul standardelor care definește sintaxa și semantica ECMAScript) au adăugat module încorporate la ECMAScript 6 (ES6).
ES6 oferă o varietate de opțiuni pentru importarea și exportul modulelor, care au fost discutate de mai multe ori. Iată câteva resurse:
- jsmodules.io
- exploringjs.com
Ce este bun la modulele ES6 în comparație cu CommonJS și AMD? Că reunește tot ce este mai bun din ambele lumi: compactitate, sintaxă declarativă, încărcare asincronă, plus beneficii suplimentare, cum ar fi dependențe circulare.
Probabil că caracteristica mea preferată a modulelor ES6 este că importurile sunt tipuri de exporturi live, doar pentru citire (comparativ cu CommonJS, unde un import este doar o copie a unui export).
Iată un exemplu despre cum funcționează:
// lib/counter.js var counter = 1; function increment() ( counter++; ) function decrement() ( counter--; ) module.exports = ( counter: counter, increment: increment, decrement: decrement ); // src/main.js var counter = require("../../lib/counter"); counter.increment(); console.log(counter.counter); // 1
În acest exemplu, am făcut două copii ale modulului de bază: prima dată când l-am exportat și a doua oară când l-am importat.
În plus, copia care se află în main.js este acum deconectat de la modulul original. Deci, chiar și atunci când ne creștem contorul, acesta returnează totuși 1 deoarece contra- aceasta este o variabilă pe care am importat-o din modul, deconectată de la modulul original.
Deci, creșterea contorului îl va incrementa în modul, dar nu îl va incrementa în versiunea copiată. Singura modalitate de a schimba versiunea copiată este să o incrementați manual:
Counter.counter++; console.log(counter.counter); // 2
Și, ES6, la import, creează o vizualizare live numai pentru citire a modulului:
// lib/counter.js export let counter = 1; export function increment() ( counter++; ) export function decrement() ( counter--; ) // src/main.js import * as counter from "../../counter"; console.log(counter.counter); // 1 counter.increment(); console.log(counter.counter); // 2
Interesant, nu-i așa? Ceea ce mi se pare cu adevărat convingător la vizualizările live numai pentru citire este că vă permit să vă împărțiți modulele în bucăți mai mici fără a pierde funcționalitatea.
Le puteți implementa și îmbina din nou (într-un proiect nou) și nicio problemă. Totul va funcționa.
Privind puțin înainte: Asamblarea modulelor
Wow! Cât de repede a trecut timpul. A fost o călătorie grozavă și sper din tot sufletul că acest articol v-a oferit o mai bună înțelegere a modulelor din JavaScript.
În următorul articol, ne vom uita la legarea modulelor, acoperind subiecte cheie, inclusiv:
- De ce colectăm module;
- Abordări diferite ale asamblarii;
- API de încărcare a modulelor ECMAScript;
- Si multe altele...
Vă reamintesc că asta curs introductiv JavaScript pentru începători. Astăzi ne vom uita la ce operatori exista în JavaScript. Legați centurile de siguranță! Va fi o mulțime de bukaf.
Când aveți o grămadă de date, trebuie să faceți ceva cu ele. Operatorii sunt ocupați cu afaceri. Întotdeauna adună, înmulțesc, împart, scad, compară, însuşesc și orice naiba fac. Fără operatori în programare, pur și simplu nu poți găti terci.
JavaScript folosește următoarele tipuri operatori:
- Operatori aritmetici
- Operatori de atribuire
- Operatori de comparație
- Operatori logici
- Operatori șiruri
- Declarații condiționale
Aceasta nu este o listă completă, dar aceasta este suficientă pentru a începe. Să ne uităm la fiecare tip de operator prezentat, de ce sunt necesare și cu ce sunt folosite. Să mergem!
Operatori aritmetici în JavaScript
Cu toții sunteți familiarizați cu operatorii aritmetici încă de la școală. Acestea sunt semnele uzuale de adunare, scădere, împărțire și înmulțire: + , - , / , * . În consecință, ei îndeplinesc aceleași funcții în programare ca și în matematica obișnuită. Nu veți avea dificultăți cu asta.
Datele cu care lucrează operatorii sunt numite operanzi.
2 + 3 // aici numerele 2 și 3 sunt operanzii, iar semnul + este operatorul de adunare
Ca și în matematică, operatorii aritmetici au propriile lor priorități: înmulțirea și împărțirea au prioritate mai mare decât adunarea și scăderea.
2 + 3 * 4 // înmulțirea este efectuată aici mai întâi și abia apoi adunarea
Și la fel ca în matematică, parantezele sunt folosite în mod activ pentru a schimba prioritatea:
(2 + 3) * 4 // aici se face mai întâi adunarea, iar apoi înmulțirea
Apropo, semnul = este și un operator. După cum am aflat deja în articolul despre , acesta este un operator de atribuire și nu este deloc un semn egal. Nu uita de asta!
Operator diviziune modul
Acum să ne uităm la operatori aritmetici mai interesanți. Și prima pictogramă va fi pictograma procent - %. În JavaScript, acestea nu sunt deloc procente ale cuvântului. Așa se notează diviziunea modulo în programare. Rezultatul unei astfel de operațiuni va fi restul diviziei. De exemplu:
100% 22 // restul va fi 12
100% 10 // restul va fi 0
În calcule, acest operator are aceeași prioritate ca înmulțirea și împărțirea, așa că nu uitați să puneți paranteze.
Combinarea operatorilor
Operatorul = poate și ar trebui să fie combinat cu alți operatori pentru a scurta notația. Exemplu:
var n = 2; // atribuiți variabilei n valoarea 2
n = n + 3; // atribuiți variabilei n o nouă valoare n + 2, obțineți 5
Același lucru poate fi scris așa:
var n = 2;
n += 3; // echivalent cu scrierea n = n + 3
Operatori de creștere ++ și decretare –
Printre operatorii aritmetici există câțiva foarte interesanți - creştereŞi scăderea. Ele sunt desemnate ++ și, respectiv, ––. Primul mărește variabila cu una, iar al doilea o scade. Această caracteristică este foarte des folosită în programare, deoarece oferă multă comoditate. Cel mai adesea poate fi găsit în expresii condiționate, dar mai multe despre asta mai târziu.
Ambii operatori au locație specificăîn înregistrare. Ele pot fi ca prefix forma (înaintea variabilei) ++n și în postfix(după variabilă) n++ . Diferența este uriașă! Nu confundați niciodată aceste forme și amintiți-le bine. Dacă acești operatori apar în fața unei variabile, atunci ca rezultat cresc valoarea acesteia cu 1. Dar! Dacă vin după variabilă, returnează valoarea inițială. Exemplu:
var n = 2, m = 0;
m = ++n // mărește n cu 1 (n = 3) și îi atribuie lui m aceeași valoare cu 3
var n = 2, m = 3;
m = n++ // crește n cu 1 (n = 3), dar setează m la valoarea anterioară n = 2
Sunt sigur că puteți înțelege cu ușurință primul exemplu. Dar cu al doilea pot apărea probleme. Pentru a fi mai ușor de înțeles acest lucru și pentru a nu vă încurca, imaginați-vă că ați atribuit mai întâi variabilei m valoarea variabilei n și numai după aceea ați mărit valoarea lui n cu unu. În primul exemplu, ați mărit mai întâi valoarea lui n cu unul, apoi ați atribuit această valoare variabilei m.
Asta e tot pentru operatorii aritmetici. Desigur, există încă o mulțime de variații și subtilități ale utilizării acestora operatori simpli, dar asta va fi mai mult decât suficient pentru a începe.
Operatori de comparație
Și din nou ne amintim de matematică. Semnele sunt familiare tuturor. În programare sunt numite operatori de comparaţie. JavaScript folosește următorii operatori de comparare:
< меньше
> mai mult
<= меньше или равно
>= mai mare sau egal cu
== egal
!= nu este egal
=== strict egal
!== strict nu este egal
Vă rugăm să rețineți că semnul „mai mare decât sau egal” este scris exact așa >= , nu => . Adică, săgeata este plasată înaintea semnului egal și nu după acesta.
Operatorii de comparare vă permit să comparați valorile variabilelor, iar rezultatul acestei operații este întotdeauna valoarea booleană adevărată sau falsă. Ele sunt de obicei folosite în expresii condiționate. Rezultatul comparației determină ce parte a codului va fi executată în continuare.
În JavaScript puteți compara diferite tipuri date în același timp, de exemplu, un număr și un șir:
12345 == „12345” // adevărat
Doar că în acest caz șirul este convertit automat într-un număr. Egalitatea strictă === sau inegalitatea!== sunt folosite numai atunci când se compară variabile de același tip.
Operatori logici
Operațiile logice în JavaScript este unul dintre subiectele destul de complicate pentru începători. Merită să-l înțelegeți temeinic pentru a avansa cu succes în stăpânirea limbii. Ele sunt folosite cel mai adesea împreună cu operatorii de comparație și produc o valoare booleană adevărată sau falsă.
Există trei operatori logici:
&& (ȘI)
|| (SAU)
! (NU)
Operator logic && (ȘI)
Operatorul && efectuează o operație AND logică pe două valori. Cu toate acestea, returnează true dacă și numai dacă ambii operanzi se evaluează la true . Dacă unul sau ambii operanzi sunt false, atunci operatorul returnează false. Exemple:
2 < 3 && 4 < 5 // true
2 < 3 && 5 < 4 // false
3 < 2 && 5 < 4 // false
Operatorii logici au o prioritate mai mica decat operatorii de comparatie, asa ca in exemplele date ne lipsim de paranteze. Este clar că mai întâi comparăm numerele între ele și abia apoi aplicăm logica.
Operator logic || (SAU)
Cu operatorul logic || (SAU) o altă melodie. Operator || efectuează o operație logic SAU pe doi operanzi. Dacă unul sau ambii operanzi sunt adevărati, returnează adevărat. Dacă ambii operanzi sunt false, returnează false. Exemple:
2 < 3 || 4 < 5 // true
2 < 3 || 5 < 4 // true
3 < 2 || 5 < 4 // false
Operatorii logici au un truc. Nu le place muncă suplimentară. La fel și eu, apropo. Întotdeauna își încep calculele de la stânga la dreapta. Și dacă prima parte a expresiei se potrivește cu condițiile lor, atunci ei nici măcar nu evaluează restul expresiei.
De exemplu, dacă operatorul || găsește valoarea adevărată chiar de la început, dă imediat valoarea adevărată și nu verifică restul. De asemenea, operatorul &&, dacă găsește o expresie falsă chiar la început, dă imediat un rezultat fals și nu verifică restul expresiei.
Și încă un truc: prioritatea operatorului AND && este mai mare decât cea a lui SAU || deci se execută mai devreme:
2 < 3 || 4 < 5 && 5 < 6 // здесь сначала будет выполнено вычисление в правой части, а потом уже в левой
Operator logic! (NU)
Operator logic! înseamnă „NU logic”. Este folosit cu un singur operand și inversează valoarea acelui operand. Dacă n este adevărat, atunci!n va fi fals. Deoarece acest operator poate fi atașat la un singur operand, pentru a inversa întreaga expresie, trebuie să fie plasat în paranteze!(n && m) .
Operatori șiruri
Am vorbit deja despre operatorii string mai devreme. Acesta este același plus + care este folosit pentru a conecta variabile șir, sau altfel - pentru concatenare(adăugarea de șiruri). Exemplu:
„Igor” + „Quentor” == „Igor Quentor”
Rețineți că primul cuvânt are un spațiu adăugat înainte de ghilimele de închidere. Dacă nu îl adăugați, liniile se vor îmbina într-un singur cuvânt „IgorQuentor”.
Acest operator are o caracteristică: dacă expresia conține cel puțin un șir, atunci ea și toate celelalte argumente se convertesc la tipul șir. De exemplu:
Operatorii aritmetici rămași lucrează numai cu numere și își reduc întotdeauna argumentele la un număr.
Declarații condiționale
JavaScript are două instrucțiuni condiționale dacă și ?: Deși, pentru a fi mai precis, dacă este de fapt instructiune de controlși destul de extins, cu o mulțime de bunătăți și caracteristici interesante. Prin urmare, va exista un articol separat despre asta. Deocamdată, să ne uităm la un operator condiționat mai simplu?:
De obicei, acest operator este scris ca?: Dar în programe arată diferit. Are trei operanzi. Primul operand precede caracterul? , al doilea este între personaje? și: al treilea - după:
stare? valoarea 1: valoarea 2
Semnificația funcționării sale este simplă: dacă este îndeplinită condiția setată, atunci valoarea 1 este returnată, dar dacă nu, valoarea 2. Acest operator condiționat servește adesea ca un înlocuitor mai simplu pentru instrucțiunea if, atunci când aceasta din urmă nu este deosebit de importantă. necesar. În același timp, înregistrarea în sine este scurtată și mai ușor de citit.
Asta e tot deocamdată!
Sper că acum înțelegeți puțin despre operatorii în JavaScript. Și pentru ca creierul să nu fiarbă, iată un scurt desen animat pentru a vă relaxa - Un programator poate face orice! :)
Operațiile matematice sunt una dintre cele mai de bază și universale funcții ale oricărui limbaj de programare. În JavaScript, numerele sunt adesea folosite în sarcini comune, cum ar fi determinarea dimensiunii unei ferestre de browser, calcularea prețului final al unei tranzacții monetare sau distanța dintre elementele dintr-un document de site.
Nu trebuie să fii bun la matematică pentru a fi un dezvoltator bun, dar este important să știi ce tipuri de operații sunt disponibile în JavaScript și cum să le folosești pentru a efectua sarcini practice.
Spre deosebire de alte limbaje de programare, JavaScript are un singur tip de date numerice; nu face distincție între numere întregi și flotanți.
Acest tutorial va acoperi operatorii aritmetici, operatorii de atribuire și ordinea operațiilor cu date numerice JavaScript.
Operatori aritmetici
Operatorii aritmetici sunt simboluri care definesc operații matematice și returnează un rezultat. De exemplu, în 3 + 7 = 10, simbolul + definește sintaxa pentru operația de adăugare.
Mulți operatori JavaScript vă sunt familiari din matematica de bază, dar există și câțiva operatori suplimentari.
Toți operatorii aritmetici JavaScript sunt prezentați în tabelul următor.
| Operator | Sintaxă | Exemplu | Definiţie |
| Plus | + | x+y | Suma lui x și y |
| Scădere | — | x - y | Diferența dintre x și y |
| Multiplicare | * | x*y | Derivată a lui x și y |
| Diviziune | / | x/y | Coeficientul lui x și y |
| Modul | % | x % y | Restul x/y |
| Exponentiație | ** | x**y | x la puterea lui y |
| Creştere | ++ | x++ | x plus unu |
| Decrementează | — | x— | x minus unu |
Adunarea și scăderea
Operatorii de adunare și scădere sunt disponibili în JavaScript și pot fi utilizați pentru a găsi suma și diferența valorilor numerice. JavaScript are un calculator încorporat, iar operațiunile matematice pot fi efectuate direct în consolă.
Semnul plus vă permite să adăugați numere, de exemplu:
Pe lângă operațiunile cu numere prime, JavaScript vă permite să atribuiți numere variabilelor și să efectuați calcule pe acestea. De exemplu, puteți atribui valori numerice variabilelor x și y și puneți rezultatul în z.
// Atribuiți valori lui x și y
fie x = 10;
fie y = 20;
//Adăugați x și y și atribuiți suma lui z
fie z = x + y;
console.log(z);
30
// Atribuiți valori lui x și y
fie x = 10;
fie y = 20;
// Scădeți x din y și atribuiți diferența lui z
fie z = y - x;
console.log(z);
10
// Atribuiți valori lui x și y
fie x = -5,2;
fie y = 2,5;
// Scădeți y din x și atribuiți diferența lui z
fie z = x - y;
console.log(z);
-7.7
O caracteristică interesantă în JavaScript pe care ar trebui să o luați în considerare și să o cunoașteți este rezultatul adăugării unui număr și a unui șir. Știm că 1 + 1 trebuie să fie egal cu 2, dar această ecuație va da un rezultat neașteptat.
fie x = 1 + „1”;
console.log(x);
tip de x;
11
"şir"
În loc să adauge numere, JavaScript convertește întreaga expresie în șiruri de caractere și le concatenează. Este important să fii atent cu tastare dinamică JavaScript deoarece poate avea rezultate nedorite.
Adunarea și scăderea în JavaScript sunt adesea folosite pentru a derula bara de navigare.
funcția scrollToId() (
const navHeight = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);
În acest caz, panoul va derula la 60 de pixeli de la id.
Înmulțirea și împărțirea
Operatorii JavaScript de multiplicare și împărțire sunt utilizați pentru a găsi derivata și câtul valorilor numerice.
Asteriscul este operatorul de multiplicare.
// Atribuiți valori lui x și y
fie x = 20;
fie y = 5;
// Înmulțiți x cu y pentru a obține produsul
fie z = x * y;
console.log(z);
100
Înmulțirea poate fi utilizată pentru a calcula prețul unui articol după ce a fost impus impozitul pe vânzări.
pret const = 26,5; // Prețul articolului înainte de taxe
const taxRate = 0,082; // Rata de impozitare de 8,2%.
// Calculați totalul după impozitare cu două zecimale
let totalPrice = preț + (preț * taxRate);
totalPrice.toFixed(2);
console.log(„Total:”, totalPrice);
Total: 28,67
Slash este operatorul de diviziune.
// Atribuiți valori lui x și y
fie x = 20;
fie y = 5;
// Împărțiți y în x pentru a obține citatul
fie z = x / y;
console.log(z);
4
Împărțirea este utilă în special atunci când se calculează timpul, cum ar fi calcularea numărului de ore sau a procentului corect pe un test.
Modulul numeric
Modulus este un alt operator aritmetic, mai puțin popular decât precedentii. Reprezentat prin simbolul %. Returnează restul când primul număr este împărțit la al doilea.
De exemplu, știm că 9 este divizibil cu 3 fără rest:
Modulul numeric vă permite să determinați dacă un număr este par sau impar, de exemplu:
// Inițializați funcția pentru a testa dacă un număr este par
const este Par = x => (
// Dacă restul după împărțirea la doi este 0, returnează adevărat
dacă (x % 2 === 0) (
returnează adevărat;
}
// Dacă numărul este impar, returnează false
returnează fals;
}
// Testează numărul
este Par (12);
adevărat
În acest exemplu, 12 este divizibil cu 2, deci este un număr par.
În programare, modulul numeric este adesea folosit în combinație cu instrucțiuni condiționale.
Exponentiație
Exponentiarea este unul dintre cei mai noi operatori din JavaScript. Sintaxa pentru exponențiere este două asteriscuri pe rând (**).
De exemplu, 10 la a cincea putere (10^5) se scrie astfel:
10 ** 5;
100000
Operația 10**5 are același rezultat ca 10*10 repetat de 5 ori.
10 * 10 * 10 * 10 * 10;
Această operație poate fi scrisă și folosind metoda Math.pow().
Math.pow(10, 5);
100000
Folosind operatorul de exponențiere − cale rapidă determina puterea unui anumit număr, dar, ca întotdeauna, atunci când alegeți între o metodă și un operator, este important să fiți consecvenți și să scrieți codul în același stil.
Creștere și descreștere
Operatorii de creștere și decrementare măresc sau micșorează valoarea numerică a unei variabile cu unu. Ele sunt reprezentate de două plusuri (++) sau două minusuri (—) și sunt adesea folosite în bucle.
Vă rugăm să rețineți că operatorii de creștere și decrementare pot fi utilizați numai cu variabile. Încercarea de a le folosi cu numere prime va duce la o eroare.
7++
Eroare de referință neprinsă: expresie din partea stângă nevalidă în operațiunea postfix
Operatorii de creștere și decrementare pot fi clasificați ca operatori de prefix și postfix, în funcție de locul în care este plasat operatorul în raport cu variabila.
Incrementul de prefix este scris ca ++x.
//Setați o variabilă
fie x = 7;
fie prefix = ++x;
console.log(prefix);
8
Valoarea lui x a crescut cu 1. Incrementul postfix este scris ca y++.
//Setați o variabilă
fie y = 7;
// Utilizați operație de creștere a prefixului
lasă postfix = y++;
console.log(postfix);
7
Operația de postfix nu a crescut valoarea. Această valoare nu va fi incrementată până când expresia nu este evaluată. Pentru a face acest lucru, trebuie să rulați operația de două ori:
fie y = 7;
y++;
y++;
console.log(y);
8
Cel mai adesea acești operatori se găsesc în bucle. In aceasta pentru buclă Operatorul este rulat de 10 ori, începând de la 0.
// Rulați o buclă de zece ori
pentru (fie i = 0; i< 10; i++) {
console.log(i);
}
0
1
2
3
4
5
6
7
8
9
În acest exemplu, bucla este iterată folosind operatorul de increment.
Mai simplu spus, x++ poate fi considerat scurt pentru x = x + 1, iar x poate fi considerat scurt pentru x = x – 1.
Operatori de atribuire
Unul dintre cei mai des utilizați operatori este operatorul de atribuire, pe care l-am văzut deja în acest tutorial. Este reprezentat printr-un semn egal (=). Simbolul = este folosit pentru a atribui valoarea din dreapta variabilei din stânga.
// Atribuiți 27 variabilei de vârstă
lasa varsta = 27;
În plus față de operatorul de alocare standard, JavaScript are operatori de alocare compuși, care combină operatorul aritmetic cu operatorul =.
De exemplu, operatorul de adăugare va începe de la valoarea inițială și îi va adăuga o nouă valoare.
// Atribuiți 27 variabilei de vârstă
lasa varsta = 27;
vârsta += 3;
console.log(varsta);
30
În esență, vârsta += 3 este aceeași cu vârsta = vârsta + 3.
Toți operatorii aritmetici pot fi combinați cu un operator de atribuire. Mai jos este un tabel de referință al operatorilor de atribuire în JavaScript.
Operatorii de atribuire compuși sunt adesea utilizați în bucle, cum ar fi incremente și decremente.
Prioritatea operatorului
Operatorii sunt executați în ordinea priorității, la fel ca în matematica obișnuită.
De exemplu, înmulțirea are prioritate mai mare decât adunarea.
// Înmulțiți mai întâi 3 cu 5, apoi adăugați 10
10 + 3 * 5;
25
Dacă trebuie să efectuați mai întâi o operație de adăugare, puneți-o între paranteze - astfel de operațiuni au întotdeauna cea mai mare prioritate.
// Mai întâi se adună 10 și 3, apoi se înmulțește cu 5
(10 + 3) * 5;
65
Mai jos veți găsi un tabel de prioritate a operatorilor aritmetici în JavaScript. Pentru creștere și decrementare, postfixul are prioritate mai mare decât prefixul.
Creșterea/descreșterea, înmulțirea/împărțirea și adunarea/scăderea au același nivel de prioritate.
Nu numai operatorii aritmetici au prioritate, ci și operatorii de atribuire, operatori logici, declarații condiționale etc. Lista completă poti vedea.
Etichete:Ești familiarizat cu aritmetica? Puteți adăuga și scădea numere? JavaScript poate, de asemenea, adăuga și scădea. JavaScript are următorii operatori: adunare +, scădere -, împărțire /, înmulțire *, împărțire cu rest %.
Var unu = 121;
var doi = 13;
alertă (unu + doi);
alertă (unu - doi);
alertă (unu * doi);
alertă (una/două);
alertă (un % doi);
Să complicăm exemplul 1
Var răspuns = ((121 - 12) * 103) + 200;
alertă(răspuns);
Să complicăm exemplul 2
VarPI = 3,14;
alertă(răspuns);
Și să complicăm al treilea exemplu
VarPI = 3,14;
răspuns var = ((121 - 12) * 103) + PI;
var answerEnd = (2 * răspuns * PI) + (-100);
alertă(răspunsSfârșit);
Și chiar și asta se poate face
Var răspuns = 101 + (-(-100));
alertă(răspuns);
Dar acest lucru este un nonsens în comparație cu ceea ce poate face JavaScript. În acest scop, există un obiect Math standard cu multe proprietăți (proprietățile sunt operații, în acest context).
Math.pow(2, 53) /* -> 2 la puterea lui 53 */
Math.round(0,6) /* -> 1,0 - rotunjește la cel mai apropiat număr întreg */
Math.ceil(0.6) /* -> 1.0 - rotunjire în sus */
Math.floor(0,6) /* -> 0,0 - rotunjire în jos */
Math.abs(-5) /* -> 5 - modul, valoare absolută */
Math.max(x, y, z) /* -> Returnează cel mai mare argument */
Math.min(x, y, z) /* -> Returnează cel mai mic argument */
Math.random(); /* -> Unde numărul de ieșire este mai mare decât 0, dar mai mic de 1 */
Math.PI /* -> Pi */
Math.E /* -> Baza logaritmului natural */
Math.sqrt(3) /* -> rădăcină pătrată a lui 3 */
Math.pow(3, 1/3) /* -> Rădăcină cubă a lui 3 */
Math.sin(0) /* -> Trigonometrie: există și Math.cos, Math.atan și altele */
Math.log(10) /* -> Logaritm natural 10 */
Math.log(100) / Math.LN10 /* -> Logaritm de 100 baza 10 */
Math.log(512) / Math.LN2 /* -> Logaritmul lui 512 baza 2 */
Math.exp(3) /* -> Math.E cub */
Cum se utilizează obiectul Math?
/* Primul exemplu */
var twoInPow = Math.pow(2, 53);
alertă(douăInPow);
/* Al doilea exemplu */
var valueRund = 0,1312;
var answerRaunt = Math.round(valueRaund);
alertă(răspunsRaunt);
/* Al treilea exemplu */
var valueRund = 0,1312;
alert(Math.round(valueRund));
/* Al patrulea exemplu: găsirea celui mai mare dintre trei numere */
var a = 12, b = 11, c = 10;
alert(Math.max(a, b, c));
În caz de în afara intervalului, pierderea unor cifre semnificative sau împărțirea cu zero, JavaScript nu afișează o eroare. Dacă rezultatul este prea mare și în afara intervalului, va fi returnată o valoare specială „infinit”, care arată ca „Infinit”.
Pierderea cifrelor semnificative: rezultatul unei operații aritmetice este foarte aproape de zero. Dacă a existat o pierdere, atunci va fi returnat 0 (zero).
Variabila globală NaN înseamnă „nu un număr”. Există o particularitate a acestei variabile: operația de testare a egalității (==) returnează întotdeauna un rezultat negativ, chiar dacă este comparată cu ea însăși.
/* Nu poți scrie așa */
dacă (x == NaN) ( ... )
Pentru a determina dacă valoarea unei variabile x este o valoare NaN, trebuie să utilizați construcția de mai jos. Această verificare va fi adevărată numai atunci când x este egal cu NaN