В чем преимущество статически типизированных языков программирования?

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

Что такое статическая типизация?

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

var num = 5;
var str = "hello";

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

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

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

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

Почему статическая типизация полезна?

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

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

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

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

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

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

Есть ли причина предпочесть динамическую типизацию?

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

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

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

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

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

Строго типизированный против слабо типизированного

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

Строго типизированный означает, что язык не выполняет много неявных преобразований типов или приведения типов. Например, C# — язык со строгой типизацией. Если вы хотите передать int функции, которая ожидает float, вы получите сообщение об ошибке.

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

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

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