unitsnet-js

The unitsnet-js package provides an efficient way to store unit variables and perform easy conversions to different units when it required.

It offers support for more than 100 unit types across various unit categories, including pretty-printing, comparison, and arithmetic methods.

The API is designed to be user-friendly and straightforward to use.

The library is built on top of the Units.NET project and leverages their definitions sources to generate the JavaScript unit classes.

The unitsnet-js package does not require any external dependencies or packages to function.

Package is available on NPM at https://www.npmjs.com/package/unitsnet-js

Units.NET on other platforms

Install via NPM:

npm install unitsnet-js

Example Usage in TypeScript

import { Angle, AngleUnits, Length, LengthUnits } from 'unitsnet-js';


let angle = Angle.FromDegrees(180);
// equals to
angle =  new Angle(180, AngleUnits.Degrees);

console.info(angle.Radians); // 3.141592653589793
console.info(angle.Microradians); // 3141592.65358979
console.info(angle.Gradians); // 200
console.info(angle.Microdegrees); // 180000000

// As an alternative, a convert style method are also available
console.info(angle.convert(AngleUnits.Radians)); // 3.141592653589793
console.info(angle.convert(AngleUnits.Microradians)); // 3141592.65358979
console.info(angle.convert(AngleUnits.Gradians)); // 200
console.info(angle.convert(AngleUnits.Microdegrees)); // 180000000

// Print the default unit toString (The default for angle is degrees)
console.info(angle.toString()); // 180 °

console.info(angle.toString(AngleUnits.Degrees)); // 180 °
console.info(angle.toString(AngleUnits.Radians)); // 3.141592653589793 rad

// Specify fraction digits max length
console.info(angle.toString(AngleUnits.Radians, 2)); // 3.14 rad

Additional methods

Check, compare, calculate etc. with unitsnet:

const length1 = Length.FromMeters(10);
const length2 = Length.FromDecimeters(100);
const length3 = Length.FromMeters(3);

// 'equals' method
console.log(length1.equals(length2)) // true;
console.log(length1.equals(length3)) // false;

// 'compareTo' method
console.log(length1.compareTo(length3)) // 1;
console.log(length3.compareTo(length1)) // -1;
console.log(length2.compareTo(length1)) // 0;

// Arithmetics methods
const results1 = length1.add(length3);
const results2 = length1.subtract(length3);
const results3 = length1.multiply(length3);
const results4 = length1.divide(length3);
const results5 = length1.modulo(length3);
const results6 = length1.pow(length3);
console.log(results1.toString(LengthUnits.Meters)) // 13 m
console.log(results2.toString(LengthUnits.Meters)) // 7 m
console.log(results3.toString(LengthUnits.Meters)) // 30 m
console.log(results4.toString(LengthUnits.Meters)) // 3.3333333333333335 m
console.log(results5.toString(LengthUnits.Meters)) // 1 m
console.log(results6.toString(LengthUnits.Meters)) // 1000 m

DTO - Data Transfer Object

As UnitsNet provides a convenient way to work within a running service, there are occasions where the data needs to be exposed outside of the service, typically through an API containing the unit value or consumed from an API.

To support this with a clear API schema and make it easy to convert to and from this schema to the specific format, it's recommended to use DTOs and the UnitsNet flavor converters.

import { Length, LengthDto, LengthUnits } from 'unitsnet-js';

// Create a Length unit object
const length = Length.FromMeters(100.01);
           
// Obtain the DTO object, represented by the default unit - meter
const lengthDto: LengthDto = length.toDto(); // {"value":100.01,"unit":"Meter"}

// Obtain the same value but represent DTO in KM 
const lengthDtoRepresentsInKM: LengthDto = length.toDto(LengthUnits.Kilometers); // {"value":0.10001,"unit":"Kilometer"}

// Obtain Length object from lengthDto

const lengthFromMetersDto = Length.FromDto(lengthDto);
// The exact same value as
const lengthFromKMDto = Length.FromDto(lengthDtoRepresentsInKM);

Check out the OpenAPI unitsnet-openapi-spec example schema.

Also, refer to the detailed discussions on GitHub: haimkastner/unitsnet-js#31 & angularsen/UnitsNet#1378.

External Arithmetics Methods

As a default, the arithmetic formula uses JavaScript default operations (e.g., +, -, etc.) However, JavaScript operations use floating point arithmetic with precision surpassing JavaScript's default IEEE 754 based implementation.

For example, you may want to perform arithmetics like the classic 0.1 + 0.2. With the default implementation, this operation yields 0.30000000000000004. Read more about this issue at https://stackoverflow.com/q/1458633/8281649

To cater to such cases, the library exposes an operator override mechanism, allowing for usage of dedicated, high precision mathematic libraries.

import numeral from 'numeral';
import { Length, setOperatorOverride, ArithmeticOperation } from 'unitsnet-js';

const lengthA = Length.FromMeters(0.1);
const lengthB = Length.FromMeters(0.2);

console.log(lengthA.add(lengthB).Meters); // 0.30000000000000004

setOperatorOverride(ArithmeticOperation.Add, (valueA: number,valueB: number) => {
	return numeral(valueA).add(valueB).value() as number;
});

console.log(lengthA.add(lengthB).Meters); // 0.3

The override mechanism is designed with high performance in mind. While running in a test context, the overhead was observed to be roughly 1%.

If your application requires real-time class performance, however, we recommend you verify this conforms to your specification.

Note that override functions are global and exported directly from the package index.

Function	Purpose	Notes
setOperatorOverride	Override a given operator
unsetOperatorOverride	Remove an operator override	Safe to call even when operator is not overridden
unsetAllOperatorOverrides	Removes all operator overrides	Safe to call even when there are no overridden operators
areAnyOperatorsOverridden	Determine whether any operators are currently overridden

Migrating from 2.x.x to 3.x.x

Version 3.0.0 consolidates some external interfaces and includes a brand new infrastructure for operator overriding (see External arithmetics methods section).

As such, a few minor breaking changes have been introduced, specified below.

If your code does not use any of these types/functions, no change is required.

Type	Name	Status	Migration Strategy	Notes
type	ArithmeticFormula	Removed	Use OperatorOverrides directly or alias the type in your code	Consolidated into new interface OperatorOverrides
type	CompareToFormula	Removed	Use OperatorOverrides directly or alias the type in your code	Consolidated into new interface OperatorOverrides
type	EqualsFormula	Removed	Use OperatorOverrides directly or alias the type in your code	Consolidated into new interface OperatorOverrides
function	setEqualsFormula	Removed	Use OperatorOverrides with OperatorType.Equals	Consolidated into new function setOperatorOverride
function	setCompareToFormula	Removed	Use OperatorOverrides with OperatorType.CompareTo	Consolidated into new function setOperatorOverride

Supported units

UnitsNet supported Units

Units.NET on other platforms

Get the same strongly typed units on other platforms, based on the same unit definitions.

Language	Name	Package	Repository	Maintainers
C#	UnitsNet	nuget	github	@angularsen
JavaScript / TypeScript	unitsnet-js	npm	github	@haimkastner
Python	unitsnet-py	pypi	github	@haimkastner
Golang	unitsnet-go	pkg.go.dev	github	@haimkastner