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

Тип данных в JavaScript определяет конкретный тип значения, которое может хранить переменная. Другими словами, тип данных — это просто “вид” значения (т.е. данных), хранящегося в переменной.

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

Тип данных в JavaScript определяет, сколько памяти будет выделено для данных, хранящихся в переменной.

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

Что такое динамические типы данных в JavaScript?

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

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

То есть это не запрещает переменной изменять тип значения во время программирования.

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

Рассмотрим следующие примеры:

var FirstName = "Shubh" // Holding string.
var AccountNumber = 123499 // Holding number.

Как вы видите в приведенном выше коде, переменная var может содержать значения любого типа, такие как строки, числа и т.д. Следовательно, JavaScript рассматривается как “свободно типизированный язык”. Мы можем поместить любые данные в универсальную переменную.

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

var my_var = "Hi Friends!"; // holding string.
  my_var = 25; // same variable holding numeric value.
  my_var = true; // same variable holding boolean value.

Другие языки (Java, C, C++ и т.д.) не позволяют создавать универсальную переменную неопределенного типа. Поэтому такие языки известны как “строго типизированные языки”.

Типы типов данных в JavaScript

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

1. Numbers
2. Strings
3. Booleans
4. Null
5. Undefined
6. Objects
7. Arrays

Первые три типа данных являются примитивными типами данных в JavaScript, поскольку они хранят только отдельные значения. Следующие два называются тривиальными типами данных, а последние два — составными или ссылочными типами данных.

Давайте разберемся с первыми тремя примитивными типами данных в JavaScript на различных примерах программ.

Примитивные типы данных JavaScript

Примитивные типы данных — это набор всех основных строительных блоков, которые представляют данные. Управление ими осуществляется непосредственно с помощью их значений. В JavaScript существует три типа примитивных типов данных.

• Числа
• Строки
• Логическое значение

Примитивные типы данных в JavaScript могут хранить только одно значение внутри связанной переменной. Вместе с данными не могут храниться дополнительные свойства или методы, поскольку они не являются объектами. Все примитивные типы данных, за исключением undefined и null, также имеют объект-оболочку в JavaScript.

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

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

1. Числа:

Числа в JavaScript используются как для представления целых чисел, так и чисел с плавающей запятой. Например, мы можем представить ваш возраст в виде числа. Числа выглядят следующим образом: 1, 23, 10.50, 23.8990 и т.д.

Как и другие языки, такие как C, C ++, Java, язык JavaScript не предоставляет специальных или отдельных типов данных для целых чисел и чисел с плавающей запятой. Он не делает разницы между целочисленными значениями и значениями с плавающей запятой. Он рассматривает все числа как значения с плавающей запятой.

Язык JavaScript представляет числа с использованием 64-разрядного формата с плавающей запятой, определенного стандартом IEEE 754. Давайте рассмотрим очень простой пример программы, в которой мы будем присваивать переменным некоторые числовые значения.

Пример 1:

<script>
      var x1 = 5;
      var x2 = 10;
      var x3 = 15;
      var x4 = 20.25;
     document.write(x1+"<br>"); // It simply prints or display on the current webpage.
     document.write(x2+"<br>");
     document.write(x3+"<br>");
     document.write(x4);
</script>

Вывод:
 5
 10
 15
 20.25

2. Строки:

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

Например, “Hello World!”, “666-2829”, “KA23VABSN” и т.д. Заключение группы символов или строки текста в одинарные или двойные кавычки показывает, что это строка. Например:

var name = "Shubh"; // String.
alert(name); // This will alert "Shubh".

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

var num = "5";
alert(num+num); // This will alert "55".

Мы знаем, что знак плюс (+) используется для сложения чисел. Когда мы будем использовать знак плюс (+) со строками, знак плюс объединяет строки вместе следующим образом:

var firstName = "Shubh";
var lastName = "Deep"
document.write(firstName+lastName); // It will print ShubhDeep.

Если мы добавим число и строку, JavaScript примет число в виде строки. Например:

1. var x = "5";
    var num = "five";
    document.write(x+num); // It will print 5five.

2. var num = 25+30+"five";
    document.write(num); // It will print 55five because JavaScript will treat 25 and 30 as numbers. That’s why it is adding.

3. var num = "five"+20;
    document.write(num); // Print five20.

4. var num = "five"+20+30;
    document.write(num); // Print five2030 because the first operand is a string.
   // Therefore, JavaScript interpreter will consider all operands as strings.

3. Логическое значение:

Мы также можем присвоить переменной логические значения (true или false). JavaScript предоставляет встроенные ключевые слова true и false для определения логических значений, поэтому кавычки не нужны.

Например:

vvar booleanValue = true; // Переменная booleanValue теперь имеет значение true.

Мы часто используем логические значения при условном тестировании. Например, рассмотрим следующие утверждения:

If (num > 18) {
   // do something
}

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

Если значение переменной num больше 18, логическое выражение принимает значение true; в противном случае оно принимает значение false.

Тривиальные типы данных

1. Null:

Null — это еще один специальный тип данных в JavaScript. Он ничего не означает (т. Е. Пустое значение). Он представляет и принимает значение false. Присвоение переменной значения null означает, что она ничего не содержит. Например:

var value = null;
alert(value); // This will open a dialog containing "null".

Не путайте null и пустое значение. Пустое значение отличается от null, которое ничем не отличается. Например, объявление переменной и присвоение ее значения пустой строке выглядит следующим образом:

var myVariable = ' ';

Переменная myVariable пуста, но не null.

2. Не определено:

Undefined — это объявление переменной без значения. Тип также не определен. Например:

