Введение в типы данных: статические, динамические, сильные и слабые

Введение в типы данных статические, динамические, сильные и слабые Изучение

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

Что такое типы данных?

Если вы занимались программированием, вы наверняка видели переменные, параметры или значения, возвращаемые функциями. Они повсюду в мире программирования. Многие программисты начинают их использовать, даже не зная, что они задают компьютеру под капотом. При определении этих значений программист указывает компьютеру, как будет называться переменная, но также сообщает компьютеру, какой это тип данных. Это целое число? Это строка символов? Это одиночный символ или сложный тип, такой как a Point? Чтобы понять типы данных, нам может быть проще перевернуть термин и подумать о нем как о «типе данных», с которым мы имеем дело.

Если вы просмотрели информацию в Интернете, вы могли прочитать противоречивую информацию о «статических» и «динамических» типах данных, а также о «сильных» и «слабых» типах данных. Это не одно и то же. Когда мы будем рассматривать различные термины ниже, имейте в виду, что язык может включать комбинацию статических / динамических и сильных / слабых типов данных. Они не эксклюзивны. Например, язык может быть статичным и сильным или статичным и слабым. Но прежде чем мы зайдем слишком далеко в определение этих терминов, зачем нам вообще это волновать?

Почему мы должны заботиться о типах данных?

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

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

  • У вас будут более эффективные программы, которые лучше используют память и хранилище. Зная, что массив целых чисел занимает меньше места, чем массив чисел типа double, можно сэкономить килобайты или даже мегабайты при работе с очень большими массивами в памяти или на жестком диске.
  • Это поможет вам расшифровать отладочные сообщения и лучше понять проблемы, связанные с типами данных. Когда программа жалуется, что не может сложить два числа, потому что одно из чисел является строкой, вы понимаете, почему. Знание этого факта поможет вам избежать ошибки при попытке добавить число к строке с самого начала.
  • Зная, как работают шрифты, вы можете быть похожи на Нео из фильма «Матрица» и знать, как нарушать правила. При добавлении целого числа к символу вы узнаете, как получить другого персонажа и почему это работает.

Статические и динамические системы ввода данных

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

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

int myNumber = 42;              // integer data type
string name = "Rocky Balboa";   // string data type
final double PI = 3.141592;     // double data type

// Function takes two integer data types, returns an integer data type
public int add(int a, int b) {
    return a + b;
}

В приведенном выше примере показано несколько определяемых переменных и пример функции, которая складывает два числа. Как видите, мы явно сообщаем языку (в данном случае Java), что имеем дело с целыми числами, строками и числами типа double. Без этих подсказок компилятору он не знал бы, как лечить myNumber. Это просто имя, которое имеет смысл для нас, а не для компьютера.

Некоторые языки со статической типизацией включают Java, C #, C ++ и Go. Но это лишь некоторые из многих.

Давайте сравним это с языком динамической типизации данных. Ниже приведен пример:

$myNumber = 42;           // integer data type
$name = "Rocky Balboa";   // string data type
$PI = 3.141592;           // float data type

// Function takes two integer data types, returns an integer data type
function add($a, $b) {
    return $a + $b;
}

Итак, куда делись все типы? В этом примере выше мы видим, что наши переменные в PHP, языке с динамической типизацией, явно не говорят, к какому типу данных они относятся. Если мы не сообщаем PHP типы данных, как он узнает? Что ж, он угадывает, основываясь на присвоенном ему значении. Он может правильно угадать, что $myNumberэто целое число, потому что значение 42 является целым числом.

Читайте также:  Изучение Vite через его исходный код

А как насчет функции? Он тоже делает предположение на основе переданных ему значений. Это означает, что он add()может принимать два целых числа и возвращать целое число или также может принимать два числа с плавающей запятой и возвращать одно число. Типы предполагаются и могут даже меняться во время выполнения. Позже мы могли бы в той же программе сказать, что $myNumberэто равно, Tomи это позволит нам преобразовать переменную в строку.

Некоторые из многих языков, которые являются динамическими, включают JavaScript, PHP, Python и Ruby.

Почему вы предпочитаете статику динамической или наоборот?

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

Итак, статика — это правильный путь? Что ж, компромисс в том, что вы должны явно определить все, прежде чем использовать его. Вам нужно ввести больше кода, вы должны заранее знать тип данных, с которыми вы имеете дело (не всегда то, что вы знаете), и вы должны знать, что будет происходить в ваших операциях. Вы должны знать, что 1 / 3даст вам, 0а не.33333и тому подобное.

Динамические языки дают вам дополнительную гибкость в этой области. Программисты часто описывают их как «более выразительные». В PHP, например, вы получите то,.3333…что и ожидали. Однако проблема в том, что если интерпретатор ошибается в типах данных, вы должны знать об этом. В противном случае он может проскользнуть мимо. Поскольку мы не можем уловить все, код на динамических языках имеет тенденцию быть немного более подверженным ошибкам и нестабильным. Типы данных в этих динамических языках обычно определяются во время выполнения. Это затрудняет обнаружение многих ошибок, пока они не попадут в производственную среду. Он может нормально работать на вашей локальной машине разработки, но производственная среда выполнения может немного отличаться, что приведет к различным предположениям интерпретатора.

