Summary  
This chapter covers the use of various assignment operators to bind values to variables in code, demonstrating leftward, rightward, and single-equals syntaxes.  

General domain of usage  
Data analysis

R provides several operators for assigning values to variables.

```r
year = 2020
year <- 2020
2020 -> year
```

However, `->` is rarely used because it reduces code readability.

Going forward, assignments will be shown using the left arrow (`<-`) and the equal sign (`=`).

Note

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Один раз выполняем пользовательский файл в отдельном окружении
#     через run_user_code(...). Получаем:
#       - res$values$...  — переменные из окружения
#       - res$logs        — весь печатный вывод (включая результаты выражений)
#  2) Каждый кейс — отдельный dynamic_test(...), то есть отдельная строка
#     в отчёте, с «говорящим» названием (успех/ошибка).
# =====================================================================

library(testthat)
source(testthat::test_path("helper-run_user_code.R"), local = TRUE)

# Ищем user_code.R в двух вариантах:
#  1) в корне проекта:        ../../user_code.R  (относительно tests/testthat)
#  2) рядом с тестами:        user_code.R        (внутри tests/testthat)
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)

# Нормализуем пути, оставляем существующие
candidates_norm <- vapply(candidates, function(p) {
  tryCatch(normalizePath(p, winslash = "/", mustWork = FALSE), error = function(e) NA_character_)
}, character(1))

exists_flags <- file.exists(candidates_norm)
if (!any(exists_flags)) {
  stop(
    sprintf(
      "user_code.R not found.\nChecked paths:\n  - %s\nWorking dir: %s",
      paste(candidates, collapse = "\n  - "),
      getwd()
    )
  )
}

user_file <- candidates_norm[which(exists_flags)[1]]  # первый найденный

# Выполняем user_code.R один раз, извлекаем переменные и перехватываем вывод
res <- run_user_code(
  file       = user_file,
  capture    = c("equal", "left", "right"),
  echo       = FALSE,
  print.eval = TRUE
)

# ---------- CASE 1 ----------
{
  ok <- !is.null(res$values$equal) && identical(res$values$equal, 29 %/% 8)

  dynamic_test(
    ok,
    "Variable 'equal' is declared and equals 29 %/% 8 (3)",
    sprintf("Expected 'equal' == 3. Got: %s", paste(res$values$equal))
  )
}

# ---------- CASE 2 ----------
{
  ok <- !is.null(res$values$left) && identical(res$values$left, 29 %% 8)

  dynamic_test(
    ok,
    "Variable 'left' is declared and equals 29 %% 8 (5)",
    sprintf("Expected 'left' == 5. Got: %s", paste(res$values$left))
  )
}

# ---------- CASE 3 ----------
{
  ok <- !is.null(res$values$right) && identical(res$values$right, res$values$equal ^ res$values$left)

  dynamic_test(
    ok,
    "Variable 'right' is declared and equals equal^left (243)",
    sprintf("Expected 'right' == 243. Got: %s", paste(res$values$right))
  )
}

# ---------- CASE 4 ----------
{
  out <- trimws(paste(res$logs, collapse = " "))
  ok  <- grepl("([^0-9]|^)3([^0-9]+)5([^0-9]+)243([^0-9]|$)", out)

  dynamic_test(
    ok,
    "Console output contains '3 5 243'",
    sprintf("Expected console output to include '3 5 243'. Actual: %s", out)
  )
}


test_hidden.R

# =====================================================================
# ВСПОМОГАТЕЛЬНЫЕ ХЕЛПЕРЫ ДЛЯ ТЕСТОВ
#
# Файл называется helper-*.R: testthat автоматически подхватывает такие
# файлы перед выполнением любых тестов в каталоге tests/testthat.
# =====================================================================

