PHP's round in TypeScript

How to use

Install via yarn add locutus and import: import { round } from 'locutus/php/math/round'.

Or with CommonJS: const { round } = require('locutus/php/math/round')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	round(1241757, -3)	1242000
2	round(3.6)	4
3	round(2.835, 2)	2.84
4	round(1.1749999999999, 2)	1.17
5	round(58551.799999999996, 2)	58551.8
6	round(4096.485, 2)	4096.49

Dependencies

This function uses the following Locutus functions:

• _php_cast_float (php/_helpers)
• _php_cast_int (php/_helpers)

Here's what our current TypeScript equivalent to PHP's round looks like.

TSTypeScript JSJavaScript TSStandalone TS JSStandalone JS

Copy code

function roundToInt(value: number, mode: string): number {
  let tmp = Math.floor(Math.abs(value) + 0.5)

  if (
    (mode === 'PHP_ROUND_HALF_DOWN' && value === tmp - 0.5) ||
    (mode === 'PHP_ROUND_HALF_EVEN' && value === 0.5 + 2 * Math.floor(tmp / 2)) ||
    (mode === 'PHP_ROUND_HALF_ODD' && value === 0.5 + 2 * Math.floor(tmp / 2) - 1)
  ) {
    tmp -= 1
  }

  return value < 0 ? -tmp : tmp
}

import { _php_cast_float as floatCast } from '../_helpers/_php_cast_float.ts'
import { _php_cast_int as intCast } from '../_helpers/_php_cast_int.ts'

export function round(value: number, precision = 0, mode = 'PHP_ROUND_HALF_UP'): number {
  //      discuss at: https://locutus.io/php/round/
  // parity verified: PHP 8.3
  //     original by: Philip Peterson
  //      revised by: Onno Marsman (https://twitter.com/onnomarsman)
  //      revised by: T.Wild
  //      revised by: Rafał Kukawski (https://blog.kukawski.pl)
  //        input by: Greenseed
  //        input by: meo
  //        input by: William
  //        input by: Josep Sanz (https://www.ws3.es/)
  //     bugfixed by: Brett Zamir (https://brett-zamir.me)
  //      revised by: Rafał Kukawski
  //       example 1: round(1241757, -3)
  //       returns 1: 1242000
  //       example 2: round(3.6)
  //       returns 2: 4
  //       example 3: round(2.835, 2)
  //       returns 3: 2.84
  //       example 4: round(1.1749999999999, 2)
  //       returns 4: 1.17
  //       example 5: round(58551.799999999996, 2)
  //       returns 5: 58551.8
  //       example 6: round(4096.485, 2)
  //       returns 6: 4096.49

  let p

  // the code is heavily based on the native PHP implementation
  // https://github.com/php/php-src/blob/PHP-7.4/ext/standard/math.c#L355

  value = floatCast(value)
  precision = intCast(precision)
  p = Math.pow(10, precision)

  if (isNaN(value) || !isFinite(value)) {
    return value
  }

  // if value already integer and positive precision
  // then nothing to do, return early
  if (Math.trunc(value) === value && precision >= 0) {
    return value
  }

  // PHP does a pre-rounding before rounding to desired precision
  // https://wiki.php.net/rfc/rounding#pre-rounding_to_the_value_s_precision_if_possible
  const preRoundPrecision = 14 - Math.floor(Math.log10(Math.abs(value)))

  if (preRoundPrecision > precision && preRoundPrecision - 15 < precision) {
    value = roundToInt(value * Math.pow(10, preRoundPrecision), mode)
    value /= Math.pow(10, Math.abs(precision - preRoundPrecision))
  } else {
    value *= p
  }

  value = roundToInt(value, mode)

  return value / p
}

function roundToInt(value, mode) {
  let tmp = Math.floor(Math.abs(value) + 0.5)

  if (
    (mode === 'PHP_ROUND_HALF_DOWN' && value === tmp - 0.5) ||
    (mode === 'PHP_ROUND_HALF_EVEN' && value === 0.5 + 2 * Math.floor(tmp / 2)) ||
    (mode === 'PHP_ROUND_HALF_ODD' && value === 0.5 + 2 * Math.floor(tmp / 2) - 1)
  ) {
    tmp -= 1
  }

  return value < 0 ? -tmp : tmp
}

import { _php_cast_float as floatCast } from '../_helpers/_php_cast_float.ts'
import { _php_cast_int as intCast } from '../_helpers/_php_cast_int.ts'

