Типове данни в javascript: основни понятия, валидиране, преобразуване

Ако програмистът е работил с езици като C # или Java, той знае, че за да декларира променлива, трябва да зададе статистическия тип данни, които ще се съхраняват в посочената променлива от самото начало. В случай че стойността на дадена променлива трябва да бъде променена на друг тип, системата ще генерира грешка. За разлика от тях JavaScript има динамичен тип данни и не е необходимо да се посочва какъв тип ще съхранява променливата, тъй като по време на изпълнение JS ще се опита да реши задачата в съответствие с дадените стойности.

Основи на данните в JavaScript

Данните в JS се разделят на две групи: примитивни и обекти. Първите включват текстов низ (String), логически данни - true или false (Logical) и числа (Number). Съществуват още два специални типа примитиви: Null и Undefined. Те показват взаимосвързаните неподредени типове данни в JavaScript, които са именувани и имат свойства.

Обектът е специално създаден от програмиста, като някои от тях включват: глобален, прототип, масиви, функции, клас, предварително дефинирани JS класове, клас RegExp за управление на регулярни изрази и съвпадение на шаблони в текст, клас за грешки за съхранение информация, свързана с грешки. Първите езици за програмиране не са използвали обекти, а само променливи.

Променливите са място в паметта на компютъра, на което разработчиците присвояват съдържание, най-често с числова стойност, тип символ или символен низ - буквено-цифрова стойност, състояща се само от текст, смесен с числа. Като пример за тип данни в JavaScript можете да дефинирате променлива "a", която съдържа 32, и да я запишете по следния начин:

a = 32.

След това можете да промените стойността на "a" и да направите:

a = 78.

Или направете променливата "a" еквивалентна на стойността на друга променлива "b", напр:

a = b,

Променливите са елементарни обекти: число, символ, вярна или невярна стойност, а, като обекти са сложни и могат да се състоят от голямо количество информация. Но и двете форми заемат едно и също място в паметта, което може да е повече или по-малко голямо.

Примитивните типове

За разлика от обектите, примитивните типове данни на JavaScript не са референтни, т.е. когато присвоите стойност от друга променлива.

JS разполага с тези примитивни типове:

• логически;
• цифров;
• малки букви;
• нула;
• неопределен.

Логичните са следните: "вярно" или "фалшив".

• var boo1 = true;
• var boo2 = false;

В JS има само един тип число, което може да бъде записано със или без десетична запетая. Num може да бъде и:

• +безкрайност;
• -Безкрайност;
• NaN (не е число).

var num1 = 32;

var num2 = + Безкрайност;

Низовете се използват за съхраняване на текст. Те трябва да са в двойни или единични кавички. В JS низовете са неизменни.

var str1 = `Здравейте, това съм аз`;

var str2 = "Здравейте, това съм аз";

Променлива, която няма стойност, неопределена.

var тест Var;

конзола.log (testVar); // не е дефиниран

Булеви - е тип данни, връщайки едно от двете: true/false. Типът данни Boolean в JavaScript е кръстен на математика Джордж Бул, затова винаги се изписва с главна буква. Възможно е да се демонстрира принцип на работа от този тип в примера:

1. Отворете конзолата на JS и въведете всеки от следните оператори, като натиснете "Enter" след всеки оператор, за да видите резултата.
2. Обърнете внимание, че след всеки оператор се използва коментар от един ред, за да се обясни какво означава той.
3. 1<10 // 1 по-малко от 10?
4. 100> 2000 // 100 е по-голямо от 2000?
5. 2 === 2 // 2 е точно равно на 2?
6. false === false //

Функцията Boolean връща булева стойност в променлива. Това може да се използва и за търсене на логическия резултат от условие и израз, което позволява на JavaScript да използва функционален тип данни.

Неизменни символи

Символите са нов примитивен тип в JS. Те се създават с функция:

const mySymbol = Symbol(`mySymbol`).

Всеки път, когато програмистът извиква тази функция, се създава нов и уникален символ. Той може да се използва като константи за представяне на понятия като цветове. Символите се използват предимно като ключове за свойства и никога не влизат в конфликт с друг ключ - символ или низ. Например, възможно е да се направи обект итеративен, използван чрез цикъл for-of и други механизми на езика, като се използва символ, съхранен в "Symbol.итератор" като ключ.

В низ А символът се използва като ключ на метода. Този уникален символ прави обекта повторяем и позволява цикъл for-of. Не е възможно символите да се превърнат в низове, тъй като има принудително или имплицитно преобразуване на типовете данни в JavaScript. Забраната за принуда предотвратява някои грешки, но също така усложнява работата със знаци.

Нов вид примитив са токените, които служат като уникални идентификатори. Програмистът създава символи с помощта на фабричната функция "Symbol()", която слабо наподобява функцията "String" - връща низове, когато е извикана от функция:

