Разумевање конверзије типа и принуде у ЈаваСцрипт-у

ЈаваСцрипт-ово динамичко куцање значи да ваш код може бити мало једноставнији, али је и даље могуће правити грешке. Да бисте их избегли, корисно је знати како ЈаваСцрипт решава вредности са различитим типовима, да их упоредите.

Разумевање конверзије типова и принуде у ЈаваСцрипт-у је кључно за писање поузданих и ефикасних програма. Сваки концепт има специфичне случајеве употребе и најбоље праксе које могу утицати на понашање вашег кода.

Зашто се конверзија куцања и принуда дешавају у ЈаваСцрипт-у?

Језик ЈаваСцрипт се динамички откуцава. То значи да, за разлику од статички откуцаних језика, ЈаваСцрипт не захтева од вас да експлицитно дефинишете тип података променљиве пре него што га употребите. Уместо тога, ЈаваСцрипт одређује тип у време извођења у зависности од вредности променљиве.

Пошто типови података нису експлицитно декларисани све до времена извршавања, када изводите операције које захтевају различите податке типове, ЈаваСцрипт аутоматски проверава њихову међусобно компатибилност за операцију коју желите да извршите. Ако су међусобно компатибилни, операција се одвија нормално.

Међутим, претпоставимо да нису компатибилни са операцијом—на пример, покушавају да додају низ и број. У таквим случајевима, ЈаваСцрипт аутоматски „приморава“ један од типова да се уклопи у други како би се осигурало да је операција успешна уместо да доведе до грешке. Овај процес је познат као принуда типа или имплицитна принуда.

Тип Принуда

Принуда типа је аутоматска конверзија вредности из једног типа података у други, коју изводи ЈаваСцрипт током покретања програма како би се осигурало да се операција успешно извршава.

Али не могу се сви типови података изнудити. Стринг, број и логички су једини ЈаваСцрипт типови података да ће језик принудити у други тип. Када покушате да извршите некомпатибилну операцију са типовима података које ЈаваСцрипт не може да принуди, појавиће се грешка.

ЈаваСцрипт приморава типове на основу типа операције и оператора који користите у операцији.

Принуда са „+“ оператором

У ЈаваСцрипт-у, „+” оператор има два различита понашања у зависности од типова његових операнада. Може да изврши и нумеричко сабирање и конкатенацију низова. Ово може довести до принуде типа када један од операнада није очекиваног типа.

Ако су оба операнда бројеви, „+” оператор врши сабирање:

дозволити број1 = 42;
дозволити нум2 = 10;
дозволити сума = број1 + број2; // Аддитион
конзола.лог (збир); // 52

Ако су оба операнда стрингови, „+” оператор врши конкатенацију низова:

дозволити стр1 = "Здраво";
дозволити стр2 = "свет";
дозволити резултат = стр1 + " " + стр2; // Конкатенација низова
конзола.лог (резултат); // "Здраво Свете"

Међутим, ако један од операнада није стринг, ЈаваСцрипт ће га имплицитно приморати у стринг пре него што изврши конкатенацију:

// Број и стринг
дозволити нум = 42;
дозволити стр = "Здраво";
// нум се приморава на стринг и затим спаја
дозволити резултат_1 = број + стр;
конзола.лог (резултат_1); // "42Хелло"
// Стринг и Боолеан
дозволити боол = истина;
// боол се приморава на стринг и затим спаја
дозволити резултат_2 = боол + стр;
конзола.лог (резултат_2); // "труеХелло"

Принуда са "-" оператором

У ЈаваСцрипт-у, „-” оператор се првенствено користи за операције одузимања. Када један или оба операнда у операцији која укључује „-” оператор није број, ЈаваСцрипт ће покушати да га натера у број.

Када су оба операнда бројеви, ЈаваСцрипт врши одузимање. Такође врши одузимање када су један или оба операнда низови који представљају број:

конст број1 = 10;
конст нум2 = 20;
конст резултат_1 = број2 - број1; // Субтрацтион
конзола.лог (резултат_1); // 10
конст стрНум = "10";
конст стрНум2 = "20";
конст резултат = стрНум2 - стрНум; // Укуцајте принуду на бројеве, а затим одузимање
конзола.лог (резултат_1); // 10

Када ниједан од операнада није број или низ који представља број, ЈаваСцрипт ће покушати да примора тип података на његов нумерички еквивалент. Ако тип података нема нумерички еквивалент, операција ће се вратити НаН (није број):

