TypeScript Integer Type

When working with TypeScript, developers often need to handle integer values precisely. Unlike some programming languages, TypeScript doesn't have a dedicated integer type. Instead, you use the number type combined with validation to ensure values are whole numbers. This guide will walk you through essential techniques for working with integers in TypeScript, from basic type definition to advanced validation and handling precision issues.

Defining an Integer Type in TypeScript

While TypeScript doesn't have a specific integer type, you can use the number type and ensure the value is an integer with type guards or validation functions.

function isInteger(value: number): boolean {
  return Number.isInteger(value);
}

let myInteger: number = 10;
console.log(isInteger(myInteger)); // true

// You can also use type assertion with validation
type Integer = number & { __brand: 'integer' };

function validateInteger(value: number): Integer {
  if (!Number.isInteger(value)) {
    throw new Error('Value must be an integer');
  }
  return value as Integer;
}

// Use in your code
const safeInteger: Integer = validateInteger(42);
// const badInteger: Integer = validateInteger(3.14); // Throws error

This approach uses TypeScript type guards to ensure values are integers before using them. For more complex validation scenarios, consider using TypeScript validation libraries like Zod, which you can integrate with Convex for database schema validation.

For converting between different types, you might also want to check out TypeScript number to string and TypeScript string to number conversions.

Performing Arithmetic Operations with Integers

You can perform arithmetic operations on integers using standard operators like +, -, *, /, and %. However, be aware that division operations might produce decimal results:

let a: number = 10;
let b: number = 3;

// Basic operations
console.log(a + b);  // 13
console.log(a - b);  // 7
console.log(a * b);  // 30
console.log(a / b);  // 3.3333... (decimal result!)
console.log(a % b);  // 1 (modulo operation)

// To ensure integer results from division
console.log(Math.floor(a / b));  // 3 (rounds down)
console.log(Math.trunc(a / b));  // 3 (truncates decimal part)
console.log(Math.round(a / b));  // 3 (rounds to nearest integer)

When working with integer arrays in TypeScript array operations, you'll often need to perform calculations on multiple values. The map function and reduce methods are useful for these operations:

const numbers: number[] = [1, 2, 3, 4, 5];

// Double each number
const doubled = numbers.map(n => n * 2);
console.log(doubled);  // [2, 4, 6, 8, 10]

// Sum all numbers
const sum = numbers.reduce((acc, curr) => acc + curr, 0);
console.log(sum);  // 15

For more advanced type operations, you might want to explore TypeScript cast techniques when dealing with complex integer scenarios. When building real-world applications, you can leverage Convex functions to handle integer validation at the database level.

Converting a String to an Integer

Converting strings to integers is a common task in TypeScript. Use the parseInt() function for this purpose, but be aware of potential pitfalls:

// Basic string to integer conversion
let stringValue: string = "42";
let integer: number = parseInt(stringValue);
console.log(integer); // 42

// Always specify the radix (base)
let hexString: string = "0xFF";
let decimalValue: number = parseInt(hexString, 16);
console.log(decimalValue); // 255

// Handle edge cases
console.log(parseInt("10.9"));      // 10 (truncates decimals)
console.log(parseInt("10px"));      // 10 (stops at non-numeric)
console.log(parseInt("abc"));       // NaN (not a number)
console.log(parseInt(""));          // NaN (empty string)

// Alternative: Number() for stricter conversion
console.log(Number("10"));          // 10
console.log(Number("10.9"));        // 10.9 (preserves decimals)
console.log(Number("10px"));        // NaN (doesn't allow non-numeric)

For comprehensive type conversion operations, refer to TypeScript string to number conversions. When working with user input in forms or API requests, you'll often need to convert strings to integers before validation. Consider using Convex validation functions to ensure data integrity at the database level.

If you need to convert numbers back to strings, see TypeScript number to string for various formatting options. The TypeScript typeof operator can help verify type conversions were successful.

Validating Integer Input

Validate integer input with type checking and value validation.

function validateIntegerInput(value: string): boolean {
  const parsed = parseInt(value, 10);
  return !isNaN(parsed) && Number.isInteger(parsed) && String(parsed) === value.trim();
}

console.log(validateIntegerInput("10"));     // true
console.log(validateIntegerInput("10.5"));   // false
console.log(validateIntegerInput("10px"));   // false
console.log(validateIntegerInput("abc"));    // false
console.log(validateIntegerInput(" 10 "));   // true

// More robust validation for specific ranges
function validateIntegerRange(value: string, min: number, max: number): boolean {
  const parsed = parseInt(value, 10);
  return !isNaN(parsed) && Number.isInteger(parsed) && parsed >= min && parsed <= max;
}

// Validate positive integers only
function validatePositiveInteger(value: string): boolean {
  const parsed = parseInt(value, 10);
  return !isNaN(parsed) && Number.isInteger(parsed) && parsed > 0;
}

