Js перетворення рядка. Перетворення типів даних на JavaScript. Перетворення значень на логічні значення

Всім доброго доби. На зв'язку Олексій Гулинін. Минулої статті ви дізналися про типи даних Javascript. У цій статті я хотів би поговорити про перетворення типів на Javascript. Перетворення типів Javascript, та й взагалі у будь-якій мові програмування, виконуються дуже часто. Спочатку хотів поговорити про перетворення типів у порівнянні змінних, чи інших умов, результатом яких є true чи false . При порівнянні змінних різних типів виконуються фонові перетворення. Тут головним моментом є те, що при таких фонових перетвореннях значення, яке зберігається в змінній, не змінюється. змінна перетворюється на той тип даних (створюється тимчасове значення змінної), який необхідний виконання операції. наведу приклад:

Порівнюються змінні рядкового типу та числового типу. при порівнянні значення цих змінних наводяться одного типу даних. Далі порівняння повертає логічне значення, а перетворені часові значення видаляються. Усі перетворення залежить від контексту — операторів, які виконують з них дії. приклад коду:

Var a = 5; var b = "15"; if (a< b) alert("a < b"); else alert("a >b");

В даному випадку змінна b буде перетворена на число (виконалося фонове перетворення типу String в тип Number, і вийде тимчасове значення змінної b типу Number = 15, яке видаляється після виконання операції порівняння), і вийде результат, що a .

Нижче наведено таблицю, яка показує, як один тип даних перетворюється на інший:

Тип значення	Контекст, у якому використовується значення
Тип значення	Рядковий	Числовий	Логічний	Об'єктний
Невизначене значення	‘undefined’	NaN	false	Error
null	‘null’	0	false	Error
Порожня стрічка	Порожня стрічка	0	false	Об'єкт String
Непорожній рядок	Непорожній рядок	Числове значення рядка або NaN	true	Об'єкт String
0	’0′	0	false	Об'єкт Number
NaN	‘NaN’	NaN	false	Об'єкт Number
Infinity	‘Infinity’	Infinity	true	Об'єкт Number
-Infinity	'-Infinity'	-Infinity	true	Об'єкт Number
Будь-яке інше число	Строкове подання числа	Саме число	true	Об'єкт Number
true	‘true’	1	true	Об'єкт Boolean
false	‘false’	0	false	Об'єкт Boolean
Об'єкт, функція	toString()	valueOf(), toString() або NaN	true	Об'єкт, функція

Перетворення типів даних

Отримати логічний тип даних можна з будь-якого типу даних. Робиться це за допомогою оператора заперечення або подвійного заперечення. Приклад:

Var a = 20; var b =! //Поверне false var c = !!a; //Поверне true

Рядок можна отримати з будь-якого об'єкта. Приклад:

Var a = 20; var b = a.toString(); //поверне "20" var c = a + ""; //поверне "20" typeof b; //Поверне string typeof c; //Поверне string

Отримання числа з рядка. Приклад:

Var a = "20"; var b = a * 1; //Поверне 20 var c = + a; //поверне 20 typeof b; //Поверне number typeof c; //поверне number

Давайте тепер на основі отриманих знань розберемо поведінку логічного "І" (&&) і логічного "АБО" (||):

Логічне "І" (&&):

Для коректного виконання цього оператора необхідно, щоб значення всіх операндів могли бути перетворені на true. Якщо значення всіх операндів можуть бути перетворені на true, то буде повернено початкове значення останнього порівнюваного операнда. Якщо значення хоча б одного операнда буде перетворено на false, то повернеться початкове значення цього операнда. Приклад:

Var a = 15; var b = "abc"; var c = 0; var resultat; resultado = a && b && c; //поверне 0 resultado = c && b && a; //поверне 0 resultado = 7 && a; //поверне 15 resultado = 7 && b; //поверне "abc"

Логічне "АБО" (||):

