14.2 Use an object before it is created (*)

All code in a knitr document, including the code in code chunks and inline R expressions, is executed in linear order from beginning to end. In theory, you cannot use a variable before it is assigned a value. However, in certain cases, we may want to mention the value of a variable earlier in the document. For example, it is common to present a result in the abstract of an article, but the result is actually computed later in the document. Below is an example that illustrates the idea but will not compile:

  1. ---
  2. title: An important report
  3. abstract: >
  4.   In this analysis, the average value of
  5.   `x` is `r mx`.
  6. ---
  8. We create the object `mx` in the following chunk:
  10. ```{r}
  11. x <- 1:100
  12. mx <- mean(x)
  13. ```

To solve this problem, the value of the object has to be saved somewhere and loaded the next time when the document is compiled. Please note that this means the document has to be compiled at least twice. Below is one possible solution using the saveRDS() function:

  1. ```{r, include=FALSE}
  2. mx <- if (file.exists('mean.rds')) {
  3.   readRDS('mean.rds')
  4. } else {
  5.   "The value of `mx` is not available yet"
  6. }
  7. ```
  9. ---
  10. title: An important report
  11. abstract: >
  12.   In this analysis, the average value of
  13.   `x` is `r mx`.
  14. ---
  16. We create the object `mx` in the following chunk:
  18. ```{r}
  19. x <- 1:100
  20. mx <- mean(x)
  21. saveRDS(mx, 'mean.rds')
  22. ```

The first time you compile this document, you will see the phrase “The value of mx is not available yet” in the abstract. Later, when you compile it again, you will see the actual value of mx.

The function knitr::load_cache() is an alternative solution, which allows you to load the value of an object from a specific code chunk after the chunk has been cached. The idea is similar to the above example, but it will save you the effort of manually saving and loading an object, because the object is automatically saved to the cache database, and you only need to load it via load_cache(). Below is the simplified example:

  1. ---
  2. title: An important report
  3. abstract: >
  4.   In this analysis, the average value of
  5.   `x` is `r knitr::load_cache('mean-x', 'mx')`.
  6. ---
  8. We create the object `mx` in the following chunk:
  10. ```{r mean-x, cache=TRUE}
  11. x <- 1:100
  12. mx <- mean(x)
  13. ```

In this example, we added a chunk label mean-x to the R code chunk (which is passed to the load_cache() function), and cached it using the chunk option cache = TRUE. All objects in this code chunk will be saved to the cache database. Again, you will have to compile this document at least twice, so the object mx can be correctly loaded from the cache database. If the value of mx is not going to be changed in the future, you do not need to compile the document one more time.

If you do not specify the object name in the second argument to load_cache(), the whole cache database will be loaded into the current environment. You can then use any objects that were in the cache database before these objects are created later in the document, e.g.,

  1. knitr::load_cache("mean-x")
  2. x  # the object `x`
  3. mx  # the object `mx`