const symbol1 = Symbol();

Функцията Symbol() има незадължителен параметър string, който ви позволява да дадете описание на новосъздадения символ. Това описание се използва, когато даден символ се преобразува в низ с помощта на "toString()" или "String()".

Аритметични оператори

JS, както всички езици за програмиране, има вградена възможност за извършване на математически операции като калкулатор. Те се извършват върху числа или променливи, които се представят като числа.

Операторът add, представен със знака плюс (+), събира две стойности и връща сума.

var x = 2 + 2; // x връща 4

Операторът за изваждане, представен със знака минус (-), изважда две стойности и връща разликата.

var x = 10 - 7; // x връща 3

Операторът за умножение, представен със звездичка (*), умножава две стойности и връща произведението.

var x = 4 * 5; // x връща 20

Операторът за деление, представен с наклонена черта (/), разделя две стойности и връща коефициента.

var x = 20 / 2; // x връща 10

По-малко познат е операторът modulo, който връща остатъка след делението, представен със знака за процент (%).

var x = 10 % 3; // връща 1

Това означава, че "3" влиза в "10" три пъти, а остатъкът е "1".

Увеличаване извършва действието, при което числото се увеличава с единица, като се използва операторът за увеличаване, представен с двойния знак плюс (++).

var x = 10;x++; // x връща 11

Това се случва след присвояването на. Възможно е също така да напишете какво се случва преди заданието. За сравнение:

++x;

var x = 10;

var y = x++;

// y е 10, x е 11;

както и:

var x = 10;

var y = ++x;

// y е 11, x е 11.

Намаляване - числото ще бъде намалено с единица с оператора за намаляване, представен с двойния знак минус (--).

var x = 10;x--;

// x връща 9

Както и по-горе, това може да се напише и така:--x;

Вариации на оператора на JS:

• оператор за присвояване;
• аритметични оператори за инкремент и декремент;
• оператори за равенство;
• релационни оператори;
• Булеви оператори.

вярно или невярно

Операторите за сравнение оценяват равенството или разликата на две стойности и връщат "true" или "false". Те често се използват в булеви твърдения. Два знака за равенство (==) означават равенство в JS. За начинаещите програмисти е лесно да объркат единичните, двойните и тройните знаци за равенство. Важното е да запомните, че единичният знак за равенство прилага стойност към променлива и никога не оценява равенството.

var x = 8;

var y = 8;

x == y; // true

Това е свободен тип за равенство и ще върне "true", дори ако вместо число е използван низ.

var x = 8;

var y = "8";

x == y; // true

Три знака за равенство (===) означават строго равенство в JS.

var x = 8;

var y = 8;

x === y; // true

Това е по-често използвана и по-прецизна форма на дефиниране на равенство от обикновената функция "equal (==)", тъй като тя изисква типът и стойността да са еднакви true, за да се върне.

var x = 8;

var y = "8";

x === y; // false

Възклицателен знак, последван от знак за равенство (!=), означава, че не е равно в JS. Това е точно обратното на "==" и се проверява само за стойност, а не за тип.

var x = 50;

var y = 50;

x != y; // false

Възклицателен знак, последван от два знака за равенство (!==), означава, че не е строго равно. Това е точно обратното на (===) и ще провери както стойността, така и типа. Друг познат герой, по-малко от (<) ще провери дали стойността вляво е по-малка от стойността вдясно. По-малко от или равно на (<=) - е същото като горното, но също ще бъде равно на "true". По-голямо от (>) ще се провери дали стойността вляво е по-голяма от стойността вдясно. Стойност, по-голяма или равна на (>=), същото като по-горе, но също така ще бъде вярно.

Динамична проверка на типа

Типовете данни и променливите в JavaScript са основен език за програмиране. Много от грешките при изпълнение на JS са грешки на типа. Например при опит за умножаване на "число" по "низ" се получава грешка "Не е число" във върнатата стойност. Понякога при извикване на функции и получаване на грешка "undefined is not a function" това се случва, когато се опитвате да получите достъп до свойство, което е неопределено. Тъй като JS не може да открие свойството, той връща стойността му по подразбиране като неопределена. Други обща грешка, свързано с типа, когато се опитвате да модифицирате или да получите достъп до свойство със стойност, която е нула или неопределена. Няма конструктори като Undefined или Null.

Системата на типовете в JS помага да се избегнат тези често срещани грешки. По дефиниция той е интерпретиран и динамичен език и изисква системата от типове да работи по време на изпълнение. Езикът също така се опитва да помогне чрез безшумно преобразуване на типове стойности. Промяната на типа или принудата е причината много разработчици да преминат към стриктна употреба(===) за проверка на равенството на стойностите.