Трохи поясню про оператори та операнди. Розберемо вираз resultado = a&&b&&c. Тут операторами є "=" і "&&", тобто. це дії. Операнди: resultado, a, b, c. Це те, над чим чинять дії.

Немає різниці в тому, якого типу змінна використовується у виразі. Якщо математичне вираз, всі його змінні автоматично будуть інтерпретовані як числові. Якщо обробляються рядки, всі «учасники» висловлювання розглядаються як рядки. Однак завдання перетворення на JavaScript "рядок у число" існує у значно ширшому контексті.

Методи JavaScript перетворення рядків у числа

Арсенал методів для перетворення рядків у числа невеликий, але достатній у всіх найпростіших випадках. Тут JavaScript (для початківців особливо) - це шлях від простого до складного на практичних прикладах.

У прикладі описано чотири різні рядки. У першому блоці виводу тип кожної змінної функції типувизначається як string. Потім кожен рядок дуже просто перетворюється на число. У другому блоці виведення видно зміни у змінних після перетворення, їх тип став числом. Приклад перетворення JavaScript parseFloat особливо показовий: було "12e+3", стало "12000".

Зміни під час перетворення рядка на число можуть бути істотними! Але мають значення лише перші символи: вони мають бути цифровими. Якщо немає жодного цифрового символу, результат буде NaN.

Зворотне перетворення рядка, що «стало» числом, не завжди такий самий рядок. Цей момент можна використовувати для перевірки правильності введення чисельної інформації.

Звичайні методи перетворення

Є цілі числа і є дробові, відповідно, JavaScript рядок у число перетворює за:

parseInt;
parseFloat.

Загальний випадок реалізується шляхом використання рядка у простому математичному виразі.

Достатньо поставити перед рядком символів знак "+" і, якщо в ньому є число, результатом виразу буде число. Значення змінної може змінитися, але тип зміниться завжди: типвідображає номер, а не string. Важливо розуміти, що використання перетвореної змінної у рядковому виразі може показати зовсім інший результат.

JavaScript для початківців у цьому контексті гранично простий. Складніше зрозуміти роботу цілісного перетворення методом pasrseInt, оскільки автоматом він працює в десятковій системі числення, але може інтерпретувати рядок як вісімковий або шістнадцятковий. При цьому не завжди це залежить від другого параметра, який вказує на систему числення.

JavaScript рядок на число перетворить завжди, але якщо в рядку немає жодного цифрового символу на початку рядка, то результатом буде NaN.

Необхідно мати уявлення про системи числення, про способи запису шістнадцяткових (число починається з "0x") та вісімкових чисел (число починається з "0").

Для розуміння нюансів роботи методу JavaScript parseFloat достатньо мати уявлення про те, що таке математичний запис речовинного числа.

Перетворення з метою сортування

JavaScript - мова браузера, тому він більше за інших мов критичний до символів за межами основного набору латинського алфавіту та цифр. Сортування – затребувана операція. Але не завжди має сенс пересилати дані на сервер для цілей сортування, простіше і практичніше виконати роботу на місці, в браузері.

Для вирішення такої задачі можна перетворити символи рядка в їх числові коди або призначити літери та цифри впорядковану послідовність цифр. Метод charCodeAt(), застосований до рядка, присвоє числове значення 98 змінної iB, тобто коду літери "b". Враховуючи, що значення коду літери "a" дорівнює 97 можна отримати номери всіх літер латинського алфавіту в порядку зростання за малими та великими наборами. Аналогічно за буквами російського алфавіту.

Власний варіант сортування через числа дозволяє сформувати необхідні набори символів. Можна, наприклад, «перемістити» кирилицю та латиницю або їх перемішати з метою залишити лише відмінні за написанням літери, додати до наборів символи табуляції та пробілу.

Формування унікального числа рядка

Якщо код букви "a" дорівнює 97, то різниця між буквою та числом 97 надасть унікальний номер букви в алфавіті. Підсумовуючи унікальні номери кожного символу рядка, важко отримати унікальне число цього рядка.

