rmarkdown-2.0.key

YAML Header !

Optional section of render (e.g. pandoc)

options written as key:value pairs (YAML).

At start of file

Between lines of - - -

Text!

Narration formatted with markdown, mixed with:

Code Chunks!

Chunks of embedded code. Each chunk:

Begins with ```{r}

ends with ```

R Markdown will run the code and append the results to the doc.

It will use the location of the .Rmd file as the working directory

Interactive!

Documents

Turn your report into an interactive Shiny !

document in 4 steps

1. Add runtime: shiny to the YAML header.

2. Call Shiny input functions to embed input objects.

3. Call Shiny render functions to embed reactive output.

4. Render with rmarkdown::run or click Run Document in

RStudio IDE

---

output: html_document

runtime: shiny

---

```{r, echo = FALSE}

numericInput("n",

"How many cars?", 5)

renderTable({

head(cars, input$n)

})

```

Embed a complete app into your document with

shiny::shinyAppDir()

NOTE: Your report will rendered as a Shiny app, which means

you must choose an html output format, like html_document,

and serve it with an active R Session.

RStudio® is a trademark of RStudio, Inc. • CC BY SA RStudio • info@rstudio.com • 844-448-1212 • rstudio.com • Learn more at rmarkdown.rstudio.com • rmarkdown 1.6 • Updated: 2016-02

R Markdown : : CHEAT SHEET

Open a new .Rmd file at File ▶ New File ▶ !

R Markdown. Use the wizard that opens to pre-

populate the file with a template

Write document by editing template

Knit document to create report; use knit button or

render() to knit

Preview Output in IDE window

Publish (optional) to web server

Examine build log in R Markdown console

Use output file that is saved along side .Rmd

modify

chunk

options

run all

chunks

run

current

chunk

insert

code

chunk

go to

code

chunk

run code

chunk(s)

publish

show

outline

synch publish

button to

accounts at

rpubs.com,

shinyapps.io

RStudio !

Connect

Reload document

Find in document

File path to output document

set

preview

location

What is R Markdown?

Insert with `r <code>`. Results appear as text without code.

One or more lines surrounded with ```{r} and ```. Place chunk

options within curly braces, aer r. Insert with

Options not listed above: R.options, aniopts, autodep, background, cache.comments, cache.lazy, cache.rebuild, cache.vars, dev, dev.args, dpi,

engine.opts, engine.path, fig.asp, fig.env, fig.ext, fig.keep, fig.lp, fig.path, fig.pos, fig.process, fig.retina, fig.scap, fig.show, fig.showtext, fig.subcap, interval,

out.extra, out.height, out.width, prompt, purl, ref.label, render, size, split, tidy.opts

Embed code with knitr syntax

Built with `r getRversion()` Built with 3.2.3

INLINE CODE CODE CHUNKS

```{r echo=TRUE}

getRversion()

```

Set with knitr::opts_chunk$set(), e.g.

GLOBAL OPTIONS

```{r include=FALSE}

knitr::opts_chunk$set(echo = TRUE)

```

Use rmarkdown::render() to render/knit at cmd line. Important args:

Workflow

input - file to render

output_format

render

rmarkd own

Parameters

Parameterize your documents to reuse with

diﬀerent inputs (e.g., data, values, etc.)

---

params:

n: 100

d: !r Sys.Date()

---

Today’s date

is `r params$d`

1. Add parameters · Create and set

parameters in the header as sub-

values of params

2. Call parameters · Call parameter

values in code as params$<name>

3. Set parameters · Set values wth

Knit with parameters or the params

argument of render():

render("doc.Rmd", params = list(n = 1,

d = as.Date("2015-01-01"))

output_options - !

List of render !

options (as in YAML)

output_file

output_dir

params - list of

params to use

envir - environment !

to evaluate code

chunks in

encoding - of input

file

.rmd Structure

.Rmd files · An R Markdown

(.Rmd) file is a record of your

research. It contains the code that a

scientist needs to reproduce your work

along with the narration that a reader

needs to understand your work.

Reproducible Research · At the click of a

button, or the type of a command, you

can rerun the code in an R Markdown file

to reproduce your work and export the

results as a finished report.

Dynamic Documents · You can choose

to export the finished report in a variety

of formats, including html, pdf, MS

Word, or RTF documents; html or pdf

based slides, Notebooks, and more.

Rmd

cache - cache results for future knits (default =

FALSE)

cache.path - directory to save cached results in

(default = "cache/")

child - file(s) to knit and then include (default =

NULL)

collapse - collapse all output into single block

(default = FALSE)

comment - prefix for each line of results (default = '##')

dependson - chunk dependencies for caching

(default = NULL)

echo - Display code in output document (default =

TRUE)

engine - code language used in chunk (default =

'R')

error - Display error messages in doc (TRUE) or

stop render when errors occur (FALSE) (default =

FALSE)

eval - Run code in chunk (default = TRUE)

message - display code messages in !

document (default = TRUE)

results (default = 'markup')!

'asis' - passthrough results!

'hide' - do not display results!

'hold' - put all results below all code

tidy - tidy code for display (default = FALSE)

warning - display code warnings in document

(default = TRUE)

fig.align - 'le', 'right', or 'center' (default =

'default')

fig.cap - figure caption as character string (default

= NULL)

fig.height, fig.width - Dimensions of plots in

inches

highlight - highlight source code (default = TRUE)

include - Include chunk in doc aer running

(default = TRUE)

IMPORTANT CHUNK OPTIONS

```{r results = 'asis'}

knitr::kable(data, caption = "Table with kable”)

```

```{r results = "asis"}

print(xtable::xtable(data, caption = "Table with xtable”),

type = "html", html.table.attributes = "border=0"))

```

```{r results = "asis"}

stargazer::stargazer(data, type = "html", title = "Table

with stargazer")

```

Plain text

End a line with two spaces

to start a new paragraph.

*italics* and **bold**

`verbatim code`

sub/superscript^2^~2~

~~strikethrough~~

escaped: \* \_ \\

endash: --, emdash: ---

equation: $A = \pi*r^{2}$

equation block:

$$E = mc^{2}$$

> block quote

# Header1 {#anchor}

## Header 2 {#css_id}

### Header 3 {.css_class}

#### Header 4

##### Header 5

###### Header 6

\textbf{Tex ignored in HTML}

<em>HTML ignored in pdfs</em>

<http://www.rstudio.com>

[link](www.rstudio.com)

Jump to [Header 1](#anchor)

image:

![Caption](smallorb.png)

* unordered list

+ sub-item 1

+ sub-item 2

- sub-sub-item 1

* item 2

Continued (indent 4 spaces)

1. ordered list

2. item 2

i) sub-item 1

A. sub-sub-item 1

(@) A list whose numbering

continues aer

(@) an interruption

Term 1

: Definition 1

|------:|:-----|---------|:------:|

| 12 | 12 | 12 | 12 |

| 123 | 123 | 123 | 123 |

| 1 | 1 | 1 | 1 |

- slide bullet 1

- slide bullet 2

(>- to have bullets appear on click)

horizontal rule/slide break:

***

A footnote [^1]

[^1]: Here is the footnote.

Write with syntax on the le to create eﬀect on right (aer render)

Pandoc’s Markdown Set render options with YAML

When you render, R Markdown

1. runs the R code, embeds results and text into .md file with knitr

2. then converts the .md file into the finished format with pandoc

Create a Reusable Template

1. Create a new package with a inst/rmarkdown/templates