Option to read numeric JSON data always as doubles

[alusiani]

It would be nice to have an option in the function fromJSON() to return doubles instead of integers, even if all numbers in the JSON string are without a decimal point or exponential format. I have some software that stores in JSON in some cases large full correlation matrices composet of just "1"s, this is a very compact format. I'd like to be able to read them back as doubles instead of integers, providing some option.

[jeroen]

What would be the benefit? R automatically coerces integers to doubles when needed so it should not change anything in your results.

[alusiani]

Thanks for the reply. I concur that the benefit is minor.

I wrote some code that reads JSON saved data for quantities with uncertainties and correlations into the R package "errors" uncertain variables, and ran into problems if I did not explicitly convert to doubles what fromJSON() returns. When using toJSON(), it silently outputs numbers that would be read back as integers if that is possible, so when going through the chain toJSON() ... fromJSON() one can start with doubles and end up with integers. If I find the time I could perhaps propose a patch, if it has a chance to be approved. I also can imagine that if the conversion is set to always be to doubles there might be speed advantages w.r.t. the case when for each conversion the code first identifies whether JSON data corresponds to integers or doubles.

[jeroen]

You can force decimals in toJSON() by setting always_decimal = TRUE like so:

jsonlite::toJSON(as.double(1:3), always_decimal = TRUE)

So that will allow you to keep the types when roundtripping:

x <- 1:3
typeof(fromJSON(toJSON(x, always_decimal = TRUE)))


x <- as.double(1:3)
typeof(fromJSON(toJSON(x, always_decimal = TRUE)))

I don't think it makes sense to do this in the parser.

[alusiani]

Thanks again, I agree that this is a solution. In my present scheme, going from "1" to "1.0" will double the space required for large 100% correlation matrices, but for most use cases what you propose is certainly acceptable.

I take the opportunity to mention that I did see the option "always_decimal" mentioned in the web, several years ago, but it does not seem to be documented. Here is the toJSON() help I see:

toJSON, fromJSON           package:jsonlite            R Documentation

Convert R objects to/from JSON

Description:

     These functions are used to convert between JSON data and R
     objects. The ‘toJSON()’ and ‘fromJSON()’ functions use a class
     based mapping, which follows conventions outlined in this paper:
     <https://arxiv.org/abs/1403.2805> (also available as vignette).

Usage:

     fromJSON(
       txt,
       simplifyVector = TRUE,
       simplifyDataFrame = simplifyVector,
       simplifyMatrix = simplifyVector,
       flatten = FALSE,
       ...
     )
     
     toJSON(
       x,
       dataframe = c("rows", "columns", "values"),
       matrix = c("rowmajor", "columnmajor"),
       Date = c("ISO8601", "epoch"),
       POSIXt = c("string", "ISO8601", "epoch", "mongo"),
       factor = c("string", "integer"),
       complex = c("string", "list"),
       raw = c("base64", "hex", "mongo", "int", "js"),
       null = c("list", "null"),
       na = c("null", "string"),
       auto_unbox = FALSE,
       digits = 4,
       pretty = FALSE,
       force = FALSE,
       ...
     )

     
Arguments:

     txt: a JSON string, URL or file

simplifyVector: coerce JSON arrays containing only primitives into an
          atomic vector

simplifyDataFrame: coerce JSON arrays containing only records (JSON
          objects) into a data frame

simplifyMatrix: coerce JSON arrays containing vectors of equal mode and
          dimension into matrix or array

 flatten: automatically ‘flatten()’ nested data frames into a single
          non-nested data frame

     ...: arguments passed on to class specific ‘print’ methods

       x: the object to be encoded

dataframe: how to encode data.frame objects: must be one of 'rows',
          'columns' or 'values'

  matrix: how to encode matrices and higher dimensional arrays: must be
          one of 'rowmajor' or 'columnmajor'.

    Date: how to encode Date objects: must be one of 'ISO8601' or
          'epoch'

  POSIXt: how to encode POSIXt (datetime) objects: must be one of
          'string', 'ISO8601', 'epoch' or 'mongo'

  factor: how to encode factor objects: must be one of 'string' or
          'integer'

 complex: how to encode complex numbers: must be one of 'string' or
          'list'

     raw: how to encode raw objects: must be one of 'base64', 'hex' or
          'mongo'

    null: how to encode NULL values within a list: must be one of
          'null' or 'list'

      na: how to print NA values: must be one of 'null' or 'string'.
          Defaults are class specific

