Gjør et R Markdown-dokument til en interaktiv opplevelse

R Markdown er en av mine favoritt ting om moderne R. Det gir en enkel måte å kombinere tekst, R-kode og resultatene av R-kode i et enkelt dokument. Og når dette dokumentet er gjengitt som HTML, kan du legge til litt brukerinteraksjon med HTML-widgets som DT for tabeller eller brosjyre for kart. (Hvis du ikke er kjent med R Markdown, kan du sjekke ut videoopplæringen min for R Markdown først og deretter komme tilbake hit.)

Men du vet kanskje ikke at det er en måte å forbedre R Markdown-interaktivitet enda mer: ved å legge til kjøretid: skinnende til dokumenthodet.

Shiny er et rammeverk for webapplikasjon for R. Som et rammeverk har det en ganske spesifikk struktur. Du kan imidlertid konvertere et R Markdown-dokument til en skinnende app uten å måtte følge mye av den stive strukturen. I stedet kan du hoppe rett inn og begynne å kode - uten å bekymre deg for noen typiske blanke oppgaver, som å sørge for at alle parenteser og kommaer er riktige innenfor dypt nestede layoutfunksjoner.

Faktisk, selv om du er en erfaren skinnende utvikler, kan et R Markdown-dokument fremdeles være nyttig for skinnende oppgaver der du ikke trenger et fullverdig program eller for å prøve ut koden raskt. Det vil fortsatt trenge en skinnende server, men hvis du har RStudio og den blanke pakken installert, har du allerede en av dem lokalt.

La oss ta en titt på hvordan runtime shiny fungerer i R Markdown.

1. Grunnleggende R Markdown

Jeg begynner med et konvensjonelt, ikke-skinnende R Markdown-dokument som har en søkbar datatabell etter Massachusetts postnummer. Brukere kan søke eller sortere etter en hvilken som helst tabellkolonne og svare på spørsmål som "Hvilke postnummer har den høyeste median husstandsinntekten Middlesex County?" eller “Hvilke postnummer har den dyreste månedlige boligen?”

Sharon Machlis /

Dette dokumentet har også et histogram som viser fordeling av husstandsinntektene og tekst som angir hvilke postnummer som har høyest og lavest inntekt. Tabellen er interaktiv, men resten av dokumentet ikke. Du kan se den gjengitte HTML-versjonen på RStudios RPubs.

Hvis du vil følge med, kan du se kode for en frittstående versjon av dette R Markdown-dokumentet - inkludert data - på GitHub. Eller hvis du vil se hvordan jeg fikk disse demografiske dataene til R, er det R-kode i denne artikkelen for å lage ditt eget datasett (og du kan tilpasse koden for å velge en annen tilstand). Hvis du oppretter din egen versjon av dataene, er koden for et grunnleggende R Markdown-dokument med en egen datafil også på GitHub.

Uansett hvilket R Markdown-dokument du velger, ser du at det er et stort sett statisk dokument med noe interaktivitet. Men hva om jeg vil ha hele dokumentet for å være interaktiv — i dette tilfellet, se histogram og tekstendring samt tabellen? Hvordan kan brukeren være i stand til å velge individuelle byer og se alle informasjon filtrert for å vises bare for disse stedene?

En løsning er å generere en side for hver by - mulig med et R-skript hvis du bruker det som kalles parametrerte rapporter. Du kan imidlertid også opprette et enkelt R Markdown-dokument som fungerer som en interaktiv app.

Legg til skinnende interaktivitet

For å legge til skinnende interaktivitet i et konvensjonelt R Markdown-dokument, begynn med å legge til kjøretid: skinnende til dokumentets YAML-overskrift, for eksempel:

---

tittel: "Median husholdningsinntekt etter postnummer"

utgang: html_document

kjøretid: skinnende

---

Når du har gjort det og trykker Lagre, blir strikkeikonet i RStudio til "Kjør dokument." Selv om utdataene fremdeles sier "html_document", vil det ikke være vanlig HTML lenger. Det er nå et mini-skinnende program.

Sharon Machlis /