Якщо для кожної позиції літери в рядку призначити вагу, наприклад, позиція:

0 вага 1;
1 вага 10;
2 вага 100;

то помножуючи унікальний номер кожного символу рядка на вагу позиції, в якій він виявлений, і підсумовуючи всі числа, можна отримати унікальне число і використовувати його як однозначну відповідність вихідному рядку.

Таке перетворення рядка в число оборотне, тобто за кількістю можна завжди отримати вихідний рядок. Таке перетворення вигідне, тому що з числом можна робити будь-яку операцію безпечно в контексті кодування, кирилиці та інших локальних особливостей сторінки сайту, сфери застосування, країни відвідувача.

«Зростаючі» селектори сторінки сайту

Часто виникає завдання створення селекторів на сторінках сайту, значення яких заздалегідь не можна вказати, але з часом вони доповнюються. У першому застосуванні порожній селектор доступний першому відвідувачу для введення інформації.

Кожне нове введення рядка інформації в селектор (будь-яким відвідувачем) трансформується в число, яке разом з оригіналом відправляється на сервер для зберігання. Коли розпочинається новий сеанс роботи або приходить новий відвідувач, селектор уже не порожній. Сторінка при завантаженні приходить до браузера з непустим селектором.

При кожному новому значенні селектора лише один раз воно відправляється на сервер для зберігання і лише один раз призначається йому унікальний цифровий код.

Для вирішення цього завдання метод JavaScript рядок у число використовувати не можна. Звичайні методи parseInt і parseFloat розраховані на інше застосування, але можна вигадати алгоритм однозначного перетворення рядка в число, причому не обов'язково оборотний. Достатньо того, що на різних наборах символів у рядку алгоритм перетворення не повторюватиметься.

Оптимізація трафіку та аналітика

Під час формування сторінки розробник використовує значні обсяги інформації. Надати відвідувачеві можливість вводити інформацію - добрий спосіб знизити рейтинг сайту внаслідок його слабкої функціональності та розчарувати відвідувача.

Призначаючи на дії відвідувача обробник події у вигляді JavaScript function за певними блоками інформації, можна сформулювати фільтр, який дозволить відвідувачеві точно поставити мету, знайти потрібну інформацію, отримати бажане рішення.

Перетворення малої інформації тут може бути як завгодно ємним у частині рядка і дуже малим у частині числа. Інакше кажучи, перетворення JavaScript рядок у число розробник виконує за своїм алгоритмом. Відвідувач маніпулює зрозумілою інформацією, але в сервер йде мінімальний обсяг даних - число.

Динаміка множини чисел за всіма відвідувачами в контексті точно відомої інформації дозволяє інший JavaScript function (не обробник), що викликається за відповіддю сервера через механізм AJAX, оперативно в реальному масштабі часу давати всім відвідувачам потрібну інформацію одночасно. Так працює система.

Такий варіант перетворення JavaScript рядок у число дуже затребуваний у розробці онлайн-ігор, інтерактивних конференцій, передачі миттєвих повідомлень тощо.

Інструментальне застосування перетворень

JavaScript та CSS у контексті обробки числової інформації дозволяють керувати відображенням сторінки без участі сервера. Правила CSS побудовані як підрядки, рекурсивні. Зазвичай параметр - число, за яким слідує кілька літер (наприклад, "px", "pt", "em", ...). Параметр є підрядком у правилі, а правило входить підрядком у стиль класу чи ідентифікатора.

Рекурсія JavaScript.Підрядок.Підстрока... виходить на потрібне число, перетворює з рядка в число, змінює його і назад записує в потрібне місце. Правило змінюється "автоматом". Це просто та зручно, ніякої участі сервера.

У JavaScript існують 2 вбудовані функції перетворення рядків у числа: parseFloat() і parseInt() .