auto_unbox: automatically ‘unbox()’ all atomic vectors of length 1. It
          is usually safer to avoid this and instead use the ‘unbox()’
          function to unbox individual elements. An exception is that
          objects of class ‘AsIs’ (i.e. wrapped in ‘I()’) are not
          automatically unboxed. This is a way to mark single values as
          length-1 arrays.

  digits: max number of decimal digits to print for numeric values. Use
          ‘I()’ to specify significant digits. Use ‘NA’ for max
          precision.

  pretty: adds indentation whitespace to JSON output. Can be TRUE/FALSE
          or a number specifying the number of spaces to indent
          (default is 2). Use a negative number for tabs instead of
          spaces.

   force: unclass/skip objects of classes with no defined JSON mapping

Details:

     The ‘toJSON()’ and ‘fromJSON()’ functions are drop-in replacements
     for the identically named functions in packages ‘rjson’ and
     ‘RJSONIO’. Our implementation uses an alternative, somewhat more
     consistent mapping between R objects and JSON strings.

     The ‘serializeJSON()’ and ‘unserializeJSON()’ functions in this
     package use an alternative system to convert between R objects and
     JSON, which supports more classes but is much more verbose.

     A JSON string is always unicode, using ‘UTF-8’ by default, hence
     there is usually no need to escape any characters. However, the
     JSON format does support escaping of unicode characters, which are
     encoded using a backslash followed by a lower case ‘"u"’ and 4 hex
     characters, for example: ‘"Z\u00FCrich"’. The ‘fromJSON’ function
     will parse such escape sequences but it is usually preferable to
     encode unicode characters in JSON using native ‘UTF-8’ rather than
     escape sequences.

References:

     Jeroen Ooms (2014). The ‘jsonlite’ Package: A Practical and
     Consistent Mapping Between JSON Data and R Objects.
     _arXiv:1403.2805_. <https://arxiv.org/abs/1403.2805>

See Also:

     ‘read_json()’, ‘stream_in()’

Examples:

     # Stringify some data
     jsoncars <- toJSON(mtcars, pretty=TRUE)
     cat(jsoncars)
     
     # Parse it back
     fromJSON(jsoncars)
     
     # Parse escaped unicode
     fromJSON('{"city" : "Z\\u00FCrich"}')
     
     # Decimal vs significant digits
     toJSON(pi, digits=3)
     toJSON(pi, digits=I(3))
     
     ## Not run:
    
     #retrieve data frame
     data1 <- fromJSON("https://api.github.com/users/hadley/orgs")
     names(data1)
     data1$login
     
     # Nested data frames:
     data2 <- fromJSON("https://api.github.com/users/hadley/repos")
     names(data2)
     names(data2$owner)
     data2$owner$login
     
     # Flatten the data into a regular non-nested dataframe
     names(flatten(data2))
     
     # Flatten directly (more efficient):
     data3 <- fromJSON("https://api.github.com/users/hadley/repos", flatten = TRUE)
     identical(data3, flatten(data2))
     ## End(Not run)

R version 4.4.3 (2025-02-28)
Platform: x86_64-redhat-linux-gnu
Running under: Fedora Linux 41 (KDE Plasma)

Matrix products: default
BLAS/LAPACK: FlexiBLAS OPENBLAS-OPENMP;  LAPACK version 3.12.0

locale:
 [1] LC_CTYPE=en_IE.UTF-8       LC_NUMERIC=C              
 [3] LC_TIME=en_IE.UTF-8        LC_COLLATE=en_IE.UTF-8    
 [5] LC_MONETARY=en_IE.UTF-8    LC_MESSAGES=en_IE.UTF-8   
 [7] LC_PAPER=en_IE.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C            
[11] LC_MEASUREMENT=en_IE.UTF-8 LC_IDENTIFICATION=C       

time zone: Europe/Rome
tzcode source: system (glibc)

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] jsonlite_2.0.0

loaded via a namespace (and not attached):
[1] compiler_4.4.3 tools_4.4.3