R Markdown er en af mine yndlings ting ved moderne R. Det giver en nem måde at kombinere tekst, R-kode og resultaterne af R-kode i et enkelt dokument. Og når dette dokument gengives som HTML, kan du tilføje brugerinteraktion med HTML-widgets som DT til tabeller eller folder til kort. (Hvis du ikke er fortrolig med R Markdown, kan du først tjekke min R Markdown-videovejledning og derefter komme tilbage her.)
Men du ved muligvis ikke, at der er en måde at forstærke R Markdown-interaktivitet endnu mere: ved at tilføje runtime: skinnende til dokumenthovedet.
Shiny er en webapplikationsramme for R. Som en ramme har den en ret specifik struktur. Du kan dog konvertere et R Markdown-dokument til en skinnende app uden at skulle følge meget af den stive struktur. I stedet kan du hoppe lige ind og starte kodning - uden at bekymre dig om nogle typiske skinnende opgaver som at sikre, at alle dine parenteser og kommaer er korrekte inden for dybt indlejrede layoutfunktioner.
Faktisk, selvom du er en erfaren skinnende udvikler, kan et R Markdown-dokument stadig være nyttigt til skinnende opgaver, hvor du ikke har brug for et fuldt anvendt program eller til hurtig afprøvning af kode. Det har stadig brug for en skinnende server, men hvis du har installeret RStudio og den skinnende pakke, har du allerede en af dem lokalt.
Lad os se på, hvordan runtime shiny fungerer i R Markdown.
1. Grundlæggende R Markdown
Jeg starter med et konventionelt, ikke-skinnende R Markdown-dokument, der indeholder en søgbar datatabel efter Massachusetts postnummer. Brugere kan søge eller sortere efter en hvilken som helst tabelkolonne og besvare spørgsmål som "Hvilke postnumre har den højeste median husstandsindkomst Middlesex County?" eller "Hvilke postnumre har den dyreste månedlige bolig?"
Sharon Machlis / Dette dokument har også et histogram, der viser fordeling af median husstandsindkomster og tekst, der angiver, hvilke postnumre der har de højeste og laveste indkomster. Tabellen er interaktiv, men resten af dokumentet er det ikke. Du kan se den gengivne HTML-version på RStudios RPubs.
Hvis du gerne vil følge med, kan du se kode til en enkeltstående version af dette R Markdown-dokument - inklusive data - på GitHub. Eller hvis du gerne vil se, hvordan jeg fik disse demografiske data til R, er der R-kode i denne artikel for at oprette dit eget datasæt (og du kan tilpasse koden for at vælge en anden tilstand). Hvis du opretter din egen version af dataene, er koden til et grundlæggende R Markdown-dokument ved hjælp af en separat datafil også på GitHub.
Uanset hvilket R Markdown-dokument du vælger, ser du, at det er et stort set statisk dokument med en vis interaktivitet. Men hvad hvis jeg gerne vil have hele dokumentet at være interaktiv - i dette tilfælde se histogram og tekstændring samt tabellen? Hvordan kan brugeren være i stand til at vælge individuelle byer og se alle oplysninger filtreret for at vise bare for disse steder?
En løsning er at generere en side for hver by - mulig med et R-script, hvis du bruger det, der kaldes parametrerede rapporter. Du kan dog også oprette et enkelt R Markdown-dokument, der fungerer som en interaktiv app.
Tilføj skinnende interaktivitet
Hvis du vil tilføje skinnende interaktivitet til et konventionelt R Markdown-dokument, skal du starte med at tilføje runtime: skinnende til dokumentets YAML-overskrift, såsom:
---titel: "Median husstandsindkomst efter postnummer"
output: html_document
runtime: skinnende
---
Når du har gjort det og trykker på Gem, bliver strikikonet i RStudio til "Kør dokument." Selvom output stadig siger "html_document", vil det ikke være almindelig HTML mere. Det er nu en mini-skinnende applikation.
Sharon Machlis / 
Sharon Machlis, Lad brugerne foretage datavalg
Nu har jeg brug for en måde for brugerne at foretage deres datavalg. Shiny har et antal "input widgets" til dette. Jeg bruger selectInput (), som opretter en rulleliste og giver brugerne mulighed for at vælge mere end et element. Shiny har andre widgets til radioknapper, tekstinput, datovælger og mere. Du kan se en samling af dem i RStudios Shiny Widgets Gallery.
Kode til min mini-app selectInput () rulleliste har fem argumenter og ser sådan ud:
selectInput ("mycities", "Vælg 1 eller flere byer:",valg = sortering (unik (markdowndata $ by)),
valgt = "Boston", multiple = SAND)
Det første argument tilselectInput (), mycities er det variabelnavn, jeg har valgt at gemme de værdier, som brugeren vælger. Det andet argument er overskriftsteksten, der vises med rullelisten. Det tredje argument valg, er en vektor af alle mulige værdier i rullelisten - i dette tilfælde unikke værdier for bynavne i mine data, sorteret alfabetisk. valgt = Boston betyder, at rullemenuen som standard er Boston, som er den valgte by (valg af et standardvalg er valgfrit). Og endelig, multiple = SAND giver brugerne mulighed for at vælge mere end en by ad gangen.
Denne kode opretter HTML-rullelisten. Hvis du kører det selectInput () kode i din R-konsol, genererer den HTML til rullemenuen (forudsat at du har indlæst skinnende og en dataramme kaldet markdowndata med en bykolonne).
Dernæst skal jeg skrive nogle R, så denne rullemenu faktisk gør noget.
Opret dynamiske variabler
Jeg koder denne interaktivitetslogik i to dele:
- Opret en dataramme - jeg kalder det
mydata—Det filtreres hver gang brugeren vælger en by. - Skriv kode til tekst, histogram og datatabel, der alle ændres baseret på min dynamiske dataramme.
Det vigtigste at huske på på dette tidspunkt er, at disse objekter ikke længere er "almindelige" R-variabler. De er dynamisk. De ændring baseret på brugerhandlinger. Og det betyder, at de fungerer lidt anderledes end variabler, som du sandsynligvis er vant til.
Hvad er specielt ved dem? Her er de tre ting, du skal vide:
- For at få adgang til værdien af en inputvariabel, der gemmer oplysninger fra din bruger, skal du bruge syntaksen
indtast $ myvarnameikke baremyvarname. Så for værdier, der er gemt imycitiesrulleliste, brugindtast $ mycities. - Objekter som grafer og tabeller, der afhænger af værdier fra din bruger, er også dynamiske og skal være reaktive. Det er lige så let som at pakke dem ind i en særlig funktion, men du skal huske at gøre det. De kan heller ikke tilgås med bare deres navne, men kræver også parenteser: en syntaks som
myvar ()og ikkemyvar. - Når duSkærm dynamisk indhold - endnu en gang ting som en tabel, et kort, et histogram eller endda tekst - det skal gengives på en speciel måde, normalt ved hjælp af en af Shiny's specielle gengivelsesfunktioner. Den gode nyhed er, at Shiny tager sig af det meste af funktionaliteten til overvågning af ændringer og beregning af resultater. Du skal bare vide, hvilken funktion du skal bruge, og derefter inkludere den i din kode.
Alt dette er ofte lettere, end det måske lyder. Sådan opretter jeg en dataramme, der hedder mydata der ændres hver gang brugeren vælger en by med mycities selectInput () rullemenu:
filter (markdowndata, City% i% input $ mycities) })mydata <- reaktiv ({
Det mydata objekt har nu en reaktivt udtrykog vil ændre værdi hver gang brugeren foretager en ændring i rullelisten, der kontrollerer mycities.
Vis dynamiske variabler
Nu vil jeg gerne kode en tabel ved brug af der filtreres mydata data.
Som du måske har gættet nu, DT :: datatabel (mydata) fungerer ikke. Og der er to grunde til det.
Først fordi mydata er et reaktivt udtryk, kan du ikke henvise til det ved navn alene. Det har brug for parenteser efter det, såsommydata ().
Men for det andetDT :: datatabel (mydata ()) fungerer heller ikke som selvstændig kode. Du får en fejlmeddelelse på noget lignende:
Drift er ikke tilladt uden en aktiv reaktiv kontekst.(Du prøvede at gøre noget, der kun kan gøres indefra
et reaktivt udtryk eller en observatør.)
Du kan muligvis se versioner af denne fejlmeddelelse ganske ofte, når du først starter. Det betyder, at du prøver at vise noget dynamisk ved hjælp af konventionel R-syntaks.
For at løse dette har jeg brug for en skinnende gengive funktion. Flere visualiseringspakker har deres egne specielle skinnende gengivelsesfunktioner, herunder DT. Dens gengivelsesfunktion er renderDT (). Hvis jeg tilføjer renderDT ({}) omkring DT-koden og kør dokumentet igen, det skal fungere.
Dette er min bordkode:
renderDT ({DT :: datatabel (mydata (), filter = 'top')%>%
formatCurrency (4: 5, cifre = 0)%>%
formatCurrency (6, currency = "", cifre = 0)
})
Bemærk: Udover at oprette og vise tabellen tilføjer denne kode også noget formatering. Kolonne 4 og 5 vises som valuta med et dollartegn og kommaer. Sekundet formatCurrency () linje til kolonne 6 tilføjer kommaer til de afrundede tal uden et dollartegn, da jeg specificerede "" som valutasymbol.
Jeg kan bruge det samme mydata () reaktiv dataramme til at oprette et histogram ved hjælp af en anden skinnende gengivelsesfunktion: renderPlot ().
renderPlot ({ggplot2 :: ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "sort", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})
Denne kode indeholder også en lille ggplot-styling, såsom at vælge farver til linjens omrids og udfylde og ændre grafens tema. Den sidste linje formaterer x-aksen for at tilføje dollartegn og kommaer, og det kræver skalapakken.
Hver af disse blokke af R-kode skal være inden for en R Markdown R-kodeblok, ligesom enhver anden R-kodebit i et konventionelt Markdown-dokument. Det kan se ud som koden nedenfor, som også navngiver klumpen "histo" (navne er valgfri) og indstiller bredden og højden af mit plot i inches.
`` {r histo, fig. bredde = 3, fig. højde = 2}renderPlot ({
ggplot2 :: ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "sort", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})
```
Hvis jeg gerne vil vise interaktiv tekst, der ændres med brugerens valg, har jeg brug for en skinnende gengivelsesfunktion, der hedder — overraskelse! -renderText (). Du kan sætte det inde i en kodebit eller bruge alternativt R Markdown-syntaksformat uden for kodestykker som dette:
Jeg har noget almindelig tekst og tilføjer derefter 'r R KODE VURDERES HER'
Syntaksen for dette er et backtick efterfulgt straks af små bogstaver r, et mellemrum, den R-kode, du vil evaluere, og slutter med en anden single backtick. Så for at tilføje en dynamisk overskrift til histogrammet kan du bruge kode som denne:
Histogram for `r renderText ({input $ mycities})`Dette fungerer fint for en enkelt by. Men hvis der er mere end en by, viser denne kode bare navnene uden komma mellem dem, f.eks Boston Cambridge Amherst. For offentlig vendt kode, vil du gerne smukke det lidt, måske ved hjælp af base R'er sæt ind() fungere:
Histogram for `r renderText ({indsæt (input $ mycities,sep = "", kollaps = ",")}) `
Du kan bruge lignende kode til at generere tekst, der fortæller brugerne postnumre med de højeste og laveste medianindkomster. Til disse beregninger oprettede jeg en reaktiv dataramme indeholdende rækken med den højeste husstandsindkomst og en anden med den laveste.
Jeg opdagede også, at den laveste medianindkomst var mistænkeligt lav - $ 2.500 i college-town community of Amherst, Mass. - hvor de gennemsnitlige månedlige boligomkostninger er $ 1.215. Mit gæt er, at det er en koncentration af studenterboliger, så jeg udelukkede ethvert postnummer med en median husstandsindkomst på mindre end $ 5.000.
Her er kode for at oprette disse to datarammer:
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 ud som typisk dplyr filter () kode, bortset fra at 1) hver er pakket ind i en reaktiv ({}) funktion, og 2) mydata dynamisk dataramme, der ændres baseret på brugerinput, kaldes mydata () og ikke bare mydata.
For at vise værdien af det første element i zip_highest_income_row datarammens ZIP-kolonne, kan jeg ikke bruge sædvanlig R-kode somzip_highest_income_row $ Zip [1]. I stedet skal jeg henvise til den dynamiske dataramme med parenteser:zip_highest_income_row () $ Zip [1] . Og pakk det derefter ind i en skinnende gengive () funktion - i dette tilfælde renderText ():
Postnummer `r renderText (zip_highest_income_row () $ ZipCode [1])` i`r renderText (zip_highest_income_row () $ City [1])`
har den højeste medianindkomst på det / de steder, du valgte,
`r renderText (skalaer :: dollar (zip_highest_income_row () $ MedianHouseholdIncome [1]))`.
Postnummer `r renderText (zip_lowest_income_row () $ ZipCode [1])` i`r renderText (zip_lowest_income_row () $ City [1])` har den laveste
medianindkomst på det / de valgte sted,
`r renderText (skalaer :: dollar (zip_lowest_income_row () $ MedianHouseholdIncome [1]))`.
Kør og del din skinnende app
Når du har tilføjet runtime: skinnende til en R Markdown, er det ikke længere en HTML-fil - det er et mini-skinnende program. Og det betyder, at det har brug for en skinnende server for at køre.
Som jeg nævnte tidligere, har alle med R, RStudio og den skinnende pakke en skinnende server på deres lokale system. Det gør det nemt at dele enhver skinnende app med andre R-brugere. Du kan sende dem et dokument via e-mail eller mere elegant placere det online som en zip-fil og bruge skinnende :: runUrl () kommando. Der er specielle runGitHub () og runGist () funktioner til apps på GitHub, der er praktiske, hvis du bruger GitHub til projekter, som automatisk vil zip yderligere filer i dit projekt, såsom datafiler.
Men chancerne er, at du på et eller andet tidspunkt vil vise dit arbejde til ikke-R-brugere, og det kræver en offentlig tilgængelig Shiny server. Sandsynligvis den nemmeste mulighed er RStudios shinyapps.io-tjeneste. Det er gratis for et par begrænsede offentlige apps med meget let brug. Betalte konti er prissat baseret på antallet af aktive timer, de tilbyder til dine apps. Aktive timer måler den tid, applikationen bruges aktivt - en person i en time er den samme time som 100 mennesker i den time. For at sikre 24x7 oppetid for et par apps skal du have en standardkonto på $ 1.100 / år med 2.000 timer.
Du kan også bygge din egen Shiny-server på en cloud-tjeneste som AWS og installationer til R og den gratis version af RStudio's Shiny-serversoftware. Der er en fantastisk trin-for-trin tutorial af Dean Attali, der viser, hvordan du gør det på Digital Ocean, hvor du kan opbygge og køre en lille skinnende server til kun $ 5 pr. Måned for hostingomkostninger uden at bekymre dig om aktive timer. Kompromiset laver din egen patch og R / biblioteksopdateringer - og du har muligvis brug for en kraftigere virtuel server end den billigste 1G-dråbe til robuste applikationer.
Tilføj et interaktivt kort
Endelig gennemgår jeg, hvordan jeg tilføjede et interaktivt kort til dette dokument ved hjælp af indlægssedlen.
For det første har du brug for en fil med geospatiale data såvel som numeriske data, så din app kender formen på hvert postnummer. Koden nedenfor forklarer, hvordan du opretter en rumlig dataramme ved hjælp af tidycensus og sf-pakkerne.
For interaktivitet opretter jeg en dynamisk version af de geodata, så kun de valgte byer vises på kortet. Nedenfor er min kode til at gøre det. Det kan se lidt gentagne ud, men jeg går efter læsbarhed i stedet for kortfattethed. Du er velkommen til at stramme din egen version.
mapdata <- reaktiv ({hvis ("Al masse"% 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 (
Fremhævet = "Ja"
) %>%
sf :: st_as_sf ()
} andet {
dplyr :: filter (ma_appdata_for_map, City% i% 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 (
Fremhævet = ifelse (By% i% input $ mycities, "Ja", "Nej")
) %>%
sf :: st_as_sf ()
}
})
Den reaktive funktion skal være kendt nu. Min hvis og andet udsagn tager højde for, om brugeren har valgt All Mass eller bare individuelle byer. For ethvert valg undtagen All Mass filtrerer jeg kun efter de valgte byer. I begge tilfælde bruger jeg en konventionel dplyr vælg () funktion til at vælge hvilke kolonner, jeg vil have på kortet, og sørg for at inkludere lat for latitude, long for longitude og geometri, der indeholder postnummer polygonformfiler. Den sidste linje i hver hvis() kodesektionen sørger for, at resultaterne er et geospatialt objekt (sf (simple features)). Selvom jeg ikke havde brug for den kode på min lokale Mac, fungerede appen bedre på shinyapps.io, da jeg inkluderede den.
Nu er det tid til at arbejde med kortfarver. Jeg opretter to reaktive farvepaletter til mit folderkort, en til indkomst og den anden til boligudgifter. I begge tilfælde bruger jeg greener, men du kan vælge det, du vil have.
incomepal <- reaktiv ({folder :: colorNumeric (palette = "Greens",
domæne = mapdata () $ MedianHouseholdIncome)
})
Housingpal <- reaktiv ({
folder :: colorNumeric (palette = "Grønne",
domæne = mapdata () $ MedianMonthlyHousingCost)
})
Jeg vil også have, at disse er reaktive, så de ændres baseret på brugervalg. Domæne-argumentet definerer de værdier, som paletten skal vises. I det første tilfælde er det mit reaktive kortdataobjekts kolonne MedianHouseholdIncome - med kortdata kodet som kortdata () da det er reaktivt; i det andet tilfælde er det kolonnen MedianMonthlyHousingCost.
Jeg opretter også nøjagtigt, hvordan jeg vil have min pop op-tekst. Dette kan tage en blanding af HTML ( er en HTML linjeskift) og datarammekolonner. Mens du helt sikkert kan bruge base R'er sæt ind() eller indsæt0 () funktioner finder jeg limpakken meget lettere, når jeg beskæftiger mig med mere end en variabel blandet med tekst. Du kan se nedenfor, at jeg bare skal vedlægge variabler, som jeg vil have evalueret inden for krøllede seler. Selvfølgelig skal popup-teksten også være reaktiv, så den ændres også med brugerens valg.
mypopups <- reaktiv ({lim :: lim ("Postnummer: {mapdata () $ ZipCode}
Median husstandsindkomst: {mapdata () $ income}
Median månedlig boligomkostning: {mapdata () $ bolig}
Befolkning: {mapdata () $ Pop}
By: {mapdata () $ City}
Amt: {mapdata () $ County} ")
})
Endelig kode for selve brochuren.
folder :: renderLeaflet ({folder (mapdata ())%>%
addProviderTiles ("CartoDB.Positron")%>%
addPolygons (fillColor = ~ incomepal () (mapdata () $ MedianHouseholdIncome),
fillOpacity = 0,7,
vægt = 1,0,
color = "sort",
smoothFactor = 0,2,
popup = mypopups (),
group = "Husstandsindkomst"
) %>%
addPolygons (fillColor = ~ Housingpal () (mapdata () $ MedianMonthlyHousingCost),
fillOpacity = 0,7,
vægt = 0,2,
color = "sort",
smoothFactor = 0,2,
popup = mypopups (),
group = "Boligomkostninger"
) %>%
addLayersControl (
baseGroups = c ("Husstandsindkomst", "Boligomkostninger"),
position = "nederst til venstre",
optioner = lagControlOptions (skjult = FALSK)
)
})
renderLeaflet () er den skinnende gengivelsesfunktion, der viser den dynamiske dataviz, der er afhængig af det dynamiske kortdataobjekt. Inde i denne funktion er der "almindelig" folder til kortlægning af foldere. Den første linje, folder (mapdata ()), opretter et R-folderobjekt fra det reaktive kortdataobjekt. Det bruger brochurepakken, som er en R-indpakning til leaflet.js-biblioteket. Næste linje tilføjer en stil med baggrundskortfliser fra CartoDB.
Det tilføj polygoner () funktion fortæller brochure, hvordan man viser postnummer polygoner. Jeg vil have det farvet af MideanHouseholdIncome-kolonnen ved hjælp af den indkomstpalette, jeg oprettede tidligere, incomepal. De fleste af resten af disse argumenter er styling. Det pop op argument indstiller popup-teksten til at være mypopups objekt, jeg oprettede tidligere, og gruppeargumentet giver et kort til kortlaget.
Jeg tilføjer et andet lignende lag til median månedlige boligomkostninger. Og endelig addLayersControl () lægger en klikbar forklaring for hvert lag nederst til venstre.
Sharon Machlis / Hvis du gerne vil vide mere om kortlægning i R med folder, se min vejledning "Opret kort i R i 10 (ret) nemme trin."
Den endelige R-markdown-fil
Du kan se den endelige R Markdown-fil på GitHub. Hvis du ser nøje på koden, bemærker du muligvis et par tilføjelser. Jeg tilføjede All Mass til selectInput () dropdown liste valg vektor, så denne kode er nu
selectInput ("mycities", "Vælg 1 eller flere byer:",valg = c ("All Mass", sort (unik (markdowndata $ City))),
multiple = SAND, valgt = "Boston")
Og så finjusterede jeg flere andre kodelinjer for at give en anden mulighed, hvis All Mass er valgt, såsom at oprette en dynamisk variabel valgt_placeringer, der vil sige "Massachusetts", hvis "All Mass" er en af de valgte byer.
selected_places <- reaktiv ({hvis ("Al masse"% i% input $ mycities) {
"Massachusetts"
} andet {
indsæt (indtast $ mycities,
sep = "", kollaps = ",")
}
})
Bemærk også det nye YAML header:
---titel: "Median husstandsindkomst efter postnummer"
output: html_document
ressource_filer:
- mamarkdowndata.rdata
- zip_mass_appdata_for_map.rds
runtime: skinnende
---
Atresources_files: mulighed siger, at dette dokument kræver to andre filer for at køre, mamarkdowndata.rdata og zip_mass_appdata_for_map.rds. Dette lader shinyapps.io vide, at disse filer skal uploades sammen med det primære R Markdown-dokument, når de implementerer en fil medrsconnect :: deployDoc ("docname.Rmd").
Du kan se dette interaktive R Markdown-dokument med Shiny i aktion på //idgrapps.shinyapps.io/runtimeshiny/. Det kan tage lidt tid at indlæse, da jeg ikke forsøgte at optimere denne kode til hastighed. RStudio har nogle ressourcer, hvis du vil lære om at fremskynde skinnende apps.
Hvordan adskiller dette sig fra en 'ægte' skinnende app?
Dette superladede-med-skinnende R Markdown-dokument adskiller sig fra en fuldgyldig skinnende app på nogle få vigtige måder.
1. En skinnende app skal være i en fil kaldet app.R eller to filer ui.R og server.R. Appen kan kilde yderligere filer med andre navne, men denne filnavngivningsstruktur er absolut. I en app med en fil.R-app er der brug for sektioner til brugergrænsefladen (brugergrænseflade, der definerer, hvad brugeren ser og interagerer med) og serveren.
2. Skinnende applayouts er bygget op omkring Bootstrap-sidegitterrammen. Du kan se mere om layoutstruktur i RStudios Shiny-applikationslayoutvejledning.
3. De fleste dynamiske komponenter, som du vil gengive, herunder ting som grafer og tabeller, skal være specifikt placeret et eller andet sted på siden med yderligere outputfunktioner og definitioner. For eksempel vil et interaktivt folderkort have brug for kode som f.eks leafletOutput ("mymap") et eller andet sted i brugergrænsefladen for at fortælle appen, hvor den skal vises, ud over serverkode som f.eks
output $ mymap <- renderLeaflet ({#MAP CODE HERE})for at definere logikken bag generering af kortet.
Her er et eksempel på en skinnende app.R-fil til denne apps histogram og tabel:
bibliotek ("skinnende")bibliotek ("dplyr")
bibliotek ("ggplot2")
bibliotek ("DT")
indstillinger (scipen = 999)
load ("mamarkdowndata.rdata") # indlæser variabel markdowndata
ma_appdata_for_map <- readRDS ("zip_mass_appdata_for_map.rds")
# Definer brugergrænseflade
ui <- fluidPage (
# Programmets titel
titlePanel ("Indtægts- og boligomkostninger efter postnummer"),
# Sidebjælke
sidebarLayout (
sidebarPanel (
selectInput ("mycities", "Vælg 1 eller flere Massachusetts-steder:", valg = c ("All Mass", sortering (unik (markdowndata $ by))), multiple = SAND, valgt = "Boston"),
br (),
stærk ("Bemærk: nogle byer kan have mere end et stednavn til postnumre. F.eks. er Allston, Brighton, Dorchester og flere andre kvarterer ikke inkluderet i postnummerets stednavn \" Boston \ ".")
),
# Vis histogram
mainPanel (
h4 (htmlOutput ("histogramHeadline")),
plotOutput ("myhistogram"),
br (),
h4 (htmlOutput ("tableHeadline")),
DTOutput ("mytable")
)
)
)
# Definer serverlogik, der kræves for at tegne et histogram
server <- funktion (input, output) {
mydata <- reaktiv ({
hvis ("Al masse"% i% input $ mycities) {
markdowndata
} andet {
filter (markdowndata, City% i% input $ mycities)
}
})
selected_places <- reaktiv ({
hvis ("Al masse"% i% input $ mycities) {
"Massachusetts"
} andet {
indsæt (indtast $ mycities,
sep = "", kollaps = ",")
}
})
output $ histogramHeadline <- renderUI ({
indsæt ("Histogram for", selected_places (), "indtægtsdata")
})
output $ tableHeadline <- renderUI ({
indsæt ("Data for", selected_places ())
})
output $ myhistogram <- renderPlot ({
ggplot (mydata (), aes (x = MedianHouseholdIncome)) +
geom_histogram (binwidth = 20000, color = "sort", fill = "darkgreen") +
theme_classic () +
xlab ("") +
ylab ("") +
skala_x_ kontinuerlig (etiketter = dollar)
})
output $ mytable <- renderDT ({
DT :: datatabel (mydata (), filter = 'top')%>%
formatCurrency (4: 5, cifre = 0)%>%
formatCurrency (6, currency = "", cifre = 0)
})
}
# Kør applikationen
shinyApp (ui = ui, server = server)
Du kan finde ud af mere om at opbygge denne slags skinnende apps på RStudios Shiny intro-tutorials.
For flere R-tip, gå til siden Gør mere med R på eller Gør mere med R-afspilningslisten på YouTube.