// труе се приморава на 1, фалсе се приморава на 0
конст боолНум = истина;
конст боолНум2 = лажно;
конст резултат_1 = боолНум - боолНум2;
конзола.лог (резултат_1); // 1
// празни низови се приморавају на 0
конст аррНум = [];
конст аррНум2 = [];
конст резултат_2 = аррНум - аррНум2;
конзола.лог (резултат_2); // 0
// празни објекти се приморавају на НаН
конст објНум = {};
конст резултат_3 = аррНум - објНум;
конзола.лог (резултат_3); // 0 - НаН = НаН

У овом примеру, ЈаваСцрипт приморава логичке вредности истина и лажно на њихове нумеричке еквивалентне вредности, 1 и 0, редом. Празни низови су принуђени на 0, а празне објекте се приморава на НаН.

Принуда са операторима једнакости (==)/().

У ЈаваСцрипт-у, оператори једнакости (== и ) упореди вредности за једнакост. Међутим, због типске принуде се понашају другачије.

„==” (лабава једнакост) оператор врши принуду типа, што значи да покушава да конвертује операнде у исти тип пре поређења:

"10" == 10; // истина

У овом примеру, ЈаваСцрипт приморава стринг „10“ на број 10, тако да се израз процењује на истина.

Међутим "” (строга једнакост) оператор не врши принуду типа. Захтева да вредност и тип буду исти да би се поређење вратило истина:

"10"10; // фалсе

У овом примеру, поређење се враћа лажно јер су операнди различитих типова (низ и број).

Генерално би требало да користите (строга једнакост) оператор у ЈаваСцрипт-у да би се избегло неочекивано понашање принуде типа.

Принуда типа или имплицитна конверзија може довести до неочекиваног понашања због своје аутоматске природе. У случајевима када треба да конвертујете типове, препоручљиво је да експлицитно конвертујете типове. Процес експлицитне конверзије типова познат је као конверзија типа. Такође се назива преливањем типа и експлицитном конверзијом типа.

Типе Цонверсион

Конверзија типа, такође позната као преливање типа, је експлицитан процес претварања вредности из једног типа података у други у ЈаваСцрипт-у помоћу уграђених функција као што је Број(), Низ(), Боолеан(), парсеИнт(), и парсеФлоат().

Можете да извршите конверзију типа тако што ћете проследити вредност коју желите да конвертујете у уграђене функције конверзије као аргумент. Ове функције затим конвертују вашу вредност у жељени тип.

Ево примера коришћења Број() функција:

конст нумСтр = "123";
конст нум = Број(нумСтр); // Конвертује стринг у број
конзола.лог (број); // 123

Прослеђивање стринга који је важећи број као аргумент за Број() функција ће вратити број. Прослеђивање низа који је неважећи број ће се вратити НаН.

Ево примера коришћења Низ() функција:

конст боол = истина;
конст стр2 = Низ(боол); // Конвертује логички у стринг
конзола.лог (стр2); // "истина"

Прослеђивање било ког типа података осим симбола у Низ() функција ће конвертовати тип података у стринг.

Ево примера коришћења Боолеан() функција:

// Претвори стринг у боолеан (истина: тачно, нетачно: нетачно)
конст стр = "Здраво";
конст боол2 = Боолеан(стр);
конзола.лог (боол2); // истина

Преношење истинитих вредности на Боолеан() функција враћа логички "тачно" док прослеђивање лажних вредности враћа логички "лажно".

Ево примера коришћења ПарсеИнт() и ПарсеФлоат() функција:

// Претвори стринг у цео број
конст нумСтр = "123.00";
конст број1 = парсеИнт(нумСтр);
конзола.лог (број1); // 123
// Претвори стринг у број са покретним зарезом
конст флоатСтр = "3.14";
конст нум2 = парсеФлоат(флоатСтр);
конзола.лог (број2); // 3.14

Тхе парсеИнт() функција анализира стринг аргумент и враћа цео број. Тхе парсеФлоат() функција конвертује стринг у број са покретним зарезом.

Коришћење врсте присиле и конверзије

Разумевањем принуде и конверзије типа, можете доносити информисане одлуке о томе када и како да их ефикасно искористите у свом коду. Важно је постићи праву равнотежу, разборито користећи принуду типа за концизан и згодан код и ослањајући се на експлицитну конверзију типа за намерне и предвидљиве конверзије типова.