export function round(value, precision = 0, mode = 'PHP_ROUND_HALF_UP') {
  //      discuss at: https://locutus.io/php/round/
  // parity verified: PHP 8.3
  //     original by: Philip Peterson
  //      revised by: Onno Marsman (https://twitter.com/onnomarsman)
  //      revised by: T.Wild
  //      revised by: Rafał Kukawski (https://blog.kukawski.pl)
  //        input by: Greenseed
  //        input by: meo
  //        input by: William
  //        input by: Josep Sanz (https://www.ws3.es/)
  //     bugfixed by: Brett Zamir (https://brett-zamir.me)
  //      revised by: Rafał Kukawski
  //       example 1: round(1241757, -3)
  //       returns 1: 1242000
  //       example 2: round(3.6)
  //       returns 2: 4
  //       example 3: round(2.835, 2)
  //       returns 3: 2.84
  //       example 4: round(1.1749999999999, 2)
  //       returns 4: 1.17
  //       example 5: round(58551.799999999996, 2)
  //       returns 5: 58551.8
  //       example 6: round(4096.485, 2)
  //       returns 6: 4096.49

  let p

  // the code is heavily based on the native PHP implementation
  // https://github.com/php/php-src/blob/PHP-7.4/ext/standard/math.c#L355

  value = floatCast(value)
  precision = intCast(precision)
  p = Math.pow(10, precision)

  if (isNaN(value) || !isFinite(value)) {
    return value
  }

  // if value already integer and positive precision
  // then nothing to do, return early
  if (Math.trunc(value) === value && precision >= 0) {
    return value
  }

  // PHP does a pre-rounding before rounding to desired precision
  // https://wiki.php.net/rfc/rounding#pre-rounding_to_the_value_s_precision_if_possible
  const preRoundPrecision = 14 - Math.floor(Math.log10(Math.abs(value)))

  if (preRoundPrecision > precision && preRoundPrecision - 15 < precision) {
    value = roundToInt(value * Math.pow(10, preRoundPrecision), mode)
    value /= Math.pow(10, Math.abs(precision - preRoundPrecision))
  } else {
    value *= p
  }

  value = roundToInt(value, mode)

  return value / p
}

// php/_helpers/_phpTypes (Locutus helper dependency)
type PhpNullish = null | undefined

type PhpInput = {} | PhpNullish

// php/_helpers/_php_cast_int (Locutus helper dependency)
type CastIntValue = PhpInput

function _php_cast_int(value: CastIntValue): number {
  // original by: Rafał Kukawski

  if (typeof value === 'number') {
    if (isNaN(value) || !isFinite(value)) {
      // from PHP 7, NaN and Infinity are casted to 0
      return 0
    }

    return value < 0 ? Math.ceil(value) : Math.floor(value)
  }
  if (typeof value === 'string') {
    return parseInt(value, 10) || 0
  }

  // Behaviour for types other than float, string, boolean
  // is undefined and can change any time.
  // To not invent complex logic
  // that mimics PHP 7.0 behaviour
  // casting value->bool->number is used
  return +!!value
}

// php/_helpers/_php_cast_float (Locutus helper dependency)
const __php_cast_int = _php_cast_int;

type CastFloatValue = PhpInput

function _php_cast_float(value: CastFloatValue): number {
  // original by: Rafał Kukawski

  if (typeof value === 'number') {
    return value
  }
  if (typeof value === 'string') {
    return parseFloat(value) || 0
  }

  // PHP docs state, that for types other than string
  // conversion is {input type}->int->float
  return __php_cast_int(value)
}

// php/math/round (target function module)
const floatCast = _php_cast_float;
const intCast = _php_cast_int;

function roundToInt(value: number, mode: string): number {
  let tmp = Math.floor(Math.abs(value) + 0.5)

  if (
    (mode === 'PHP_ROUND_HALF_DOWN' && value === tmp - 0.5) ||
    (mode === 'PHP_ROUND_HALF_EVEN' && value === 0.5 + 2 * Math.floor(tmp / 2)) ||
    (mode === 'PHP_ROUND_HALF_ODD' && value === 0.5 + 2 * Math.floor(tmp / 2) - 1)
  ) {
    tmp -= 1
  }

  return value < 0 ? -tmp : tmp
}

function round(value: number, precision = 0, mode = 'PHP_ROUND_HALF_UP'): number {
  //      discuss at: https://locutus.io/php/round/
  // parity verified: PHP 8.3
  //     original by: Philip Peterson
  //      revised by: Onno Marsman (https://twitter.com/onnomarsman)
  //      revised by: T.Wild
  //      revised by: Rafał Kukawski (https://blog.kukawski.pl)
  //        input by: Greenseed
  //        input by: meo
  //        input by: William
  //        input by: Josep Sanz (https://www.ws3.es/)
  //     bugfixed by: Brett Zamir (https://brett-zamir.me)
  //      revised by: Rafał Kukawski
  //       example 1: round(1241757, -3)
  //       returns 1: 1242000
  //       example 2: round(3.6)
  //       returns 2: 4
  //       example 3: round(2.835, 2)
  //       returns 3: 2.84
  //       example 4: round(1.1749999999999, 2)
  //       returns 4: 1.17
  //       example 5: round(58551.799999999996, 2)
  //       returns 5: 58551.8
  //       example 6: round(4096.485, 2)
  //       returns 6: 4096.49

  let p

  // the code is heavily based on the native PHP implementation
  // https://github.com/php/php-src/blob/PHP-7.4/ext/standard/math.c#L355

  value = floatCast(value)
  precision = intCast(precision)
  p = Math.pow(10, precision)

  if (isNaN(value) || !isFinite(value)) {
    return value
  }

  // if value already integer and positive precision
  // then nothing to do, return early
  if (Math.trunc(value) === value && precision >= 0) {
    return value
  }

  // PHP does a pre-rounding before rounding to desired precision
  // https://wiki.php.net/rfc/rounding#pre-rounding_to_the_value_s_precision_if_possible
  const preRoundPrecision = 14 - Math.floor(Math.log10(Math.abs(value)))

  if (preRoundPrecision > precision && preRoundPrecision - 15 < precision) {
    value = roundToInt(value * Math.pow(10, preRoundPrecision), mode)
    value /= Math.pow(10, Math.abs(precision - preRoundPrecision))
  } else {
    value *= p
  }

  value = roundToInt(value, mode)

  return value / p
}