Sharon Machlis,

La brukerne ta datavalg

Nå trenger jeg en måte for brukere å ta sine datavalg. Shiny har en rekke “input widgets” for dette. Jeg bruker selectInput (), som oppretter en rullegardinliste og lar brukerne velge mer enn ett element. Shiny har andre småprogram for radioknapper, tekstinnganger, datovelgere og mer. Du kan se en samling av dem på RStudio’s Shiny Widgets Gallery.

Kode for mineappene mine selectInput () rullegardinlisten har fem argumenter og ser slik ut:

selectInput ("mycities", "Velg 1 eller flere byer:",
valg = sortering (unik (markdowndata $ by)),
valgt = "Boston", multiple = SANT)

Det første argumentet tilselectInput (), mycities er variabelnavnet jeg har valgt for å lagre verdiene brukeren velger. Det andre argumentet er overskriftsteksten som vises med rullegardinlisten. Det tredje argumentet, valg, er en vektor av alle mulige verdier i rullegardinlisten — i dette tilfellet unike verdier av bynavn i mine data, sortert alfabetisk. valgt = Boston betyr at rullegardinmenyen som standard er at Boston er den valgte byen (å velge et standardvalg er valgfritt). Og endelig, multiple = SANT lar brukerne velge mer enn en by om gangen.

Denne koden oppretter HTML-rullegardinlisten. Hvis du kjører det selectInput () kode i R-konsollen din, vil den generere HTML for rullegardinmenyen (forutsatt at du har Shiny lastet inn og en dataramme kalt markdowndata med en City-kolonne).

Deretter må jeg skrive noen R slik at rullegardinmenyen faktisk gjør noe.

Lag dynamiske variabler

Jeg vil kode denne interaktivitetslogikken i to deler:

Lag en dataramme - jeg vil kalle det mydata—Det filtreres hver gang brukeren velger en by.
Skriv kode for tekst, histogram og datatabell som alle vil endres basert på min dynamiske dataramme.

Det viktigste å huske på på dette punktet er at disse objektene ikke lenger er "vanlige" R-variabler. De er dynamisk. De endring basert på brukerhandlinger. Og det betyr at de fungerer litt annerledes enn variabler du sannsynligvis er vant til.

Hva er spesielt med dem? Her er de tre tingene du trenger å vite:

For å få tilgang til verdien av en inngangsvariabel som lagrer informasjon fra brukeren din, trenger du syntaksen skriv inn $ myvarname, ikke bare myvarname. Så for verdier som er lagret i mycities rullegardinliste, bruk skriv inn $ mycities.
Objekter som grafer og tabeller som er avhengig av verdiene fra brukeren din, er også dynamiske og må være reaktive. Det er like enkelt som å pakke dem inn i en spesiell funksjon, men du må huske å gjøre det. De kan heller ikke nås med bare navnene sine, men krever også parenteser: en syntaks som myvar () og ikke myvar.
Når duvise dynamisk innhold - igjen, ting som en tabell, et kart, et histogram eller til og med tekst - det må gjengis på en spesiell måte, vanligvis ved å bruke en av Shiny's spesielle gjengivelsesfunksjoner. Den gode nyheten er at Shiny tar seg av det meste av funksjonaliteten til å overvåke endringer og beregne resultater. Du trenger bare å vite hvilken funksjon du skal bruke, og deretter inkludere den i koden din.

Dette er ofte enklere enn det kan høres ut. Slik oppretter jeg en dataramme som heter mydata som endres hver gang brukeren velger en by med mycities selectInput () fall ned :

mydata <- reaktiv ({

filter (markdowndata, City% i% input $ mycities)

})

De mydata gjenstand har nå en reaktivt uttrykkog vil endre verdi hver gang brukeren gjør en endring i rullegardinlisten som kontrollerer mycities.

Vis dynamiske variabler

Nå vil jeg kode en tabell ved hjelp av det filtrerte mydata data.

Som du kanskje har gjettet nå, DT :: datatable (mydata) vil ikke fungere. Og det er to grunner til hvorfor.

