Js преобразование типов. Типы данных JavaScript и jQuery. Преобразование в булевы значения

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

Синтаксический

Var parsed = parseInt("97", 10);

parseInt и parseFloat - это две функции, используемые для разбора строк на числа. Синтаксический анализ остановится молча, если он попадет в символ, который он не распознает, что может быть полезно для синтаксического анализа строк, например "92px", но это также несколько опасно, поскольку оно не даст вам никакой ошибки при плохом вводе, вместо этого вы "вернем NaN, если строка не начинается с числа. Пробел в начале строки игнорируется. Вот пример того, что он делает что-то по-другому, что вам нужно, и не указывает, что что-то пошло не так:

Var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Хорошая практика всегда указывать в качестве второго аргумента. В старых браузерах, если строка начиналась с 0, она была бы интерпретирована как восьмеричная, если бы не было указано значение radix, которое привлекло много людей врасплох. Поведение для шестнадцатеричного запуска запускается, если строка начинается с 0x, если не указано значение radix. 0xff . Стандарт фактически изменился с помощью ecmascript 5, поэтому современные браузеры больше не запускают восьмеричные, когда указана ведущая 0, если не указано значение radix. parseInt понимает радики до основания 36, и в этом случае как верхние, так и строчные буквы обрабатываются как эквивалентные.

Изменение типа строки на число

Все другие трюки, упомянутые выше, которые не используют parseInt, подразумевают неявное принуждение строки к числу. Я предпочитаю делать это явно,

Var cast = Number("97");

Это отличается от методов анализа (хотя он все еще игнорирует пробелы). Он более строгий: если он не понимает всю строку, чем возвращает NaN , поэтому вы не можете использовать ее для строк типа 97px . Поскольку вам требуется примитивное число, а не объект обертки Number, убедитесь, что вы не ставите new перед функцией Number.

Очевидно, что преобразование в число дает вам значение, которое может быть float, а не целое число, поэтому, если вы хотите целое число, вам нужно его изменить. Есть несколько способов сделать это:

Var rounded = Math.floor(Number("97.654")); // other options are Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // rounded rather than truncated var bitwised = Number("97.654")|0; // do not use for large numbers

Любой побитовый оператор (здесь я поразрядный или, но вы также можете сделать двойное отрицание, как в более раннем ответе или бит-сдвиге) преобразует значение в 32-битное целое число, и большинство из них преобразуется в подписанный целое число. Обратите внимание, что этот не будет нужен для больших целых чисел . Если целое число не может быть представлено в 32 битах, оно будет завершено.

~~"3000000000.654" === -1294967296 // This is the same as Number("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit "300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

Чтобы правильно работать с большими числами, вы должны использовать методы округления

Math.floor("3000000000.654") === 3000000000 // This is the same as Math.floor(Number("3000000000.654"))

Имейте в виду, что все эти методы понимают экспоненциальную нотацию, поэтому 2e2 является 200 , а не NaN. Кроме того, Number понимает "Бесконечность", в то время как методы анализа не делают.

Пользовательский

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

Всегда проверяйте, что вывод Number или один из методов анализа - это число, которое вы ожидаете. Вы почти наверняка захотите использовать isNaN , чтобы убедиться, что число не NaN (обычно это единственный способ узнать, что синтаксический анализ не удалось).

| |

В 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 и используйте оператор typeof, чтобы проверить тип.

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

На данный момент переменной odyssey присвоено числовое значение 2001. Оператор typeof подтверждает, что значение является числом.

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

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 . В данной статье я бы хотел поговорить про преобразование типов в 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 . Это то, над чем совершаются действия.

JavaScript – нетипизированный язык (точнее, слабо типизированный или динамически типизированный). Это значит, что мы не должны задавать тип переменной при ее объявлении. Нетипизированность придает JavaScript гибкость и простоту, предпочтительную для языка сценариев (хотя эти особенности достаются ценой отсутствия строгости, важной для длинных и более сложных программ, которые часто пишутся на более строгих языках, таких как C или Java). Важной чертой гибкой работы с типами данных в JavaScript являются выполняемые интерпретатором автоматические преобразования данных. Например, если методу document.write() передается число, JavaScript автоматически преобразует его в эквивалентное строковое представление. Аналогично, проверяя строковое значение в условии инструкции if, JavaScript автоматически преобразует эту строку в логическое значение – в false, если строка пуста, и в true в противном случае.

