PowerShell - это строго типизированный язык?

Может быть, если нужно.

Вот так:

[1] » [int]$x = 5
[2] » $x
5
[3] » $x = 'haha'
Cannot convert value "haha" to type "System.Int32". Error: "Input string was not in a correct format."
At line:1 char:3
+ $x  <<<< = 'haha'
[4] »

Используйте обозначение [type], чтобы указать, заботитесь ли вы о строгой типизации переменных.

РЕДАКТИРОВАТЬ:

Как указал край, это не мешает PowerShell интерпретировать «5» как целое число при выполнении (5 + «5»). Я выкопал еще немного, и, согласно Брюсу Пайетту в Windows PowerShell в действии, PowerShell на самом деле является «беспорядочным языком». Так что, я думаю, мой ответ - «вроде как».

Технически это строго типизированный язык.

Вы можете отказаться от объявления типов в оболочке, позволяя ей вести себя как язык сценариев с динамической типизацией, но при этом слабо типизированные объекты будут заключены в оболочку типа «PsObject». Объявляя объекты с использованием синтаксиса «New-Object», объекты становятся строго типизированными и не переносятся.

$compilerParameters = New-Object System.CodeDom.Compiler.CompilerParameters

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

PowerShell имеет строгую систему типов с надежным выводом типов и динамически типизирован.

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

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

• Статическая и динамическая проверка типов
• Сильный и слабый набор текста
• Безопасный и небезопасный набор текста
• Явное и неявное объявление и вывод
• Структурные системы против систем номинативного типа

"PowerShell is a strongly typed language.

However, it only requires you to declare the type where there is ambiguity.

If it is able to infer a type, it does not require you to specify it."

Я думаю, вам нужно будет определить, что вы подразумеваете под "строго типизированным":

In computer science and computer programming, the term strong typing is used to describe those situations where programming languages specify one or more restrictions on how operations involving values having different datatypes can be intermixed. The antonym is weak typing. However, these terms have been given such a wide variety of meanings over the short history of computing that it is often difficult to know, out of context, what an individual writer means when using them.

--Википедия

Существует некоторая путаница вокруг терминологии. Эта статья объясняет полезную таксономию систем типов.

PowerShell динамически, неявно типизирован:

> $x=100
> $x=dir

Нет ошибок типа - переменная может изменить свой тип во время выполнения. Это похоже на Python, Perl, JavaScript, но отличается от C++, Ява, C# и т. д.

Тем не мение:

> [int]$x = 100
> $x = dir
Cannot convert "scripts-2.5" to "System.Int32".

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

Я видел, как некоторые говорили, что PowerShell использует вывод типа (потому что вам не нужно объявлять тип переменной), но я думаю, что это неправильные слова. Вывод типа - это функция систем, которая выполняет проверку типов во время компиляции (например, «var» в C#). PowerShell проверяет типы только во время выполнения, поэтому может проверять фактическое значение, а не делать вывод.

Однако происходит некоторое автоматическое преобразование типов:

> [int]$a = 1
> [string]$b = $a
> $b
1
> $b.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     String                                   System.Object

Таким образом, типы немного преобразуются на лету. По большинству определений это сделает PowerShell языком слабо типизированный. Он определенно слабее, чем, например, Python, который (почти?) Никогда не конвертирует типы на лету. Но, вероятно, не такой слабый, как Perl, который конвертирует почти все, что нужно.

Я думаю, что дальнейшее рассмотрение добавления String в пример Int даст больше засыпки для обсуждения. Что считается приведением динамического типа? Кто-то в одном из комментариев сказал, что в этом случае:

4 + "4"

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

4 + [System.Convert]::ToInt32("4")

Обратите внимание, что это означает, что "4" остается строкой на протяжении всего процесса. Чтобы продемонстрировать это, рассмотрим этот пример:

19# $foo = "4"
20# $foo.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     String                                   System.Object


21# 4 + $foo
8
22# $foo.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     String                                   System.Object

PowerShell имеет простую и понятную динамическую типизацию. Так он описан его создателем Брюсом Пайеттом.

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

Кроме того, PowerShell имеет динамическую область видимости (если кто-нибудь знает, что это значит).