parseFloat() приймає аргументом рядок, який необхідно привести до чисельного типу, та повертає число типу float. Число має утримуватися на початку рядка. Якщо після числа у рядку йдуть ще якісь символи, вони відсікаються. Дробова частина числа має бути записана через точку (кома не сприймається як роздільник). Якщо parseFloat() не може перетворити рядок, то вона повертає NaN.

Також функція може обробити «число n, помножене на 10 ступенем x», яке в програмуванні прийнято записувати через букву E, наприклад: 0.5E6 або 0.5E+6. Ступінь може бути негативна: 0.5E-6, що дорівнює 0.5*10^-6 або 0.5/1000000.

ParseFloat("3.78kg") // 3.78 parseFloat("kg33") // NaN parseFloat("0004.111") // 4.111 parseFloat("0x66") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003

Функція parseInt(string[, radix]) приймає як перший аргумент рядок, аналізує його і повертає ціле число (тип integer). Функція намагається аналізувати систему числення, в якій записано число у вихідному рядку (наприклад, десятковий, вісімковий або шістнадцятковий — але не тільки ці). Також систему числення можна вказати очевидно, передавши її другим параметром radix. Параметр radix може приймати будь-яке число від 2 до 36 (у системах вище 10 використовуються літери англійського алфавіту, від A до Z).

Числа типу 1.5e6 функція не обробляє так, як parseFloat() .

Будь ласка, ознайомтеся з прикладами нижче, щоб не наколотися на підводні камені, заховані в роботі функції parseInt() .

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 у вісімковій системі це 56 у десятковій) parseInt(""070"") // 56 (ВАЖЛИВО!!! нуль спочатку змусить функцію проаналізувати рядок як вісімкове число) parseInt(" "88"",8) // NaN (у вісімковій системі немає цифри 8) parseInt(""a1"") // NaN (ВАЖЛИВО!!! Функція за замовчуванням не сприймає число як 16-річне, якщо не дописати на початку рядки 0x) parseInt(""a1"",16) // 161 (тут явно вказана система числення) parseInt(""0xa1"") // 161 (правильний формат 16-річного числа, можна не вказувати другий параметр) parseInt( ""099"") // 0 (ВАЖЛИВО!!! Число сприймається як вісімкове, але містить неприпустимі символи) parseInt(""0.5e6"") // 0 (ВАЖЛИВО!!! не працює як parseFloat) parseInt("" ZZ"",36) // 1295 parseInt("-FF"") // NaN parseInt(""-FF"",16) // -255

Якщо Ви обробляєте дані з текстового поля, які вводить користувач, завжди використовуйте parseInt() разом із другим параметром radix, це убезпечить Ваш код від несподіваних результатів.

| |

У JavaScript дані діляться на типи, що допомагає групувати дані та визначити, які значення можна присвоїти і які операції можна виконати.

Хоча через приведення типів JavaScript автоматично перетворює багато значень, для досягнення очікуваних результатів найкраще перетворювати типи даних вручну.

Цей мануал навчить перетворити примітивні типи даних JavaScript, включаючи числа, рядки та логічні елементи.

Неявне перетворення

Мова програмування JavaScript дуже добре справляється із обробкою несподіваних значень. JavaScript не відхиляє несподіваних значень, а намагається перетворити. Це неявне перетворення називається приведенням типів (type coercion).

Окремі методи автоматично перетворюють значення, щоб їх використовувати. Метод alert() приймає рядок як свій параметр, а інші типи автоматично перетворює на рядки. Таким чином, можна передати цьому методу числове значення:

Якщо запустити цей рядок, браузер поверне спливаюче вікно зі значенням 8.5, яке вже буде перетворено на рядок.

Використовуючи рядки, що складаються з чисел разом з математичними операторами, ви виявите, що JavaScript може обробляти значення, неявно перетворюючи рядки в числа:

// Віднімання
"15" - "10";
5
// Модуль
"15" % "10";
5