Основное правило состоит в том, что когда значение одного тип встречается в контексте, где требуется значение какого-то другого типа, JavaScript автоматически пытается преобразовать значение требуемым образом. Поэтому, например, в контексте, предполагающем логическую переменную, число преобразуется в логическое значение.

Объект в строковом контексте преобразуется в строку. Cтроку в числовом контексте JavaScript пытается преобразовать в число.

Преобразования «объект-элементарный тип»
Например, в логическом контексте все приведенные ниже объекты преобразуются в true:

New Boolean(false) // Внутреннее значение равно false, но объект
// преобразуется в true
new Number(0)
new String("")
new Array()

Преобразование объектов в числа начинается с вызова метода valueOf() этого объекта. Большинство объектов наследуют стандартный метод valueOf() класса Object, который просто возвращает сам объект. Так как стандартный метод valueOf() не возвращает элементарного значения, JavaScript затем пытается преобразовать объект в число путем вызова его метода toString() и преобразования полученной строки в число. Для массивов это приводит к интересным результатам. Вспомните, что метод toString()преобразует элементы массива в строки, а затем возвращает результат конкатенации этих строк с запятыми между ними. Следовательно, массив без элементов преобразуется в пустую строку, которая преобразуется в 0! Кроме того, если массив состоит из одного элемента, числа n, то массив преобразуется в строковое представление этого числа, которое затем преобразуется обратно в само число n.

Если массив содержит более одного элемента, или если его единственный элемент не является числом, массив преобразуется в NaN. В JavaScript контекст не всегда определяется однозначно! Оператор + и операторы сравнения (и >=) работают как с числами, так и со строками, поэтому когда объект используется с одним из этих операторов, неясно, во что он должен преобразовываться – в число или в строку. В большинстве случаев JavaScript сначала пытается преобразовать объект путем вызова метода valueOf(). Если этот метод возвращает элементарное значение (обычно число), используется это значение. Однако часто valueOf() просто возвращает объект без преобразования; в этом случае JavaScript затем пытается преобразовать объект в строку с помощью вызова метода toString(). Имеется только одно исключение из этого правила преобразования: когда объект Date используется с оператором +, преобразование выполняется с помощью метода toString(). Существование этого исключения обусловлено тем, что Date имеет как метод toString(), так и метод valueOf(). При использовании Date с оператором + почти всегда требуется выполнить строковую конкатенацию. Но когда Date участвует в операциях сравнения, почти всегда требуется выполнить числовое сравнение, для того чтобы определить, какой из двух моментов времени предшествовал другому.

Большинство объектов либо не имеют метода valueOf(), либо этот метод не возвращает полезных результатов.

Когда к объекту применяется оператор +, обычно имеет место строковая конкатенация, а не сложение. Когда к объекту применяется оператор сравнения, обычно выполняется строковое сравнение, а не числовое.

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

И наконец, помните, что метод valueOf() не называется toNumber(), строго говоря, его задача состоит в преобразовании объекта в осмысленное элементарное значение, поэтому некоторые объекты могут иметь методы valueOf(), возвращающие строки.

Явные преобразования типов
Java-Script не определяет оператор преобразования, как в языках C, C++ и Java, но предоставляет сходные средства. В JavaScript 1.1 (и в стандарте ECMA-262) Number(), Boolean(), String() и Object() могут вызываться не только как конструкторы, но и как функции. Будучи вызваны таким образом, эти функции пытаются преобразовать свои
аргументы в соответствующий тип. Например, вы можете преобразовать любое значение x в строку с помощью String(x) и любое значение y в объект с помощью Object(y).

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

Var x_as_string = x + "";

Чтобы преобразовать значение в число, вычтите из него ноль:

Var x_as_number = x - 0;

Принудительно преобразовать какое-либо значение в логическое можно с помощью оператора!, примененного дважды:

Var x_as_boolean = !!x;

Из-за склонности JavaScript к автоматическому преобразованию данных в необходимый в данный момент тип, явные преобразования обычно не требуются. Однако изредка они оказываются полезными, и могут применяться для того, чтобы сделать программу понятнее и точнее.

