¿Para qué utilizan las personas JScript.Net?

asp.net

Question

Me interesa saber quién usa JScript.Net y para qué tipo de aplicaciones. Cada vez que leo documentación de .NET de MSDN, siempre noto las muestras de JScript, pero en todos los años que he sido un desarrollador de C #, nunca he conocido a nadie que lo use.

¿Para qué tipo de aplicaciones utilizan las personas y cómo miden, en términos de flexibilidad, potencia y uso general, C #?

[ Editar: Solo para aclarar: no estoy preguntando qué es JScript.Net, estoy preguntando para qué lo usa realmente la gente, es decir , si estoy interesado en conocer los escenarios de uso reales y cómo las personas lo han encontrado para trabajar)

Answer 1

Acabo de suponer que fue utilizado por Microsoft para inflar la cantidad de idiomas soportados por .NET en el lanzamiento con fines de marketing.

Answer 2

Bueno, estoy tratando de usarlo. No puedo decir que he tenido éxito.

No he hecho mucha codificación web en ningún entorno, pero aquí están mis 2 centavos.

Quería exponer algunas tablas de bases de datos a una página web, así que lancé una página rápida clásica ASP (sí, sí, lo sé) que extrajo los datos de SQL Server y devolvió la tabla como un objeto JSON. En lugar de localizar un serializador JSON para VBScript, escribí ambas partes en el script J (ava) e importé json2.js en el servidor para proporcionar la serialización. Funcionó de maravilla; Honestamente, tardó menos de una hora en escupir una buena representación JSON de la tabla, 50 minutos de los cuales fue un intento infructuoso de que JScript importara json2.min.js directamente en lugar de arrojar <% %> json2.min.js <% %> envoltorios a su alrededor y renombrándolo json2.min.asp .

Pero todos dicen que es malo y está mal usar Classic ASP en este día y edad, así que estoy tratando de reemplazar mi rápida y sucia aplicación ASP + Jscript + ADO con ASP.NET + Jscript.NET + ADO.NET. Después de algunos momentos de golpes de tecla, tengo ASP.NET v4.0.30319 en IIS6 y tengo una página "hola, mundo" que hace algunos bucles simples javascript a través de la directiva <@ language = "JScript"> . Hasta aquí todo bien.

Estaba siguiendo las Mejores Prácticas aquí, estaría envolviendo todo en una clase, etc., pero como solo trato de salir de la entrada traté de hacer un puerto rápido de mi código existente, que importa varios bits útiles de Javascript de otra los archivos que usan ASP include sentencias.

Incluir algunas cosas simples usando <--#incude file="somejsconstants.asp" --> funcionó bien y me permitió acceder a las constantes de ese archivo. Pero mi intento de extraer el serializador JSON con <--#incude file="json2.min.asp" --> no funcionó, y el encendido de una versión de json2.js modificada adecuadamente para ser una página aspx independiente y lanzó el mismo error. (El error del compilador es que los Objects of type ''jscript_aspx'' do not have such a member .) JScript.NET parece estar descontento con el uso de cierres, una construcción casi omnipresente en las bibliotecas de JavaScript actuales.

De las publicaciones anteriores está claro que hay muchas formas de serializar objetos JSON en la plataforma .NET, pero mi intuición es que si JScript.NET descifra Javascript escrito por Douglas Crockford, entonces es un estilo raro e incompatible que no vale la pena invertir. tiempo adentro. También podría seguir las masas de ASP.NET y usar C #.

Answer 3

Como una mejora para los archivos por lotes y para las aplicaciones de consola, ya que permite una hibridación ordenada (sin resultados innecesarios) gracias a sus directivas. Guarde el siguiente ejemplo con la extensión .bat y verifique su resultado:

@if (@X)==(@Y) @end /* JScript comment
@echo off
setlocal

for /f "tokens=* delims=" %%v in (''dir /b /s /a:-d  /o:-n "%SystemRoot%/Microsoft.NET/Framework/*jsc.exe"'') do (
   set "jsc=%%v"
)

if not exist "%~n0.exe" (
    "%jsc%" /nologo /out:"%~n0.exe" "%~dpsfnx0"
)

 %~n0.exe %*

endlocal & exit /b %errorlevel%


*/

import System;

Console.WriteLine("hello from jscript.net");

Aquí se pueden encontrar algunos ejemplos .

Answer 4

Con la herramienta Metastorm BPM de Business Process Management, puede usar JScript.Net para extender sus flujos de trabajo. Por ejemplo, puede agregar .dlls .Net personalizados al motor e interactuar con ellos en sus procesos utilizando JScript.Net.

Mi experiencia fue bastante positiva. Implementé algunas secuencias de comandos pequeñas, pero preferiría escribir scripts con JScript.Net en VBScript (el segundo lenguaje de scripts compatible) en cualquier momento.

Answer 5

JScript .NET es un lenguaje de scripting moderno con una amplia variedad de aplicaciones. Es un verdadero lenguaje orientado a objetos, y aún así mantiene su sensación de "scripting" . JScript .NET mantiene una compatibilidad totalmente retroactiva con las versiones anteriores de JScript, al tiempo que incorpora excelentes funciones nuevas y proporciona acceso al Common Language Runtime y .NET Framework (desde JScript.NET ).