Але не всі оператори працюють передбачувано. Особливо це стосується оператора +: він виконує складання чисел та конкатенацію рядків.

// Під час роботи з рядками + виконує конкатенацію
"2" + "3";
"23"

Оскільки оператор + має багато призначень, у цьому прикладі він сприймає значення 2 та 3 як рядкові, незважаючи на те, що вони виражаються числовими рядками. Тому він об'єднує рядки "2" і "3" і отримує 23, а не складає 2 і 3 і отримує 5.

Подібна неоднозначність має місце у коді і іноді викликає несподівані результати, тому краще по можливості явно перетворювати типи даних. Це допоможе в підтримці коду та обробці помилок.

Перетворення значень на рядки

Щоб явно перетворити значення на рядок, викличте метод String() або n.toString().

Спробуйте перетворити логічне значення true на рядок за допомогою String().

Це поверне рядковий літерал "true".

Також можна спробувати передати функції число:

Вона поверне рядковий літерал:

Тепер спробуйте використати String() зі змінною. Призначте числове значення змінної odyssey і використовуйте тип оператора, щоб перевірити тип.

let odyssey = 2001;
console.log(typeof odyssey);
number

На даний момент змінної odyssey присвоєно числове значення 2001 року. Оператор типупідтверджує, що значення є числом.

Тепер присвойте змінної odyssey її еквівалент всередині функції String(), а потім використовуйте типвідповіді, щоб переконатися, що значення змінної успішно перетворено з числа на рядок.

odyssey = String(odyssey); // "2001"
console.log(typeof odyssey);
string

Як бачите, тепер змінна odyssey містить рядок.

Функція n.toString() працює аналогічно. Замініть змінну n.

let blows = 400;
blows.toString();

Змінна blows міститиме рядок.

Замість змінної можна помістити значення у круглих дужках:

(1776). toString (); // returns "1776"
(false).toString(); // returns "false"
(100 + 200). toString (); // returns "300"

String() і n.toString() явно перетворюють логічні та числові значення в рядки.

Перетворення значень у числа

Метод Number() може перетворити значення на число. Часто виникає необхідність перетворити рядки, що складаються з чисел, але іноді потрібно перетворювати і логічні значення.

Для прикладу передайте методу Number() такий рядок:

Рядок буде перетворено на число і більше не буде укладено в лапки.

Також можна присвоїти рядок змінної і потім перетворити його.

let dalmatians = "101";
Number(dalmatians);
101

Рядковий літерал «101» було перетворено на число 101.

Рядки з пробілів або порожні рядки будуть перетворені на число 0.

Number(" "); // returns 0
Number(""); // returns 0

Майте на увазі, що рядки, які не складаються з чисел, перетворюються на NaN, що означає Not a Number. Це стосується і числам, розділеним пробілами.

Number("twelve"); // returns NaN
Number("20,000"); // returns NaN
Number("2 3"); // returns NaN
Number("11-11-11"); // returns NaN

У логічних даних значення false дорівнюватиме 0, а true дорівнюватиме 1.

Перетворення значень на логічні значення

Щоб перетворити числа чи рядки на логічні значення, використовується метод Boolean(). Наприклад, це допомагає визначити, вводить користувач дані текстове поле чи ні.

Будь-яке значення, яке інтерпретується як порожнє, наприклад, число 0, порожній рядок, значення undefined, NaN або null перетворюються на false.

Boolean(0); // returns false
Boolean(""); // returns false
Boolean(undefined); // returns false
Boolean (NaN); // returns false
Boolean (null); // returns false

Інші значення, включаючи рядкові літерали, що складаються з прогалин, будуть перетворені на true.

Boolean (2000); // returns true
Boolean(" "); // returns true
Boolean("Maniacs"); // returns true

Зверніть увагу: рядковий літерал "0" перетворюється на true, оскільки це не порожнє значення:

Boolean("0"); // returns true

