Какой тип имеет переменная f

Типы данных

Значение в JavaScript всегда относится к данным определённого типа. Например, это может быть строка или число.

Есть восемь основных типов данных в JavaScript. В этой главе мы рассмотрим их в общем, а в следующих главах поговорим подробнее о каждом.

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

// Не будет ошибкой let message = "hello"; message = 123456;

Языки программирования, в которых такое возможно, называются «динамически типизированными». Это значит, что типы данных есть, но переменные не привязаны ни к одному из них.

Число

let n = 123; n = 12.345;

Числовой тип данных ( number ) представляет как целочисленные значения, так и числа с плавающей точкой.

Существует множество операций для чисел, например, умножение * , деление / , сложение + , вычитание — и так далее.

Кроме обычных чисел, существуют так называемые «специальные числовые значения», которые относятся к этому типу данных: Infinity , -Infinity и NaN .

Infinity представляет собой математическую бесконечность ∞. Это особое значение, которое больше любого числа. Мы можем получить его в результате деления на ноль:

alert( 1 / 0 ); // Infinity

Или задать его явно:

alert( Infinity ); // Infinity

alert( "не число" / 2 ); // NaN, такое деление является ошибкой

Значение NaN «прилипчиво». Любая математическая операция с NaN возвращает NaN :

alert( NaN + 1 ); // NaN alert( 3 * NaN ); // NaN alert( "не число" / 2 - 1 ); // NaN

Математические операции – безопасны

Математические операции в JavaScript «безопасны». Мы можем делать что угодно: делить на ноль, обращаться с нечисловыми строками как с числами и т.д.

Скрипт никогда не остановится с фатальной ошибкой (не «умрёт»). В худшем случае мы получим NaN как результат выполнения.

Специальные числовые значения относятся к типу «число». Конечно, это не числа в привычном значении этого слова.

Подробнее о работе с числами мы поговорим в главе Числа.

BigInt

В JavaScript тип number не может безопасно работать с числами, большими, чем (2 53 -1) (т. е. 9007199254740991 ) или меньшими, чем -(2 53 -1) для отрицательных чисел.

Если говорить совсем точно, то, технически, тип number может хранить большие целые числа (до 1.7976931348623157 * 10 308 ), но за пределами безопасного диапазона целых чисел ±(2 53 -1) будет ошибка точности, так как не все цифры помещаются в фиксированную 64-битную память. Поэтому можно хранить «приблизительное» значение.

Например, эти два числа (прямо за пределами безопасного диапазона) совпадают:

console.log(9007199254740991 + 1); // 9007199254740992 console.log(9007199254740991 + 2); // 9007199254740992

То есть все нечетные целые числа, большие чем (2 53 -1) , вообще не могут храниться в типе number .

В большинстве случаев безопасного диапазона чисел от -(2 53 -1) до (2 53 -1) вполне достаточно, но иногда нам требуется весь диапазон действительно гигантских целых чисел без каких-либо ограничений или пропущенных значений внутри него. Например, в криптографии или при использовании метки времени («timestamp») с микросекундами.

Тип BigInt был добавлен в JavaScript, чтобы дать возможность работать с целыми числами произвольной длины.

Чтобы создать значение типа BigInt , необходимо добавить n в конец числового литерала:

// символ "n" в конце означает, что это BigInt const bigInt = 1234567890123456789012345678901234567890n;

Так как необходимость в использовании BigInt –чисел появляется достаточно редко, мы рассмотрим их в отдельной главе BigInt. Ознакомьтесь с ней, когда вам понадобятся настолько большие числа.

В данный момент BigInt поддерживается только в браузерах Firefox, Chrome, Edge и Safari, но не поддерживается в IE.

Строка

Строка ( string ) в JavaScript должна быть заключена в кавычки.

let str = "Привет"; let str2 = 'Одинарные кавычки тоже подойдут'; let phrase = `Обратные кавычки позволяют встраивать переменные $`;

В JavaScript существует три типа кавычек.

1. Двойные кавычки: «Привет» .
2. Одинарные кавычки: ‘Привет’ .
3. Обратные кавычки: `Привет` .

Двойные или одинарные кавычки являются «простыми», между ними нет разницы в JavaScript.

Обратные же кавычки имеют расширенную функциональность. Они позволяют нам встраивать выражения в строку, заключая их в $ . Например:

