Js приведение к строке. Типы данных JavaScript и jQuery. Обычные методы преобразования

На уроке будут разобраны функции javaScript для преобразования типов данных; даны примеры с решениями по использованию различных методов javascript вывода текста и его ввода

Напоминаем, что данный сайт не претендует на полное изложение информации по теме. Целью портала является предоставление возможности усваивания материала на основе готовых решенных примеров по javaScript с лабораторными заданиями для закрепления материала. Представленные на сайте сайт лабораторные задания по javaScript выстроены последовательно по мере увеличения сложности. Сайт сайт может быть использован учителями и преподавателями в качестве вспомогательного наглядного пособия.

Иногда в программе требуется преобразовать тип переменной. Рассмотрим основные функции, связанные с преобразованием типов:

• parseInt(строка, основание)

преобразует указанную в параметре строку в целое число . Если есть второй параметр — система счисления — преобразование происходит по указанному основанию системы счисления (8, 10 или 16):

parseInt("3.14") // результат = 3 parseInt("-7.875") // результат = -7 parseInt("435") // результат = 435 parseInt("Вася") /* результат = NaN, то есть не является числом */ parseInt("15" ,8) // результат = 13

Важно:
Функция parseInt() отсекает дробную часть числа. Чтобы округлить число необходимо использовать метод Math.round()


• parseFloat (строка)

преобразует указанную строку в число с плавающей разделительной точкой (десятичной):

parseFloat("3.14") // результат = 3.14 parseFloat("-7.875") // результат = -7.875 parseFloat ("435") // результат = 435 parseFloat ("Вася") /* результат = NaN, то есть не является числом */ parseFloat ("17.5") // результат = 17.5

Важно: Обе функции и parseInt() и parseFloat() используют в качестве параметра строку и преобразуют ее в число




Кроме того, в javascript предусмотрены еще два способа преобразований:
1. Обычные преобразования:

x = Number(x) // к числу x = String(x) // к строке x = Boolean(x) // к булеву типу

2. Компактные преобразования:

x = +x // к числу x = x + "" // к строке x = !!x // к булеву типу

• Функция javascript isNaN(значение)

служит для определения того, является ли значение выражения числом:

isNaN(123) /* результат false (то есть это - число) */ isNaN("50 рублей") /* результат true (то есть это - не число) */

Иногда можно получить такую ошибку JavaScript — NaN — когда значение не является числом (а ожидается число):

var b; document.write(b); // b=undefined

• Для того чтобы узнать текущий тип данных конкретной переменной в javascript используется функция typeof:

typeof 33 // возвращает строку "number", typeof "A String" // возвращает строку "string", typeof true // возвращает строку "boolean", typeof null // возвращает строку "object"

typeof 33 // возвращает строку "number", typeof "A String" // возвращает строку "string", typeof true // возвращает строку "boolean", typeof null // возвращает строку "object"

Пример 1. Создайте сценарий:

• с двумя строковыми переменными со значениями "строка1" и "строка2" ; с помощью операции конкатенации объедините строки;
• с двумя числовыми переменными со значениями 3.14 и FF ; выведите их произведение, преобразованное в целое число. Для вывода значений используйте метод document.write() .

✍ Решение:

• script :

// для кода JavaScript

• В коде для javascript инициализируйте две строковые переменные:

var c=3.14; var d=0xFF; // 16-я система счисления

Вспомним, что для чисел 16-й системы используется префикс 0x .

• Инициализируйте две числовые переменные:

// Инициализация двух переменных: var a="строка1"; var b="строка2";

• Выведите результаты с помощью метода document.write() с несколькими параметрами, разделенными через запятую. Чтобы вывести в две строки следует применить тег br . Для преобразования в целый тип используйте функцию parseInt() :

document.write ("конкатенация: " , a+ b, " произведение: " , parseInt(c* d) ) ;