# -----------------------------------------------------------------------------
# run_user_code(...)
#  - безопасно запускает user_code.R в отдельном окружении (env)
#  - перехватывает ВЕСЬ вывод (stdout): как результаты выражений, так и print()/cat()
#  - возвращает:
#       values  — список запрошенных переменных (по именам из аргумента capture)
#       logs    — вектор строк перехваченного вывода
#       env     — окружение, где выполнялся user_code (можно исследовать при необходимости)
#
# ПАРАМЕТРЫ:
#   file        — путь к user_code.R
#   capture     — character-вектор имён переменных, которые нужно извлечь после выполнения
#   inject      — список объектов/функций, которые нужно «подложить» в среду исполнения
#                 (можно использовать для моков/маскировки опасных функций: system, file.remove и т.д.)
#   echo        — печатать код при исполнении (обычно FALSE)
#   print.eval  — ПЕЧАТАТЬ РЕЗУЛЬТАТЫ ВЫРАЖЕНИЙ. Ключевая опция, чтобы строки вида
#                 `prices['Armchair']` попадали в stdout без явного print().
#
# БЕЗОПАСНОСТЬ:
#   - В базовом R нет полноценной «песочницы». Мы изолируем код в новом env,
#     но ОС-доступ не блокируется магически.
#   - Для задач онлайн-платформы можно частично «глушить» опасные вызовы через inject,
#     например:
#       inject = list(
#         system      = function(...) stop("system disabled"),
#         file.remove = function(...) stop("file.remove disabled")
#       )
# -----------------------------------------------------------------------------
run_user_code <- function(
  file = "user_code.R",
  capture = character(0),
  inject = list(),
  echo = FALSE,
  print.eval = TRUE
) {
  # Бросаем явную ошибку, если файла нет (проще диагностировать)
  stopifnot(file.exists(file))

  # Изолированное окружение: parent=baseenv() (без лишних пользовательских объектов сверху)
  env <- new.env(parent = baseenv())

  # Подмешиваем моки/данные в окружение (при необходимости)
  if (length(inject)) list2env(inject, envir = env)

  # ВАЖНО: перехватываем весь вывод выполнения файла.
  # source(..., local=env, echo, print.eval) исполняет код ВНУТРИ env.
  # print.eval=TRUE заставляет R печатать результаты выражений (как в консоли),
  # что позволяет проверять «голые» выражения без print().
  logs <- utils::capture.output(
    base::source(file, local = env, echo = echo, print.eval = print.eval)
  )

  # Собираем запрошенные значения переменных
  values <- setNames(vector("list", length(capture)), capture)
  for (nm in capture) {
    if (exists(nm, envir = env, inherits = FALSE)) {
      values[[nm]] <- get(nm, envir = env, inherits = FALSE)
    } else {
      values[[nm]] <- NULL
    }
  }

  list(values = values, logs = logs, env = env)
}

# -----------------------------------------------------------------------------
# dynamic_test(condition, success, failure)
#  - Создаёт ОДИН тест с «динамическим» названием.
#  - Если condition=TRUE → тест называется success.
#  - Если condition=FALSE → тест называется failure, и тест проваливается.
#  - Используем настоящую expectation (expect_true(TRUE)), чтобы репортёры всегда
#    печатали имя успеха (TAP, progress и т.д.).
# -----------------------------------------------------------------------------
dynamic_test <- function(condition, success, failure) {
  if (isTRUE(condition)) {
    testthat::test_that(success, {
      testthat::expect_true(TRUE)
    })
  } else {
    testthat::test_that(failure, {
      testthat::fail(failure)
    })
  }
}
# =====================================================================

helper-run_user_code.R

Gain a solid understanding of R, one of the most widely used languages for data analysis. Explore fundamental data types and one-dimensional values, then advance to multi-dimensional structures, including matrices, data frames, and lists. Build the skills needed to apply R effectively in statistical analysis and data-driven decision-making.

Learn the essentials of R syntax, such as arithmetic, variables, printing functions, and comments. Strengthen your understanding of computational logic through exercises.

Explore R's data types and understand their role in data handling. Build skills in working with vectors as essential structures for organizing and analyzing information.

Develop the ability to manage categorical data effectively. Discover how to structure, group, and interpret values by converting raw data into clear categories.

Understand how to represent and work with structured two-dimensional data. Build confidence in transforming, labeling, and applying operations to matrices for analytical tasks.

Master the most widely used data structure in R for tabular information. Learn to organize, transform, and extract insights from datasets to support data-driven decisions.

Learn how lists extend beyond vectors by storing elements of different types and lengths. Develop the ability to create, access, and modify lists for organizing complex data structures.

Assignment Operators

解答