let name = "Иван"; // Вставим переменную alert( `Привет, $!` ); // Привет, Иван! // Вставим выражение alert( `результат: $` ); // результат: 3

Выражение внутри $ вычисляется, и его результат становится частью строки. Мы можем положить туда всё, что угодно: переменную name , или выражение 1 + 2 , или что-то более сложное.

Обратите внимание, что это можно делать только в обратных кавычках. Другие кавычки не имеют такой функциональности встраивания!

alert( "результат: $" ); // результат: $ (двойные кавычки ничего не делают)

Мы рассмотрим строки более подробно в главе Строки.

Нет отдельного типа данных для одного символа.

В некоторых языках, например C и Java, для хранения одного символа, например «a» или «%» , существует отдельный тип. В языках C и Java это char .

В JavaScript подобного типа нет, есть только тип string . Строка может содержать ноль символов (быть пустой), один символ или множество.

Булевый (логический) тип

Булевый тип ( boolean ) может принимать только два значения: true (истина) и false (ложь).

Такой тип, как правило, используется для хранения значений да/нет: true значит «да, правильно», а false значит «нет, не правильно».

let nameFieldChecked = true; // да, поле отмечено let ageFieldChecked = false; // нет, поле не отмечено

Булевые значения также могут быть результатом сравнений:

let isGreater = 4 > 1; alert( isGreater ); // true (результатом сравнения будет "да")

Мы рассмотрим булевые значения более подробно в главе Логические операторы.

Значение «null»

Специальное значение null не относится ни к одному из типов, описанных выше.

Оно формирует отдельный тип, который содержит только значение null :

let age = null;

В JavaScript null не является «ссылкой на несуществующий объект» или «нулевым указателем», как в некоторых других языках.

Это просто специальное значение, которое представляет собой «ничего», «пусто» или «значение неизвестно».

В приведённом выше коде указано, что значение переменной age неизвестно.

Значение «undefined»

Специальное значение undefined также стоит особняком. Оно формирует тип из самого себя так же, как и null .

Оно означает, что «значение не было присвоено».

Если переменная объявлена, но ей не присвоено никакого значения, то её значением будет undefined :

let age; alert(age); // выведет "undefined"

Технически мы можем присвоить значение undefined любой переменной:

let age = 123; // изменяем значение на undefined age = undefined; alert(age); // "undefined"

…Но так делать не рекомендуется. Обычно null используется для присвоения переменной «пустого» или «неизвестного» значения, а undefined – для проверок, была ли переменная назначена.

Объекты и символы

Тип object (объект) – особенный.

Все остальные типы называются «примитивными», потому что их значениями могут быть только простые значения (будь то строка, или число, или что-то ещё). В объектах же хранят коллекции данных или более сложные структуры.

Объекты занимают важное место в языке и требуют особого внимания. Мы разберёмся с ними в главе Объекты после того, как узнаем больше о примитивах.

Тип symbol (символ) используется для создания уникальных идентификаторов в объектах. Мы упоминаем здесь о нём для полноты картины, изучим этот тип после объектов.

Оператор typeof

Оператор typeof возвращает тип аргумента. Это полезно, когда мы хотим обрабатывать значения различных типов по-разному или просто хотим сделать проверку.

У него есть две синтаксические формы:

// Обычный синтаксис typeof 5 // Выведет "number" // Синтаксис, напоминающий вызов функции (встречается реже) typeof(5) // Также выведет "number"

Если передается выражение, то нужно заключать его в скобки, т.к. typeof имеет более высокий приоритет, чем бинарные операторы:

typeof 50 + " Квартир"; // Выведет "number Квартир" typeof (50 + " Квартир"); // Выведет "string"

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

Вызов typeof x возвращает строку с именем типа:

typeof undefined // "undefined" typeof 0 // "number" typeof 10n // "bigint" typeof true // "boolean" typeof "foo" // "string" typeof Symbol("id") // "symbol" typeof Math // "object" (1) typeof null // "object" (2) typeof alert // "function" (3)

Последние три строки нуждаются в пояснении:

