Внимавайте с принудителното въвеждане: тази разширена функция може да е причина за фини грешки, така че се уверете, че знаете как работи.
Динамичното писане на JavaScript означава, че вашият код може да бъде малко по-прост, но все още е възможно да правите грешки. За да ги избегнете, е полезно да знаете как JavaScript разрешава стойности с различни типове, за да ги сравнявате.
Разбирането на преобразуването на типове и принудата в JavaScript е от решаващо значение за писането на надеждни и ефективни програми. Всяка концепция има конкретни случаи на употреба и най-добри практики, които могат да повлияят на поведението на вашия код.
Защо преобразуването на типове и принудата се случват в JavaScript?
Езикът JavaScript се въвежда динамично. Това означава, че за разлика от статично въведените езици, JavaScript не изисква да дефинирате изрично типа данни на променлива, преди да я използвате. Вместо това JavaScript определя типа по време на изпълнение в зависимост от стойността на променливата.
Тъй като типовете данни не се декларират изрично до време на изпълнение, когато извършвате операции, изискващи различни данни типове, JavaScript автоматично проверява тяхната съвместимост един с друг за операцията, която искате да извършите. Ако те са съвместими помежду си, операцията протича нормално.
Да предположим обаче, че те са несъвместими с операцията - например опит за добавяне на низ и число. В такива случаи JavaScript автоматично „принуждава“ един от типовете да пасне на другия, за да гарантира, че операцията е успешна, вместо да извежда грешка. Този процес е известен като принуда на типа или имплицитна принуда.
Тип принуда
Принудяването на тип е автоматично преобразуване на стойност от един тип данни в друг, извършвано от JavaScript по време на изпълнение на програма, за да се гарантира, че дадена операция се изпълнява успешно.
Но не всички типове данни могат да бъдат принудени. Низът, числото и булевата стойност са единствените Типове данни на JavaScript че езикът ще се превърне в различен тип. Когато се опитате да извършите несъвместима операция с типове данни, които JavaScript не може да принуди, това ще изведе грешка.
JavaScript принуждава типове въз основа на типа операция и оператора, който използвате в операцията.
Принуда с оператора „+“.
В JavaScript, „+” Операторът има две различни поведения в зависимост от типовете на неговите операнди. Може да извършва както числово събиране, така и конкатенация на низове. Това може да доведе до принудителен тип, когато един от операндите не е от очаквания тип.
Ако и двата операнда са числа, „+” операторът извършва добавяне:
позволявам num1 = 42;
позволявам num2 = 10;
позволявам сума = num1 + num2; // Добавяне
конзола.log (сума); // 52
Ако и двата операнда са низове, „+” операторът извършва конкатенация на низове:
позволявам str1 = "Здравейте";
позволявам str2 = "свят";
позволявам резултат = str1 + " " + str2; // Конкатенация на низове
конзола.log (резултат); // "Здравей свят"
Ако обаче един от операндите не е низ, JavaScript имплицитно ще го преобразува в низ, преди да извърши конкатенацията:
// Число и низ
позволявам брой = 42;
позволявам str = "Здравейте";// num се принуждава към низ и след това се свързва
позволявам резултат_1 = номер + str;
конзола.log (резултат_1); // "42Здравей"// Низ и булев тип
позволявам bool = вярно;
// bool се принуждава към низ и след това се конкатенира
позволявам резултат_2 = bool + str;
конзола.log (резултат_2); // "trueHello"
Принуда с оператора „-“.
В JavaScript, „-” Операторът се използва предимно за операции за изваждане. Когато един или двата операнда в операция, включваща „-” не е число, JavaScript ще се опита да го превърне в число.
Когато и двата операнда са числа, JavaScript извършва изваждане. Той също така извършва изваждане, когато един или двата операнда са низове, които представляват число:
конст num1 = 10;
конст num2 = 20;
конст резултат_1 = num2 - num1; // Изваждане
конзола.log (резултат_1); // 10
конст strNum = "10";
конст strNum2 = "20";
конст резултат = strNum2 - strNum; // Въведете принуда към числа, след това изваждане
конзола.log (резултат_1); // 10
Когато нито един от операндите не е число или низ, представляващ число, JavaScript ще се опита да принуди типа данни към неговия цифров еквивалент. Ако типът данни няма цифров еквивалент, операцията ще се върне NaN (Не е номер):
// true се принуждава към 1, false се принуждава към 0
конст boolNum = вярно;
конст boolNum2 = невярно;
конст резултат_1 = boolNum - boolNum2;
конзола.log (резултат_1); // 1// празните масиви се принуждават към 0
конст arrNum = [];
конст arrNum2 = [];
конст резултат_2 = arrNum - arrNum2;
конзола.log (резултат_2); // 0
// празните обекти се принуждават към NaN
конст objNum = {};
конст резултат_3 = arrNum - objNum;
конзола.log (резултат_3); // 0 - NaN = NaN
В този пример JavaScript принуждава булеви стойности вярно и невярно към техните числени еквивалентни стойности, 1 и 0, съответно. Празните масиви се принуждават да 0, и празните обекти са принудени да NaN.
Принуда с операторите за равенство (==)/().
В JavaScript операторите за равенство (== и ) сравнете стойности за равенство. Те обаче се държат по различен начин поради принуда на типа.
„==” (свободно равенство) операторът извършва принуда на типа, което означава, че се опитва да преобразува операнди в същия тип преди сравнение:
"10" == 10; // вярно
В този пример JavaScript принуждава низа „10“ към числото 10, така че изразът се оценява на вярно.
Както и да е "” (стриктно равенство) операторът не извършва принуда на типа. Изисква стойността и типът да бъдат еднакви, за да се върне сравнението вярно:
"10"10; // невярно
В този пример сравнението се връща невярно тъй като операндите са от различни типове (низ и число).
Като цяло трябва да използвате (строго равенство) оператор в JavaScript, за да се избегне неочаквано принудително поведение на типа.
Типовата принуда или неявното преобразуване може да доведе до неочаквано поведение поради автоматичния си характер. В случаите, когато трябва да конвертирате типове, е препоръчително да конвертирате изрично типовете. Процесът на изрично преобразуване на типовете е известен като преобразуване на типове. Нарича се още като преобразуване на типове и изрично преобразуване на типове.
Тип преобразуване
Преобразуването на тип, известно още като преобразуване на тип, е изричен процес на преобразуване на стойност от един тип данни в друг в JavaScript с помощта на вградени функции като номер(), низ (), Boolean(), parseInt(), и parseFloat().
Можете да извършите преобразуване на тип, като подадете стойността, която искате да преобразувате, във вградените функции за преобразуване като аргумент. След това тези функции преобразуват вашата стойност в желания тип.
Ето един пример за използване на номер() функция:
конст numStr = "123";
конст брой = Номер(numStr); // Преобразува низ в число
конзола.log (брой); // 123
Подаване на низ, който е валидно число, като аргумент на номер() функцията ще върне число. Подаване на низ, който е невалидно число, ще се върне NaN.
Ето един пример за използване на низ () функция:
конст bool = вярно;
конст str2 = низ(bool); // Преобразува булево значение в низ
конзола.log (str2); // "вярно"
Предаване на произволен тип данни в освен символ в низ () функцията ще преобразува типа данни в низ.
Ето един пример за използване на Boolean() функция:
// Преобразуване на низ в булево (truthy: true, false: false)
конст str = "Здравейте";
конст bool2 = Булева стойност(str);
конзола.log (bool2); // вярно
Предаване на верни стойности на Boolean() функцията връща булевото „true“, докато предаването на фалшиви стойности връща булевото „false“.
Ето един пример за използване на ParseInt() и ParseFloat() функция:
// Преобразуване на низ в цяло число
конст numStr = "123.00";
конст num1 = parseInt(numStr);
конзола.log (номер1); // 123
// Преобразуване на низ в число с плаваща запетая
конст floatStr = "3.14";
конст num2 = parseFloat(floatStr);
конзола.log (номер 2); // 3.14
The parseInt() функция анализира низов аргумент и връща цяло число. The parseFloat() функция преобразува низ в число с плаваща запетая.
Използване на принуда и преобразуване на типа
Чрез разбирането на принудата на типа и преобразуването можете да вземате информирани решения кога и как да ги използвате ефективно във вашия код. Важно е да постигнете правилния баланс, като използвате разумно принудителното въвеждане на типа за кратък и удобен код и разчитате на изрично преобразуване на типа за умишлено и предвидимо преобразуване на тип.