Además, es posible que también le resulte útil este post de : ¿Se puede utilizar JScript.NET para crear una secuencia de comandos de una aplicación .NET?

En cuanto a quién está usando, sinceramente, no estoy al tanto (estoy bastante seguro de que hay por ahí).

Lea Introducción a JScript.NET .

Mi opinión personal fue que podría ser impresionante para los desarrolladores web que están acostumbrados a escribir en JScript simple y desean obtener los beneficios de .NET sin necesidad de aprender un nuevo idioma, o para aquellos que desean tener todo su código escrito en un idioma.

Answer 6

JScript .NET es uno de los idiomas admitidos para escribir extensiones de aplicaciones para la familia de productos de edición de medios de Sony. Sound Forge & Vegas.

En particular, Sound Forge tiene una ventana que puede usar para editar y ejecutar scripts para manipular archivos de audio.

Resulta que Microsoft hizo que sea muy fácil agregar secuencias de comandos a su aplicación utilizando uno (o todos) los idiomas compatibles con .NET. VB, JScript y C #. Solo tiene que exponer algunos objetos de su aplicación y entregar esos objetos (ensamblados en realidad) al compilador junto con el texto del script del usuario.

Tienen un foro web para guionistas de Sound Forge

Answer 7

La página de Wikipedia de JScript.NET es bastante explicativa: http://en.wikipedia.org/wiki/JScript_.NET

En resumen, parece ser JavaScript con la biblioteca .NET.

Answer 8

Llegué tarde a la fiesta aquí, pero quiero agregar mi opinión:

Veo que JScript.NET es útil para el código del lado del servidor. Es bastante natural usar algo del lado del servidor que es esencialmente lo mismo que lo que usa el lado del cliente. Además, hace que trabajar con JSON sea mucho más fácil, por lo que puede ser una gran ventaja si está creando un servicio web que se comunica a través de JSON.

Escribí un servicio web donde trabajo en C # pero estoy pensando en migrar a JScript.NET por esos motivos.

Answer 9

Lo uso bastante, casi exclusivamente, para ASP.NET y material web relacionado.

Puede usarlo para casi todo lo que puede usar para otros lenguajes .NET. Hace MSIL, al igual que los demás;) Compilado con la opción "rápida" que convierte algunos de los rasgos nativos de JavaScript, como las extensiones de prototipo y eval, se comporta como cualquier otro código en el CLR.

Ciertamente, no es un miembro de la familia con todas las de la ley, en el sentido de que parece haber quedado atrás en .NET 1.1 en términos de características, el soporte de herramientas no es inexistente y la documentación es francamente horrible. Eso es parte de por qué me gusta tanto, en realidad, me hace sentir como si estuviera programando.

Si tiene un montón de (j) scripts que se deben convertir a .NET, esta es la opción más obvia, ya que normalmente necesitará muy poca reescritura para que funcione. De lo contrario, no hay ninguna razón particular para elegir JScript.NET sobre cualquier otro lenguaje .NET, y hay muchas razones para no hacerlo.

Todo se reduce a las preferencias personales, ya que todo termina en el mismo código CLR, independientemente del idioma. Encuentro JScript.NET fácil de usar, natural de escribir y con una simplicidad flexible como ningún otro idioma lo intenté, así que lo uso hasta que encuentro un problema que el lenguaje simplemente no puede manejar. No ha sucedido aún

Answer 10

No sé cómo se compara el rendimiento, pero sé que JScript.NET es uno de los idiomas que puede usar con Unity 3D .

Answer 11

Recomiendo a todos no usarlo o solo en dosis homeopáticas. Lamentablemente, tengo que trabajar mucho con él por razones heredadas, y como se dijo antes, se desarrolló para .NET 1.1 y no se actualizó porque no tiene soporte para genéricos, no admite delegados, no puede declarar eventos, etc. Nunca fue muy extendido y actualmente no está desarrollado (aunque a veces Microsoft todavía soluciona un error que presento). Pero ese es el problema menor: hay problemas importantes en el compilador, el código válido puede bloquearse fácilmente y entonces todo lo que tiene es una excepción lanzada en algún lugar en la profundidad de jsc.exe sin ninguna pista de qué archivo está causando el colapso y menos qué línea de código. Aquí hay un ejemplo de lo que sucede (estuve lanzando una matriz fuertemente tipada en una colección):

