¿PowerShell es un lenguaje fuertemente tipado?
strong-typing (7)
PowerShell está definitivamente en la categoría de lenguajes dinámicos, pero ¿se consideraría fuertemente tipado?
Creo que mirar agregar una cadena a un ejemplo Int más proporcionaría más grano para el molino de discusión. ¿Qué se considera de tipo dinámico? Alguien en uno de los comentarios dijo que en este caso:
4 + "4"
El "4" se convierte en Int32 . No creo que ese sea el caso en absoluto. En cambio, creo que un paso intermedio ocurre cuando el comando se cambia a:
4 + [System.Convert] :: ToInt32 ("4")
Tenga en cuenta que esto significa que "4" se mantiene como una cadena durante todo el proceso. Para demostrar esto, considere este ejemplo:
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
Creo que necesitarás definir lo que quieres decir con "Strongly Typed":
En informática y programación de computadoras, el término tipado fuerte se usa para describir aquellas situaciones en las que los lenguajes de programación especifican una o más restricciones sobre cómo las operaciones que involucran valores que tienen diferentes tipos de datos pueden entremezclarse. El antónimo es tipeo débil. Sin embargo, a estos términos se les ha dado una gran variedad de significados sobre la corta historia de la informática que a menudo es difícil saber, fuera de contexto, lo que significa un escritor individual al usarlos.
Técnicamente es un lenguaje fuertemente tipado.
Puede rechazar la declaración de tipos en el shell, lo que le permite comportarse como un lenguaje de scripting de tipo dinámico, pero envolverá los objetos de tipo débil en un contenedor de tipo "PsObject". Al declarar objetos usando la sintaxis "Nuevo-Objeto", los objetos son fuertemente tipados y no envueltos.
$compilerParameters = New-Object System.CodeDom.Compiler.CompilerParameters
Me retracto de mi respuesta anterior, citada a continuación. Debería haber dicho algo más matizado como:
PowerShell tiene un sistema de tipo fuerte con inferencia de tipo robusto y está tipeado dinámicamente.
Me parece que hay varios problemas en juego aquí, por lo que las respuestas que piden una mejor definición de lo que se entiende por un "lenguaje fuertemente tipado" probablemente sean más acertadas en su enfoque de la cuestión.
Dado que PowerShell cruza muchos límites, la respuesta a dónde se encuentra PowerShell probablemente exista en un diagrama de Venn que consta de las siguientes áreas:
- Comprobación de tipo estática frente a dinámica
- Tipeo fuerte vs. débil
- Mecanografía segura vs. insegura
- Declaración explícita e implícita e inferencia
- Sistemas de tipo estructural vs. nominativo
"PowerShell es un lenguaje fuertemente tipado.
Sin embargo, solo requiere que declare el tipo donde hay ambigüedad.
Si es capaz de inferir un tipo, no requiere que lo especifique ".
PowerShell se escribe dinámicamente, simple y llanamente. Es descrito como tal por su creador, Bruce Payette.
Además, si alguien ha tomado una clase básica de lenguaje de programación, lo sabrá. El hecho de que haya un sistema de anotación de tipo no significa que esté fuertemente tipado. Incluso las variables anotadas de tipo se comportan dinámicamente durante un lanzamiento. Cualquier lenguaje que le permita asignar una cadena a una variable e imprimirlo y luego asignar un número a la misma variable y hacer cálculos con ella se tipea dinámicamente.
Además, PowerShell tiene un alcance dinámico (si alguien aquí sabe lo que eso significa).
Puede ser si lo necesitas.
Al igual que:
[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] »
Use la notación [tipo] para indicar si le importan las variables fuertemente tipadas.
EDITAR :
Como lo señaló edg , esto no impide que PowerShell interprete "5" como un entero al ejecutar (5 + "5"). Cavé un poco más, y de acuerdo con Bruce Payette en Windows PowerShell en acción , PowerShell es en realidad un "lenguaje de promiscuidad de tipo". Entonces, supongo, mi respuesta es "más o menos".
Hay una cierta cantidad de confusión alrededor de la terminología. Este artículo explica una taxonomía útil de los sistemas de tipos.
PowerShell se escribe de forma dinámica e implícita:
> $x=100
> $x=dir
Sin errores de tipo: una variable puede cambiar su tipo en tiempo de ejecución. Esto es como Python , Perl , JavaScript pero diferente de C ++ , Java , C # , etc.
Sin embargo:
> [int]$x = 100
> $x = dir
Cannot convert "scripts-2.5" to "System.Int32".
Por lo tanto, también admite el tipado explícito de variables si lo desea. Sin embargo, la comprobación de tipos se realiza en tiempo de ejecución en lugar de en tiempo de compilación, por lo que no está tipado estáticamente .
He visto a algunos decir que PowerShell utiliza la inferencia de tipo (porque no tiene que declarar el tipo de una variable), pero creo que son las palabras equivocadas. La inferencia de tipo es una característica de los sistemas que realiza la verificación de tipos en tiempo de compilación (como " var " en C #). PowerShell solo comprueba tipos en tiempo de ejecución, por lo que puede verificar el valor real en lugar de hacer inferencias.
Sin embargo, hay una cierta cantidad de conversión automática de tipo:
> [int]$a = 1
> [string]$b = $a
> $b
1
> $b.GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True String System.Object
Entonces algunos tipos se convierten sobre la marcha. En la mayoría de las definiciones, esto hará que PowerShell sea un lenguaje débilmente tipado . Sin duda es más débil que, por ejemplo, Python, que (¿casi?) Nunca convierte tipos sobre la marcha. Pero probablemente no esté tan débil como Perl, que convertirá casi todo lo que necesite.