Først fordi mydata er et reaktivt uttrykk, kan du ikke referere til det ved navn alene. Det trenger parentes etter det, som f.eksmydata ().

Men for det andreDT :: datatable (mydata ()) fungerer heller ikke som frittstående kode. Du får en feilmelding som dette:

Drift er ikke tillatt uten en aktiv reaktiv kontekst.

(Du prøvde å gjøre noe som bare kan gjøres innenfra

et reaktivt uttrykk eller observatør.)

Du kan se versjoner av denne feilmeldingen ganske ofte når du starter. Det betyr at du prøver å vise noe dynamisk ved hjelp av konvensjonell R-syntaks.

For å fikse dette trenger jeg en skinnende gjengi funksjon. Flere visualiseringspakker har sine egne spesielle Shiny render-funksjoner, inkludert DT. Dens gjengivelsesfunksjon er renderDT (). Hvis jeg legger til gjengi DT ({}) rundt DT-koden og kjør dokumentet på nytt, det skal fungere.

Dette er tabellkoden min:

renderDT ({
DT :: datatabel (mydata (), filter = 'top')%>%
formatCurrency (4: 5, sifre = 0)%>%
formatCurrency (6, currency = "", sifre = 0)
})

Merk: I tillegg til å lage og vise tabellen, legger denne koden også til litt formatering. Kolonne 4 og 5 vises som valuta, med dollartegn og komma. Den andre formatCurrency () linje for kolonne 6 legger til kommaene til de avrundede tallene uten dollartegn, siden jeg spesifiserte "" som valutasymbol.

Jeg kan bruke det samme mydata () reaktiv dataramme for å lage et histogram ved hjelp av en annen skinnende gjengivelsesfunksjon: renderPlot ().

renderPlot ({
ggplot2 :: ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "black", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})

Den koden inkluderer også litt ggplot-styling, for eksempel å velge farger for linjens omriss og fylle og endre grafens tema. Den siste linjen formaterer x-aksen for å legge til dollartegn og komma, og det krever skalaen.

Hver av disse blokkene med R-kode må være innenfor en R Markdown R-kodebit, akkurat som alle andre R-kodebiter i et konvensjonelt Markdown-dokument. Det kan se ut som koden nedenfor, som også gir navnet "histo" (navn er valgfritt) og setter bredden og høyden på plottet mitt i tommer.