Динамичната проверка на типа данни в JavaScript се извършва чрез библиотеката TypeRight. Наред с други характеристики, той използва подхода за имплементиране на следните псевдокласове, чиято единствена цел е да бъдат дясната страна на оператора instanceof:

• PrimitiveUndefined.
• PrimitiveNull.
• PrimitiveBoolean.
• PrimitiveNumber.
• PrimitiveString.
• PrimitiveSymbol.

TypeRight понастоящем не предоставя клас да проверявате Стойността е обект, но може лесно да се добави.

Променливи контейнери

Променливите в JS са контейнери, които съдържат данни за многократна употреба. Преди ES2015 променливите в JavaScript се декларираха единствено с ключовата дума var:

• var x;
• var y;
• var z;

Днес променливите се определят от типовете: var, let и const. Те са уникални по свой начин и служат за подобряване на разработването на кодове, но препоръчва се да използвате: let - ако е възможно и const - когато стойността на променливата трябва да остане постоянна. Използването на променливи за съхранение на данни е в основата на езика и се състои от три части.

Декларация на променлива - тук променливата се регистрира в съответния обхват. Примери за деклариране на променливи:

• var x;
• варна чаша;
• var car.

Инициализацията се извършва, когато се декларира променлива. В този случай паметта или пространството се присвояват от JavaScript енджина. Поради това, след като променлива бъде декларирана, тя придобива стойността неопределена още преди присвояването.

Присвояването на променлива е най-важната стъпка при използването на. Тук към променливата се присвояват данни, които са стойности, като се използва операторът за присвояване "=".

Стойностите в JavaScript приемат един от стандартните типове данни:

• низ;
• брой;
• логически;
• нула;
• неопределен.

Синтаксисът за присвояване на тип може да бъде видян по-горе само при низове, които имат единични или двойни кавички. Също така булевите стойности могат да бъдат true или false. При именуването на променливи в JavaScript трябва да се спазват определени правила, а именно

1. Имената трябва да започват с малка буква.
2. Имената не могат да съдържат символи или да започват със символи.
3. Имената не могат да започват с цифра.
4. Имената могат да съдържат комбинация от главни букви, малки букви и цифри.

Начинът, по който се инициализира JS

Променлива се инициализира, когато съдържанието или стойността ѝ се задават за първи път. Например price = 22,55 може да е начинът, по който променливата се инициализира. Може да бъде деклариран и инициализиран по едно и също време. Например, можете да запишете променлива "цена = 22,55", с която променливата е била декларирана и инициализирана на същия ред. JS не изисква деклариране на типа на променливата и дори позволява променливата да съхранява съдържание от различни типове в различни моменти. Например, можете да използвате "цена = 22,55", а на по-късен етап пишете цена = "много скъпо". Това е нещо, което в други езици може да доведе до грешка, но е възприето от JavaScript.

JS ви позволява да използвате променлива, без да я декларирате. В много езици за програмиране една променлива трябва да бъде декларирана, преди да бъде използвана, но JS не задължава. Когато езикът открие променлива, която не е декларирана, той автоматично я създава и разрешава използването ѝ.

Неправилното използване на ключовата дума var може да доведе до грешка, която да спре работата на JS, т.е. уебстраницата няма да се покаже правилно. var се използва само за деклариране на променлива, не може да се използва за нищо друго. След като променлива е декларирана, тя ще се използва без ключовата дума var преди нея. Ако променливата вече е декларирана, JavaScript ще се опита да продължи и да я извлече.

Демонстрирайте работа

Можете да демонстрирате как работи кодът, за да затвърдите основните понятия за типовете данни на JavaScript, програмата чете кода, показан на снимката и записан във файла с разширение html.

След като визуализирате резултата, се уверете, че уеб страницата се визуализира нормално, т.е. JavaScript се изпълнява нормално, и очакван резултат трябва да показва следното:

1. Валидна променлива цена: неопределена (приема се).
2. Променливата data1 е валидна: null (accept).
3. Валидна променлива цена: 32,55 (приемете).
4. Двойна цена: 65.1 (приемете).
5. Сумата, получена чрез умножаване на цената по количеството, е: 325,5 (приемам).
6. Променлива цена в момента: много скъпо (приемам).
7. Двойна цена сега: NaN (приемам).
8. Променливата цена е обявена за втори път и вече е валидна: 99.55 (вземете я).
9. Променлива $ discount_applied: 0.55 (accept).

Разбирането на начина на работа на даден език автоматично ще направи програмиста по-добър програмист. Но като се има предвид, че "практиката прави доброто", не е достатъчно да научите само теорията; важно е да започнете да прилагате на практика основите на JavaScript за работа с бази данни и данни. След като прочете горната информация, за начинаещите няма да е трудно да отговорят на въпроса колко типа данни има в JavaScript.