JavaScript — это язык, который считается динамическим. С введением TypeScript, надмножества JavaScript, программисты представили идею явного объявления типов данных для переменных, чтобы сделать язык более статичным. По мере роста популярности JavaScript — даже за пределами браузера с такими инструментами, как Node.js — программисты хотели добавить преимущества статической типизации данных, чтобы исключить некоторые неправильные предположения, которые JavaScript делает при работе с типами данных. JavaScript печально известен своими неверными догадкамипри работе с данными и их типами. Это пример превращения JavaScript, динамического языка, в нечто большее, чем язык со статической типизацией, для раннего обнаружения ошибок и создания более здорового кода. Это тем более важно, учитывая, что JavaScript проникает в серверные приложения с помощью Node.js.

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

Сильные и слабые системы ввода данных

Как кратко упоминалось ранее, термины сильных и слабых типов данных часто путают со статическими и динамическими. Люди склонны смешивать статичность как синоним сильного и динамичного как слабого. Это не тот случай.

Сильные / слабые типы данных — это то, как язык обрабатывает значения, с которыми он оперирует. Будет ли язык незаметно делать какие-то предположения при работе с типами данных и помогать вам, или он просто остановится и пожалуется, что не знает, что делать? Давайте посмотрим на пример того, как это работает:

int main() {
    int a = 5;
    std::string b = "5";

    // Houston, we have a problem!
    std::cout << (a + b);
    return ;
}

В этом примере C ++ мы пытаемся сложить целое число и строку. Да, язык статически типизирован, но он не пытается скрыть для программиста bцелое число, чтобы он мог сложить два числа вместе. Он просто сразу помечает проблему и отказывается. Эта проверка выполняется, когда мы пытаемся скомпилировать программу (или иногда IDE, когда вы ее пишете). Здесь мы пытаемся использовать тип таким образом, который противоречит его определению как строка. Строго типизированные языки включают в некоторой степени C #, Java, Go, Python и C ++, и все они помечают что-то подобное.

Теперь у C ++ есть способы ослабить свою строго типизированную систему, но это выходит за рамки данной статьи. Мы рассмотрим слабые типы данных, а затем поговорим о сильных / слабых вместе и о том, что все не так четко, как статическая / динамическая типизация.

Слабые языки с типизированными данными пытаются помочь программисту в выполнении своих операций. Давайте взглянем на JavaScript и посмотрим, как он может выполнять операцию, аналогичную той, что мы сделали в нашем примере на C ++ выше:

const a = 5;
const b = "5";

console.log((a + b));

Если вы знаете что-нибудь о JavaScript и его особенностях, вы знаете, что приведенный выше код будет работать без проблем. Программисту это ни на что не укажет. Но он не выведет 10 на консоль, как вы могли ожидать. Вы могли подумать, что он увидит целое число и строку и скажет: «Ого, подожди минутку, я не знаю, что с этим делать!» Вместо этого JavaScript пытается принудить или преобразовать одно из значений, чтобы оно было похоже на другое, выполнить вычисление, дать результат и двигаться дальше. Здесь результат будет, «55»поскольку он преобразует значение переменной aв строку, а затем объединяет их. Результатом будет строковый тип данных.

Читайте также:  Шпаргалка по Big-O Notation: быстрые ответы на вопросы Big-O

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

Используя эти термины, мы можем сказать, что такой язык, как Python, который является динамическим, также является строго типизированным. Вам не нужно явно определять тип при создании значения (динамическая часть), но если вы попытаетесь и затем используете этот тип так, как он не ожидает, он немедленно отметит проблему и завершит работу (сильный набор текста).

Почему вы предпочитаете сильную слабую или наоборот?

Сильные языки — это строгие языки. Опять же, они удостоверяются, что точно знают, что намерен делать программист. Если возникает ошибка, чаще всего это ошибка программиста, не понимающего операций. Эти ошибки также потенциально указывают на непонимание проблемы. Если вы пытаетесь добавить 5число к «5«строке, то, возможно, вы не понимаете, почему это не имеет смысла для компьютера. Это заставляет вас прийти к истине об операции и прямо говорит компьютеру, что вы хотите сделать (обычно с помощью некоторой формы механизма преобразования / преобразования). Это, как правило, приводит к созданию более надежного и менее подверженного ошибкам кода в производственной среде, но добавляет время и препятствия для перепрыгивания во время разработки.

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

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

Степени силы

Теперь мы рассмотрели сильную и слабую типизацию. Важно отметить, что, в отличие от четкой границы, существующей со статической / динамической типизацией, языки могут демонстрировать разную степень силы или слабости. Это ставит языки в широкий спектр. Вот почему в одних статьях говорится, что C ++ слаб, а в других — что он силен. Это отношения. Что делает его спектром, так это то, что некоторые языки предлагают инструменты, помогающие с преобразованием и изменением типов на лету. Некоторые используют такие вещи, как указатели. Вот почему вы можете слышать, как люди говорят, что Java более строго типизирован, чем C или C ++, хотя очевидно, что C ++ строго типизирован по сравнению с JavaScript.

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

Выбор стиля, подходящего для вашего проекта

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

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

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

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

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

Заключение

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

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

Оцените статью
bestprogrammer.ru
Добавить комментарий