Преобразование чисел в строки
Преобразование чисел в строки выполняется в JavaScript, возможно, чаще других. Хотя обычно это происходит автоматически, имеется несколько полезных способов явного преобразования этого рода. Два мы уже видели:

Var string_value = String(number); // Использование конструктора String()
// в качестве функции
var string_value = number + ""; // Конкатенация с пустой строкой

Еще одну возможность предоставляет метод toString():

String_value = number.toString();

Метод toString() объекта Number (элементарные числовые значения преобразуются в объекты Number, поэтому вы можете вызвать этот метод) принимает необязательный аргумент, задающий основание системы счисления, в которую будет выполнено преобразование. Если аргумент не указан, преобразование выполняется по основанию 10. Но можно преобразовывать числа и с другими основаниями (между 2 и 36). Например:

Var n = 17;
binary_string = n.toString(2); // Равно "10001"
octal_string = "0" + n.toString(8); // Равно "021"
hex_string = "0x" + n.toString(16); // Равно "0x11"

Недостаток версий JavaScript до версии 1.5 состоит в отсутствии стандартного способа, позволяющего указать количество десятичных знаков в строке, получаемой в результате преобразования числа, или потребовать использования экспоненциальной нотации. Это может усложнить отображение чисел, имеющих традиционные форматы, например денежных значений.

ECMAScript v3 и JavaScript 1.5 обходят это препятствие, добавляя в класс Number три новых метода преобразования числа в строку. Метод toFixed() преобразует число в строку и выводит указанное количество цифр после десятичной точки, не используя экспоненциальной нотации. Метод toExponential() преобразует число в строку, записывая его в экспоненциальной нотации с одной цифрой перед десятичной точкой и указанным количеством цифр после нее. Метод toPrecision() выводит число с помощью указанного количества значащих цифр. Если такого количества значащих цифр недостаточно для вывода целой части числа, оно записывается в экспоненциальной нотации. Обратите внимание, что все три метода корректно округляютфинальные цифры результирующей строки. Посмотрите на следующие примеры:

Var n = 123456.789;
n.toFixed(0); // "123457"
n.toFixed(2); // "123456.79"
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"

Преобразование строк в числа
Мы видели, что в числовом контексте строки, представляющие числа, автоматически преобразуются в реальные числа. Как было показано выше, это преобразование можно сделать явным:

Var number = Number(string_value);
var number = string_value - 0;

Такое преобразование неудобно из-за своей излишней строгости. Оно работает только с десятичными числами, и хотя преобразование допускает ведущие и замыкающие пробелы, оно не допускает наличия в строке каких-либо непробельных символов после числа. Для более гибких преобразований можно применять функции parseInt() и parseFloat(). Эти функции преобразуют и возвращают любое число, присутствующее в начале строки, игнорируя любые замыкающие нечисловые символы. Функция parseInt() обрабатывает только целые, а parseFloat() – как целые числа, так и числа с плавающей точкой. Если строка начинается с «0x» или «0X», parseInt() интерпретирует ее как шестнадцатеричное число. Например:

ParseInt("3 blind mice"); // Возвращает 3
parseFloat("3.14 meters"); // Возвращает 3.14
parseInt("12.34"); // Возвращает 12
parseInt("0xFF"); // Возвращает 255

Функция parseInt() может иметь второй аргумент, указывающий основание системы счисления обрабатываемого числа. Допустимые значения – от 2 до 36. Например:

ParseInt("11", 2); // Возвращает 3 (1*2 + 1)
parseInt("ff", 16); // Возвращает 255 (15*16 + 15)
parseInt("zz", 36); // Возвращает 1295 (35*36 + 35)
parseInt("077", 8); // Возвращает 63 (7*8 + 7)
parseInt("077", 10); // Возвращает 77 (7*10 + 7)

Если parseInt() и parseFloat() не могут преобразовать указанную строку в число, они возвращают NaN.

ParseInt("eleven"); // Возвращает NaN
parseFloat("$72.47"); // Возвращает NaN

Последнее обновление: 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() возвращает строку. Поэтому эту строку нам надо преобразовать в число, чтобы выполнить с ней операции.

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

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