Перетворення чисел і рядків на логічні значення дозволяє оцінювати дані в двійковій системі і може використовуватися для управління потоком у програмах.

Висновок

Тепер ви знаєте, як JavaScript перетворює типи даних. часто через наведення типів дані перетворюються неявно, що може спричинити виникнення несподіваних значень. Рекомендовано явно перетворювати типи даних, щоб гарантувати коректну роботу програм.

JavaScript надає кілька вбудованих типів даних. Крім них ця стаття розглядає віртуальні типи в jQuery, такі як селектори, розширені псевдотипи як події, а також всі види функцій.

Краще, якщо ви спробуєте більшість прикладів, викладених нижче. Це можна легко зробити, просто скопіювавши ці приклади в консоль Firebug – розширення браузера Firefox.

Щоразу, коли в прикладах проводяться операції в булевському контексті (наприклад, при порівнянні), важливо знати, як поводиться в такому контексті кожен з типів даних:

Var x = "" if (x) console.log("x defaulted to true") else console.log("x defaulted to false")

У цьому випадку надрукується "x дорівнює false".

Для зменшення обсягу прикладів використовується оператор заперечення, щоб показати булівський контекст:

X // true

Типи даних у jQuery

Рядки
- Вбудовані методи для рядків
- Властивість length
- Булівський контекст
Числа
- Булівський контекст
- Parsing Numbers
- Numbers to Strings
- NaN та Infinity
- Integer
- Float
Булівський тип
Об'єкти
- Dot Notation
- Array Notation
- Iteration
- Boolean default
- Prototype
Options
Масиви
- Iteration
- Boolean Default
- Array Notation
Функції
- Аргументи
- Context, Call and Apply
- Область видимості
- Closures
- Proxy Pattern
Callback-функції
Селектори
Події
Елементи
jQuery-тип
Тип XMLHttpRequest

Рядки

"Це рядок JavaScript!" "І це теж рядок!"

Рядок у JavaScript - це незмінний об'єкт, який містить жодного, один або кілька символів.

Тип рядків є "string". Дізнатися тип рядка можна так:

Typeof "some string"; // "string"

Використання лапок у рядках

Рядок може бути визначений за допомогою одинарних або подвійних лапок. Ви можете вільно використовувати одинарні лапки всередині рядка, укладеного в подвійні лапки і навпаки. Щоб використовувати подвійні лапки всередині рядків, укладених у подвійні лапки, їх потрібно екранувати за допомогою зворотного слішу. Це стосується і одинарних лапок.

"You make "me" sad." "Holy "cranking" moses!" " Головна" "Головна"

Вбудовані методи для рядків

JavaScript має декілька вбудованих методів для маніпулювання рядками, результат яких може бути як рядок, так, наприклад, і масив:

"hello".charAt(0) // "h" - отримання символу в потрібній позиції рядка "hello".toUpperCase() // "HELLO" - перетворення рядка у верхній регістр "Hello".toLowerCase() // "hello" - Перетворення рядка в нижній регістр "hello". ") // ["1", "2", "3"] - розбиття рядка на масив за певним підрядком

Властивість length

Рядки мають властивість length, яка визначає довжину рядка.

"Hello".length // 5 "".length // 0

Булівський контекст

Порожній рядок прирівнюється до значення false:

!"" // true !"hello" // false !"true" // false !new Boolean(false) // false

Числа

12 3.543