For form validation in real applications, consider using Convex functions with validation. This ensures data integrity at both the client and server level. The TypeScript typeof operator helps with runtime type checking, while TypeScript string to number conversions are essential for processing user input.

When working with collections of integers, TypeScript array methods like every() and some() can help validate multiple values at once:

const values: string[] = ["1", "2", "3", "4", "5"];
const allIntegers = values.every(val => validateIntegerInput(val));
console.log(allIntegers); // true

Checking if a Number is an Integer

Use the Number.isInteger() function to check if a number is an integer.

// Basic integer checks
console.log(Number.isInteger(10));     // true
console.log(Number.isInteger(10.0));   // true (still an integer)
console.log(Number.isInteger(10.5));   // false
console.log(Number.isInteger("10"));   // false (string)
console.log(Number.isInteger(NaN));    // false
console.log(Number.isInteger(Infinity)); // false

// Creating a type guard function
function isInteger(value: unknown): value is number {
  return typeof value === 'number' && Number.isInteger(value);
}

// Using the type guard
const values: unknown[] = [10, "10", 10.5, null, true];
const integers = values.filter(isInteger);
console.log(integers); // [10]

// Custom validation for specific use cases
function isSafeInteger(value: number): boolean {
  return Number.isInteger(value) && 
         value >= Number.MIN_SAFE_INTEGER && 
         value <= Number.MAX_SAFE_INTEGER;
}

The TypeScript typeof operator works together with Number.isInteger() to create robust type guards. When working with arrays of values, TypeScript array methods like filter() help separate integers from other values.

For database operations, consider using TypeScript validation patterns in your Convex functions to ensure data integrity. Type checking is especially important when dealing with user input or external data sources.

Handling Integer Overflow

JavaScript and TypeScript use IEEE 754 double-precision floating-point numbers, which have limits for representing integers. Beyond these limits, precision is lost:

// Safe integer limits
console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991
console.log(Number.MIN_SAFE_INTEGER);  // -9007199254740991

// Checking if an integer is safe
function isSafeInteger(value: number): boolean {
  return Number.isSafeInteger(value);
}

// When precision is lost
const largeNumber = Number.MAX_SAFE_INTEGER + 1;
console.log(largeNumber);  // 9007199254740992
console.log(largeNumber + 1);  // 9007199254740992 (no change!)

// Using BigInt for larger integers
const bigInteger = BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1);
console.log(bigInteger.toString());  // 9007199254740992n

// Converting between Number and BigInt
const bigToNumber = Number(BigInt(42));
const numberToBig = BigInt(42);

// Note: BigInt cannot be mixed with regular numbers in operations
// const invalid = bigInteger + 1;  // TypeError
const valid = bigInteger + BigInt(1);

When working with large numbers in TypeScript applications, consider using Convex's TypeScript best practices to handle data integrity issues. For complex calculations that might exceed safe integer limits, explore TypeScript cast operations to work with BigInt values.

The built-in BigInt type provides arbitrary-precision integers but requires careful handling when converting between number types. For database operations with large integers, Convex validation can help ensure values stay within safe ranges.

Using Integer-Specific Functions

TypeScript provides several functions useful for working with integers, primarily through the Math object:

// Rounding functions
const number: number = 10.7;
console.log(Math.floor(number));   // 10 (rounds down)
console.log(Math.ceil(number));    // 11 (rounds up)
console.log(Math.round(number));   // 11 (rounds to nearest)
console.log(Math.trunc(number));   // 10 (removes decimal)

// Working with absolute values
console.log(Math.abs(-42));        // 42

// Finding min/max in arrays
const numbers: number[] = [5, 2, 8, 1, 9];
console.log(Math.min(...numbers)); // 1
console.log(Math.max(...numbers)); // 9

// Generating random integers
function randomInteger(min: number, max: number): number {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log(randomInteger(1, 10)); // Random integer between 1 and 10

// Converting to specific bases
const decimal: number = 255;
console.log(decimal.toString(16)); // "ff" (hexadecimal)
console.log(decimal.toString(2));  // "11111111" (binary)

When working with collections of integers, TypeScript array methods complement these Math functions. For data validation in your applications, Convex's validation system supports integer constraints and transformations.

These functions are essential when building applications that process numeric data. For more complex mathematical operations, consider exploring TypeScript map operations to apply transformations across arrays of integers.

Final Thoughts on TypeScript Integer Handling

Working with integers in TypeScript requires careful validation and awareness of JavaScript's number type limitations. Always validate user input, use type guards for runtime checks, and be mindful of safe integer limits. For values beyond Number.MAX_SAFE_INTEGER, consider using BigInt for arbitrary-precision arithmetic.