var num; // Value is undefined, type is undefined
document.write(num); // It will print undefined.

Здесь есть две строки кода. В первой строке объявляется переменная с именем num. Объявление переменной указывает движку JavaScript выделить пространство памяти, которое мы можем использовать для хранения данных. Поскольку мы не присваиваем никаких данных переменной num, последующая строка вернет значение undefined.

Undefined отличается от null, но и null, и undefined вычисляются одинаково.

Непримитивные типы данных (ссылочные типы данных) в JavaScript

В JavaScript существует три непримитивных типа данных. В JavaScript непримитивные типы данных также называются составными или ссылочными типами данных. Они следующие:

• Объекты
• Массивы
• Функции

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

Давайте разберемся со всеми тремя непримитивными типами данных в JavaScript на примерах программ один за другим.

1. Объекты:

Объекты в JavaScript представляют собой набор свойств, каждое из которых может содержать значение. Мы записываем эти свойства в виде пар имя: значение (или пар ключ: значение), разделенных в JavaScript запятыми.

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

Объекты Javascript создаются с помощью фигурных скобок. Давайте разберемся в них с помощью нескольких примеров.

a) var myObject = { }; // an empty object.

b) An object with several properties:
    var person = {
                     firstName: "Ivaan",
                     lastName: "Sagar",
                     age: 04,
                     eyeColor: "blue",
                     hairColor: "black"
                  };

В предыдущем примере кода создается объект с именем person, который имеет пять свойств: имя, фамилия, возраст, цвет глаз и цвет волос. Значения, содержащиеся в каждом свойстве, — Ivaan, Sagar, 04, blue и black соответственно.

Оператор.используется для доступа к свойству объекта. Например, мы можем получить доступ к свойству LastName объекта person следующим образом:

document.write(person.lastName); // It will print Sagar.

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

Пример 2:

<script>
var person = {
               firstName: "Ivaan",
               lastName: "Sagar",
               age: 04,
               eyeColor: "blue",
               hairColor: "black"
    };
  document.write("Full name: " +person.firstName+" " +person.lastName+ "<br>");
  document.write("Age: " +person.age +"<br>");
  document.write("Eye color: " +person.eyeColor+ "<br>");
  document.write("Hair color: " +person.hairColor)
</script>

Выходные данные:
 Полное имя: Иваан Сагар
 Возраст: 4 года
 Цвет глаз: голубой
 Цвет волос: черный

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

2. Массивы:

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

Следовательно, индекс 0 содержит первый элемент, индекс 1 содержит второй элемент, индекс 2 содержит третий элемент и так далее. Мы записываем массив в квадратных скобках ([ ]) в JavaScript. Элементы в массиве должны разделяться запятыми.

Давайте разберемся в этом с помощью примера программы.

Пример 3:

<script>
 var num = [20, 40, 50];
 document.write(nums[0], "<br>");
 document.write(nums[1], "<br>");
 document.write(nums[2]);
</script>

Вывод:
 20
 40
 50

Мы узнаем больше о массивах позже, в следующем руководстве.

3. Функции:

Функция — это блок кода JavaScript, который записывается один раз и выполняется, когда “кто-то” его вызывает. JavaScript предоставляет некоторые предопределенные функции, и мы также можем определить нашу собственную функцию, называемую пользовательскими функциями.

Определение функции выглядит следующим образом:

function sum(x, y) {
     return x+y;
}

Мы узнаем больше о типах данных функций в главе о функциях JavaScript.

Оператор Typeof в JavaScript

Оператор typeof в JavaScript используется для поиска типа переменной JavaScript. Он возвращает тип переменной или выражения.

Давайте разберемся в этом с помощью примера программы.

Пример 4:

<script>
  var x = 20;
  var name = "Ivaan";
  document.write(typeof 20+ "<br>");
  document.write(typeof "name");
</script>

Вывод: 
число 
 строка

Выделение памяти для примитивных значений

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

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

Когда мы присваиваем значение переменной, интерпретатор определяет, является ли это примитивным или нет (т.е. Ссылочным) значением. Если это значение примитивного типа, интерпретатор сохраняет его в небольшой области памяти, известной как стек, поскольку значения примитивных типов данных занимают фиксированный объем памяти. Однако во многих языках, таких как Java, строки считаются ссылочным типом данных, а не примитивным типом данных, поскольку длина строки может различаться.

Посмотрите на приведенный ниже рисунок, как JavaScript выделяет место в памяти для различных типов данных.

Выделение памяти для непримитивных (ссылочных) значений

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

Ссылочные значения не могут храниться в стеке, потому что у них нет фиксированных размеров. Они могут увеличиваться в размере. Адрес памяти имеет фиксированный размер, поэтому его можно легко разместить в памяти стека. Значение, помещенное в пространство стека, на самом деле является адресом местоположения в куче, где хранится объект.

Другими словами, переменная, которую вы используете для хранения объекта, на самом деле содержит не сам объект, а скорее ссылку (адрес памяти) на местоположение в куче, где хранятся данные объекта. Эта ссылка указывает на данные объекта, позволяя переменной косвенно обращаться к объекту и манипулировать им.

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

На приведенном выше рисунке показаны несколько значений примитивных типов данных, хранящихся в стеке. Каждая переменная примитивного типа данных обычно занимает определенный объем памяти, и к ней осуществляется прямой доступ.

Когда в стеке есть адрес памяти, он действует как указатель, указывающий на объект, расположенный в памяти кучи. Доступ к куче осуществляется не последовательно, поскольку объект может занимать разное количество места в памяти. Они могут динамически расширяться или сжиматься.