Înțelegerea conversiei de tip și a constrângerii în JavaScript

Tastarea dinamică a JavaScript înseamnă că codul dvs. poate fi puțin mai simplu, dar este totuși posibil să faceți greșeli. Pentru a le evita, este util să știți cum JavaScript rezolvă valorile cu diferite tipuri, pentru a le compara.

Înțelegerea conversiei de tip și a constrângerii în JavaScript este crucială pentru scrierea unor programe fiabile și eficiente. Fiecare concept are cazuri de utilizare specifice și cele mai bune practici care pot afecta comportamentul codului dvs.

De ce se întâmplă conversia tipului și constrângerea în JavaScript?

Limbajul JavaScript este tastat dinamic. Aceasta înseamnă că, spre deosebire de limbajele tipizate static, JavaScript nu necesită să definiți în mod explicit tipul de date al unei variabile înainte de a o utiliza. În schimb, JavaScript determină tipul în timpul execuției, în funcție de valoarea variabilei.

Deoarece tipurile de date nu sunt declarate în mod explicit până în timpul execuției, când efectuați operațiuni care necesită date diferite tipuri, JavaScript verifică automat compatibilitatea lor între ele pentru operația pe care doriți să o efectuați. Dacă sunt compatibile între ele, operațiunea decurge normal.

Totuși, să presupunem că sunt incompatibile cu operația - de exemplu, încercarea de a adăuga un șir și un număr. În astfel de cazuri, JavaScript „constrânge” automat unul dintre tipuri pentru a se potrivi cu celălalt pentru a se asigura că operația are succes în loc să arunce o eroare. Acest proces este cunoscut sub numele de constrângere de tip sau constrângere implicită.

Tip Coerciție

Coerciția de tip este conversia automată a unei valori de la un tip de date la altul, efectuată de JavaScript în timpul rulării unui program pentru a se asigura că o operație se execută cu succes.

Dar nu toate tipurile de date pot fi forțate. Șirul, numărul și booleanul sunt singurele Tipuri de date JavaScript că limbajul va constrânge într-un alt tip. Când încercați să efectuați o operațiune incompatibilă cu tipuri de date pe care JavaScript nu le poate constrânge, va genera o eroare.

JavaScript forțează tipurile în funcție de tipul de operație și de operatorul pe care îl utilizați în operație.

Coerciție cu operatorul „+”.

În JavaScript, „+” operatorul are două comportamente diferite în funcție de tipurile operanzilor săi. Poate efectua atât adăugarea numerică, cât și concatenarea șirurilor. Acest lucru poate duce la constrângere de tip atunci când unul dintre operanzi nu este de tipul așteptat.

Dacă ambii operanzi sunt numere, „+” operatorul efectuează adăugarea:

lăsa num1 = 42;
lăsa num2 = 10;
lăsa suma = num1 + num2; // Adăugare
consolă.log (suma); // 52

Dacă ambii operanzi sunt șiruri de caractere, „+” operatorul efectuează concatenarea șirurilor:

lăsa str1 = "Buna ziua";
lăsa str2 = "lume";
lăsa rezultat = str1 + " " + str2; // Concatenare șiruri
consolă.log (rezultat); // "Salut Lume"

Cu toate acestea, dacă unul dintre operanzi nu este un șir, JavaScript îl va constrânge implicit într-un șir înainte de a efectua concatenarea:

// Număr și șir
lăsa num = 42;
lăsa str = "Buna ziua";
// num este forțat la un șir și apoi concatenat
lăsa rezultat_1 = num + str;
consolă.log (rezultat_1); // "42Bună ziua"
// String și Boolean
lăsa bool = Adevărat;
// bool este forțat la un șir și apoi concatenat
lăsa rezultat_2 = bool + str;
consolă.log (rezultat_2); // „adevărat Bună ziua”

Coerciție cu operatorul „-”.

În JavaScript, „-Operatorul ” este folosit în primul rând pentru operațiile de scădere. Când unul sau ambii operanzi într-o operație care implică „-” operatorul nu este un număr, JavaScript va încerca să-l constrângă într-un număr.

Când ambii operanzi sunt numere, JavaScript efectuează scăderea. De asemenea, efectuează scăderea atunci când unul sau ambii operanzi sunt șiruri care reprezintă un număr:

const num1 = 10;
const num2 = 20;
const rezultat_1 = num2 - num1; // Scădere
consolă.log (rezultat_1); // 10
const strNum = "10";
const strNum2 = "20";
const rezultat = strNum2 - strNum; // Tastați constrângere la numere, apoi scădere
consolă.log (rezultat_1); // 10

Când niciunul dintre operanzi nu este un număr sau un șir care reprezintă un număr, JavaScript va încerca să forțeze tipul de date la echivalentul său numeric. Dacă tipul de date nu are echivalent numeric, operația va reveni NaN (Nu este un număr):