// php/_helpers/_php_cast_int (Locutus helper dependency)
function _php_cast_int(value) {
  // original by: Rafał Kukawski

  if (typeof value === 'number') {
    if (isNaN(value) || !isFinite(value)) {
      // from PHP 7, NaN and Infinity are casted to 0
      return 0
    }

    return value < 0 ? Math.ceil(value) : Math.floor(value)
  }
  if (typeof value === 'string') {
    return parseInt(value, 10) || 0
  }

  // Behaviour for types other than float, string, boolean
  // is undefined and can change any time.
  // To not invent complex logic
  // that mimics PHP 7.0 behaviour
  // casting value->bool->number is used
  return +!!value
}

// php/_helpers/_php_cast_float (Locutus helper dependency)
const __php_cast_int = _php_cast_int

function _php_cast_float(value) {
  // original by: Rafał Kukawski

  if (typeof value === 'number') {
    return value
  }
  if (typeof value === 'string') {
    return parseFloat(value) || 0
  }

  // PHP docs state, that for types other than string
  // conversion is {input type}->int->float
  return __php_cast_int(value)
}

// php/math/round (target function module)
const floatCast = _php_cast_float
const intCast = _php_cast_int

function roundToInt(value, mode) {
  let tmp = Math.floor(Math.abs(value) + 0.5)

  if (
    (mode === 'PHP_ROUND_HALF_DOWN' && value === tmp - 0.5) ||
    (mode === 'PHP_ROUND_HALF_EVEN' && value === 0.5 + 2 * Math.floor(tmp / 2)) ||
    (mode === 'PHP_ROUND_HALF_ODD' && value === 0.5 + 2 * Math.floor(tmp / 2) - 1)
  ) {
    tmp -= 1
  }

  return value < 0 ? -tmp : tmp
}

function round(value, precision = 0, mode = 'PHP_ROUND_HALF_UP') {
  //      discuss at: https://locutus.io/php/round/
  // parity verified: PHP 8.3
  //     original by: Philip Peterson
  //      revised by: Onno Marsman (https://twitter.com/onnomarsman)
  //      revised by: T.Wild
  //      revised by: Rafał Kukawski (https://blog.kukawski.pl)
  //        input by: Greenseed
  //        input by: meo
  //        input by: William
  //        input by: Josep Sanz (https://www.ws3.es/)
  //     bugfixed by: Brett Zamir (https://brett-zamir.me)
  //      revised by: Rafał Kukawski
  //       example 1: round(1241757, -3)
  //       returns 1: 1242000
  //       example 2: round(3.6)
  //       returns 2: 4
  //       example 3: round(2.835, 2)
  //       returns 3: 2.84
  //       example 4: round(1.1749999999999, 2)
  //       returns 4: 1.17
  //       example 5: round(58551.799999999996, 2)
  //       returns 5: 58551.8
  //       example 6: round(4096.485, 2)
  //       returns 6: 4096.49

  let p

  // the code is heavily based on the native PHP implementation
  // https://github.com/php/php-src/blob/PHP-7.4/ext/standard/math.c#L355

  value = floatCast(value)
  precision = intCast(precision)
  p = Math.pow(10, precision)

  if (isNaN(value) || !isFinite(value)) {
    return value
  }

  // if value already integer and positive precision
  // then nothing to do, return early
  if (Math.trunc(value) === value && precision >= 0) {
    return value
  }

  // PHP does a pre-rounding before rounding to desired precision
  // https://wiki.php.net/rfc/rounding#pre-rounding_to_the_value_s_precision_if_possible
  const preRoundPrecision = 14 - Math.floor(Math.log10(Math.abs(value)))

  if (preRoundPrecision > precision && preRoundPrecision - 15 < precision) {
    value = roundToInt(value * Math.pow(10, preRoundPrecision), mode)
    value /= Math.pow(10, Math.abs(precision - preRoundPrecision))
  } else {
    value *= p
  }

  value = roundToInt(value, mode)

  return value / p
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

---

« More PHP math functions

Star