1. Math — это встроенный объект, который предоставляет математические операции и константы. Мы рассмотрим его подробнее в главе Числа. Здесь он служит лишь примером объекта.
2. Результатом вызова typeof null является «object» . Это официально признанная ошибка в typeof , ведущая начало с времён создания JavaScript и сохранённая для совместимости. Конечно, null не является объектом. Это специальное значение с отдельным типом.
3. Вызов typeof alert возвращает «function» , потому что alert является функцией. Мы изучим функции в следующих главах, где заодно увидим, что в JavaScript нет специального типа «функция». Функции относятся к объектному типу. Но typeof обрабатывает их особым образом, возвращая «function» . Так тоже повелось от создания JavaScript. Формально это неверно, но может быть удобным на практике.

Итого

В JavaScript есть 8 основных типов данных.

• Семь из них называют «примитивными» типами данных:
  • number для любых чисел: целочисленных или чисел с плавающей точкой; целочисленные значения ограничены диапазоном ±(2 53 -1) .
  • bigint для целых чисел произвольной длины.
  • string для строк. Строка может содержать ноль или больше символов, нет отдельного символьного типа.
  • boolean для true / false .
  • null для неизвестных значений – отдельный тип, имеющий одно значение null .
  • undefined для неприсвоенных значений – отдельный тип, имеющий одно значение undefined .
  • symbol для уникальных идентификаторов.
  • object для более сложных структур данных.

  Оператор typeof позволяет нам увидеть, какой тип данных сохранён в переменной.

  • Имеет две формы: typeof x или typeof(x) .
  • Возвращает строку с именем типа. Например, «string» .
  • Для null возвращается «object» – это ошибка в языке, на самом деле это не объект.

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

  Какой тип имеет переменная f

  Переменные. Оператор присваивания.

  Понятие переменной величины вам известно из математики.

  Пусть несколько лет назад ваш рост равнялся 1 50 см. Обозначим этот факт так: r = 1 50 . Теперь он равен 160 см, то есть r = 160.

  Получает­ ся, что величина г изменилась. Поэтому она называется переменной величиной.

  Числа 1 50 и 160 называются значениями переменной ве личины r .

  Любой язык программирования умеет обращаться с переменными величинами.

  Прежде всего, мы можем задавать компьютеру значение той или иной переменной величины.

  Это мы можем сделать при помощи оператора, который называется оператором присваива ния.

  Так, если мы хотим сказать, что а имеет значение 6, то должны просто записать а = 6.

  Эта запись и называется оператором присваива ния. Говорят, что величине а присваивается значение 6.

  С момента выполнения оператора а = 6 компьютер будет помнить, что а равно шести.

  После выполнения следующего фрагмента программы:

  компьютер будет знать, что а равно 16, b равно 16, у равно 33. Итак, при помощи оператора присваивания вы можете и вычислять.

  Мы ви дим, что справа от знака равенства в операторе присваивания можно писать не только числа, но и переменные величины, и выражения.

  Выражения в Visual Basic могут быть разных типов .

  Здесь это были 4* 3 + 4, а, а + b + 1. Любое ариф метическое выражение имеет численное значение.

  Теперь чуть-чуть о свойствах объектов. Выражение может вклю чать в себя не только переменные величины,

  но и свойства объектов, имеющие подходящее значение. Например, Y = a + b + Form 1. Width

  В левой части оператора присваивания также может стоять не только переменная, но и свойство объекта.

  Например, Form 1. Width = а + b + у. В последнем случае действие этого оператора вы сразу увидите на экране.

  Необходимо помнить, что если слева от знака равенства стоит переменная величина, то Visual Basic выполняет оператор присваивания «в

  уме». Имеется в виду, что результат его выполнения не отображает­ся на экране, а только запоминается. Как же увидеть значение

  пере менной величины?

  Создайте в проекте текстовое поле и дополните программу последнего примера:

  t = 0 : n = 2* t +40 : z = — n : Text 1. Text = z Теперь значение величины z , равное -40, вы будете видеть в тексто­ вом поле.

  Нужно иметь в виду, что оператор присваивания слева от знака равенства не может стоять число или выражение. Можно писать f=45 , но не наоборот. Можно писать d=f+t+9*g , но не наоборот.

  Объявление переменных величин.

  Переменные необходимо объявлять, то есть задать тип переменной (см. таблицу 1). Для того, чтобы Visual Basic понял, число перед ним, строка или другой тип переменной. Иначе программа может работать неправильно. Как объявлять переменные?

  Dim f As Integer

  Dim stro_ka As String

  Dim m1 As Boolean

  Dim имя_переменной As Byte

  то есть переменная f имеет тип integer, переменная stro_ka имеет тип string , переменная m1 имеет тип boolean.

  Переменные пока можно объявлять в самом начале программы. Затем рассмотрим другие способы объявления переменных.

  Символы, которые НЕЛЬЗЯ использовать в именах переменных:

  пробел, специальные слова (команды), начинать переменную с цифры.

  Задача: Сложить числа и слова в двух текстовых полях.

  Решение: Создать шесть текстовых полей, надпись( Label ) и кнопку так, как показано на рисунке:

  

  Dim slovo1 As String
  Dim slovo2 As String
  Dim a As Integer
  Dim b As Integer
  Private Sub Command1_Click()
  a = Text1.Text ‘ переменной а присваиваем значение, введенное вами в первое текстовое поле
  b = Text2.Text ‘ переменной b присваиваем значение, введенное вами во второе текстовое поле
  slovо1 = Text3.Text ‘ переменной slovo1 присваиваем значение, введенное вами в третье текстовое поле
  slovo2 = Text4.Text ‘ переменной slovo2 присваиваем значение, введенное вами в четвертое текстовое поле
  Text5.Text = a + b ‘ в текстовое поле 5 печатаем результат сложения числовых переменных
  Text6.Text = slovo1 + slovo2 ‘ в текстовое поле 5 печатаем результат сложения числовых переменных

  А теперь попробуйте ввести числа в текстовые поля 3 и 4. Например 21 и 11, в текстовом поле 6 получится не 32, а 2111. Так произошло потому что в этих текстовых полях строковые переменные, а не числовые, а строки складываются только таким способом.

  Действия арифметики обозначаются в Visual Basic следующим об­ разом:

  Действие	Результат	Смысл
  2 +3	5	Плюс
  4 — 1	3	Минус
  2 * 3	6	Умножить
  10 / 2	5	Разделить
  17 \ 5	3.	Целочисленное деление (17 делится на 5, получается 3, в остатке 2)
  17 Mod 5	2	Остаток от целочисленного деления
  2 ^ 3	8	2 3 (два в кубе) — возведение в степень

  Действие	Результат	Смысл
  Sqr(25)	5	Корень квадратный
  Round (5.82716)	6	Округление до целых
  Round (5.82716,3)	5.827	Округление до трех знаков после точки
  Abs(-20)	20	Абсолютная величина (модуль) числа
  Fix (3.98)	3	Целая часть числа (дробная часть отбрасывается)
  Fix (-3.98)	-3
  Int (3.98)	3	Наибольшее целое число, не превышающее вы ражения в скобках
  Int (-3.98)	-4
  Rnd	0.73088	Случайное число из диапазона (0-1)

  Кроме того, имеются функции Sin , Cos , Tan (тангенс), Atn (арктан­ генс), Exp , Log и др.

  На уроках математики мы привыкли писать ab + cd , подразумевая: а умножить на b плюс с умножить на d . В Visual Basic это выражение мы обязаны писать так: а * b + с * d . Иначе компьютер подумает, что нужно к переменной, имеющей имя ab , прибавить переменную, имеющую имя cd . Во избежание двусмысленности знак умножения положено писать всегда, в том числе и перед скобками. Например, а*( b + с).

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

  a + 1

  b + 1

  очень затруднен. Поэтому для обозначения деления и выбрана косая черта. Это выражение на Visual Basic положено записывать так: (а+1)/( b +1). Если бы мы не поставили скобки, то выражение получилось бы таким: а + 1/ b + 1, а это неправильно, так как компьютер, как и мы, всегда перед сложением и вычитанием выполняет умножение и деле ние; поэтому в последнем случае он бы сначала разделил 1 на b , а затем к результату прибавил а и 1.

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

  Все типы переменных:

  Вопрос 6 — ГДЗ по Информатике 8 класс Учебник Босова. Параграф 3.2

  

  

  На этой странице рассмотрим все ответы на Вопрос 6 из учебника по информатике 8 класс Босова
  6. Какой тип имеет переменная f, если после выполнения оператором write (f) на экран было выведено следующее число?
  а) 125
  б) 1.25Е+2

  Параграф 1.1

  Параграф 1.2

  Параграф 1.3

  Типы данных в Kotlin

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

  fun main() { val s = "Hello" val i = 2 var f = 1.34 println(s) println(i + f) // выведет 3.34 }

  Kotlin относится к языкам со статической типизацией. Это значит, что у переменных есть тип, и его нельзя поменять. Их тип статичен, то есть постоянен. Например, если в приведенном выше коде мы попробуем присвоить переменной f новое значение, которое не является вещественным числом, то встроенный в IntelliJ IDEA анализатор кода сообщит об ошибке. Если мы проигнорируем и попытаемся скомпилировать проект, на ту же самую ошибку укажет уже компилятор.

  

  В данном случае ошибка гласит «The integer literal does not conform to the expected type Double», что можно перевести как «Целочисленный литерал не подходит к ожидаемому типу Double». Double – это один из типов вещественных чисел. Литералами в программировании называют известные значения простых типов. IntelliJ IDEA предлагает нам исправить ошибку путем присваивания литерала 10.0 – вещественного числа с нулевой дробной частью. Однако обратим внимание на другое.

  Мы нигде не указывали, что переменная f должна быть типом Double . Почему же ее посчитали таковой? На самом деле мы указали ее тип, но не явно. Тип переменной был выведен из присвоенного ей инициирующего (начального) значения. Компилятор посмотрел на число 1.34 и определил, что оно типа Double . А поскольку мы его присваиваем в том же выражении, в котором объявляем переменную, он сделал вывод, что переменная f должна быть соответствующего типа. Аналогично произошло и с другими переменными – их тип определился как String и Int . В IntelliJ IDEA чтобы увидеть тип переменной, надо установить на нее курсор и нажать Ctrl + Shift + P .

  

  В большинстве других языков со статической типизацией нет таких умных компиляторов, способных выводить тип переменной, исходя из ее значения. Поэтому там тип задается явно. Мы можем явно задавать тип и в Kotlin. Однако, если присваивание идет сразу, это излишне. А вот если нет, тогда явное задание типа – единственный вариант объявления переменной.

  import kotlin.random.Random fun main() { val s: String = "number: " val i: Int = Random.nextInt(1,10) val f: Double if (i > 5) f = i * 1.5 else f = i * 2.0 println(s + i) println(f) }

  

  Рассмотрим подробно приведенную выше программу. В Kotlin объявление переменной с явным указанием типа имеет такой синтаксис:

  

  Переменной s сразу присваивается значение, по которому можно вывести ее тип. Поэтому явно ее тип можно было бы не указывать, о чем сообщает IntelliJ IDEA окрашивая излишества в серый цвет.

  Переменной i также сразу присваивается значение, и ее тип Int можно было бы не указывать. Но, видимо, поскольку значение определяется выражением, а не литералом, среда не считает лишним явное указание типа переменной. Так код яснее.

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

  Выражение Random.nextInt(1, 10) генерирует случайное целое число от 1 до 9 включительно. Слова from и until , которые вы видите на изображении, не пишутся. Их высвечивает среда для удобства, чтобы было понятно, какие параметры определены в функции nextInt .

  Функция-метод nextInt принадлежит объекту Random , который мы импортируем из стандартной библиотеки Kotlin выражением import kotlin.random.Random . Слово kotlin – это имя библиотеки, random – имя пакета в ней. Пакет – это подкаталог, находящийся в каталоге kotlin , а Random – это объект, находящийся в одном из файлов пакета random . Там запрограммирована логика работы функции nextInt . Чтобы пользоваться этой функцией, понимать принцип ее работы нам не обязательно. Достаточно знать, что в нее передается, и что она возвращает.

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

  

  В списке автодополнения надо выбрать то, что вам надо, и нажать Enter . Если же импорта не произошло (так бывает при вставке готового куска кода), то IntelliJ IDEA выделяет неизвестные объекты красным цветом. Надо установить курсор в выделенное слово и навести на него указатель мыши, после чего появится сообщение, предлагающее выполнить импорт нажатием Alt + Enter .

  

  Ниже объявления переменных в программе используется условный оператор if-else , который будет изучаться позже. Пока достаточно знать, что если значение i больше 5, то f будет присвоено значение i , умноженное на 1.5, во всех остальных случаях – умноженное на 2.

  Цель этого примера показать, что первое значение переменной не обязательно присваивать сразу. Бывают ситуации, когда это происходит позже в коде. Конечно, можно там же и объявить переменную. Однако придание программному коду структуры, объявление всех используемых переменных в начале делает код более понятным. Такой код легче понимать и обслуживать.

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

  

  Булевый, символьный и строковый типы представлены каждый одним классом (не считая типов с поддержкой null , которые мы не будем здесь рассматривать). Соответственно, Boolean , Char и String . Для чисел и массивов существует множество классов.

  Так классы чисел в первую очередь подразделяются на целочисленные и вещественные. Основными классами целых являются Byte , Short , Int и Long . Вещественных классов два – Float и Double . Предел значений типа Byte – от -128 до 127 включительно, типа Long – девятнадцатизначное число. Float вмещает меньшую длину дробной части по-сравнению с Double .

  Когда вы присваиваете целое или вещественное значение без явного объявления типа, они будут автоматически определены как Int или Double . Однако если целое число выходит за диапазон типа Int , лежащий в границах от -2147483648 до 2147483647, то для переменной устанавливается тип Long .

  У литералов типа Float в конце обязательно должна стоять буква F или f . К литералам типа Long можно приписывать букву L .

  

  Значениями переменных символьного типа Char являются отдельно взятые символы. Для обозначения символьного литерала используются одинарные кавычки.

  fun main() { val ch = 'w' val uniChar: Char = '\u27F0' println(ch) println(uniChar) }

  

  Символы можно выражать через их шестнадцатеричный код по таблице символов Юникод. Так в примере выше в литерале обратный слэш ( \ ) и буква u говорят, все что далее следует интерпретировать как код символа ( 27F0 ). С помощью таких кодов можно выводить символы, которых нет на клавиатуре, в том числе весьма причудливые.

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

  Переменные булевого, или логического, типа могут принимать всего два значения. Либо true , либо false . Либо истина, либо ложь. Значения булевого типа возвращаются в результате выполнения логических выражений – обычно сравнения чего-то с чем-то, когда ответ может быть только «да» или «нет». Мы использовали одно из таких логических выражений выше в условном операторе if-else , когда сравнивали значение переменной i с числом 5.

  import kotlin.random.Random fun main() { val b1: Boolean = true val b2 = false val i = Random.nextInt(10) val b3 = i > 5 println(i) println(b3) println(b1 > b2) }

  

  В примере переменные b1 , b2 и b3 имеют тип Boolean . Переменная i содержит случайное число от 0 до 9 включительно. Значение b3 зависит от значения i . Если значение i больше пяти, то b3 будет присвоено true , иначе – false .

  В программировании истина больше лжи. Поэтому выражение b1 > b2 возвращает истину. Здесь следует обратить внимание, что сравнивать мы можем не только числа, но и объекты других типов. А вот принцип, согласно которому происходит сравнение, определяется предусмотренным для этого кодом, который находится в классе, которому принадлежит данный объект.

  Так, если попробуем сравнить две строки, то они будут сравниваться лексикографически – по буквам, а не, скажем, по длине. В примере ниже, вторая буква строки «acd» больше, чем вторая буква строки «abcd», так как ‘c’ стоит дальше от начала алфавита, чем ‘b’, и имеет больший соответствующий ей числовой код.

  fun main() { println("acd" > "abcd") // выведет true }

  Практическая работа:

  1. Используя функцию nextDouble() объекта Random , напишите код, выводящий на экран случайное вещественное число от 0 до 1, а также случайное вещественное от -2 до 2.
  2. Разные типы данных занимают разный объем памяти. С помощью свойства SIZE_BYTES выведите на экран размер, который выделяется под каждый экземпляр целочисленных типов данных. Пример: println(Int.SIZE_BYTES) .
  3. Какой результирующий тип данных получится при сложении целого и вещественного числа, двух целых разных типов, «сложении» числа и строки?

  X Скрыть Наверх

  Kotlin с нуля. Курс для начинающих

  Похожие публикации:

  1. Как в outlook настроить автоматическое получение почты
  2. Как называют в композиции объектов способ повторного использования
  3. Почему взрывается баллон с кислородом
  4. Что такое цикл в программировании