Jint 3.0.1
See the version list below for details.
dotnet add package Jint --version 3.0.1
NuGet\Install-Package Jint -Version 3.0.1
<PackageReference Include="Jint" Version="3.0.1" />
paket add Jint --version 3.0.1
#r "nuget: Jint, 3.0.1"
// Install Jint as a Cake Addin #addin nuget:?package=Jint&version=3.0.1 // Install Jint as a Cake Tool #tool nuget:?package=Jint&version=3.0.1
Jint
Jint is a Javascript interpreter for .NET which can run on any modern .NET platform as it supports .NET Standard 2.0 and .NET 4.6.2 targets (and later).
Use cases and users
- Run JavaScript inside your .NET application in a safe sand-boxed environment
- Expose native .NET objects and functions to your JavaScript code (get database query results as JSON, call .NET methods, etc.)
- Support scripting in your .NET application, allowing users to customize your application using JavaScript (like Unity games)
Some users of Jint include RavenDB, EventStore, OrchardCore, ELSA Workflows, docfx, JavaScript Engine Switcher, and many more.
Supported features
ECMAScript 2015 (ES6)
- ✔ ArrayBuffer
- ✔ Arrow function expression
- ✔ Binary and octal literals
- ✔ Class support
- ✔ DataView
- ✔ Destructuring
- ✔ Default, rest and spread
- ✔ Enhanced object literals
- ✔
for...of
- ❌ Generators
- ✔ Template strings
- ✔ Lexical scoping of variables (let and const)
- ✔ Map and Set
- ✔ Modules and module loaders
- ✔ Promises (Experimental, API is unstable)
- ✔ Reflect
- ✔ Proxies
- ✔ Symbols
- ❌ Tail calls
- ✔ Typed arrays
- ✔ Unicode
- ✔ Weakmap and Weakset
ECMAScript 2016
- ✔
Array.prototype.includes
- ✔
await
,async
- ✔ Block-scoping of variables and functions
- ✔ Exponentiation operator
**
- ✔ Destructuring patterns (of variables)
ECMAScript 2017
- ✔
Object.values
,Object.entries
andObject.getOwnPropertyDescriptors
ECMAScript 2018
- ✔
Promise.prototype.finally
- ✔ RegExp named capture groups
- ✔ Rest/spread operators for object literals (
...identifier
) - ✔ SharedArrayBuffer
ECMAScript 2019
- ✔
Array.prototype.flat
,Array.prototype.flatMap
- ✔
String.prototype.trimStart
,String.prototype.trimEnd
- ✔
Object.fromEntries
- ✔
Symbol.description
- ✔ Optional catch binding
ECMAScript 2020
- ✔
BigInt
- ✔
export * as ns from
- ✔
for-in
enhancements - ✔
globalThis
object - ✔
import
- ✔
import.meta
- ✔ Nullish coalescing operator (
??
) - ✔ Optional chaining
- ✔
Promise.allSettled
- ✔
String.prototype.matchAll
ECMAScript 2021
- ✔ Logical Assignment Operators (
&&=
||=
??=
) - ✔ Numeric Separators (
1_000
) - ✔
AggregateError
- ✔
Promise.any
- ✔
String.prototype.replaceAll
- ✔
WeakRef
- ✔
FinalizationRegistry
ECMAScript 2022
- ✔ Class Fields
- ✔ RegExp Match Indices
- ✔ Top-level await
- ✔ Ergonomic brand checks for Private Fields
- ✔
.at()
- ✔ Accessible
Object.prototype.hasOwnProperty
(Object.hasOwn
) - ✔ Class Static Block
- ✔ Error Cause
ECMAScript 2023
- ✔ Array find from last
- ✔ Change Array by copy
- ✔ Hashbang Grammar
- ✔ Symbols as WeakMap keys
ECMAScript Stage 3 (no version yet)
- ✔
ArrayBuffer.prototype.transfer
- ✔ Array Grouping -
Object.groupBy
andMap.groupBy
- ✔ Import attributes
- ✔ JSON modules
- ✔
Promise.withResolvers
- ✔ Resizable and growable ArrayBuffers
- ✔ Set methods (
intersection
,union
,difference
,symmetricDifference
,isSubsetOf
,isSupersetOf
,isDisjointFrom
) - ✔ ShadowRealm
Other
- Further refined .NET CLR interop capabilities
- Constraints for execution (recursion, memory usage, duration)
Follow new features as they are being implemented, see https://github.com/sebastienros/jint/issues/343
Performance
- Because Jint neither generates any .NET bytecode nor uses the DLR it runs relatively small scripts really fast
- If you repeatedly run the same script, you should cache the
Script
orModule
instance produced by Esprima and feed it to Jint instead of the content string - You should prefer running engine in strict mode, it improves performance
You can check out the engine comparison results, bear in mind that every use case is different and benchmarks might not reflect your real-world usage.
Discussion
Join the chat on Gitter or post your questions with the jint
tag on stackoverflow.
Video
Here is a short video of how Jint works and some sample usage
https://docs.microsoft.com/shows/code-conversations/sebastien-ros-on-jint-javascript-interpreter-net
Thread-safety
Engine instances are not thread-safe and they should not accessed from multiple threads simultaneously.
Examples
This example defines a new value named log
pointing to Console.WriteLine
, then runs
a script calling log('Hello World!')
.
var engine = new Engine()
.SetValue("log", new Action<object>(Console.WriteLine));
engine.Execute(@"
function hello() {
log('Hello World');
};
hello();
");
Here, the variable x
is set to 3
and x * x
is evaluated in JavaScript. The result is returned to .NET directly, in this case as a double
value 9
.
var square = new Engine()
.SetValue("x", 3) // define a new variable
.Evaluate("x * x") // evaluate a statement
.ToObject(); // converts the value to .NET
You can also directly pass POCOs or anonymous objects and use them from JavaScript. In this example for instance a new Person
instance is manipulated from JavaScript.
var p = new Person {
Name = "Mickey Mouse"
};
var engine = new Engine()
.SetValue("p", p)
.Execute("p.Name = 'Minnie'");
Assert.AreEqual("Minnie", p.Name);
You can invoke JavaScript function reference
var add = new Engine()
.Execute("function add(a, b) { return a + b; }")
.GetValue("add");
add.Invoke(1, 2); // -> 3
or directly by name
var engine = new Engine()
.Execute("function add(a, b) { return a + b; }");
engine.Invoke("add", 1, 2); // -> 3
Accessing .NET assemblies and classes
You can allow an engine to access any .NET class by configuring the engine instance like this:
var engine = new Engine(cfg => cfg.AllowClr());
Then you have access to the System
namespace as a global value. Here is how it's used in the context on the command line utility:
jint> var file = new System.IO.StreamWriter('log.txt');
jint> file.WriteLine('Hello World !');
jint> file.Dispose();
And even create shortcuts to common .NET methods
jint> var log = System.Console.WriteLine;
jint> log('Hello World !');
=> "Hello World !"
When allowing the CLR, you can optionally pass custom assemblies to load types from.
var engine = new Engine(cfg => cfg
.AllowClr(typeof(Bar).Assembly)
);
and then to assign local namespaces the same way System
does it for you, use importNamespace
jint> var Foo = importNamespace('Foo');
jint> var bar = new Foo.Bar();
jint> log(bar.ToString());
adding a specific CLR type reference can be done like this
engine.SetValue("TheType", TypeReference.CreateTypeReference<TheType>(engine));
and used this way
jint> var o = new TheType();
Generic types are also supported. Here is how to declare, instantiate and use a List<string>
:
jint> var ListOfString = System.Collections.Generic.List(System.String);
jint> var list = new ListOfString();
jint> list.Add('foo');
jint> list.Add(1); // automatically converted to String
jint> list.Count; // 2
Internationalization
You can enforce what Time Zone or Culture the engine should use when locale JavaScript methods are used if you don't want to use the computer's default values.
This example forces the Time Zone to Pacific Standard Time.
var PST = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
var engine = new Engine(cfg => cfg.LocalTimeZone(PST));
engine.Execute("new Date().toString()"); // Wed Dec 31 1969 16:00:00 GMT-08:00
This example is using French as the default culture.
var FR = CultureInfo.GetCultureInfo("fr-FR");
var engine = new Engine(cfg => cfg.Culture(FR));
engine.Execute("new Number(1.23).toString()"); // 1.23
engine.Execute("new Number(1.23).toLocaleString()"); // 1,23
Execution Constraints
Execution constraints are used during script execution to ensure that requirements around resource consumption are met, for example:
- Scripts should not use more than X memory.
- Scripts should only run for a maximum amount of time.
You can configure them via the options:
var engine = new Engine(options => {
// Limit memory allocations to MB
options.LimitMemory(4_000_000);
// Set a timeout to 4 seconds.
options.TimeoutInterval(TimeSpan.FromSeconds(4));
// Set limit of 1000 executed statements.
options.MaxStatements(1000);
// Use a cancellation token.
options.CancellationToken(cancellationToken);
}
You can also write a custom constraint by deriving from the Constraint
base class:
public abstract class Constraint
{
/// Called before script is run and useful when you use an engine object for multiple executions.
public abstract void Reset();
// Called before each statement to check if your requirements are met; if not - throws an exception.
public abstract void Check();
}
For example we can write a constraint that stops scripts when the CPU usage gets too high:
class MyCPUConstraint : Constraint
{
public override void Reset()
{
}
public override void Check()
{
var cpuUsage = GetCPUUsage();
if (cpuUsage > 0.8) // 80%
{
throw new OperationCancelledException();
}
}
}
var engine = new Engine(options =>
{
options.Constraint(new MyCPUConstraint());
});
When you reuse the engine and want to use cancellation tokens you have to reset the token before each call of Execute
:
var engine = new Engine(options =>
{
options.CancellationToken(new CancellationToken(true));
});
var constraint = engine.Constraints.Find<CancellationConstraint>();
for (var i = 0; i < 10; i++)
{
using (var tcs = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
constraint.Reset(tcs.Token);
engine.SetValue("a", 1);
engine.Execute("a++");
}
}
Using Modules
You can use modules to import
and export
variables from multiple script files:
var engine = new Engine(options =>
{
options.EnableModules(@"C:\Scripts");
})
var ns = engine.Modules.Import("./my-module.js");
var value = ns.Get("value").AsString();
By default, the module resolution algorithm will be restricted to the base path specified in EnableModules
, and there is no package support. However you can provide your own packages in two ways.
Defining modules using JavaScript source code:
engine.Modules.Add("user", "export const name = 'John';");
var ns = engine.Modules.Import("user");
var name = ns.Get("name").AsString();
Defining modules using the module builder, which allows you to export CLR classes and values from .NET:
// Create the module 'lib' with the class MyClass and the variable version
engine.Modules.Add("lib", builder => builder
.ExportType<MyClass>()
.ExportValue("version", 15)
);
// Create a user-defined module and do something with 'lib'
engine.Modules.Add("custom", @"
import { MyClass, version } from 'lib';
const x = new MyClass();
export const result as x.doSomething();
");
// Import the user-defined module; this will execute the import chain
var ns = engine.Modules.Import("custom");
// The result contains "live" bindings to the module
var id = ns.Get("result").AsInteger();
Note that you don't need to EnableModules
if you only use modules created using Engine.Modules.Add
.
.NET Interoperability
- Manipulate CLR objects from JavaScript, including:
- Single values
- Objects
- Properties
- Methods
- Delegates
- Anonymous objects
- Convert JavaScript values to CLR objects
- Primitive values
- Object → expando objects (
IDictionary<string, object>
and dynamic) - Array → object[]
- Date → DateTime
- number → double
- string → string
- boolean → bool
- Regex → RegExp
- Function → Delegate
- Extensions methods
Security
The following features provide you with a secure, sand-boxed environment to run user scripts.
- Define memory limits, to prevent allocations from depleting the memory.
- Enable/disable usage of BCL to prevent scripts from invoking .NET code.
- Limit number of statements to prevent infinite loops.
- Limit depth of calls to prevent deep recursion calls.
- Define a timeout, to prevent scripts from taking too long to finish.
Branches and releases
- The recommended branch is main, any PR should target this branch
- The main branch is automatically built and published on MyGet. Add this feed to your NuGet sources to use it: https://www.myget.org/F/jint/api/v3/index.json
- The main branch is occasionally published on NuGet
Product | Versions Compatible and additional computed target framework versions. |
---|---|
.NET | net5.0 was computed. net5.0-windows was computed. net6.0 is compatible. net6.0-android was computed. net6.0-ios was computed. net6.0-maccatalyst was computed. net6.0-macos was computed. net6.0-tvos was computed. net6.0-windows was computed. net7.0 was computed. net7.0-android was computed. net7.0-ios was computed. net7.0-maccatalyst was computed. net7.0-macos was computed. net7.0-tvos was computed. net7.0-windows was computed. net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. |
.NET Core | netcoreapp2.0 was computed. netcoreapp2.1 was computed. netcoreapp2.2 was computed. netcoreapp3.0 was computed. netcoreapp3.1 was computed. |
.NET Standard | netstandard2.0 is compatible. netstandard2.1 is compatible. |
.NET Framework | net461 was computed. net462 is compatible. net463 was computed. net47 was computed. net471 was computed. net472 was computed. net48 was computed. net481 was computed. |
MonoAndroid | monoandroid was computed. |
MonoMac | monomac was computed. |
MonoTouch | monotouch was computed. |
Tizen | tizen40 was computed. tizen60 was computed. |
Xamarin.iOS | xamarinios was computed. |
Xamarin.Mac | xamarinmac was computed. |
Xamarin.TVOS | xamarintvos was computed. |
Xamarin.WatchOS | xamarinwatchos was computed. |
NuGet packages (162)
Showing the top 5 NuGet packages that depend on Jint:
Package | Downloads |
---|---|
Elsa.Scripting.JavaScript
Elsa is a set of workflow libraries and tools that enable lean and mean workflowing capabilities in any .NET Core application. This package provides a JavaScript expression evaluator based on Jint. |
|
JavaScriptEngineSwitcher.Jint
JavaScriptEngineSwitcher.Jint contains a `JintJsEngine` adapter (wrapper for the Jint). |
|
BizDoc.Core
Workflow framework engine |
|
OrchardCore.ContentFields
Orchard Core CMS is a Web Content Management System (CMS) built on top of the Orchard Core Framework. Provides features to add content fields and indexing them for a content type. |
|
OrchardCore.Html
Orchard Core CMS is a Web Content Management System (CMS) built on top of the Orchard Core Framework. The Html module enables content items to have rich content using Html syntax. |
GitHub repositories (48)
Showing the top 5 popular GitHub repositories that depend on Jint:
Repository | Stars |
---|---|
OrchardCMS/OrchardCore
Orchard Core is an open-source modular and multi-tenant application framework built with ASP.NET Core, and a content management system (CMS) built on top of that framework.
|
|
elsa-workflows/elsa-core
A .NET workflows library
|
|
EventStore/EventStore
EventStoreDB, the event-native database. Designed for Event Sourcing, Event-Driven, and Microservices architectures
|
|
dotnet/docfx
Static site generator for .NET API documentation.
|
|
BililiveRecorder/BililiveRecorder
录播姬 | mikufans 生放送录制
|
Version | Downloads | Last updated |
---|---|---|
4.1.0 | 4,865 | 10/27/2024 |
4.0.3 | 49,127 | 9/23/2024 |
4.0.2 | 44,513 | 8/26/2024 |
4.0.1 | 40,035 | 8/10/2024 |
4.0.0 | 28,627 | 7/24/2024 |
3.1.6 | 29,578 | 8/10/2024 |
3.1.5 | 48,109 | 7/13/2024 |
3.1.4 | 43,632 | 6/27/2024 |
3.1.3 | 125,388 | 6/15/2024 |
3.1.2 | 57,844 | 5/25/2024 |
3.1.1 | 62,423 | 4/26/2024 |
3.1.0 | 40,480 | 4/10/2024 |
3.0.2 | 20,278 | 4/5/2024 |
3.0.1 | 135,988 | 2/25/2024 |
3.0.0 | 190,412 | 1/19/2024 |
2.11.58 | 6,857,335 | 11/27/2017 |
2.11.55 | 8,361 | 11/27/2017 |
2.11.23 | 164,974 | 8/30/2017 |
2.11.21 | 3,199 | 8/30/2017 |
2.11.20 | 3,036 | 8/30/2017 |
2.11.10 | 87,194 | 8/10/2017 |
2.10.4 | 490,636 | 3/22/2017 |
2.10.3 | 294,020 | 12/28/2016 |
2.10.2 | 28,973 | 10/17/2016 |
2.10.1 | 3,564 | 10/16/2016 |
2.10.0 | 3,215 | 10/16/2016 |
2.9.1 | 178,366 | 7/27/2016 |
2.9.0 | 5,282 | 7/26/2016 |
2.8.0 | 154,854 | 2/26/2016 |
2.7.1 | 72,520 | 11/1/2015 |
2.6.0 | 30,780 | 9/22/2015 |
2.5.0 | 116,645 | 5/26/2015 |
2.4.0 | 37,886 | 10/14/2014 |
2.3.0 | 4,947 | 10/3/2014 |
2.2.0 | 7,942 | 7/9/2014 |
2.1.0 | 34,000 | 3/4/2014 |
2.0.0 | 18,322 | 3/3/2014 |