0Pricing
R Academy · Lekcja

Używanie source() do ładowania skryptów

Wykonuj zewnętrzne skrypty R i współdziel kod między plikami za pomocą source().

Używanie source() do ładowania skryptów to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Dlaczego używać source()?

W miarę rozrastania się projektów R przechowywanie całego kodu w jednym pliku staje się niepraktyczne. Funkcja source() pozwala wczytać i wykonać zewnętrzny plik skryptu R, dzieląc pracę na logiczne, wielokrotnego użytku moduły.

To podstawa uporządkowanego tworzenia programów w R.

# Imagine helpers.R contains:
# add <- function(a, b) a + b
# multiply <- function(a, b) a * b

# Load it into your main script:
source('helpers.R')

# Now use the functions defined there:
result <- add(3, 5)
cat('Result:', result)

Podstawowa składnia source()

Najprostsza postać source() przyjmuje ścieżkę do pliku jako jedyny argument. Plik jest odczytywany, a każde zawarte w nim wyrażenie jest obliczane w bieżącym środowisku, tak jak po bezpośrednim wpisaniu kodu.

# source() with a relative path (file in working directory)
source('my_functions.R')

# source() with an absolute path
source('/Users/alice/projects/utils.R')

# After sourcing, all objects and functions defined
# in the file are available in your current session
cat('Script loaded successfully')

Parametr echo

Parametr echo określa, czy każde wyrażenie z wczytywanego pliku jest wyświetlane w konsoli podczas wykonywania. Domyślnie echo = FALSE, dzięki czemu konsola pozostaje przejrzysta. Ustawienie TRUE jest przydatne podczas debugowania.

# Default: silent loading (echo = FALSE)
source('helpers.R')

# Verbose: print each expression as it runs
source('helpers.R', echo = TRUE)

# echo = TRUE output looks like:
# > add <- function(a, b) a + b
# > multiply <- function(a, b) a * b
cat('Done')

print.eval i verbose

Dwa kolejne parametry zapewniają dokładniejszą kontrolę nad wyjściem. print.eval określa, czy wyniki wyrażeń są wyświetlane (podobnie jak w trybie interaktywnym). verbose wyświetla dodatkowe informacje o samym procesie wczytywania.

# print.eval: print the VALUE of each expression
source('helpers.R', echo = TRUE, print.eval = TRUE)

# verbose: extra details like file name and line numbers
source('helpers.R', verbose = TRUE)

# Typical use: debugging a complex script
# source('complex_analysis.R', echo = TRUE, print.eval = TRUE)
cat('Parameters explored')

Parametr local — odizolowany zakres

Domyślnie source() wykonuje kod w środowisku globalnym, więc wszystkie utworzone obiekty pojawiają się w obszarze roboczym. Ustawienie local = TRUE uruchamia skrypt w nowym, odizolowanym środowisku, dzięki czemu globalny obszar roboczy pozostaje uporządkowany.

# Without local: objects pollute global env
source('data_prep.R')        # x, y, temp_df all appear in ls()

# With local = TRUE: objects stay inside
source('data_prep.R', local = TRUE)
# x, y, temp_df are NOT in your global workspace

# Verify nothing leaked:
cat('Objects in workspace:', length(ls()))

# local can also be an environment object:
my_env <- new.env()
source('data_prep.R', local = my_env)

sys.source() — bezpieczniejsze wczytywanie

sys.source() to alternatywa niższego poziomu, która pomija część narzutu source(). Nie zmienia katalogu roboczego i nie oblicza opcji keepSource. Jest często używana podczas tworzenia pakietów i budowania narzędzi wewnętrznych.

# sys.source() loads a file into a specific environment
utils_env <- new.env()
sys.source('utils.R', envir = utils_env)

# Access functions from that environment explicitly
result <- utils_env$my_helper(10)
cat('Result:', result)

# sys.source does not echo or verbose options
# It is faster and more predictable for package internals
cat('sys.source demo complete')

Ścieżki względne a bezwzględne

Używanie ścieżek względnych w source() zwiększa przenośność projektu — ścieżka do pliku jest rozwiązywana względem bieżącego katalogu roboczego. Ścieżki bezwzględne działają wszędzie, ale przestają działać po przeniesieniu projektu. W pracy opartej na projektach preferowane są ścieżki względne.

# Relative path — resolved from getwd()
source('R/helpers.R')          # good for projects
source('scripts/utils.R')      # subfolder
source('../shared/common.R')   # parent folder

# Absolute path — fragile, machine-specific
source('/Users/alice/project/R/helpers.R')

# Check current working directory first:
cat('Working dir:', getwd())

# Best practice: use file.path() for clarity
source(file.path('R', 'helpers.R'))

Wczytywanie wielu plików

