学习33 min read

shiny网页学习笔记（完结）

Views 178

A translation is not available yet. The Chinese original is shown below.

教程一、shiny网页学习（整合）

01 什么是shiny

官网定义：简单直接的从R构建交互式的网页应用的R包

Shiny是一个独立的网络框架，可以使用R语言构建交互式的网页App
Shiny App是一种用浏览器查看的交互式的网页App

02 为什么使用shiny

shiny可以让任何会用R的人都可以构建网页应用，不依赖HTML CSS Js等语言就可以构建一个图表丰富的，交互式的网页应用。

部署到服务器（仅支持linux）：Shinyapps.io Shiny Server

03 shiny代表作品

covid-2019.live（现停用）

《访问总量 1700万+ 的疫情数据可视化应用的开发故事》
可以用来开开眼界，作者的博客也设计得不错

简单有意思的ermoji

Install ermoji with devtools

devtools::install_github("gadenbuie/ermoji")

04 shiny的文件结构

单文件版本

顾名思义，即整个shiny里面只有一份文件

library(shiny)

ui <- fluidPage(
  
)

server <- function(input, output, session) {
  
}

shinyApp(ui, server)

双文件版本

即将单文件版本中的ui和server分别放入两个文件当中

05 shiny的运行方式

1.runExample()

2.快捷键

Shift+Ctrl+Enter

Alt+Shift+K：打开快捷键大全

3.运行在Rstudio中的控制台console

4.运行在Rstudio中的jobs

5.运行在单独的R会话

！！！06 shiny入门

Hands-On Programming with R

Rstudio cloud

Rstudio cheatsheets

shiny 案例

07 UI和Server

UI

UI决定了你的app用户体验，也被称为客户端

Widgets

UI部分是你放控件（input widgets）的地方

控件可以在gallery中找到现成的，也可以在dreamrs中的shinyWidgets中找到更多精良的控件

自定义程序外观

使用HTML,CSS,JS等，也可以使用包来完成这些操作

推荐包：htmlwidgets

两种常见的页面布局

fluidPage()

navbarPage()

UI禁止做的事

  • 不能直接创建图表，必须先在server中渲染，并且在ui中使用对应的输出函数
  • 不能直接访问控件的值
  • 如果需要创建交叉依赖的控件，就需要在server部分使用对应的函数

server

server是你能运行你R代码的地方，包括你的数据整理，计算，还有数据可视化的代码

更新控件的函数：

updateSelectInput()

相互依赖的控件实现，也只能通过server端的update*Input这类函数

0809 实例讲解

实例代码

ui.R

fluidPage(
 shiny::sliderInput(
   inputId = "exp",
   label = "次方",
   min = 2, max = 5,
   value = 2
 ),
 plotOutput(
   "curve_plot"
 )
)

serve.R

function(input, output, session) {
  output$curve_plot <- shiny::renderPlot({
    curve(x^input$exp, from = -5, to = 5)
  }
    
  )
}

讲解

输入变量

  • input$exp
  • 每个控件（input widgets），会创建至少一个输入变量
  • 像交互式图像，比如htmlwidgets就会创建许多输入变量，用来跟踪单机，拖放，缩放等

输出变量

  • output$curve_plot
  • 在server中被创建，以供我们渲染内容并发送到ui

一些需要注意的原则

ui部分

  • 不要包含输入变量，比如input&exp
  • 不要包含单独的输出变量，比如output$plot，而是应该使用引号的变量名比如ployOutput("plot")

server部分

  • 需要通过赋值符号传给输出变量来创建新的内容比如output$curve_plot <-
  • 选择合适的渲染函数，render*()，将创建的新内容传递给客户端ui部分
  • 如果要访问输入变量，需要使用input$var

需要使用成对的输出和渲染函数

session参数尽量不要省略，避免报错

session参数作用：

  • 收集用户信息

  • 更新服务器端的ui元素

    • 包含数据中特定值的下拉菜单
    • 创建相互依赖的控件
    • 在shiny模块中构建可重复使用的ui元素
  • 手机访问者数据

一些常见的渲染和输出函数

image-20240304222058745

image-20240304222153839

image-20240304222202910

推荐：htmlwidgets

10 相互依赖的控件

update函数

shiny::observeEvent(input$mycolor_1,{
    shinyWidgets::updateColorPicker(session,inputId = mycolor)})

教程二、shiny app tutorial

一、总览

同教程一

二、widgets使用

textInput

  • 在Shiny中，textInput允许用户输入文本。可以使用textInput小部件来收集用户的输入，并在应用程序中使用该输入进行各种操作，比如数据过滤、图表生成等