// true este forțat la 1, false este forțat la 0
const boolNum = Adevărat;
const boolNum2 = fals;
const rezultat_1 = boolNum - boolNum2;
consolă.log (rezultat_1); // 1
// tablourile goale sunt forțate la 0
const arrNum = [];
const arrNum2 = [];
const rezultat_2 = arrNum - arrNum2;
consolă.log (rezultat_2); // 0
// obiectele goale sunt forțate la NaN
const objNum = {};
const rezultat_3 = arrNum - objNum;
consolă.log (rezultat_3); // 0 - NaN = NaN

În acest exemplu, JavaScript forțează valorile booleene Adevărat și fals la valorile lor numerice echivalente, 1 și 0, respectiv. Matricele goale sunt forțate 0, iar obiectele goale sunt forțate NaN.

Coerciție cu operatorii de egalitate (==)/().

În JavaScript, operatorii de egalitate (== și ) compara valorile pentru egalitate. Cu toate acestea, ei se comportă diferit din cauza constrângerii de tip.

„==Operatorul ” (egalitate liberă) efectuează constrângere de tip, ceea ce înseamnă că încearcă să convertească operanzi în același tip înainte de comparare:

"10" == 10; // Adevărat

În acest exemplu, JavaScript forțează șirul „10” la numărul 10, astfel încât expresia evaluează la Adevărat.

Însă "Operatorul ” (egalitate strictă) nu efectuează constrângere de tip. Este necesar ca valoarea și tipul să fie aceleași pentru ca comparația să revină Adevărat:

"10"10; // fals

În acest exemplu, comparația revine fals deoarece operanzii sunt de diferite tipuri (șir și număr).

În general, ar trebui să utilizați operator (egalitate strictă) în JavaScript pentru a evita comportamentul de constrângere de tip neașteptat.

Coerciția de tip sau conversia implicită poate duce la un comportament neașteptat datorită naturii sale automate. În cazurile în care trebuie să convertiți tipuri, este recomandabil să convertiți în mod explicit tipurile. Procesul de conversie explicită a tipurilor este cunoscut sub numele de conversie de tip. De asemenea, se mai numește turnare de tip și conversie explicită de tip.

Conversie tip

Conversia tipului, cunoscută și sub denumirea de tip casting, este procesul explicit de conversie a unei valori de la un tip de date la altul în JavaScript, folosind funcții încorporate, cum ar fi Număr(), Şir(), boolean(), parseInt(), și parseFloat().

Puteți efectua conversia tipului prin trecerea valorii pe care doriți să o convertiți în funcțiile de conversie încorporate ca argument. Aceste funcții vă convertesc apoi valoarea în tipul dorit.

Iată un exemplu folosind Număr() funcţie:

const numStr = "123";
const num = Număr(numStr); // Convertește un șir într-un număr
consolă.log (num); // 123

Trecerea unui șir care este un număr valid ca argument la Număr() funcția va returna un număr. Trecerea unui șir care este un număr nevalid va reveni NaN.

Iată un exemplu folosind Şir() funcţie:

const bool = Adevărat;
const str2 = Şir(bool); // Convertește un boolean într-un șir
consolă.log (str2); // "Adevărat"

Trecerea oricărui tip de date în, cu excepția unui simbol, în Şir() funcția va converti tipul de date într-un șir.

Iată un exemplu folosind boolean() funcţie:

// Convertiți un șir într-un boolean (adevărat: adevărat, fals: fals)
const str = "Buna ziua";
const bool2 = boolean(str);
consolă.log (bool2); // Adevărat

Transmiterea valorilor de adevăr către boolean() funcția returnează valoarea booleană „adevărată” în timp ce trecerea valorilor false returnează valoarea booleană „falsă”.

Iată un exemplu folosind ParseInt() și ParseFloat() funcţie:

// Convertiți un șir într-un număr întreg
const numStr = "123.00";
const num1 = parseInt(numStr);
consolă.log (num1); // 123
// Convertiți un șir într-un număr în virgulă mobilă
const floatStr = "3.14";
const num2 = parseFloat(floatStr);
consolă.log (num2); // 3.14

The parseInt() funcția parsează un argument șir și returnează un număr întreg. The parseFloat() funcția convertește un șir într-un număr în virgulă mobilă.

Utilizarea tipului de constrângere și conversie

Înțelegând constrângerea și conversia tipului, puteți lua decizii informate cu privire la când și cum să le utilizați eficient în codul dvs. Este important să găsiți echilibrul corect, folosind constrângerea de tip în mod judicioasă pentru un cod concis și convenabil și bazându-vă pe conversia de tip explicită pentru conversii de tip intenționate și previzibile.