Można wielokrotnie wywoływać source(), aby wczytać kilka plików pomocniczych. Często stosuje się pojedynczy plik wejściowy w stylu setup.R lub _targets.R, który wczytuje wszystkie potrzebne moduły we właściwej kolejności.

# main.R — entry point that loads all modules
source('R/data_loading.R')
source('R/cleaning.R')
source('R/analysis.R')
source('R/plotting.R')

# Or source all .R files in a directory:
r_files <- list.files('R', pattern = '\\.R$', full.names = TRUE)
for (f in r_files) {
  source(f)
  cat('Loaded:', f, '\n')
}
cat('All modules loaded')

source() z parametrem chdir

Parametr chdir tymczasowo zmienia katalog roboczy na katalog zawierający wczytywany plik na czas jego wykonywania. Jest to przydatne, gdy skrypt pomocniczy korzysta wewnętrznie z własnych ścieżek względnych.

# Suppose scripts/analysis.R uses source('helpers.R')
# and helpers.R is also in scripts/

# Without chdir: R looks for helpers.R in YOUR working dir
source('scripts/analysis.R')          # may fail

# With chdir = TRUE: working dir shifts to scripts/ temporarily
source('scripts/analysis.R', chdir = TRUE)   # helpers.R found!

# After source() returns, working dir goes back to original
cat('Working dir restored:', getwd())

Wczytywanie podczas uruchamiania za pomocą .Rprofile

Plik .Rprofile w katalogu domowym (lub w katalogu głównym projektu) jest uruchamiany automatycznie przy każdym starcie R. Można użyć w nim source(), aby automatycznie wczytywać narzędzia, ustawiać opcje lub dołączać pakiety przy każdym uruchomieniu sesji.

# .Rprofile (in ~ or project root):
# source('~/.R/my_utils.R')     # load personal helpers
# options(scipen = 999)          # no scientific notation

# To open and edit .Rprofile:
file.edit('~/.Rprofile')

# To see where .Rprofile files are looked for:
cat(Sys.getenv('R_PROFILE_USER'))

# Caution: heavy .Rprofile slows R startup
# Keep it minimal — load only what you always need
cat('.Rprofile concept shown')

source() w praktyce — struktura projektu

Przejrzysta struktura stosowana w praktyce polega na umieszczeniu wszystkich skryptów pomocniczych w folderze R/ oraz utworzeniu pojedynczego pliku run.R lub main.R, który je wczytuje. Dzięki temu projekt łatwo odtworzyć i udostępnić.

# Project structure:
# my_project/
#   run.R             <- entry point
#   R/
#     01_load.R       <- data loading
#     02_clean.R      <- data cleaning
#     03_model.R      <- modeling
#     04_report.R     <- output

# run.R content:
cat('=== Starting analysis ===\n')
source('R/01_load.R')
source('R/02_clean.R')
source('R/03_model.R')
source('R/04_report.R')
cat('=== Analysis complete ===\n')

Szybkie sprawdzenie

Jaki parametr funkcji source() zapobiega pojawianiu się obiektów utworzonych we wczytywanym pliku w środowisku globalnym?

source() — najważniejsze informacje

source() to wbudowany w R sposób na modularizację kodu:

  • source('file.R') — wczytuje i uruchamia skrypt w środowisku globalnym
  • echo = TRUE — wyświetla każde wyrażenie (świetne podczas debugowania)
  • local = TRUE — uruchamia kod w izolacji, bez skutków ubocznych w środowisku globalnym
  • chdir = TRUE — tymczasowo zmienia katalog roboczy na lokalizację pliku
  • sys.source() — alternatywa niższego poziomu używana w pakietach
  • Ze względu na przenośność preferowane są ścieżki względne i praca oparta na projektach
  • Używaj .Rprofile, aby automatycznie wczytywać narzędzia pomocnicze przy uruchamianiu R
# Quick reference
source('R/helpers.R')                        # basic load
source('R/helpers.R', echo = TRUE)           # verbose
source('R/helpers.R', local = TRUE)          # isolated
source('scripts/run.R', chdir = TRUE)        # local paths

env <- new.env()
sys.source('R/helpers.R', envir = env)       # low-level

cat('source() mastered!')

Często zadawane pytania

Czy lekcja „Używanie source() do ładowania skryptów” jest bezpłatna?

Tak — pełny tekst „Używanie source() do ładowania skryptów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Używanie source() do ładowania skryptów”?

Wykonuj zewnętrzne skrypty R i współdziel kod między plikami za pomocą source(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Używanie source() do ładowania skryptów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Używanie source() do ładowania skryptów
  2. Komentarze, styl i czytelność
  3. Katalogi robocze i ścieżki plików
  4. Projekty R i zarządzanie obszarem roboczym
← Powrót do R Academy