library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("textInput示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个textInput
      textInput("user_input", "请输入文本：", value = "")
    ),
    mainPanel(
      # 在主面板中显示用户输入的文本
      textOutput("output_text")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户输入的输出
  output$output_text <- renderText({
    # 输出用户输入的文本
    paste("您输入的文本是：", input$user_input)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

radioButtons

  • 在Shiny中，radioButtons用于提供一组选项，用户可以从中选择一个选项。
library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("radioButtons示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个radioButtons
      radioButtons("color", "请选择颜色：", 
                   choices = c("红色", "绿色", "蓝色"), 
                   selected = "红色")
    ),
    mainPanel(
      # 在主面板中显示用户选择的颜色
      textOutput("output_color")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户选择的输出
  output$output_color <- renderText({
    # 输出用户选择的颜色
    paste("您选择的颜色是：", input$color)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

sliderInput

  • 在Shiny中，sliderInput用于创建一个滑块，允许用户在指定的范围内选择一个值。
library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("sliderInput示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个sliderInput
      sliderInput("slider", "选择一个值：", 
                  min = 0, max = 100, value = 50)
    ),
    mainPanel(
      # 在主面板中显示滑块选择的值
      textOutput("output_value")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户滑块选择的输出
  output$output_value <- renderText({
    # 输出用户选择的值
    paste("您选择的值是：", input$slider)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

selectInput

  • 在Shiny应用程序中，selectInput用于创建一个下拉菜单，允许用户从预定义的选项中选择一个值。
library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("selectInput示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个selectInput
      selectInput("choice", "请选择一个选项：", 
                  choices = c("选项1", "选项2", "选项3"), 
                  selected = "选项1")
    ),
    mainPanel(
      # 在主面板中显示用户选择的选项
      textOutput("output_choice")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户选择的输出
  output$output_choice <- renderText({
    # 输出用户选择的选项
    paste("您选择的选项是：", input$choice)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

合并使用

library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("混合使用Widgets示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个textInput
      textInput("text_input", "请输入文本：", value = ""),
      # 添加一个selectInput
      selectInput("select_input", "请选择一个选项：", 
                  choices = c("选项1", "选项2", "选项3"), 
                  selected = "选项1"),
      # 添加一个sliderInput
      sliderInput("slider", "选择一个值：", 
                  min = 0, max = 100, value = 50)
    ),
    mainPanel(
      # 在主面板中显示用户输入的文本
      textOutput("output_text"),
      # 在主面板中显示用户选择的选项
      textOutput("output_choice"),
      # 在主面板中显示用户选择的值
      textOutput("output_value")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户输入的输出
  output$output_text <- renderText({
    # 输出用户输入的文本
    paste("您输入的文本是：", input$text_input)
  })
  
  # 创建一个响应用户选择的选项的输出
  output$output_choice <- renderText({
    # 输出用户选择的选项
    paste("您选择的选项是：", input$select_input)
  })
  
  # 创建一个响应用户滑块选择的输出
  output$output_value <- renderText({
    # 输出用户选择的值
    paste("您选择的值是：", input$slider)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

dateInput

  • inputId：输入元素的 ID，用于在服务器端和 UI 部分引用该输入元素。
  • label：输入框的标签。
  • value：可选参数，设置输入框的默认日期。默认为 NULL。
  • min：可选参数，设置可选择的最小日期。默认为 NULL，表示没有限制。
  • max：可选参数，设置可选择的最大日期。默认为 NULL，表示没有限制。

  • format：可选参数，设置日期的显示格式。默认为 "yyyy-mm-dd"。

    dateInput(inputId, label, value = NULL, min = NULL, max = NULL, format = "yyyy-mm-dd")

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("dateInput 示例"),
  sidebarLayout(
    sidebarPanel(
      dateInput("date_picker", "选择日期", value = Sys.Date(), min = "2022-01-01", max = "2022-12-31")
    ),
    mainPanel(
      textOutput("selected_date")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_date <- renderText({
    paste("您选择的日期是：", input$date_picker)
  })
}

# Run the application
shinyApp(ui = ui, server = server)

dateRangeInput

  • inputId：输入元素的 ID，用于在服务器端和 UI 部分引用该输入元素。
  • label：输入框的标签。
  • start：可选参数，设置日期范围的起始日期。默认为 NULL。
  • end：可选参数，设置日期范围的结束日期。默认为 NULL。
  • min：可选参数，设置可选择的最小日期范围。默认为 NULL，表示没有限制。
  • max：可选参数，设置可选择的最大日期范围。默认为 NULL，表示没有限制。
  • format：可选参数，设置日期的显示格式。默认为 "yyyy-mm-dd"。
  • separator：可选参数，设置日期范围的分隔符。默认为 " to "。
library(shiny)

# UI
ui <- fluidPage(
  titlePanel("dateRangeInput 示例"),
  sidebarLayout(
    sidebarPanel(
      dateRangeInput("date_range_picker", "选择日期范围", 
                     start = Sys.Date(), end = Sys.Date() + 7, 
                     format = "yyyy-mm-dd", separator = " ~ ")
    ),
    mainPanel(
      textOutput("selected_date_range")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_date_range <- renderText({
    paste("您选择的日期范围是：", input$date_range_picker[1], "到", input$date_range_picker[2])
  })
}

# Run the application
shinyApp(ui = ui, server = server)

结合csv

updateDateInput

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("updateDateInput 示例"),
  sidebarLayout(
    sidebarPanel(
      dateInput("date_picker", "选择日期", value = Sys.Date()),
      br(),
      actionButton("add_seven_days", "Date +7"),
      actionButton("reset_date", "重置")
    ),
    mainPanel(
      textOutput("selected_date")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_date <- renderText({
    paste("您选择的日期是：", input$date_picker)
  })
  
  observeEvent(input$add_seven_days, {
    updateDateInput(session, "date_picker", value = input$date_picker + 7)
  })
  
  observeEvent(input$reset_date, {
    updateDateInput(session, "date_picker", value = Sys.Date())
  })
}

# Run the application
shinyApp(ui = ui, server = server)

三、renderPlot()

  • 作用：

    renderPlot是Shiny中用于生成图形的server端函数。它负责将图形的生成逻辑包含在Shiny应用程序的服务器端，并根据用户的输入或其他动态数据的变化而更新图形。

    具体来说，renderPlot函数接受一个包含绘图逻辑的函数作为参数，并在Shiny应用程序的UI界面中将其呈现为一个绘图区域。当Shiny的输入参数或其他相关数据发生变化时，renderPlot函数会自动重新执行绘图函数，并更新UI界面中的图形，使得图形能够动态地响应用户操作或数据变化。

实例：

library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("renderPlot示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个sliderInput
      sliderInput("n", "选择点的数量：", min = 10, max = 100, value = 50)
    ),
    mainPanel(
      # 在主面板中显示绘图
      plotOutput("plot")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户输入的绘图
  output$plot <- renderPlot({
    # 根据用户选择的点的数量绘制随机散点图
    x <- rnorm(input$n)
    y <- rnorm(input$n)
    plot(x, y, main = paste("散点图 (点的数量:", input$n, ")"))
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

四、tabset

  • 作用

    tabset在Shiny中是一个用于创建选项卡式界面的布局组件。通过tabsetPanel函数可以在Shiny的UI界面中创建一个选项卡式的布局，用户可以通过点击选项卡来切换不同的内容。

    tabsetPanel函数接受一个或多个tabPanel函数作为参数，每个tabPanel函数表示一个选项卡面板，其中包含了该选项卡的内容。选项卡面板中的内容可以是任何Shiny UI元素，比如文本、图形、表格等。

示例

library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("tabsetPanel示例"),
  tabsetPanel(
    tabPanel("选项卡1",
             h3("这是选项卡1的内容"),
             plotOutput("plot1")),
    tabPanel("选项卡2",
             h3("这是选项卡2的内容"),
             plotOutput("plot2"))
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 在选项卡1中绘制图形
  output$plot1 <- renderPlot({
    plot(rnorm(100), main = "选项卡1中的图形")
  })
  
  # 在选项卡2中绘制图形
  output$plot2 <- renderPlot({
    plot(runif(100), main = "选项卡2中的图形")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

五、reactive

  • 作用：

    reactive函数是Shiny中用于创建响应式对象的函数。在Shiny中，响应式对象是一种特殊的对象，它可以根据应用程序中的输入或其他响应式对象的变化而自动更新其值。这样可以使得应用程序能够根据用户的操作或数据的变化动态地更新界面。

    reactive函数用于将普通的R代码转换为响应式对象。它接受一个或多个表达式作为参数，并返回一个响应式对象，该对象的值会根据表达式中使用的输入或其他响应式对象的变化而自动更新。

    在Shiny应用程序中，reactive函数通常用于创建一个或多个响应式对象，这些对象的值可以通过input对象中的输入或其他响应式对象的值进行计算。然后，可以在app的其他部分使用这些响应式对象，比如在renderPlot、renderTable等函数中使用它们的值来生成图形、表格等内容。

示例：

library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("reactive示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个textInput
      textInput("text_input", "请输入文本：", value = "")
    ),
    mainPanel(
      # 在主面板中显示用户输入的文本的长度
      textOutput("output_length")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户输入的响应式对象
  input_text_length <- reactive({
    # 计算用户输入的文本的长度
    nchar(input$text_input)
  })
  
  # 创建一个响应用户输入文本长度的输出
  output$output_length <- renderText({
    # 输出用户输入的文本的长度
    paste("您输入的文本的长度是：", input_text_length())
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

六、download

plot-PDF/PNG

要在Shin中使用downloadButton以PNG或PDF格式下载plot

  1. 创建一个UI元素来存放下载按钮，通常使用downloadButton函数
  2. 创建一个服务器端的响应式函数（reactive）来生成需要下载的绘图或其他内容。
  3. 将生成的内容保存为临时文件，然后将文件的路径传递给downloadHandler函数
  4. 在downloadHandler函数中定义下载的行为，包括文件名和文件格式。

  • 示例

    library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("下载示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个下载按钮
      downloadButton("download_plot", "下载")
    ),
    mainPanel(
      # 在主面板中显示绘图
      plotOutput("plot")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应式函数来生成绘图
  plot_data <- reactive({
    # 生成一张随机的散点图
    plot(rnorm(100), rnorm(100))
  })
  
  # 在主面板中显示绘图
  output$plot <- renderPlot({
    plot_data()
  })
  
  # 定义下载处理函数
  output$download_plot <- downloadHandler(
    # 文件名
    filename = function() {
      paste("plot", Sys.Date(), ".png", sep = "_")
    },
    # 下载内容
    content = function(file) {
      # 保存绘图为PNG文件
      png(file)
      plot_data()
      dev.off()
      # 将PNG文件复制到临时目录
      file.copy("Rplot.png", file)
    }
  )
}

# 运行应用程序
shinyApp(ui = ui, server = server)

downloadHandler()

downloadHandler函数在Shiny应用程序中用于处理文件下载操作。它允许你定义一个自定义的处理函数，在用户点击下载按钮时执行该函数，并生成要下载的文件内容。

table data

通过downloadButton和downloadHandler结合使用来实现

  • 示例：

    library(shiny)

# 创建一个示例的数据框
data <- data.frame(
  ID = 1:5,
  Name = c("Alice", "Bob", "Charlie", "David", "Eve"),
  Score = c(80, 75, 90, 85, 88)
)

# 定义UI界面
ui <- fluidPage(
  titlePanel("下载表格数据示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个下载按钮
      downloadButton("download_data", "下载表格数据")
    ),
    mainPanel(
      # 在主面板中显示表格数据
      tableOutput("table")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 在主面板中显示表格数据
  output$table <- renderTable({
    data
  })
  
  # 定义下载处理函数
  output$download_data <- downloadHandler(
    # 文件名
    filename = function() {
      paste("table_data", Sys.Date(), ".csv", sep = "_")
    },
    # 下载内容
    content = function(file) {
      # 将数据框保存为CSV文件
      write.csv(data, file, row.names = FALSE)
    }
  )
}

# 运行应用程序
shinyApp(ui = ui, server = server)

webshot包

library(shiny)
library(plotly)
library(ggplot2)
library(webshot)
library(htmlwidgets)

# UI
ui <- fluidPage(
  titlePanel("Save Plotly & ggplotly graphs"),
  sidebarLayout(
    sidebarPanel(
      selectInput("plot_type", "Select Plot Type", choices = c("plotly", "ggplot2")),
      selectInput("export_format", "Select Export Format", choices = c("png", "jpeg", "pdf")),
      actionButton("download_btn", "Download Plot")
    ),
    mainPanel(
      plotlyOutput("my_plot")
    )
  )
)

# Server
server <- function(input, output) {
  output$my_plot <- renderPlotly({
    # Create a sample plot based on the selected plot type
    if (input$plot_type == "plotly") {
      p <- plot_ly(mtcars, x = ~wt, y = ~mpg, type = "scatter", mode = "markers")
    } else if (input$plot_type == "ggplot2") {
      p <- ggplot(mtcars, aes(x = wt, y = mpg)) + geom_point()
      p <- ggplotly(p)
    }
    p
  })
  
  observeEvent(input$download_btn, {
    # Save the plot based on the selected plot type and export format
    output_file <- paste("plot.", input$export_format, sep = "")
    if (input$plot_type == "plotly") {
      save_plotly <- output$my_plot
      saveWidget(save_plotly, 
                 file = output_file, 
                 selfcontained = TRUE,
                 background = "white",
                 width = 800,
                 height = 600)
    } else if (input$plot_type == "ggplot2") {
      save_ggplotly <- output$my_plot
      saveWidget(save_ggplotly, 
                 file = output_file, 
                 selfcontained = TRUE,
                 background = "white",
                 width = 800,
                 height = 600)
    }
    webshot::webshot(output_file, output_file, cliprect = "viewport")
  })
}

# Run the application
shinyApp(ui = ui, server = server)

七、常用函数学习

submitButton()

submitButton是Shiny中用于创建提交按钮的函数。提交按钮通常用于在表单中，当用户完成填写表单内容后，点击提交按钮以提交表单数据。

具体来说，submitButton函数的作用包括：

  1. 创建提交按钮：使用submitButton函数可以在Shiny应用程序的UI界面中创建一个提交按钮。
  2. 触发表单提交操作：当用户点击提交按钮时，会触发与之相关联的表单提交操作，通常是将表单数据发送到服务器端进行处理。
  3. 提交表单数据：通过submitButton函数的参数，可以指定在用户点击提交按钮时所执行的操作，比如更新数据、执行计算、生成报告等。
  • 示例
library(shiny)

# 定义UI界面
ui <- fluidPage(
  titlePanel("submitButton示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个文本输入框
      textInput("text_input", "请输入文本："),
      # 添加一个提交按钮
      submitButton("提交")
    ),
    mainPanel(
      # 在主面板中显示用户输入的文本
      textOutput("output_text")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output) {
  # 创建一个响应用户输入的输出
  output$output_text <- renderText({
    # 输出用户输入的文本
    paste("您输入的文本是：", input$text_input)
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

renderUI()与uiOutput()

  • renderUI 是 Shiny 中用于动态生成 UI 元素的函数。根据用户的输入或其他条件来动态地创建、更新或删除 UI 元素。
    renderUI 函数通常与 uiOutput 或 htmlOutput 配合使用。renderUI 生成的内容将被渲染到 uiOutput 或 htmlOutput 所指定的位置。
  • uiOutput 则是 Shiny中用于插入动态 UI 元素的函数。它通常与 renderUI 函数配合使用，renderUI 生成的内容将被渲染到 uiOutput 所指定的位置。

  • 示例

    library(shiny)

# 定义 UI
ui <- fluidPage(
  titlePanel("Dynamic UI 示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个选择输入，用户选择不同的选项将触发不同的 UI 元素的生成
      selectInput("selector", "选择一个选项：", choices = c("Option 1", "Option 2"))
    ),
    mainPanel(
      # 使用 uiOutput 用于动态生成 UI 元素
      uiOutput("dynamic_ui")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output, session) {
  # 根据用户的选择生成不同的 UI 元素
  output$dynamic_ui <- renderUI({
    choice <- input$selector
    
    # 根据选择生成不同的 UI 元素
    if (choice == "Option 1") {
      tagList(
        h3("选项1被选择："),
        p("这是选项1的内容。")
      )
    } else if (choice == "Option 2") {
      tagList(
        h3("选项2被选择："),
        p("这是选项2的内容。")
      )
    }
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

actionButton()

actionButton 是 Shiny 中用于创建动作按钮的函数。动作按钮通常用于触发某种特定的动作或操作，比如提交表单、执行计算、更新数据等。

  • 基本格式：
> actionButton(inputId, label, icon = NULL, width = NULL, ...)

  • 参数说明：

    • inputId：按钮的 ID，用于在服务器端识别按钮的点击事件。
    • label：按钮的标签，即按钮上显示的文本。
    • icon：可选参数，用于指定按钮上显示的图标。
    • width：可选参数，用于指定按钮的宽度。
    • ...：其他可选参数，用于设置按钮的样式或属性。

  • 示例：

    library(shiny)

# 定义 UI
ui <- fluidPage(
  titlePanel("动作按钮示例"),
  sidebarLayout(
    sidebarPanel(
      # 添加一个动作按钮
      actionButton("action_btn", "点击我执行操作")
    ),
    mainPanel(
      # 在主面板中显示点击次数
      verbatimTextOutput("click_count")
    )
  )
)

# 定义服务器逻辑
server <- function(input, output, session) {
  # 追踪按钮点击次数
  click_count <- reactiveVal(0)
  
  # 监听按钮点击事件
  observeEvent(input$action_btn, {
    # 每次点击按钮，增加点击次数
    click_count(click_count() + 1)
  })
  
  # 在主面板中显示点击次数
  output$click_count <- renderPrint({
    paste("按钮已被点击", click_count(), "次。")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

    在服务器逻辑中，使用 observeEvent 函数来监听按钮的点击事件，并在每次点击按钮时更新按钮点击次数。最后，使用 renderPrint 函数在主面板中显示按钮点击次数。

isolate()

isolate() 函数在 Shiny 中用于隔离响应式表达式的执行。它通常用于防止某些特定的输入值发生变化时触发响应式表达式的重新计算。

  • isolate() 函数的基本用法如下：
isolate(expr)

  • 参数说明：

    • expr：要隔离的表达式，通常是一个响应式表达式。

fileInput()

  1. 在UI部分，添加fileInput函数。
  2. 在server部分，可以使用input$fileId来访问上传的文件
  • 示例：
library(shiny)

# UI
ui <- fluidPage(
  titlePanel("文件输入示例"),
  fileInput("file", "选择CSV文件", accept = c(".csv")),
  tableOutput("contents")
)

# Server
server <- function(input, output) {
    options(shiny.maxRequestSize = 10*1024^2) # 将最大上传大小限制设置为10MB
  # 其他服务器逻辑
  # 读取上传的文件
  data <- reactive({
    req(input$file)
    read.csv(input$file$datapath)
  })
  
  # 显示上传文件的内容
  output$contents <- renderTable({
    data()
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

具体情况具体分析，举一反三即可

conditionalPanel()

conditionalPanel 函数用于根据条件显示或隐藏 UI 元素。它通常与 uiOutput 和 renderUI 配合使用，根据用户的选择或其他条件动态显示或隐藏特定的 UI 元素。

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("Conditional Panel 示例"),
  
  # 添加一个单选按钮组
  radioButtons("choice", "选择一个选项：", choices = c("显示文本框", "隐藏文本框")),
  
  # 条件面板，根据单选按钮的选择来显示或隐藏文本框
  conditionalPanel(
    condition = "input.choice == '显示文本框'",
    textInput("text_input", "输入文本：", "")
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# Run the application
shinyApp(ui = ui, server = server)

reactiveValue()

reactiveValue() 函数用于创建一个响应式值，该值可以根据 Shiny 中的输入、输出或其他响应式值的变化而自动更新

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("计数器示例"),
  actionButton("increment_btn", "+1"),
  actionButton("decrement_btn", "-1"),
  actionButton("reset_btn", "归零"),
  textOutput("counter_text")
)

# Server
server <- function(input, output) {
  # 创建一个响应式值用于存储计数值
  rv <- reactiveValues(counter = 0)
  
  # 当按下“+1”按钮时，计数值加1
  observeEvent(input$increment_btn, {
    rv$counter <- rv$counter + 1
  })
  
  # 当按下“-1”按钮时，计数值减1
  observeEvent(input$decrement_btn, {
    rv$counter <- rv$counter - 1
  })
  
  # 当按下“归零”按钮时，计数值归零
  observeEvent(input$reset_btn, {
    rv$counter <- 0
  })
  
  # 显示计数值
  output$counter_text <- renderText({
    paste("当前计数值为：", rv$counter)
  })
}

# Run the application
shinyApp(ui = ui, server = server)

eventReactive()

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("eventReactive 示例"),
  actionButton("btn", "点击我"),
  textOutput("output")
)

# Server
server <- function(input, output) {
  # 创建一个触发事件
  button_click <- eventReactive(input$btn, {
    # 当按钮被点击时，触发该事件,返回按钮点击次数
    input$btn
  })
  
  # 显示触发事件的值
  output$output <- renderText({
    paste("按钮点击次数为:", button_click())
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

fluidRow()与column()

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("布局示例"),
  fluidRow(
    column(4,
           h3("列1"),
           p("这是列1中的内容。")
    ),
    column(4,
           h3("列2"),
           p("这是列2中的内容。")
    ),
    column(4,
           h3("列3"),
           p("这是列3中的内容。")
    )
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# 运行应用程序
shinyApp(ui = ui, server = server)

navbarPage()与navbarMenu()

library(shiny)

# UI
ui <- navbarPage(
  title = "导航栏示例",inverse = T, selected = "关于", 
  #position = "fixed-bottom"  "static-top"  "fixed-top"
  tabPanel("首页",
           fluidRow(
             column(6, h3("欢迎来到首页！")),
             column(6, img(src = "https://david03.oss-cn-guangzhou.aliyuncs.com/blogpic/202402282111163.gif", height = 100))
           )
  ),
  navbarMenu("功能",
             tabPanel("功能1",
                      p("这是功能1的内容。")
             ),
             tabPanel("功能2",
                      p("这是功能2的内容。")
             )
  ),
  tabPanel("关于",
           p("这是关于页面的内容。")
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# 运行应用程序
shinyApp(ui = ui, server = server)

navlistPanel()

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("带有下拉式父菜单的 navlistPanel 示例"),
  navlistPanel(
    "导航列表",
    tabPanel("页面1",
             p("这是页面1的内容。")
    ),
    tabPanel("页面2",
             p("这是页面2的内容。")
    ),
    navbarMenu(
      title = "父菜单项1",
      tabPanel("子页面1",
               p("这是父菜单项1的子页面1的内容。")
      ),
      tabPanel("子页面2",
               p("这是父菜单项1的子页面2的内容。")
      )
    ),
    navbarMenu(
      title = "父菜单项2",
      tabPanel("子页面3",
               p("这是父菜单项2的子页面3的内容。")
      ),
      tabPanel("子页面4",
               p("这是父菜单项2的子页面4的内容。")
      )
    )
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# 运行应用程序
shinyApp(ui = ui, server = server)

selectInput()与updateSelectInput()

  • 介绍

    • selectInput()

      selectInput(inputId, label, choices, selected = NULL, multiple = FALSE)
      • inputId：元素的唯一标识符。
      • label：下拉菜单的标签。
      • choices：一个命名列表，包含下拉菜单中的选项。键是选项的值，值是显示给用户的标签。
      • selected：可选参数，指定默认选中的选项。
      • multiple：逻辑值，指定是否允许多选。默认为 FALSE，表示单选。

    • updateSelectInput()

      updateSelectInput(session, inputId, choices, selected = NULL)
      • session：shinyServer 函数中的 session 对象。
      • inputId：要更新的 selectInput() 的输入 ID。
      • choices：新的选项列表。
      • selected：可选参数，指定要选中的选项。如果为 NULL，则不更改当前选择。

  • 示例

    library(shiny)

# UI
ui <- fluidPage(
  titlePanel("SelectInput 与 updateSelectInput 示例"),
  sidebarLayout(
    sidebarPanel(
      selectInput("my_select", "选择一个字母：",
                  choices = c("A", "B", "C", "选择所有选项"), # 添加选择所有选项
                  selected = "选择所有选项", multiple = TRUE), # 默认选择选择所有选项
      actionButton("update_btn", "更新选项")
    ),
    mainPanel(
      textOutput("selected_output")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_output <- renderText({
    if ("选择所有选项" %in% input$my_select) { # 如果选择了选择所有选项
      paste("您选择了所有选项：", paste(setdiff(c("A", "B", "C"), "选择所有选项"), collapse = ", ")) # 显示除选择所有选项外的所有选项
    } else {
      paste("您选择了：", paste(input$my_select, collapse = ", ")) # 否则显示所选选项
    }
  })
  
  observeEvent(input$update_btn, {
    updateSelectInput(session, "my_select", choices = c("D", "E", "F", "选择所有选项"), selected = "选择所有选项", multiple = TRUE)
  })
}

# Run the application
shinyApp(ui = ui, server = server)

updateCheckboxGroupInput()

实现全选和全不选功能，可以使用这个函数

示例如下：

####updateCheckboxGroupInput()####
library(shiny)

# UI
ui <- fluidPage(
  titlePanel("Select All / None 示例"),
  sidebarLayout(
    sidebarPanel(
      checkboxGroupInput("my_checkbox_group", "选择选项：",
                         choices = c("Option 1", "Option 2", "Option 3"),
                         selected = NULL),
      actionButton("select_all_btn", "全选"),
      actionButton("select_none_btn", "全不选")
    ),
    mainPanel(
      textOutput("selected_output")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_output <- renderText({
    paste("您选择了：", paste(input$my_checkbox_group, collapse = ", "))
  })
  
  observeEvent(input$select_all_btn, {
    updateCheckboxGroupInput(session, "my_checkbox_group", 
                             selected = c("Option 1", "Option 2", "Option 3"))
  })
  
  observeEvent(input$select_none_btn, {
    updateCheckboxGroupInput(session, "my_checkbox_group", 
                             choices = c("Option 1", "Option 2", "Option 3"), 
                             selected = NULL)
  })
}

# Run the application
shinyApp(ui = ui, server = server)

也可以使用updateSelectInput() 和 updateCheckboxInput()来实现全选全不选功能，示例如下：

####updateSelectInput() 和 updateCheckboxInput()####
library(shiny)

# UI
ui <- fluidPage(
  titlePanel("Select All / None 示例"),
  sidebarLayout(
    sidebarPanel(
      selectInput("my_select", "选择一个选项：",
                  choices = c("Option 1", "Option 2", "Option 3"),
                  selected = NULL,
                  multiple = TRUE),
      checkboxInput("select_all", "全选", value = FALSE),
      checkboxInput("select_none", "全不选", value = FALSE)
    ),
    mainPanel(
      textOutput("selected_output")
    )
  )
)

# Server
server <- function(input, output, session) {
  output$selected_output <- renderText({
    paste("您选择了：", paste(input$my_select, collapse = ", "))
  })
  
  observeEvent(input$select_all, {
    if (input$select_all) {
      updateCheckboxInput(session, "select_none", value = FALSE) # 确保 "全不选" 复选框未选中
      updateSelectInput(session, "my_select", 
                        choices = c("Option 1", "Option 2", "Option 3"),
                        selected = c("Option 1", "Option 2", "Option 3")) # 选中所有选项
    }
  })
  
  observeEvent(input$select_none, {
    if (input$select_none) {
      updateCheckboxInput(session, "select_all", value = FALSE) # 确保 "全选" 复选框未选中
      updateSelectInput(session, "my_select", 
                        choices = c("Option 1", "Option 2", "Option 3"),
                        selected = NULL) # 取消选中所有选项
    }
  })
}

# Run the application
shinyApp(ui = ui, server = server)

八、添加

图片，视频

library(shiny)

# UI
ui <- fluidPage(
  titlePanel("图片和视频示例"),
  
  # 显示图片
  img(src = "https://www.example.com/image.jpg", width = "400px"),
  
  # 显示视频
  tags$video(
    controls = "controls",
    width = "400px",
    height = "300px",
    src = "https://www.example.com/video.mp4"
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# Run the application
shinyApp(ui = ui, server = server)

PDF

####添加PDF####
library(shiny)

# UI
ui <- fluidPage(
  titlePanel("嵌入 PDF 示例"),
  
  # 嵌入 PDF
  tags$iframe(style="height:400px ; width:100% ; scrolling = yes",
    src = "https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf",
  )
)

# Server
server <- function(input, output) {
  # 服务器逻辑
}

# Run the application
shinyApp(ui = ui, server = server)

九、package

shinythemes

  1. cerulean
  2. cosmo
  3. flatly
  4. journal
  5. lumen
  6. paper
  7. readable
  8. sandstone
  9. simplex
  10. spacelab
  11. superhero
  12. united
  13. yeti
library(shiny)
library(shinythemes)

# UI
ui <- fluidPage(
  theme = shinytheme("flatly"), # 更改主题为 "flatly"
  titlePanel("Old Faithful Geyser Data"),
  sidebarLayout(
    sidebarPanel(
      sliderInput("bins",
                  "Number of bins:",
                  min = 1,
                  max = 50,
                  value = 30)
    ),
    mainPanel(
      plotOutput("distPlot")
    )
  )
)

# Server
server <- function(input, output) {
  output$distPlot <- renderPlot({
    # generate bins based on input$bins from ui
    x    <- faithful$waiting
    bins <- seq(min(x), max(x), length.out = input$bins + 1)
    
    # draw the histogram with the specified number of bins
    hist(x, breaks = bins, col = 'darkgray', border = 'white')
  })
}

# Run the application
shinyApp(ui = ui, server = server)

rhandsontable

gpt提供文本

rhandsontable 是一个用于在 Shiny 应用程序中显示交互式数据表格的包。它基于 handsontable JavaScript 库，并提供了许多功能和选项，使您可以在应用程序中创建灵活的、可交互的数据表格。

rhandsontable 的主要功能和用法包括：

  1. 显示数据表格：您可以将数据以表格的形式显示在 Shiny 应用程序中，使用户可以轻松查看和操作数据。
  2. 交互性：用户可以通过单击、拖动、调整列宽、行高等方式与数据表格进行交互。他们还可以在表格中编辑单元格内容。
  3. 数据编辑：rhandsontable 允许用户直接在表格中编辑数据。用户可以添加、删除和编辑单元格的内容，并且这些更改会自动反映在应用程序中。
  4. 数据校验：您可以配置校验规则，以确保用户输入的数据符合特定的规范或条件。例如，您可以限制用户输入的数据类型、范围、格式等。
  5. 数据导出：rhandsontable 允许用户将表格中的数据导出为常见的数据格式，如 CSV、Excel、JSON 等，以便进一步处理或分享数据。

以下是一个简单的示例，演示了如何在 Shiny 应用程序中使用 rhandsontable：

library(shiny)
library(rhandsontable)

# UI
ui <- fluidPage(
  titlePanel("rhandsontable 示例"),
  sidebarLayout(
    sidebarPanel(
      fileInput("file", "上传文件"),
      numericInput("rows", "行数", value = 5),
      numericInput("cols", "列数", value = 5),
      actionButton("create", "创建表格")
    ),
    mainPanel(
      rHandsontableOutput("hot")
    )
  )
)

# Server
server <- function(input, output, session) {
  # 创建空的表格
  data <- reactiveVal(NULL)
  
  observeEvent(input$create, {
    data(data.frame(matrix(NA, nrow = input$rows, ncol = input$cols)))
  })
  
  observeEvent(input$file, {
    data(read.csv(input$file$datapath))
  })
  
  output$hot <- renderRHandsontable({
    if (!is.null(data())) {
      rhandsontable(data())
    }
  })
}

# Run the application
shinyApp(ui = ui, server = server)

在这个示例中，用户可以选择上传一个文件或手动创建一个空的数据表格。然后，他们可以在数据表格中编辑数据，并且编辑的结果会实时地显示在应用程序中。

shinyjs

  • shinyjs 是一个 R 包，它为 Shiny 提供了一组 JavaScript 工具函数，使得在 Shiny 应用程序中执行 JavaScript 代码更加容易和方便。通过 shinyjs 包，便可以轻松地在 Shiny 中添加 JavaScript 功能，例如控制页面元素的显示/隐藏、禁用/启用、滚动到特定位置、显示提示框等等。

  • shinyjs 的主要功能包括：

    • 控制页面元素： shinyjs 在 Shiny 中控制页面元素的属性，例如显示/隐藏、禁用/启用、更改样式等。
    • 与 JavaScript 交互：可以在 Shiny 中调用 JavaScript 函数，以便执行复杂的操作或与外部 JavaScript 库进行交互。
    • 简化操作：shinyjs 提供了一系列简化的函数，使得在 Shiny 中执行常见的 JavaScript 操作更加容易和方便。
    • 动态更新：可以使用 shinyjs 实时地动态更新页面元素，而无需刷新整个页面。
    • 事件绑定：shinyjs 允许绑定 JavaScript 事件处理程序，以响应用户的交互操作，例如点击、拖动等。

具体功能：image-20240418011600683

hide隐藏元素

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("hide_btn", "隐藏按钮"),
  verbatimTextOutput("hide_output")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$hide_btn, {
    hide("hide_btn")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

show显示元素

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("hide_btn", "隐藏按钮"),
  actionButton("show_btn", "显示按钮"),
  verbatimTextOutput("show_output")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$hide_btn, {
    hide("hide_btn")
  })
  observeEvent(input$show_btn, {
    show("hide_btn")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

toggle切换元素的显示/隐藏状态

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("toggle_btn", "切换按钮显示/隐藏"),
  verbatimTextOutput("toggle_output")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$toggle_btn, {
    toggle("toggle_btn")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

hidden

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("toggle_btn", "切换按钮显示/隐藏"),
  verbatimTextOutput("hidden_output")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$toggle_btn, {
    toggle("toggle_btn")
    output$hidden_output <- renderPrint({
      hidden("toggle_btn")
    })
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

alert弹出提示框

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("alert_btn", "弹出提示框")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$alert_btn, {
    alert("这是一个提示框！")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

delay延迟执行操作

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("delay_btn", "延迟执行操作")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$delay_btn, {
    delay(3000, {
      alert("三秒后执行此操作！")
    })
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

enable启用元素

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("disable_btn", "禁用按钮"),
  actionButton("enable_btn", "启用按钮")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$disable_btn, {
    disable("disable_btn")
  })
  observeEvent(input$enable_btn, {
    enable("disable_btn")
  })
}

# 运行应用程序
shinyApp(ui = ui, server = server)

disable禁用元素

library(shiny)
library(shinyjs)

# UI
ui <- fluidPage(
  useShinyjs(),  # 激活 shinyjs
  actionButton("disable_btn", "禁用按钮"),
  actionButton("enable_btn", "启用按钮")
)

# Server
server <- function(input, output, session) {
  observeEvent(input$disable_btn, {
    disable("disable_btn")
  })
  observeEvent(input$enable_btn, {
    enable("disable_btn")
  })
}

# 运行应用程序
shinyApp(ui = ui, server

ShinyDashboard

ShinyDashboard 提供了一套易于使用的函数和模板，使得创建专业外观的仪表板变得更加容易。

library(shiny)
library(shinydashboard)

# Define UI
ui <- dashboardPage(
  dashboardHeader(title = "My Dashboard"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", tabName = "widgets", icon = icon("th"))
    )
  ),
  dashboardBody(
    tabItems(
      tabItem(tabName = "dashboard",
              fluidRow(
                box(title = "Box 1", "Content for Box 1"),
                box(title = "Box 2", "Content for Box 2")
              )
      ),
      tabItem(tabName = "widgets",
              h2("Widgets Page"),
              sliderInput("slider", "Slider:", min = 1, max = 100, value = 50),
              checkboxInput("checkbox", "Checkbox:", value = TRUE),
              actionButton("button", "Button")
      )
    )
  )
)

# Define server logic
server <- function(input, output) {
  
}

# Run the application
shinyApp(ui = ui, server = server)
  • dashboardPage 函数定义了仪表板的整体布局。
  • dashboardHeader 函数定义了仪表板的页眉部分，可以包含标题和其他元素。
  • dashboardSidebar 函数定义了仪表板的侧边栏，其中包含了菜单项。
  • sidebarMenu 函数定义了侧边栏中的菜单项。
  • dashboardBody 函数定义了仪表板的主体部分，包含了各种选项卡。
  • tabItems 函数定义了每个选项卡的内容。
  • tabItem 函数定义了选项卡中的子元素，例如容器和widgets。
  • box 函数定义了一个带有标题的容器框。
  • 其他的 Shiny widgets（如 sliderInput、checkboxInput、actionButton）用于与用户进行交互。

GPT提供：

library(shiny)
library(shinydashboard)

# Define UI
ui <- dashboardPage(
  dashboardHeader(title = "My Dashboard"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard"),
               menuSubItem("Subitem 1", tabName = "subitem1"),
               menuSubItem("Subitem 2", tabName = "subitem2")),
      menuItem("Widgets", tabName = "widgets", icon = icon("th"))
    )
  ),
  dashboardBody(
    tabItems(
      tabItem(tabName = "dashboard",
              fluidRow(
                infoBox("Box 1", value = 100, subtitle = "Subtitle for Box 1"),
                infoBox("Box 2", value = 200, subtitle = "Subtitle for Box 2")
              ),
              tabBox(
                tabPanel("Tab 1", "Content for Tab 1"),
                tabPanel("Tab 2", "Content for Tab 2")
              )
      ),
      tabItem(tabName = "widgets",
              h2("Widgets Page"),
              valueBox("Value Box", 300, icon = icon("info"), color = "purple"),
              sliderInput("slider", "Slider:", min = 1, max = 100, value = 50),
              checkboxInput("checkbox", "Checkbox:", value = TRUE),
              actionButton("button", "Button")
      )
    )
  )
)

# Define server logic
server <- function(input, output) {
  
}

# Run the application
shinyApp(ui = ui, server = server)
  • menuSubItem 函数允许您在侧边栏菜单项中添加子菜单项。在 "Dashboard" 菜单项中，我们添加了两个子菜单项 "Subitem 1" 和 "Subitem 2"。
  • infoBox 函数创建一个信息框，显示一个数字值和一个标题。在 "Dashboard" 页面中，我们创建了两个信息框，分别显示值为 100 和 200。
  • tabBox 函数允许您在选项卡中创建多个选项卡。在 "Dashboard" 页面中，我们创建了一个包含两个选项卡的 tabBox。
  • valueBox 函数创建一个值框，显示一个数字值和一个标题。在 "Widgets" 页面中，我们创建了一个值框，显示值为 300。
library(shiny)
library(shinydashboard)

# Define UI
ui <- dashboardPage(
  dashboardHeader(title = "My Dashboard"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", tabName = "widgets", icon = icon("th"))
    )
  ),
  dashboardBody(
    tabItems(
      tabItem(tabName = "dashboard",
              tabBox(
                tabPanel("Tab 1", 
                         fluidRow(
                           infoBox("Box 1", value = 100, subtitle = "Subtitle for Box 1"),
                           infoBox("Box 2", value = 200, subtitle = "Subtitle for Box 2")
                         )
                ),
                tabPanel("Tab 2", "Content for Tab 2")
              )
      ),
      tabItem(tabName = "widgets",
              h2("Widgets Page"),
              valueBox("Value Box", 300, icon = icon("info"), color = "purple"),
              sliderInput("slider", "Slider:", min = 1, max = 100, value = 50),
              checkboxInput("checkbox", "Checkbox:", value = TRUE),
              actionButton("button", "Button")
      )
    )
  )
)

# Define server logic
server <- function(input, output) {
  
}

# Run the application
shinyApp(ui = ui, server = server)
大学学习 R语言

Author
DavidYR
Title
shiny网页学习笔记（完结）
Reuse
Unless otherwise stated, this is original content by Davidの3号基地. Reposts must credit the author and include a link to the original.

Comments

No comments yet. Share your thoughts.

Leave a comment

Your email will not be published. Fields marked * are required.

Replies inherit the original privacy. Keep this browser’s cookies; an email address alone cannot restore access.

Find an article