Числа JavaScript мають 64-бітний формат подвійної точності за стандартом IEEE 754. Вони також є незмінними. Для роботи з числами доступні всі оператори, такі як у мові C (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

Типом чисел є "number". Перевірити тип чисел можна так:

Typeof 12 // "number" typeof 3.543 // "number"

Булівський контекст

Якщо число дорівнює нулю, воно прирівнюється до false:

0 // true !1 // false !-1 // false

Через те, що числа реалізовані у форматі з подвійною точністю, результат такого прикладу не є помилковим:

0.1 + 0.2 // 0.30000000000000004

Об'єкт Math

JavaScript надає функції для роботи з числами в об'єкті Math:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

Перетворення у числа

Функції parseInt і parseFloat перетворюють рядки на числа. І та, і інша функція виконує неявне перетворення, якщо не вказано систему числення:

ParseInt("123") = 123 (неявне перетворення десяткового числа) parseInt("010") = 8 (нев'яне перетворення вісімкового числа) parseInt("0xCAFE") = 51966 (неявне перетворення шістнадцяткового числа) parseInt("010" = 10 (явне перетворення десяткового числа із зазначенням системи числення 10) parseInt("11", 2) = 3 (явне перетворення двійкового числа) parseFloat("10.10") = 10.1

Перетворення чисел у рядки

Якщо додавати числа до рядка за допомогою операції "+", результатом завжди буде рядок. Щоб зробити обчислення і тільки потім додати число до рядка, не забудьте укласти обчислення в круглі дужки:

""+1+2; // "12" "" + (1 + 2); // "3" "" + 0.0000001; // "1e-7" parseInt(0.0000001); // 1 (зверніть увагу!)

Ви також можете використовувати JavaScript-клас String, який перетворює передане значення на рядок:

String(1) + String(2); // "12" String(1 + 2); // "3"

Типи NaN та Infinity

Перетворення значень, які є числами, призводить до результату NaN. Функція isNaN визначає, чи дорівнює передане до неї значення NaN:

ParseInt("hello", 10) // NaN isNaN(parseInt("hello", 10)) // true

Поділ на нуль дає як результат нескінченність (Infinity):

1/0 // Infinity

І значення NaN та Infinity мають тип "number":

Typeof NaN // "number" typeof Infinity // "number"

Зауважте, що порівняння значень NaN відбувається нестандартним способом:

NaN == NaN // false (!)

Infinity == Infinity // true

Тип Integer

Integer - цілісний тип.

Тип Float

Float - тип чисел з плаваючою точкою.

Булівський тип (Boolean)

Булівський тип JavaScript може приймати значення true або false:

If (true) console.log("always!") if (false) console.log("never!")

Наприклад, булевський тип виглядає наступним чином при заданні налаштувань при підключенні плагінів jQuery:

$("...").somePlugin(( hideOnStartup: true, onlyOnce: false ));

Об'єкти

Все JavaScript є об'єктом. Найпростіший спосіб створити об'єкт:

Var x = (); var y = (name: "Pete", age: 15);

Типом для об'єктів є "object":

Typeof() // "object"

Властивості об'єкту

Ви можете змінювати та отримувати властивості об'єкта, використовуючи точкову нотацію:

Y.name // "Pete" y.age // 15 x.name = y.name + "Pan" // "Pete Pan" x.age = y.age + 1 // 16

Ви також можете використовувати об'єкт як масив:

Var operations = (increase: "++", decrease: "--") var operation = "increase"; operations // "++"; operations["multiply"] = "*"; // "*"

Ітерації біля об'єктів

Ітерування над об'єктами здійснюється дуже легко за допомогою оператора циклу for-in:

Var obj = (name: "Pete", age: 15); for(key in obj) ( alert("key is "++", value is "+obj); )

jQuery надає функцію

для ітерацій за властивостями об'єктів або елементами масивів:

JQuery.each(obj, function(key, value) ( console.log("key", key, "value", value); ));

Булівський контекст

Об'єкт, незалежно від того, має він властивості чи ні, завжди має значення true:

!() // false

Прототипи

Усі об'єкти мають властивість prototype. Щоразу, коли інтерпретатор шукає будь-які властивості об'єкта, він також перевіряє його прототип. У jQuery цей механізм широко використовується для додавання методів до екземплярів об'єктів jQuery.

Var form = $("#myform"); form.clearForm; // undefined form.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); form.clearForm() // може бути застосовано до всіх екземплярів об'єктів jQuery, оскільки новий метод було додано до прототипу