`` {r histo, fig.width = 3, fig.thight = 2}
renderPlot ({
ggplot2 :: ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "black", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})
```

Hvis jeg vil vise interaktiv tekst som endres med brukerens valg, trenger jeg en skinnende gjengivelsesfunksjon som heter - overraskelse! -renderText (). Du kan plassere det i en kodebit, eller bruke alternativt R Markdown-syntaksformat utenfor kodebiter som dette:

Jeg har litt ren tekst og legger deretter til 'r R KODE VIL VURDERES HER'

Syntaksen for dette er ett backtick fulgt umiddelbart av en liten bokstav r, et mellomrom, R-koden du vil evaluere, og slutter med en annen single backtick. Så, for å legge til en dynamisk overskrift for histogrammet, kan du bruke kode som denne:

Histogram for `r renderText ({input $ mycities})`

Dette fungerer bra for en enkelt by. Imidlertid, hvis det er mer enn en by, vil den koden bare vise navnene uten komma mellom dem, for eksempel Boston Cambridge Amherst. For offentlig vendt kode, vil du gjøre det litt bedre, kanskje ved hjelp av base R-er lim inn() funksjon:

Histogram for `r renderText ({lim inn (skriv inn $ mycities,
sep = "", kollaps = ",")}) `

Du kan bruke lignende kode for å generere tekst som forteller brukerne om postnummer med høyest og laveste medianinntekt. For disse beregningene opprettet jeg en reaktiv dataramme som inneholder raden med høyest husholdningsinntekt og en annen med lavest.

Jeg oppdaget også at den laveste medianinntekten var mistenkelig lav - $ 2500 i college-town community of Amherst, Mass. - der den gjennomsnittlige månedlige boligkostnaden er $ 1 215. Jeg antar at det er en konsentrasjon av studentboliger, så jeg ekskluderte postnummer med en median husstandsinntekt på mindre enn $ 5000.

Her er kode for å lage de to datarammene:

zip_highest_income_row <- reaktiv ({
filter (mydata (), MedianHouseholdIncome == max (MedianHouseholdIncome, na.rm = TRUE))
})
zip_lowest_income_row <- reaktiv ({
filter (mydata (), MedianHouseholdIncome> = 5000)%>%
filter (MedianHouseholdIncome == min (MedianHouseholdIncome, na.rm = TRUE))
})

Dette skal se ut som typisk dplyr filter () kode, bortsett fra at 1) hver er pakket inn i en reaktiv ({}) funksjon, og 2) mydata dynamisk dataramme som endres basert på brukerinndata blir referert til som mydata () og ikke bare mydata.

For å vise verdien av det første elementet i zip_highest_income_row datarammens ZIP-kolonne, kan jeg ikke bruke vanlig R-kode somzip_highest_income_row $ Zip [1]. I stedet må jeg referere til den dynamiske datarammen med parenteser:zip_highest_income_row () $ Zip [1] . Og pakk det deretter inn i en skinnende gjengi () funksjon — i dette tilfellet renderText ():

Postnummer `r renderText (zip_highest_income_row () $ ZipCode [1])` in
`r renderText (zip_highest_income_row () $ City [1])`
har den høyeste medianinntekten på stedet / stedene du valgte,
`r renderText (skalaer :: dollar (zip_highest_income_row () $ MedianHouseholdIncome [1]))`.

Postnummer `r renderText (zip_lowest_income_row () $ ZipCode [1])` in
`r renderText (zip_lowest_income_row () $ City [1])` har den laveste
medianinntekt på stedet / stedene du valgte,
`r renderText (skalaer :: dollar (zip_lowest_income_row () $ MedianHouseholdIncome [1]))`.

Kjør og del din Shiny-app

Når du har lagt til kjøretid: skinnende til en R Markdown, er det ikke en HTML-fil lenger - det er et mini-skinnende program. Og det betyr at den trenger en skinnende server for å kjøre.

Som jeg nevnte tidligere, har alle med R, RStudio og den blanke pakken en skinnende server på sitt lokale system. Det gjør det enkelt å dele hvilken som helst skinnende app med andre R-brukere. Du kan sende dem et dokument via e-post eller, mer elegant, legge det online som en zip-fil og bruke skinnende :: runUrl () kommando. Det er spesielle runGitHub () og runGist () funksjoner for apper på GitHub som er praktiske hvis du bruker GitHub for prosjekter, som automatisk vil zip ekstra filer i prosjektet ditt, for eksempel datafiler.

Men sjansen er at du på et eller annet tidspunkt vil vise arbeidet ditt til ikke-R-brukere, og det krever en offentlig tilgjengelig Shiny server. Sannsynligvis det enkleste alternativet er RStudios shinyapps.io-tjeneste. Det er gratis for noen få begrensede offentlige apper med veldig lett bruk. Betalte kontoer er priset basert på antall aktive timer de tilbyr for appene dine. Aktive timer måler tiden applikasjonen brukes aktivt - en person på i en time er samme time som 100 personer i den timen. For å sikre 24x7 oppetid for et par apper, trenger du standardkontoen $ 1100 per år med 2000 timer.

Du kan også bygge din egen Shiny-server på en skytjeneste som AWS og installasjoner for R og den gratis versjonen av RStudios Shiny-serverprogramvare. Det er en flott trinnvis veiledning av Dean Attali som viser hvordan du gjør det på Digital Ocean, hvor du kan bygge og kjøre en liten skinnende server for bare $ 5 per måned med hostingkostnader uten å bekymre deg for aktive timer. Avveien gjør din egen oppdatering og oppdateringer av R / biblioteket - og du trenger kanskje en kraftigere virtuell server enn den billigste 1G-dråpen for robuste applikasjoner.

Legg til et interaktivt kart

Til slutt vil jeg gå gjennom hvordan jeg la til et interaktivt kart i dette dokumentet ved hjelp av pakningsvedlegget.

Først trenger du en fil med geospatiale data samt numeriske data, slik at appen din vet formen på hvert postnummer. Koden nedenfor forklarer hvordan du lager en romlig dataramme ved hjelp av tidycensus og sf-pakkene.

For interaktivitet oppretter jeg en dynamisk versjon av de geografiske dataene, slik at bare de valgte byene vises på kartet. Nedenfor er koden min for å gjøre det. Det kan se litt repeterende ut, men jeg går på lesbarhet i stedet for kortfattethet. Stram gjerne din egen versjon.

mapdata <- reaktiv ({
if ("All Mass"% i% input $ mycities) {
ma_appdata_for_map%>%
dplyr :: select (ZipCode = GEOID, MedianHouseholdIncome = medincome, MedianMonthlyHousingCost = medmonthlyhousingcost, Population = pop, City, County = county.name, State, Lat, Long, income, Housing, Pop, geometry)%>%
mutere (
Fremhevet = "Ja"
) %>%
sf :: st_as_sf ()
} annet {
dplyr :: filter (ma_appdata_for_map, City% in% input $ mycities)%>%
dplyr :: select (ZipCode = GEOID, MedianHouseholdIncome = medincome, MedianMonthlyHousingCost = medmonthlyhousingcost, Population = pop, City, County = county.name, State, Lat, Long, income, Housing, Pop, geometry)%>%
dplyr :: mutere (
Fremhevet = ifelse (By% i% input $ mycities, "Ja", "Nei")
) %>%
sf :: st_as_sf ()
}
})

Den reaktive funksjonen skal være kjent nå. Min hvis og ellers uttalelser tar hensyn til om brukeren har valgt All Mass eller bare enkeltbyer. For alle valg unntatt All Mass, filtrerer jeg bare etter de valgte byene. I begge tilfeller bruker jeg en konvensjonell dplyr velg () funksjon for å velge hvilke kolonner jeg vil ha på kartet, og sørg for å inkludere lat for breddegrad, lang for lengdegrad og geometri som inneholder postnummer polygonformfiler. Den siste linjen i hver hvis() kodeseksjonen sørger for at resultatene er et geospatialt objekt fra sf (simple features). Selv om jeg ikke trengte den koden på min lokale Mac, fungerte appen bedre på shinyapps.io da jeg inkluderte den.

Nå er det på tide å jobbe med kartfarger. Jeg setter opp to reaktive fargepaletter for brosjyrekartet mitt, en for inntekt og den andre for boligkostnader. I begge tilfeller bruker jeg greener, men du kan velge hva du vil.

incomepal <- reaktiv ({
brosjyre :: colorNumeric (palett = "greener",
domain = mapdata () $ MedianHouseholdIncome)
})
Housingpal <- reaktiv ({
brosjyre :: colorNumeric (palett = "Grønne",
domain = mapdata () $ MedianMonthlyHousingCost)
})

Jeg vil at disse også skal være reaktive, så de endres basert på brukervalg. Domeneargumentet definerer verdiene som paletten skal vises. I det første tilfellet er det mitt reaktive kartdataobjekts MedianHouseholdIncome-kolonne - med kartdata kodet som kartdata () siden det er reaktivt; i det andre tilfellet er det kolonnen MedianMonthlyHousingCost.

Jeg vil også sette opp nøyaktig hvordan jeg vil at popup-teksten min skal vises. Dette kan ta en blanding av HTML (

er HTML-linjeskift) og datarammekolonner. Mens du absolutt kan bruke base R’er lim inn() eller lim inn 0 () funksjoner, finner jeg limpakken mye lettere når jeg arbeider med mer enn en variabel blandet med tekst. Du kan se nedenfor at jeg bare trenger å legge ved variabler jeg vil evaluere i krøllete bukseseler. Selvfølgelig må popup-teksten også være reaktiv, så den endres også med brukerens valg.

mypopups <- reaktiv ({
lim :: lim ("Postnummer: {mapdata () $ ZipCode}
Median husholdningsinntekt: {mapdata () $inntekt}
Median månedlig boligkostnad: {mapdata () $ bolig}
Befolkning: {mapdata () $ Pop}
By: {mapdata () $ City}
Fylke: {mapdata () $ County} ")
})

Til slutt kode for selve brosjyrekartet.

brosjyre :: renderLeaflet ({
brosjyre (kartdata ())%>%
addProviderTiles ("CartoDB.Positron")%>%
addPolygons (fillColor = ~ incomepal () (mapdata () $ MedianHouseholdIncome),
fillOpacity = 0,7,
vekt = 1.0,
farge = "svart",
smoothFactor = 0,2,
popup = mypopups (),
group = "Husholdningsinntekt"
) %>%
addPolygons (fillColor = ~ Housingpal () (mapdata () $ MedianMonthlyHousingCost),
fillOpacity = 0,7,
vekt = 0,2,
farge = "svart",
smoothFactor = 0,2,
popup = mypopups (),
group = "Boligutgifter"
) %>%
addLayersControl (
baseGroups = c ("Husholdningsinntekt", "Boligkostnader"),
posisjon = "nederst til venstre",
alternativer = lagControlOptions (skjult = FALSE)
)
})

renderLeaflet () er den skinnende gjengivelsesfunksjonen som viser den dynamiske dataviz som stole på det dynamiske kartdataobjektet. Inne i den funksjonen er "vanlig" kartleggings kode. Første linje, brosjyre (kartdata ()), oppretter et R-brosjyreobjekt fra det reaktive kartdataobjektet. Den bruker pakningsvedlegget, som er en R-innpakning til biblioteket leaflet.js. Neste linje legger til en stil med bakgrunnskartfliser fra CartoDB.

De addPolygons () funksjonen forteller brosjyren hvordan du viser postnummer polygoner. Jeg vil at den skal farges av MideanHouseholdIncome-kolonnen ved hjelp av inntektspaletten jeg opprettet tidligere, incomepal. De fleste av de andre argumentene er styling. De popup argument setter popup-teksten til å være mypopups objektet jeg opprettet tidligere, og gruppeargumentet gir et navn til kartlaget.

Jeg legger til et annet lignende lag for median månedlige boligutgifter. Og til slutt, addLayersControl () setter en klikkbar forklaring for hvert lag nederst til venstre.

Sharon Machlis /

Hvis du vil lære mer om kartlegging i R med brosjyre, kan du se veiledningen min "Lag kart i R i 10 (ganske) enkle trinn."

Den siste R nedmarkeringsfilen

Du kan se den endelige R Markdown-filen på GitHub. Hvis du ser nøye på koden, kan du legge merke til noen få tillegg. Jeg la All Mass til selectInput () rullegardinlistevalgvektor, slik at koden er nå

selectInput ("mycities", "Velg 1 eller flere byer:",
valg = c ("All Mass", sort (unik (markdowndata $ City))),
multiple = TRUE, valgt = "Boston")

Og så justerte jeg flere andre kodelinjer for å gi et annet alternativ hvis All Mass er valgt, for eksempel å lage en dynamisk variabel valgt_places som vil si "Massachusetts" hvis "All Mass" er en av de valgte byene.

selected_places <- reaktiv ({
if ("All Mass"% i% input $ mycities) {
"Massachusetts"
} annet {
lim inn (skriv inn $ mycities,
sep = "", kollaps = ",")
}
})

Legg også merke til den nye YAML-overskriften:

---

tittel: "Median husholdningsinntekt etter postnummer"

utgang: html_document

ressursfiler:

- mamarkdowndata.rdata

- zip_mass_appdata_for_map.rds

kjøretid: skinnende

---

Atresources_files: alternativ sier at dette dokumentet krever to andre filer for å kunne kjøres, mamarkdowndata.rdata og zip_mass_appdata_for_map.rds. Dette lar shinyapps.io vite at disse filene må lastes opp sammen med R Markdown-dokumentet når du distribuerer en fil medrsconnect :: deployDoc ("docname.Rmd").

Du kan se dette interaktive R Markdown-dokumentet med Shiny i aksjon på //idgrapps.shinyapps.io/runtimeshiny/. Det kan ta litt tid å laste inn, siden jeg ikke prøvde å optimalisere denne koden for hastighet. RStudio har noen ressurser hvis du vil lære om å øke hastigheten på skinnende apper.

Hvordan er dette forskjellig fra en 'ekte' skinnende app?

Dette superladede-med-skinnende R Markdown-dokumentet skiller seg fra en fullverdig Shiny-app på noen få viktige måter.

1. En skinnende app må være i en fil som heter app.R eller to filer ui.R og server.R. Appen kan kilde tilleggsfiler med andre navn, men den filnavnstrukturen er absolutt. I en en-fil app.R-app er det behov for seksjoner for brukergrensesnittet (brukergrensesnitt, som definerer hva brukeren ser og samhandler med) og serveren.

2. Blanke appoppsett er bygget opp rundt rutenettet for Bootstrap-sidegitteret. Du kan se mer om layoutstruktur i RStudios Shiny applikasjonslayoutguide.

3. De fleste dynamiske komponentene du vil gjengi, inkludert ting som grafer og tabeller, må være spesielt plassert et sted på siden med tilleggsutgangsfunksjoner og definisjoner. For eksempel trenger et interaktivt brosjyrer kart som f.eks leafletOutput ("mymap") et sted i brukergrensesnittet for å fortelle appen hvor den skal vises, i tillegg til serverkode som f.eks

output $ mymap <- renderLeaflet ({#MAP CODE HERE})

for å definere logikken bak generering av kartet.

Her er et eksempel på en skinnende app.R-fil for denne appens histogram og tabell:

bibliotek ("skinnende")
bibliotek ("dplyr")
bibliotek ("ggplot2")
bibliotek ("DT")
alternativer (scipen = 999)
load ("mamarkdowndata.rdata") # laster variabel markdowndata
ma_appdata_for_map <- readRDS ("zip_mass_appdata_for_map.rds")
# Definer brukergrensesnitt
ui <- fluidPage (
# Søknadstittel
titlePanel ("Inntekt og boligkostnader etter postnummer"),
# Sidefelt
sidebarLayout (
sidepanelPanel (
selectInput ("mycities", "Choose 1 or more Massachusetts locations:", valg = c ("All Mass", sort (unik (markdowndata $ City))), multiple = TRUE, valgt = "Boston"),
br (),
sterk ("Merk: noen byer kan ha mer enn ett stedsnavn for postnummer. For eksempel er Allston, Brighton, Dorchester og flere andre nabolag ikke inkludert i postnummer \" Boston \ ".")
),
# Vis histogram
mainPanel (
h4 (htmlOutput ("histogramHeadline")),
plotOutput ("myhistogram"),
br (),
h4 (htmlOutput ("tableHeadline")),
DTOutput ("mytable")
)
)
)
# Definer serverlogikk som kreves for å tegne et histogram
server <- funksjon (input, output) {
mydata <- reaktiv ({
if ("All Mass"% i% input $ mycities) {
markdowndata
} annet {
filter (markdowndata, City% i% input $ mycities)
}
})
selected_places <- reaktiv ({
if ("All Mass"% i% input $ mycities) {
"Massachusetts"
} annet {
lim inn (skriv inn $ mycities,
sep = "", kollaps = ",")
}
})
output $ histogramHeadline <- renderUI ({
lim inn ("Histogram for", valgt_plasser (), "inntektsdata")
})
output $ tableHeadline <- renderUI ({
lim inn ("Data for", selected_places ())
})
output $ myhistogram <- renderPlot ({
ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "black", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})
output $ mytable <- renderDT ({
DT :: datatabel (mydata (), filter = 'top')%>%
formatCurrency (4: 5, sifre = 0)%>%
formatCurrency (6, currency = "", sifre = 0)
})
}
# Kjør applikasjonen
shinyApp (ui = ui, server = server)