***INTERNAL COMPILER ERROR***
Microsoft.Vsa.VsaException: InternalCompilerError (0x80133021): System.NotSupportedException: Not supported in a non-reflected type.
   at System.Reflection.Emit.SymbolType.GetMember(String name, MemberTypes type, BindingFlags bindingAttr)
   at System.Type.GetMember(String name, BindingFlags bindingAttr)
   at Microsoft.JScript.Convert.GetToXXXXMethod(IReflect ir, Type desiredType, Boolean explicitOK)
   at Microsoft.JScript.Convert.EmittedCallToConversionMethod(AST ast, ILGenerator il, Type source_type, Type target_type)
   at Microsoft.JScript.Convert.Emit(AST ast, ILGenerator il, Type source_type, Type target_type, Boolean truncationPermitted)
   at Microsoft.JScript.Binding.TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, Boolean construct, Boolean brackets)
   at Microsoft.JScript.Lookup.TranslateToILCall(ILGenerator il, Type rtype, ASTList argList, Boolean construct, Boolean brackets)
   at Microsoft.JScript.Call.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.Binding.TranslateToILSet(ILGenerator il, AST rhvalue)
   at Microsoft.JScript.Lookup.TranslateToILSet(ILGenerator il, Boolean doBoth, AST rhvalue)
   at Microsoft.JScript.VariableDeclaration.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.Block.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.FunctionObject.TranslateToIL(CompilerGlobals compilerGlobals)
   at Microsoft.JScript.FunctionDeclaration.TranslateToILInitializer(ILGenerator il)
   at Microsoft.JScript.Block.TranslateToILInstanceInitializers(ILGenerator il)
   at Microsoft.JScript.Class.TranslateToCOMPlusClass()
   at Microsoft.JScript.Class.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.Package.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.Block.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.ScriptBlock.TranslateToIL(ILGenerator il, Type rtype)
   at Microsoft.JScript.ScriptBlock.TranslateToILClass(CompilerGlobals compilerGlobals, Boolean pushScope)
   at Microsoft.JScript.VsaStaticCode.TranslateToIL()
   at Microsoft.JScript.Vsa.VsaEngine.DoCompile()
   at Microsoft.Vsa.BaseVsaEngine.Compile()

Buena suerte si tiene que encontrar el problema con dicho mensaje.

JScript.NET tiene algunas características que podrían ser interesantes para algunos proyectos, como creación de prototipos (agregar nuevas propiedades y también creo métodos para una instancia existente de cualquier objeto), tiene tipo de funciones Lamda desde .NET 1.1 (tal vez 1.0), etc. Pero para llegar a este comportamiento totalmente diferente de lo que era posible con .NET 1.1 tenían que incluir todo en el tiempo de ejecución-ayudantes, JScript.NET tiene una clase String propia, que se convierte en System.String de un lado a otro siempre que sea necesario. Lo mismo ocurre con las matrices, JScript tiene su propia implementación y debe convertirlas cada vez que se llame a una función de marco con una matriz como parámetro, etc.

Experimenté cosas tan divertidas como que una solicitud a la base de datos se ejecutó dos veces si lo pasaba directamente como parámetro de un método ( DoSomething(myRequest.Execute()) , el resultado de la solicitud era de tipo System.String[][] ) pero todo está funcionando bien si asigno el resultado primero a una variable y luego lo paso al método, o si tratas de ordenar una matriz con System.Array.Sort(..) simplemente se ignora y entonces en.

Tengo la sensación de que JScript.NET fue un caso de estudio para probar que también es posible implementar lenguajes con una filosofía muy diferente, y Microsoft se dio por vencido cuando se dieron cuenta de que su enfoque no estaba bien elegido, pero aprendieron la lección e hicieron una excelente trabajo con PowerShell que tiene una filosofía algo similar.

Pero para abreviar: no use JScript.NET si no es necesario, use un lenguaje moderno como C # o VB.NET, y si necesita funcionalidad de scripting, le recomiendo usar CSScript.

Answer 12

Rob: he utilizado JScript.NET con ira en un lugar de mi código, que es esencialmente exponer la funcionalidad de su método eval. Aquí hay una versión reducida:

static public class Evaluator
{
    private const string _jscriptSource =
        @"package Evaluator
        {
           class Evaluator
           {
              public function Eval(expr : String) : String 
              { 
                 return eval(expr); 
              }
           }
        }";

    static private object _evaluator;
    static private Type _evaluatorType;

    static Evaluator()
    {
        InstantiateInternalEvaluator();
    }

    static private void InstantiateInternalEvaluator()
    {
        JScriptCodeProvider compiler = new JScriptCodeProvider();

        CompilerParameters parameters;
        parameters = new CompilerParameters();
        parameters.GenerateInMemory = true;

        CompilerResults results;
        results = compiler.CompileAssemblyFromSource(parameters, _jscriptSource);

        Assembly assembly = results.CompiledAssembly;
        _evaluatorType = assembly.GetType("Evaluator.Evaluator");

        _evaluator = Activator.CreateInstance(_evaluatorType);
    }

    static public object EvaluateToObject(string statement)
    {
        try
        {
            return _evaluatorType.InvokeMember(
                "Eval",
                BindingFlags.InvokeMethod,
                null,
                _evaluator,
                new object[] {statement}
                );
        }
        catch (Exception)
        {
            InstantiateInternalEvaluator();
            return null;
        }
    }

Obviamente puedes crear sobrecargas para otros tipos de devolución. ¡No puedo reclamar la idea original de que esto fuera mío! Los usos para esto serían, por ejemplo, evaluar una expresión de cadena como 3 + 4 a 7 sin análisis de expresión.