document.write("конкатенация: ",a+b,"
произведение: ", parseInt(c*d));

Задание Js 1: Даны переменные: a="12"; b="7.15";

Найдите числовых значений переменной a на переменную b . Используйте функции преобразования типов.
Результатом должно быть число 5 .

X = Math.round(x)

Вопросы для самоконтроля:

Назовите функцию, преобразующую указанную в параметре строку в целое число.

Назовите функцию, преобразующую указанную строку в число с плавающей разделительной точкой.

В каком случае может возникнуть ошибка NaN ?

Когда значение переменной может быть undefined ?

Методы javaScript вывода данных и ввода (диалоговые окна)

JavaScript может выдавать сообщения и запрашивать данные у пользователя с помощью трех диалоговых окон, вызываемых методами alert , confirm и prompt . Рассмотрим работу с ними:

Важно: Во всех трех случаях использования методов ввода или вывода объект window можно опускать:

window.alert ("сообщение" ) ; // строгий синтаксис

window.alert("сообщение"); // строгий синтаксис

alert("сообщение" ) ; // нестрогий синтаксис

alert("сообщение"); // нестрогий синтаксис

Этот объект означает «окно», и для краткости обращения к методам разрешено его не использовать, поэтому в синтаксисе он выделен квадратными скобками

Пример 2:

✍ Решение:

1 задание:

• Создайте веб-страницу с html-скелетом и тегом script :

// для кода JavaScript

• В коде для javascript инициализируйте переменную для присваивания ей значения - имени, которое введет пользователь в модальное окно prompt() :

document.write("Привет, ", name," !");

• Протестируйте сценарий в браузере.

2 задание:

• Создайте веб-страницу с html-скелетом и тегом script .
• В коде для javascript инициализируйте две переменных для присваивания им значений - чисел, которое введет пользователь в модальные окна prompt() . Для преобразования в целый тип используйте функцию parseInt() .

Вспомним, что метод prompt() возвращает строковое значение. Поэтому для дальнейшей работы с числами, значения необходимо преобразовать в числовой тип:

var a = parseInt(prompt("Введите первое число")); var b = parseInt(prompt("Введите второе число"));

Всем доброго времени суток. На связи Алексей Гулынин. В прошлой статье вы узнали про типы данных в 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 = !a; //вернет 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; resultat = a && b && c; //вернет 0 resultat = c && b && a; //вернет 0 resultat = 7 && a; //вернет 15 resultat = 7 && b; //вернет "abc"

Логическое "ИЛИ" (||):

Немного поясню про операторы и операнды. Разберем выражение resultat = a && b && c . Здесь операторами являются "=" и "&&" , т.е. это действия. Операнды: resultat, a, b ,c . Это то, над чем совершаются действия.

Последнее обновление: 1.11.2015

Нередко возникает необходимость преобразовать одни данные в другие. Например:

Var number1 = "46"; var number2 = "4"; var result = number1 + number2; console.log(result); //464

Обе переменных представляют строки, а точнее строковые представления чисел. И в итоге мы получим не число 50, а строку 464. Но было бы неплохо, если бы их тоже можно было бы складывать, вычитать, в общем работать как с обычными числами.

В этом случае мы можем использовать операции преобразования. Для преобразования строки в число применяется функция parseInt() :

Var number1 = "46"; var number2 = "4"; var result = parseInt(number1) + parseInt(number2); console.log(result); // 50

Для преобразования строк в дробные числа применяется функция parseFloat() :

Var number1 = "46.07"; var number2 = "4.98"; var result = parseFloat(number1) + parseFloat(number2); console.log(result); //51.05

При этом строка может иметь смешанное содержимое, например, "123hello", то есть в данном случае есть цифры, но есть и обычные символы. Но метод parseInt() все равно попытается выполнить преобразование:

Var num1 = "123hello"; var num2 = parseInt(num1); console.log(num2); // 123

Если методу не удастся выполнить преобразование, то он возвращает значение NaN (Not a Number), которое говорит о том, что строка не представляет число и не может быть преобразована.

С помощью специальной функции isNaN() можно проверить, представляет ли строка число. Если строка не является числом, то функция возвращает true, если это число - то false:

Var num1 = "javascript"; var num2 = "22"; var result = isNaN(num1); console.log(result); // true - num1 не является числом result = isNaN(num2); console.log(result); // false - num2 - это число

Выше мы рассматривали перевод строк в числа в десятичной системе. Однако мы можем переводить числа в любую систему. По умолчанию интерпретатор JavaScript сам отгадывает, в число из какой системы исчисления мы хотим преобразовать строку (как правило, выбирается десятичная система). Но мы можем с помощью второго параметра явно указать, что хотим преобразовать строку в число в определенной системе. Например, преобразование в число в двоичной системе:

Var num1 = "110"; var num2 = parseInt(num1, 2); console.log(num2); // 6

Результатом будет 6, так как 110 в двоичной системе - это число 6 в десятичной.

Теперь напишем небольшую программу, в которой используем операции с переменными:

JavaScript var strSum = prompt("Введите сумму вклада", 1000); var strPercent = prompt("Введите процентную ставку", 10); var sum = parseInt(strSum); var procent = parseInt(strPercent); sum = sum + sum * procent / 100; alert("После начисления процентов сумма вклада составит: " + sum);

С помощью функции prompt() в браузере выводится диалоговое окно с предложением ввести некоторое значение. Второй аргумент в этой функции указывает на значение, которое будет использоваться по умолчанию.

Однако функция prompt() возвращает строку. Поэтому эту строку нам надо преобразовать в число, чтобы выполнить с ней операции.

После открытия страницы в браузере мы увидим приглашение к вводу суммы вклада:

Затем подобное сообщение отобразится и для ввода процента. И в конце программа получит данные, преобразует их в числа и выполнит подсчет.

В JavaScript значения достаточно свободно (явно и неявно) могут быть преобразованы из одного типа в другой. Например, если какой-нибудь оператор ожидает получить значение определённого типа, а ему передаётся значение другого типа, то интерпретатор автоматически попытается выполнить преобразования к нужному типу:

Console.log(10 + " машин"); // "10 машин". Число неявно преобразуется в строку console.log("7" * "4"); // 28. Обе строки неявно преобразуются в числа

Неявное преобразование - это когда интерпретатор автоматически выполняет преобразование типов, т. е. без участия программиста. Явное преобразование - это когда преобразование выполняет сам программист. Явное преобразование иначе называют приведением типов :

Console.log("7" * "4"); // 28. Неявное преобразование console.log(Number("7") * Number("4")); // 28. Явное преобразование

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

Значение Преобразование в: Строку Число Булево Объект

undefined null	"undefined" "null"	NaN 0	false false	ошибка typeError ошибка typeError
true false	"true" "false"	1 0		new Boolean(true) new Boolean(false)
"" (пустая строка) "1.2" "one" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	false true true true true true true	new String("") new String("1.2") new String("one") new String("-10") new String("+10") new String("011") new String("0xff")
0 -0 NaN Infinity -Infinity 3	"0" "0" "NaN" "Infinity" "-Infinity" "3"		false false false true true true	new Number(0) new Number(-0) new Number(NaN) new Number(Infinity) new Number(-Infinity) new Number(3)
{} (любой объект) (пустой массив) (1 числовой элемент) arr (любой другой массив) function(){} (любая функция)	см. Преобразование объектов "" "9" см. Преобразование объектов см. Преобразование объектов	см. Преобразование объектов 0 9 NaN NaN	true true true true true

Для явного преобразования в простые типы используются следующие функции: Boolean() , Number() , String() . При неявном преобразования интерпретатор использует те же функции, что используются для явного преобразования.

Для явного преобразования можно использовать операторы вместо функций. Например, если один из операндов оператора + является строкой, то другой операнд также преобразуется в строку. Унарный оператор + преобразует свой операнд в число. Унарный оператор! преобразует операнд в логическое значение и инвертирует его. Всё это стало причиной появления следующих своеобразных способов преобразования типов, которые можно встретить на практике:

X + "" // То же, что и String(x) +x // То же, что и Number(x). Можно также встретить x - 0 !!х // То же, что и Boolean(x)

Преобразование в числа

Функция Number() преобразует значения по следующим правилам:

• Логические значения true и false преобразуются в 1 и 0 соответственно.
• Числа возвращаются без изменения.
• Значение null преобразуется в 0 .
• Значение undefined преобразуется в NaN .

Для строк действуют особые правила:

• Если строка содержит только цифры с начальным знаком + или - либо без знака, она всегда преобразуется в целое десятичное число. Начальные нули игнорируются, например "0011" преобразуется в 11.
• Если строка представляет собой число с плавающей точкой с начальным знаком + или - либо без знака, она преобразуется в соответствующее число с плавающей точкой (начальные нули также игнорируются).
• Если строка представляет собой число в шестнадцатеричном формате, она преобразуется в соответствующее целое десятичное число.
• Если строка пустая, она преобразуется в 0 .
• Если строка содержит что-то отличное от предыдущих вариантов, она преобразуется в NaN .
• Для объектов вызывается метод valueOf() , а возвращаемое им значение автоматически преобразуется по предыдущим правилам. Если это преобразование даёт в результате NaN , вызывается метод toString() и применяются правила преобразования строк в числа.

Унарные операторы + и - работают по тем же правилам, что и функция Number() .

Преобразование в булевы значения

Функция Boolean() преобразует значение в его логический эквивалент:

• Следующие значения в результате преобразования дают значение false: undefined , null , 0 , -0 , NaN , "" .
• Значение false возвращается без изменения.
• Все остальные значения в результате преобразования дают значение true .

Преобразование в строки

Функция String() преобразует значения по следующим правилам:

• Для всех значений кроме null и undefined автоматически вызывается метод toString() и возвращается строковое представление значения.
• Для значения null возвращается строка "null" .
• Для значения undefined возвращается строка "undefined" .

Преобразование простых типов в объекты

Для преобразования простых значений в объекты используются конструкторы Boolean() , Number() , String() :

Var oNum = new Number(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(typeof oNum); // "object" alert(typeof oStr); // "object" alert(typeof oBool); // "object"

Преобразование объектов в простые значения

Все объекты наследуют два метода преобразования: toString() и valueOf() .

Метод toString() возвращает строковое представление объекта. По умолчанию он ничего интересного не возвращает:

Alert({x: 1}.toString()); // ""

Некоторые типы имеют более специализированные версии метода toString() . Например, метод toString() у массива преобразует все его элементы в строки и затем объединяет их в одну строку, вставляя запятые между ними:

Alert(.toString()); // "1,2,3"

Задача метода valueOf() определена не так чётко: предполагается, что он должен преобразовать объект в представляющее его простое значение, если такое значение существует. Объекты по своей сути являются составными значениями, и большинство объектов не могут быть представлены в виде единственного простого значения, поэтому по умолчанию метод valueOf() возвращает не простое значение, а ссылку на него:

Alert(typeof {x:2}.valueOf()); // "object"

При преобразовании объекта в строку интерпретатор JavaScript выполняет следующие действия:

• Если объект имеет метод toString() , интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует значение в строку (если оно не является строкой) и возвращает результат преобразования.
• Если объект не имеет метода toString() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода valueOf() . Если этот метод определён, интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует это значение в строку (если оно не является строкой) и возвращает результат преобразования.

При преобразовании объекта в число интерпретатор выполняет те же действия, но первым пытается применить метод valueOf() :

• Если объект имеет метод valueOf() , возвращающий простое значение, интерпретатор преобразует (при необходимости) это значение в число и возвращает результат.
• Если объект не имеет метода valueOf() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода toString() . Если объект имеет метод toString() , возвращающий простое значение, интерпретатор выполняет преобразование и возвращает полученное значение.
• В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

Методы toString() и valueOf() доступны для чтения и записи, поэтому их можно переопределить и явно указать, что будет возвращаться при преобразовании:

Var obj = {}; obj.toString = function() { return "объект"; }; alert("Это " + obj); // "Это объект"

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 and 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".replace(/e|o/g, "x") // "hxllx" - замена части строки на подстроку по шаблону регулярного выражения "1,2,3".split(",") // ["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 (явное преобразование десятичного числа с указанием системы счисления 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, так как новый метод был добавлен к прототипу