R 語言定義 ¶

2.1.1 向量 ¶

向量可以視為包含資料的連續儲存格。儲存格透過 編製索引操作，例如 x[5]，來存取。更多詳細資料說明請參閱 編製索引。

R 有六種基本的（「原子」）向量類型：邏輯、整數、實數、複數、字元（在 C 中又稱為「字串」）和原始。不同向量類型的模式和儲存模式列於下表。

typeof	mode	storage.mode
邏輯	邏輯	邏輯
整數	數字	整數
雙精度	數字	雙精度
複數	複數	複數
字元	字元	字元
原始	原始	原始

單一數字，例如 4.2，以及字串，例如 "four point two" 仍為長度為 1 的向量；沒有更基本的類型。長度為零的向量是可能的（且有用的）。

字元向量的單一元素通常稱為字元字串 或簡稱字串。 ¹

2.1.2 清單 ¶

清單（「一般向量」）是另一種資料儲存。清單有元素，每個元素都可以包含任何類型的 R 物件，亦即清單的元素不必是同種類型。清單元素透過三個不同的索引操作存取。這些操作在索引中詳細說明。

清單是向量，而基本向量類型稱為原子向量，在有必要排除清單時使用。

2.1.3 語言物件 ¶

R 語言由三種類型的物件組成。它們是 呼叫、表達式和 名稱。 由於 R 有 "expression" 類型的物件，因此我們將盡量避免在其他情境中使用表達式這個字。特別是語法正確的表達式將稱為 陳述式。

這些物件的模式分別為 "call"、"expression" 和 "name"。

可以使用 quote 機制直接從表達式建立這些物件，並使用 as.list 和 as.call 函數將其轉換為清單或從清單轉換為這些物件。 可以使用標準索引運算提取 解析樹的組成部分。

• 符號物件

2.1.4 表達式物件 ¶

在 R 中，可以有 "expression" 類型的物件。表達式 包含一個或多個陳述式。陳述式是語法正確的 符號集合。 表達式物件是特殊語言物件，其中包含已剖析但未評估的 R 陳述式。主要差異在於表達式物件可以包含多個此類表達式。另一個較為細微的差異是，"expression" 類型的物件僅在明確傳遞給 eval 時才會 評估，而其他語言物件在某些意外情況下可能會被評估。

表達式物件的行為很像清單，其組成部分的存取方式應與清單的組成部分相同。

2.1.5 函數物件 ¶

在 R 中，函數是物件，而且可以像其他物件一樣進行處理。函數（或更精確地說，函數封閉）有三個基本組成部分：一個形式引數清單、一個主體和一個環境。引數清單是一個以逗號分隔的引數清單。一個引數可以是一個符號，或一個‘符號 = 預設值’結構，或特殊引數...。第二種形式的引數用於指定引數的預設值。如果函數在呼叫時未指定任何值，則會使用此值。 ...引數很特別，可以包含任意數量的引數。通常在引數數量未知或引數將傳遞給另一個函數的情況下使用它。

主體是一個已剖析的 R 陳述式。它通常是大括號中的陳述式集合，但它可以是一個單一陳述式、一個符號甚至是一個常數。

函數的 環境是在建立函數時處於活動狀態的環境。在該環境中繫結的任何符號都是擷取的，並且可供函數使用。函數程式設計理論中將函數程式碼和其環境中的繫結結合稱為「函數封閉」。在本文件中，我們通常使用術語「函數」，但使用「封閉」來強調附加環境的重要性。

可以使用formals、body和environment結構（所有三個結構也可以用於指定的一側）來擷取和處理封閉物件的三個部分。 最後一個結構可以用於移除不需要的環境擷取。

當呼叫函數時，會建立一個新的環境（稱為評估環境），其封閉（請參閱環境）是函數封閉中的環境。這個新環境最初會以函數中未評估的參數填充；隨著評估進行，會在其中建立局部變數。

還有一個功能，可以用 as.list 和 as.function 將函數轉換成清單結構，反之亦然。 這些功能已包含在內，以提供與 S 的相容性，但建議不要使用。

2.1.6 NULL ¶

有一個稱為 NULL 的特殊物件。每當需要指出或指定一個物件不存在時，就會使用它。它不應與長度為零的向量或清單混淆。

NULL 物件沒有類型和可修改的屬性。R 中只有一個 NULL 物件，所有實例都指向它。若要測試 NULL，請使用 is.null。您無法在 NULL 上設定屬性。

2.1.7 內建物件和特殊形式 ¶

這兩種物件包含 R 的內建 函數，亦即在程式碼清單中顯示為 .Primitive 的函數（以及透過 .Internal 函數存取的函數，因此使用者無法將其視為物件）。兩者的差異在於引數處理方式。內建函數會評估其所有引數，並依照 依值呼叫 傳遞給內部函數，而特殊函數會將未評估的引數傳遞給內部函數。

從 R 語言來看，這些物件只是另一種函數。 is.primitive 函數可以將它們與已詮釋的 函數區分開來。

2.1.8 承諾物件 ¶

承諾物件是 R 延遲評估機制的一部分。它們包含三個槽：一個值、一個表達式和一個 環境。當呼叫 函數時，會比對引數，然後將每個形式引數繫結到一個承諾。會將提供給該形式引數的表達式和呼叫函數的環境指標儲存在承諾中。

直到存取該參數前，承諾中沒有與之關聯的值。存取參數時，會在儲存的環境中評估儲存的表達式，並傳回結果。承諾也會儲存結果。substitute 函式會萃取表達式槽的內容。這讓程式設計師可以存取與承諾關聯的值或表達式。

在 R 語言中，承諾物件幾乎只會隱含地看到：實際的函式參數是這種型別。還有一個 delayedAssign 函式，會讓表達式變成承諾。在 R 程式碼中通常沒有辦法檢查物件是不是承諾，也沒有辦法使用 R 程式碼來判斷承諾的環境。

2.1.9 點點點 ¶

... 物件型別儲存為一種類型的 pairlist。可以在 C 程式碼中以慣用的 pairlist 方式存取 ... 的元件，但 ... 不容易在已詮釋的程式碼中作為物件存取，甚至通常不應該假設有這種物件的存在，因為這在未來可能會改變。

可以將物件擷取為清單（強制承諾！）例如在 table 中可以看到

    args <- list(...)
## ....
    for (a in args) {
## ....

請注意，實作 ... 作為 pairlist 物件 並非 R API 的一部分，且 base R 之外的程式碼不應依賴 ... 的此一目前說明。另一方面，上述 list(...) 存取，以及其他「點存取」函數 ...length()、...elt()、...names()，以及「保留字」..1、..2 等，請參閱說明頁面 ?dots，是穩定 R API 的一部分。

如果函數具有 ... 作為形式參數，則任何與形式參數不符的實際參數都會與 ... 相符。

2.1.10 環境 ¶

環境可以視為由兩件事組成。一個 框架，包含一組符號值對，以及一個 封裝，指向封裝環境的指標。當 R 查詢符號的值時，會檢查框架，如果找到相符的符號，則會傳回其值。如果沒有，則會存取封裝環境，然後重複此程序。環境形成一個樹狀結構，封裝扮演父項的角色。環境樹的根部是一個空的 環境，可透過 emptyenv() 取得，它沒有父項。它是基本套件環境 的直接父項（可透過 baseenv() 函數取得）。

環境會由函數呼叫隱含建立，如 函數物件 和 詞法環境 所述。在此情況下，環境包含函數的局部變數（包括參數），且其封閉環境是目前呼叫函數的環境。環境也可以由 new.env 直接建立。 可以使用 ls、names、$、[、[[、get 和 get0 存取環境的框架內容， 並且可以使用 $<-、[[<- 和 assign 以及 eval 和 evalq 進行操作。

可以使用 parent.env 函數存取環境的封閉環境。

與大多數其他 R 物件不同，將環境傳遞給函數或用於指定時，不會複製環境。因此，如果您將相同的環境指定給多個符號並變更其中一個，其他符號也會變更。特別是，將屬性指定給環境可能會造成意外結果。

2.1.11 配對清單物件 ¶

配對清單物件類似於 Lisp 的點對點清單。它們廣泛用於 R 的內部，但在解譯的程式碼中很少見，儘管它們是由 formals 傳回，並且可以由 (例如) pairlist 函數建立。零長度的配對清單為 NULL，這在 Lisp 中是可以預期的，但與零長度清單相反。 這樣的每個物件都有三個槽位，一個 CAR 值、一個 CDR 值和一個 TAG 值。TAG 值為文字字串，而 CAR 和 CDR 通常分別代表清單項目 (頭部) 和清單的其餘部分 (尾部)，並以 NULL 物件作為終結符 (CAR/CDR 術語是傳統 Lisp，最初是指 60 年代早期 IBM 電腦上的位址和遞減暫存器)。

配對清單在 R 語言中以與一般向量（「清單」）完全相同的方式處理。特別是，使用相同的 [[]] 語法存取元素。配對清單的使用已不建議，因為一般向量通常使用起來更有效率。當從 R 存取內部配對清單時，通常會將其轉換為一般向量（包括子集）。

在極少數情況下，配對清單對使用者可見：一個是 .Options。

2.1.12「任何」類型 ¶

物件不可能是「任何」類型，但它仍然是有效的類型值。它用於某些（相當罕見的）情況，例如 as.vector(x, "any")，表示不應執行類型 轉換。

2.2.1 名稱 ¶

當存在時，names 屬性會標籤向量或清單的個別元素。當列印物件時，如果存在，names 屬性會用於標籤元素。names 屬性也可以用於索引目的，例如 quantile(x)["25%"]。

可以使用 names 和 names<- 建構來取得和設定名稱。 後者會執行必要的相容性檢查，以確保名稱屬性具有適當的類型和長度。

配對清單和一維陣列會特別處理。對於配對清單物件，會使用虛擬 names 屬性；names 屬性實際上是由清單組件的標籤建構的。對於一維陣列，names 屬性實際上會存取 dimnames[[1]]。

2.2.2 維度 ¶

dim 屬性用於實作陣列。陣列的內容儲存在向量中，以欄優先順序排列，而 dim 屬性是整數向量，用於指定陣列各自的範圍。R 確保向量的長度為維度長度的乘積。一個或多個維度的長度可以為零。

向量與一維陣列不同，因為後者有長度為一的 dim 屬性，而前者沒有 dim 屬性。

2.2.3 Dimnames ¶

陣列可以使用 dimnames 屬性分別命名每個維度，該屬性是字元向量的清單。dimnames 清單本身可以有名稱，這些名稱在列印陣列時用於範圍標題。

2.2.4 類別 ¶

R 有精密的類別系統²，主要透過 class 屬性控制。此屬性是包含物件繼承的類別清單的字元向量。這形成 R 中「通用方法」功能的基礎。

使用者幾乎可以不受限制地存取和操作此屬性。並未檢查物件是否實際包含類別方法預期的元件。因此，變更 class 屬性時應謹慎，且在有特定建立和 轉換函數時應優先使用這些函數。

2.2.5 時間序列屬性 ¶

tsp 屬性用於保留時間序列、開始、結束和頻率的參數。此結構主要用於處理具有週期性子結構的序列，例如每月或每季資料。

2.2.6 屬性複製 ¶

變更物件時是否應複製屬性是一個複雜的領域，但有一些一般規則 (Becker, Chambers & Wilks，1988 年，第 144–6 頁)。

純量函數（對向量進行逐元素運算，其輸出與輸入類似）應保留屬性（可能除了類別）。

二元運算通常會從較長的引數複製大部分屬性（如果長度相同，則優先使用第一個引數的值）。這裡的「大部分」表示除了 names、dim 和 dimnames 之外的一切，這些屬性會由運算子的程式碼適當地設定。

子集化（除了空索引）通常會捨棄所有屬性，除了 names、dim 和 dimnames，這些屬性會適當地重新設定。另一方面，子指派通常會保留屬性，即使長度已變更。強制轉換會捨棄所有屬性。

排序的預設方法會捨棄所有屬性，除了名稱，名稱會與物件一起排序。

2.3.1 因子 ¶

因子用於描述可以有有限數值（性別、社會階級等）的項目。因子具有 levels 屬性和類別 "factor"。此外，它也可以包含 contrasts 屬性，該屬性控制在建模函數中使用因子時所使用的參數化。

因子可能是純粹的名稱，或是有序的類別。後者的情況下，應定義為 class 向量 c("ordered"," factor")。

目前使用整數陣列來實作因子，以指定實際層級，以及第二個名稱陣列，對應到整數。很不幸的是，使用者經常利用實作來讓某些計算更容易。然而，這是一個實作問題，無法保證在 R 的所有實作中都成立。

2.3.2 資料框物件 ¶

資料框是 R 中最接近 SAS 或 SPSS 資料集的結構，也就是「案例對變數」資料矩陣。

資料框是由向量、因子和/或矩陣組成的清單，所有長度都相同（矩陣的情況下為列數）。此外，資料框通常有一個 names 屬性，標示變數，以及一個 row.names 屬性，標示案例。

資料框可以包含一個與其他元件長度相同的清單。清單可以包含不同長度的元素，因此提供了一個用於不規則陣列的資料結構。然而，在撰寫本文時，此類陣列通常無法正確處理。

3.1.1 常數 ¶

直接在提示中輸入的任何數字都是常數，並且會被評估。

> 1
[1] 1

也許出乎意料的是，從表達式 1 返回的數字是數字。在大多數情況下，整數和數字值之間的差異並不重要，因為 R 在使用數字時會做正確的事。然而，有時我們希望明確為常數創建一個整數值。我們可以通過調用函數 as.integer 或使用其他各種技術來做到這一點。但也許最簡單的方法是用後綴字符「L」限定我們的常數。例如，要創建整數值 1，我們可以使用

> 1L
[1]

我們可以使用「L」後綴限定任何數字，以使其成為明確的整數。因此，「0x10L」從十六進制表示法中創建整數值 16。常數 1e3L 給出 1000 作為整數而不是數字值，並且等於 1000L。（請注意，「L」被視為限定術語 1e3 而不是 3。）如果我們使用「L」限定一個不是整數值的值，例如 1e-3L，我們會收到一個警告，並且會創建數字值。如果數字中有一個不必要的十進制點，例如 1.L，也會創建一個警告。

當我們對複數使用「L」時，我們會得到一個語法錯誤，例如 12iL 會給出一個錯誤。

常數相當無聊，要了解更多，我們需要符號。

3.1.2 符號查詢 ¶

當建立一個新變數時，它必須有一個名稱，以便它可以被參照，而且它通常有一個值。名稱本身是一個符號。當一個符號被評估時，它的值會被傳回。稍後我們將詳細說明如何確定與符號關聯的值。

在這個小範例中，y是一個符號，它的值是 4。符號也是一個 R 物件，但除了在進行「語言程式設計」（語言程式設計）時，很少需要直接處理符號。

> y <- 4
> y
[1] 4

3.1.3 函式呼叫 ¶

在 R 中執行的大部分運算都涉及函式的評估。我們也將這稱為函式呼叫。函式以名稱呼叫，並附有以逗號分隔的引數清單。

> mean(1:10)
[1] 5.5

在這個範例中，函式mean以一個引數呼叫，即從 1 到 10 的整數向量。

R 包含大量具有不同用途的函式。大多數用於產生 R 物件的結果，但其他則用於其副作用，例如列印和繪製函式。

函數呼叫可以有標記（或命名）參數，如同 plot(x, y, pch = 3) 中的。沒有標記的參數稱為位置，因為函數必須從呼叫參數的順序位置中區分其意義，例如 x 表示橫軸變數，而 y 表示縱軸變數。對於具有大量選用參數的函數而言，使用標記/名稱顯然很方便。

一種特殊類型的函數呼叫可以出現在 指定運算符的左側，如下所示

> class(x) <- "foo"

此結構實際上所做的，是用原始物件和右側呼叫函數 class<-。此函數執行物件修改，並傳回結果，然後將結果儲存回原始變數中。（至少在概念上，這是發生的事情。會做一些額外的努力來避免不必要的資料複製。）

3.1.4 運算符 ¶

R 允許使用算術表達式，其中運算符類似於 C 程式語言的運算符，例如

> 1 + 2
[1] 3

可以使用括號對表達式進行分組，與函數呼叫混合，並以直接的方式指定給變數

> y <- 2 * (a + log(x))

R 包含多個運算符。它們列在下表中。

-	減號，可以是一元或二元
+	加號，可以是一元或二元
!	一元非
~	波浪號，用於模型公式，可以是一元或二元
?	說明
:	序列，二元（在模型公式中：交互作用）
*	乘法，二元
/	除法，二元
^	指數，二元
%x%	特殊二元運算子，x 可以替換為任何有效名稱
%%	模數，二元
%/%	整數除法，二元
%*%	矩陣乘積，二元
%o%	外積，二元
%x%	克羅內克積，二元
%in%	匹配運算子，二元（在模型公式中：巢狀）
<	小於，二元
>	大於，二元
==	等於，二元
>=	大於或等於，二元
<=	小於或等於，二元
&	與，二元，向量化
&&	與，二元，非向量化
|	或，二元，向量化
||	或，二元，非向量化
<-	左賦值，二元
->	右賦值，二元
$	清單子集，二元

除了語法之外，應用運算子和呼叫函數之間沒有區別。事實上，x + y 可以等效地寫成 `+`(x, y)。請注意，由於「+」是非標準函數名稱，因此需要加上引號。

R 一次處理整個資料向量，而大多數基本運算子和基本數學函數（例如 log）都是向量化的（如上表所示）。這表示例如新增兩個相同長度的向量會建立一個包含元素和的向量，並隱式地迴圈遍歷向量索引。這也適用於其他運算子，例如 -、* 和 /，以及較高維度的結構。特別注意，將兩個矩陣相乘不會產生一般的矩陣乘積（%*% 運算子用於此目的）。與向量化運算相關的一些較細微的重點將在 基本算術運算 中討論。

若要存取原子向量的個別元素，通常會使用 x[i] 結構。

> x <- rnorm(5)
> x
[1] -0.12526937 -0.27961154 -1.03718717 -0.08156527  1.37167090
> x[2]
[1] -0.2796115

清單組件較常使用 x$a 或 x[[i]] 存取。

> x <- options()
> x$prompt
[1] "> "

索引結構也可以出現在 指派的右側。

如同其他運算子，索引實際上是由函式完成，可以使用 `[`(x, 2) 取代 x[2]。

R 的索引運算包含許多進階功能，在 索引 中有進一步說明。

3.2.1 if ¶

if/else 陳述式有條件地評估兩個陳述式。有一個會被評估的條件，如果值為TRUE，則會評估第一個陳述式；否則會評估第二個陳述式。if/else 陳述式會傳回所選陳述式的值作為其值。正式語法為

if ( statement1 )
    statement2
else
    statement3

首先，會評估 statement1 以產生 value1。如果 value1 是第一個元素為 TRUE 的邏輯向量，則會評估 statement2。如果 value1 的第一個元素為 FALSE，則會評估 statement3。如果 value1 是數值向量，則當 value1 的第一個元素為零時，會評估 statement3，否則會評估 statement2。只會使用 value1 的第一個元素。所有其他元素都會被忽略。如果 value1 的類型不是邏輯或數值向量，則會發出錯誤訊號。

if/else 陳述式可用於避免數值問題，例如取負數的對數。由於 if/else 陳述式與其他陳述式相同，因此您可以指定它們的值。以下兩個範例是等效的。

> if( any(x <= 0) ) y <- log(1+x) else y <- log(x)
> y <- if( any(x <= 0) ) log(1+x) else log(x)

else 子句是可選的。陳述式 if(any(x <= 0)) x <- x[x <= 0] 是有效的。當 if 陳述式不在區塊中時，else（如果存在）必須出現在與 statement2 結尾相同的行上。否則，statement2 結尾的新行會完成 if，並產生一個語法上完整的陳述式，該陳述式會被評估。一個簡單的解決方案是使用包在括號中的複合陳述式，將 else 放在與標記陳述式結尾的閉合括號相同的行上。

if/else 陳述式可以巢狀。

if ( statement1 ) {
    statement2
} else if ( statement3 ) {
    statement4
} else if ( statement5 ) {
    statement6
} else
    statement8

一個偶數編號的陳述式將會被評估，並傳回結果值。如果省略選用的 else 子句，且所有奇數編號的 陳述式 評估為 FALSE，則不會評估任何陳述式，並傳回 NULL。

奇數編號的 陳述式 會依序評估，直到其中一個評估為 TRUE，然後評估關聯的偶數編號 陳述式。在此範例中，陳述式6 僅會在 陳述式1 為 FALSE、陳述式3 為 FALSE 且 陳述式5 為 TRUE 時評估。允許的 else if 子句數量沒有限制。

3.2.2 迴圈 ¶

R 有三個提供明確迴圈的陳述式。⁴ 它們是 for、while 和 repeat。兩個內建建構，next 和 break，提供對評估的額外控制。R 提供其他函式進行隱式迴圈，例如 tapply、apply 和 lapply。此外，許多運算，特別是算術運算，都是向量化的，因此您可能不需要使用迴圈。

有兩個陳述式可用於明確控制迴圈。它們是 break 和 next。 break 陳述式會導致退出目前正在執行的最內層迴圈。next 陳述式會立即導致控制權傳回迴圈的開頭。然後執行迴圈的下一次反覆運算（如果有的話）。不會評估目前迴圈中 next 下方的任何陳述式。

迴圈陳述式傳回的值總是 NULL，而且會隱藏傳回。

3.2.3 repeat ¶

repeat 陳述式會導致重複評估主體，直到特別要求中斷。這表示您在使用 repeat 時需要小心，因為有無限迴圈的危險。repeat 迴圈的語法是

repeat statement

使用 repeat 時，statement 必須為區塊陳述式。您需要同時執行一些運算，並測試是否要中斷迴圈，而這通常需要兩個陳述式。

3.2.4 while ¶

while 陳述式與 repeat 陳述式非常類似。 while 迴圈的語法為

while ( statement1 ) statement2

其中 statement1 會被評估，如果其值為 TRUE，則會評估 statement2。此程序會持續進行，直到 statement1 評估為 FALSE 為止。

3.2.5 for ¶

for 迴圈的語法為

for ( name in vector )
   statement1

其中 vector 可以是向量或清單。對於 vector 中的每個元素，變數 name 會設定為該元素的值，並評估 statement1。副作用是變數 name 在迴圈結束後仍然存在，且具有迴圈評估的 vector 最後一個元素的值。

3.2.6 switch ¶

技術上來說，switch 只是另一個函式，但其語意接近其他程式語言的控制結構。

語法為

switch (statement, list)

其中 list 的元素可以命名。首先，statement 會被評估，並取得結果 value。如果 value 是 1 到 list 長度之間的數字，則會評估 list 中對應的元素，並傳回結果。如果 value 太大或太小，則會傳回 NULL。

> x <- 3
> switch(x, 2+2, mean(1:10), rnorm(5))
[1]  2.2903605  2.3271663 -0.7060073  1.3622045 -0.2892720
> switch(2, 2+2, mean(1:10), rnorm(5))
[1] 5.5
> switch(6, 2+2, mean(1:10), rnorm(5))
NULL

如果 value 是字元向量，則會評估 ... 中名稱與 value 完全相符的元素。如果沒有相符的項目，則會使用單一未命名參數作為預設值。如果未指定預設值，則會傳回 NULL。

> y <- "fruit"
> switch(y, fruit = "banana", vegetable = "broccoli", "Neither")
[1] "banana"
> y <- "meat"
> switch(y, fruit = "banana", vegetable = "broccoli", "Neither")
[1] "Neither"

常見的 switch 用法是根據函式其中一個參數的字元值進行分支。

> centre <- function(x, type) {
+ switch(type,
+        mean = mean(x),
+        median = median(x),
+        trimmed = mean(x, trim = .1))
+ }
> x <- rcauchy(10)
> centre(x, "mean")
[1] 0.8760325
> centre(x, "median")
[1] 0.5360891
> centre(x, "trimmed")
[1] 0.6086504

switch 會傳回已評估陳述式的值，或是在沒有評估任何陳述式時傳回 NULL。

若要從已存在的選項清單中進行選擇，switch 可能不是用來選取一個選項進行評估的最佳方式。通常會透過 eval 和子集運算子 [[ 直接使用 eval(x[[condition]]) 會比較好。

3.3.1 循環利用規則 ¶

如果嘗試將兩個具有不同元素數量的結構相加，則會將最短的結構循環利用至最長的結構長度。也就是說，例如將 c(1, 2, 3) 加到六個元素的向量中，則實際上會將 c(1, 2, 3, 1, 2, 3) 相加。如果較長向量的長度不是較短向量的倍數，則會發出警告。

從 R 1.4.0 開始，任何涉及零長度向量的算術運算都會產生零長度的結果。

3.3.2 名稱傳播 ¶

名稱傳播（我想，第一個獲勝 - 即使它沒有名稱?? —- 第一個 *有名稱* 的獲勝，循環利用會導致最短的失去名稱）

3.3.3 維度屬性 ¶

(矩陣+矩陣，維度必須匹配。向量+矩陣：先回收，然後檢查維度是否匹配，如果不匹配則報錯)

3.3.4 NA 處理 ¶

統計意義上的缺失值，即值未知的變數，其值為 NA。這不應與未提供函數參數的 missing 屬性混淆（請參閱 參數）。

由於原子向量的元素必須具有相同的類型，因此有多種 NA 值類型。在特定情況下，這對使用者而言特別重要。 NA 的預設類型為 logical，除非強制轉換為其他類型，因此缺失值可能會觸發邏輯索引而不是數字索引（有關詳細資訊，請參閱 索引）。

使用 NA 進行的數字和邏輯計算通常會傳回 NA。如果運算結果對於 NA 可能採取的所有值都相同，則運算可能會傳回此值。特別是，「FALSE & NA」為 FALSE，「TRUE | NA」為 TRUE。 NA 不等於任何其他值或自身；使用 is.na 測試 NA。 但是，NA 值會在 match 中與另一個 NA 值匹配。

結果未定義的數字計算，例如「0/0」，會產生 NaN 值。這只存在於 double 類型和複數類型的實數或虛數部分。提供 is.nan 函數來特別檢查 NaN，is.na 也會傳回 TRUE 給 NaN。 將 NaN 轉換為邏輯或整數類型會產生適當類型的 NA，但轉換為字元會產生字串 "NaN"。 NaN 值無法比較，因此涉及 NaN 的等式或排序測試將會產生 NA。 match 將其視為與任何 NaN 值相符（且沒有其他值，甚至 NA）。

字元類型的 NA 自 R 1.5.0 起與字串 "NA" 不同。需要指定明確字串 NA 的程式設計師應使用「NA_character_」而非 "NA"，或使用 is.na<- 將元素設定為 NA。

有常數 NA_integer_、NA_real_、NA_complex_ 和 NA_character_，它們會在 (剖析器中) 產生適當類型的 NA 值，且在無法識別 NA 類型時會在反剖析中使用 (而且 control 選項要求執行此動作)。

原始向量沒有 NA 值。

3.4.1 根據向量進行索引 ¶

R 允許使用向量作為索引的一些強大建構。我們將首先討論簡單向量的索引。為簡化起見，假設表達式為 x[i]。然後根據 i 的類型存在以下可能性。

• 整數。 i 的所有元素都必須具有相同的符號。如果它們為正，則選取那些索引號碼的 x 元素。如果 i 包含負元素，則選取除那些元素之外的所有元素。

  如果 i 為正且超過 length(x)，則對應的選取為 NA。對於 i 的負超出邊界值，自 R 2.6.0 版本開始，會默不作聲地忽略，因為它們表示要捨棄不存在的元素，而這是一個空操作（「no-op」）。

  特殊情況是零索引，它沒有任何效果：x[0] 是個空向量，否則在正負索引中包含零的效果與省略它們的效果相同。

• 其他數字。非整數值在使用前會轉換為整數（朝零截尾）。
• 邏輯。索引 i 通常應該與 x 長度相同。如果它較短，則其元素將會像 基本算術運算 中討論的那樣被循環使用。如果它較長，則 x 在概念上會用 NA 延伸。所選取的 x 值是 i 為 TRUE 的那些值。
• 字元。在 i 中的字串會與 x 的 names 屬性進行比對，並使用產生的整數。對於 [[ 和 $，如果完全比對失敗，則會使用部分比對，因此如果 x 不包含名為 "aa" 的元件，而 "aabb" 是唯一具有前綴 "aa" 的名稱，則 x$aa 將比對 x$aabb。對於 [[，部分比對可透過 exact 參數進行控制，其預設值為 NA，表示允許部分比對，但發生時應產生警告。將 exact 設定為 TRUE 可防止部分比對發生，FALSE 值允許部分比對且不會發出任何警告。請注意，[ 始終需要完全比對。字串 "" 具有特殊用途：它表示「沒有名稱」且不比對任何元素（甚至沒有名稱的元素）。請注意，部分比對僅在擷取時使用，而不在替換時使用。
• 因子。結果與 x[as.integer(i)] 相同。從未使用因子層級。如果需要，請使用 x[as.character(i)] 或類似的結構。
• 空。運算式 x[] 會傳回 x，但會從結果中移除「不相關」的屬性。只有 names，以及在多維陣列中會保留 dim 和 dimnames 屬性。
• NULL。這會被視為 integer(0)。

以遺失（即 NA）值進行索引會產生 NA 結果。此規則也適用於邏輯索引的情況，即 x 中有 i 中 NA 選擇器的元素會包含在結果中，但其值會是 NA。

不過，請注意，NA 有不同的模式—文字常數的模式為 "logical"，但它經常會自動強制轉換為其他類型。這會產生一個影響，即 x[NA] 的長度為 x，但 x[c(1, NA)] 的長度為 2。這是因為在前一種情況下適用邏輯索引的規則，但在後一種情況下適用整數索引的規則。

使用 [ 進行索引也會對任何名稱屬性執行相關的子集化。

3.4.2 索引矩陣和陣列 ¶

子集化多維度結構通常遵循與單維度索引相同的規則，針對每個索引變數，dimnames 的相關組成部分取代 names。不過，有幾項特殊規則適用

通常，結構會使用對應於其維度的索引數目來存取。不過，也可以使用單一索引，這種情況下會忽略 dim 和 dimnames 屬性，而結果實際上等同於 c(m)[i]。請注意，m[1] 通常與 m[1, ] 或 m[, 1] 非常不同。

可以使用整數矩陣作為索引。在這種情況下，矩陣的欄位數目應與結構的維度數目相符，而結果會是一個向量，長度與矩陣的列數相同。以下範例顯示如何一次提取元素 m[1, 1] 和 m[2, 2]。

> m <- matrix(1:4, 2)
> m
     [,1] [,2]
[1,]    1    3
[2,]    2    4
> i <- matrix(c(1, 1, 2, 2), 2, byrow = TRUE)
> i
     [,1] [,2]
[1,]    1    1
[2,]    2    2
> m[i]
[1] 1 4

索引矩陣可能不包含負索引。NA 和零值是允許的：包含零的索引矩陣中的列會被忽略，而包含 NA 的列會在結果中產生 NA。

在使用單一 索引和矩陣索引的情況下，如果存在 names 屬性，則會使用該屬性，就像結構是一維的一樣。

如果索引運算導致結果有一個長度為一的範圍，例如選擇一個三維矩陣的單一區塊（例如 m[2, , ]），對應的維度通常會從結果中刪除。如果產生單一維度結構，就會取得一個向量。這偶爾是不需要的，而且可以透過在索引運算中加入「drop = FALSE」來關閉。請注意，這是 [ 函式的附加引數，而且不會新增到索引計數。因此，選擇矩陣第一列為 1 乘以 n 矩陣的正確方式為 m[1, , drop = FALSE]。忘記停用刪除功能是常在一般子常式中失敗的原因，其中索引偶爾但通常長度為一。這個規則仍然適用於一維陣列，其中任何子集都會產生向量結果，除非使用「drop = FALSE」。

請注意，向量與一維陣列不同，後者具有 dim 和 dimnames 屬性（長度皆為一）。無法輕易從子集運算取得一維陣列，但可以明確建構它們，而且會由 table 傳回。這有時很有用，因為 dimnames 清單的元素本身可以命名，但 names 屬性不行。

某些運算（例如 m[FALSE, ]）會產生結構，其中一個維度具有零範圍。R 通常會試著合理處理這些結構。

3.4.3 索引其他結構 ¶

運算子 [ 是一個通用函數，允許新增類別方法，以及 $ 和 [[ 運算子也是如此。因此，可以為任何結構設定使用者定義的索引運算。此類函數（例如 [.foo）會呼叫一組引數，其中第一個引數為要索引的結構，其餘為索引。在 $ 的情況下，即使使用 x$"abc" 形式，索引引數的模式仍為 "symbol"。務必注意，類別方法不一定會以相同的方式運作，例如在部分比對方面。

類別方法 [ 最重要的範例是資料框所使用的範例。本文不會詳細說明（請參閱 [.data.frame 的說明頁面），但廣義來說，如果提供兩個索引（即使其中一個為空），它會為結構建立類似矩陣的索引，而此結構基本上是長度相同的向量清單。如果提供單一索引，它會被解釋為索引欄位清單，在這種情況下，drop 引數會被忽略，並會顯示警告。

基本運算子 $ 和 [[ 可以套用至環境。只允許字元索引，且不會執行部分比對。

3.4.4 子集指定 ¶

指定結構子集等於複雜指定的一般機制中的特殊情況

x[3:5] <- 13:15

此指令的結果等於執行下列指令

`*tmp*` <- x
x <- "[<-"(`*tmp*`, 3:5, value=13:15)
rm(`*tmp*`)

請注意，指標會先轉換為數字指標，然後沿著數字指標順序替換元素，就好像使用了 for 迴圈一樣。任何現有的變數名為 `*tmp*` 都會被覆寫並刪除，且此變數名稱不應在程式碼中使用。

同樣的機制也可以套用在 [ 以外的其他函式。替換函式的名稱與 <- 貼在一起。其最後一個引數必須稱為 value，這是要指派的新值。例如，

names(x) <- c("a","b")

等於

`*tmp*` <- x
x <- "names<-"(`*tmp*`, value=c("a","b"))
rm(`*tmp*`)

複雜指派的巢狀結構會遞迴評估

names(x)[3] <- "Three"

等於

`*tmp*` <- x
x <- "names<-"(`*tmp*`, value="[<-"(names(`*tmp*`), 3, value="Three"))
rm(`*tmp*`)

在封閉環境中進行的複雜指派（使用 <<-）也允許

names(x)[3] <<- "Three"

等於

`*tmp*` <<- get(x, envir=parent.env(), inherits=TRUE)
names(`*tmp*`)[3] <- "Three"
x <<- `*tmp*`
rm(`*tmp*`)

也等於

`*tmp*` <- get(x,envir=parent.env(), inherits=TRUE)
x <<- "names<-"(`*tmp*`, value="[<-"(names(`*tmp*`), 3, value="Three"))
rm(`*tmp*`)

只有目標變數會在封閉環境中評估，因此

e<-c(a=1,b=2)
i<-1
local({
   e <- c(A=10,B=11)
   i <-2
   e[i] <<- e[i]+1
})

在 LHS 和 RHS 使用 i 的區域值，並在超指派陳述式的 RHS 使用 e 的區域值。它將外部環境中的 e 設定為

 a  b 
 1 12

也就是說，超指派等於四行

`*tmp*` <- get(e, envir=parent.env(), inherits=TRUE)
`*tmp*`[i] <- e[i]+1
e <<- `*tmp*`
rm(`*tmp*`)

類似地

x[is.na(x)] <<- 0

等於

`*tmp*` <- get(x,envir=parent.env(), inherits=TRUE)
`*tmp*`[is.na(x)] <- 0
x <<- `*tmp*`
rm(`*tmp*`)

而不是

`*tmp*` <- get(x,envir=parent.env(), inherits=TRUE)
`*tmp*`[is.na(`*tmp*`)] <- 0
x <<- `*tmp*`
rm(`*tmp*`)

這兩種候選詮釋只有在也有區域變數 x 時才有所不同。最好避免使用與超指派的目標變數相同名稱的區域變數。由於這個案例在 1.9.1 及更早版本中處理不正確，因此一定沒有這種程式碼的嚴重需求。

3.5.1 全域環境 ¶

全域環境是使用者工作區的根目錄。從命令列進行的指定作業會導致相關物件屬於全域環境。它的封閉環境是搜尋路徑上的下一個環境，依此類推，回到作為基本環境封閉的空環境。

3.5.2 詞彙環境 ¶

每次呼叫函式都會建立一個框架，其中包含函式中建立的局部變數，並在環境中評估，而環境與框架結合會建立一個新的環境。

注意術語：框架是一組變數，環境是框架的巢狀（或等效地：最內層框架加上封閉環境）。

環境可以指定給變數或包含在其他物件中。但是，請注意它們不是標準物件，特別是它們在指定時不會被複製。

封閉（模式 "函數"）物件將包含它在其中建立的環境，作為其定義的一部分（預設。可以使用 environment<- 來處理環境）。當函數隨後被呼叫時，它的 評估環境會以封閉的環境作為封閉來建立。請注意，這不一定是呼叫者的環境！

因此，當在 函數內部請求變數時，會先在 評估環境中搜尋，然後在封閉中搜尋，封閉的封閉中搜尋，等等；一旦到達全域環境或套件的環境，搜尋會沿著搜尋路徑繼續進行，直到基本套件的環境。如果在那裡找不到變數，搜尋將會繼續進行到空環境，並且會失敗。

3.5.3 呼叫堆疊 ¶

每次呼叫 函數時，都會建立一個新的評估框架。在運算的任何時間點，都可以透過 呼叫堆疊 存取目前作用中的環境。每次呼叫函數時，都會在內部建立一個稱為內容的特殊建構，並將其置於內容清單中。當函數完成評估時，其內容會從呼叫堆疊中移除。

讓呼叫堆疊中較高層級定義的變數可用，稱為 動態範圍。變數的繫結會由變數最近（時間上）的定義決定。這與 R 中的預設範圍規則相矛盾，後者使用函數定義所在 環境中的繫結（詞彙範圍）。某些函數，特別是使用和處理模型公式的函數，需要透過直接存取呼叫堆疊來模擬動態範圍。

可透過一系列函數存取 呼叫堆疊，這些函數的名稱以「sys.」開頭。它們簡要列示如下。

sys.call

取得指定內容的呼叫。

sys.frame

取得指定內容的評估框架。

sys.nframe

取得所有作用中內容的環境框架。

sys.function

取得在指定內容中呼叫的函數。

sys.parent

取得目前函數呼叫的父呼叫。

sys.calls

取得所有作用中內容的呼叫。

sys.frames

取得所有作用中內容的評估框架。

sys.parents

取得所有作用中環境的數字標籤。

sys.on.exit

設定一個函數，在指定環境退出時執行。

sys.status

呼叫 sys.frames、sys.parents 和 sys.calls。

parent.frame

取得指定父環境的評估框架。

3.5.4 搜尋路徑 ¶

除了評估 環境結構之外，R 有一個環境搜尋路徑，用於搜尋其他地方找不到的變數。這用於兩件事：函數套件和附加的使用者資料。

搜尋路徑的第一個元素是全域環境，最後一個是基礎套件。一個 Autoloads 環境用於保存可以按需載入的代理物件。其他環境使用 attach 或 library 插入路徑。

具有 命名空間 的套件有不同的搜尋路徑。當從此類套件中的物件開始搜尋 R 物件時，會先搜尋套件本身，然後搜尋其匯入，然後搜尋基礎命名空間，最後搜尋全域環境和其餘的常規搜尋路徑。其效果是對同一個套件中其他物件的參考將解析為套件，而且物件不會被全域環境或其他套件中同名的物件遮罩。

4.1.1 語法和範例 ¶

撰寫 函數的語法為

function ( arglist ) body

函數宣告的第一個組成部分是關鍵字 function，用來向 R 指示您想要建立一個函數。

一個 參數清單是一個以逗號分隔的正式參數清單。一個正式參數可以是一個符號、一個「符號 = 表達式」形式的陳述，或一個特殊正式參數 ...。

主體可以是任何有效的 R 表達式。通常，主體是一組包含在花括號（「{」和「}」）中的表達式。

通常 函數會指定給符號，但並非必要。由呼叫 函數 回傳的值是一個函數。如果沒有給予名稱，它會被稱為 匿名函數。匿名函數最常作為其他函數的參數，例如 apply 系列或 outer。

這裡有一個簡單的函數：echo <- function(x) print(x)。因此 echo 是接受單一參數的函數，當呼叫 echo 時，它會列印其參數。

4.1.2 參數 ¶

函數的正式參數定義在函數呼叫時將提供值的變數。這些參數的名稱可以在函數主體中使用，在函數呼叫時取得提供的數值。

預設參數值可以使用特殊格式「name = expression」指定。在此情況下，如果使用者在呼叫函數時未指定參數值，則會將表達式與對應符號關聯。當需要值時，會在函數的評估架構中評估expression。

也可以使用函數 missing 指定預設行為。當使用正式參數的名稱呼叫 missing 時，如果正式參數未與任何實際參數配對，且在函數主體中未進行後續修改，則會傳回 TRUE。因此，missing 的參數將具有預設值（如果有）。missing 函數不會強制評估參數。

特殊參數類型 ... 可包含任何數量的提供參數。它用於各種目的。它允許您撰寫函數，該函數會接收任意數量的參數。它可用於將一些參數吸收至中間函數中，然後可由後續呼叫的函數萃取。

4.3.1 評估環境 ¶

當呼叫或執行 函數時，會建立一個新的 評估框架。在此框架中，正式參數會根據 參數比對 中提供的規則與提供的參數進行比對。函數主體中的陳述會依序在此 環境框架中評估。

評估框架的封閉框架是與被呼叫函數相關聯的環境框架。這可能與 S 不同。儘管許多函數都有 .GlobalEnv 作為其環境，但這並非一定正確，且在具有命名空間的套件中定義的函數（通常）具有套件命名空間作為其環境。

4.3.2 引數配對 ¶

此小節適用於封閉函數，但不適用於基本函數。後者通常會忽略標籤並執行位置配對，但應參閱其說明頁面以了解例外，其中包括 log、round、signif、rep 和 seq.int。

在 函數評估中發生的第一件事是將形式引數配對到實際或提供的引數。這是透過三階段程序完成的

1. 標籤上的完全配對。 對於每個指定的提供引數，將搜尋形式引數清單以找出名稱完全配對的項目。讓同一個形式引數配對到多個實際引數，或反之亦然，會產生錯誤。
2. 標籤上的部分配對。將每個剩下的指定提供引數與剩下的形式引數進行比較，使用部分配對。如果提供引數的名稱與形式引數的第一部分完全配對，則這兩個引數會被視為已配對。產生多個部分配對會產生錯誤。請注意，如果 f <- function(fumble, fooey) fbody，則 f(f = 1, fo = 2) 是非法的，即使第二個實際引數只配對到 fooey。 f(f = 1, fooey = 2) 是合法的，因為第二個引數完全配對，且已從部分配對的考量中移除。如果形式引數包含 ...，則部分配對只會套用於其前面的引數。
3. 位置配對。任何不匹配的正式參數會依序連結到未命名的提供參數。如果有一個 ... 參數，它會使用剩餘的參數，無論是否有標記。

如果任何參數仍然不匹配，就會宣告錯誤。

參數配對會透過函數 match.arg、match.call 和 match.fun 來擴充。 存取 R 使用的部分配對演算法的方式是透過 pmatch。

4.3.3 參數評估 ¶

關於 評估 函數參數最重要的資訊之一，就是提供的參數和預設參數的處理方式不同。提供的函數參數會在呼叫函數的評估架構中評估。函數的預設參數會在函數的評估架構中評估。

在 R 參數中呼叫函數的語意是呼叫傳值。一般來說，提供的參數會像是在使用提供值初始化的區域變數，以及對應正式參數的 名稱。在函數中變更提供的參數值，不會影響呼叫架構中變數的值。

R 有一種延遲評估函數參數的形式。參數在需要時才會評估。重要的是，在某些情況下，參數將永遠不會被評估。因此，使用函數參數來導致副作用是一種不好的風格。在 C 中，使用 foo(x = y) 這種形式來呼叫 foo，並同時將 y 的值賦值給 x，這種風格不應在 R 中使用。無法保證參數將永遠被評估，因此 賦值可能不會發生。

同樣值得注意的是，如果評估參數，foo(x <- y) 的效果是改變呼叫 環境中的 x 的值，而不是在 foo 的 評估環境中。

可以在函數內部存取用作參數的實際（非預設）表達式。這種機制是透過承諾來實作的。當評估 函數時，用作參數的實際表達式會儲存在承諾中，並儲存指向函數被呼叫的環境的指標。當（如果）評估參數時，儲存的表達式會在函數被呼叫的環境中評估。由於只使用指向環境的指標，因此對該環境所做的任何變更都會在此評估期間生效。然後，結果值也會儲存在承諾中的另一個位置。後續評估會擷取這個儲存的值（不會執行第二次評估）。也可以使用 substitute 存取未評估的表達式。

當呼叫 函數時，每個形式參數會在呼叫的當地環境中分配一個承諾，其中包含實際參數的表達式槽（如果存在）和包含呼叫者環境的環境槽。如果呼叫中未提供形式參數的實際參數，且有預設表達式，則會以類似方式將其分配給形式參數的表達式槽，但將 環境設定為當地環境。

透過在承諾的環境中評估表達式槽的內容來填入承諾的值槽的程序稱為 強制 承諾。承諾只會被強制一次，之後會直接使用值槽內容。

當需要承諾的值時，會強制承諾。這通常發生在內部 函數中，但也可以透過直接評估承諾本身來強制承諾。當預設表達式依賴於當地環境中另一個形式參數或其他變數的值時，偶爾會用到這個方式。以下範例中可以看到，單獨的 label 確保標籤是在下一行變更 x 的值之前根據 x 的值建立的。

function(x, label = deparse(x)) {
    label
    x <- x + 1
    print(label)
}

承諾的表達式槽本身也可能包含其他承諾。當未評估的參數作為參數傳遞給另一個函數時，就會發生這種情況。在強制承諾時，其表達式中的其他承諾也會在評估時遞迴強制。

4.3.4 範圍 ¶

範圍或範圍規則僅為評估器用來尋找符號值的規則組。 每個電腦語言都有一組此類規則。在 R 中，規則相當簡單，但確實存在用於顛覆通常或預設規則的機制。

R 遵守稱為詞彙範圍的一組規則。這表示在建立表達式時有效的變數繫結用於提供表達式中任何未繫結符號的值。

大多數範圍的有趣屬性都與評估函數有關，而我們專注於此問題。符號可以是繫結或未繫結。函數的所有形式參數都在函數主體中提供繫結符號。函數主體中的任何其他符號都是局部變數或未繫結變數。局部變數是在函數中定義的變數。由於 R 沒有變數的正式定義，因此僅在需要時使用它們，因此難以確定變數是否為局部變數。局部變數必須先定義，這通常透過在指定左側來完成。

在評估過程中，如果偵測到未繫結符號，則 R 會嘗試為其尋找值。範圍規則決定此程序如何進行。在 R 中，會先搜尋函數的環境，然後是其封閉區域，依此類推，直到到達全域環境。

全域環境會引導環境搜尋清單，此清單會依序搜尋符合的符號。然後使用第一個符合項的值。

當這組規則與函數可以從其他函數傳回為值的事實結合時，就會獲得一些相當不錯但乍看之下很奇特的屬性。

一個簡單的範例

f <- function() {
    y <- 10
    g <- function(x) x + y
    return(g)
}
h <- f()
h(3)

一個相當有趣的疑問是當評估 h 時會發生什麼事。當評估函數主體時，並不會有問題決定局部變數或繫結變數的值。範圍規則決定語言將如何尋找未繫結變數的值。

當評估 h(3) 時，我們看到它的主體是 g 的主體。在那個主體內，x 繫結到形式參數，而 y 未繫結。在一個具有 詞彙範圍的語言中，x 將會與值 3 關聯，而 y 將會與值 10 關聯，而這值是 f 的局部變數，所以 h(3) 應該會傳回值 13。在 R 中，這的確會發生。

在 S 中，因為不同的範圍規則，會得到一個錯誤，指出未找到 y，除非在你的工作區中有一個變數 y，在這種情況下，它的值會被使用。

10.1.1 剖析模式 ¶

R 中的剖析有以下三種不同的變異

• 讀取-評估-列印迴圈
• 剖析文字檔案
• 剖析字元字串

讀取-評估-列印迴圈形成 R 的基本命令列介面。文字輸入會一直讀取，直到完整的 R 表達式可用。表達式可以分隔在數個輸入行中。主要提示（預設為 ‘> ’）表示剖析器已準備好接受新的表達式，而延續提示（預設為 ‘+ ’）表示剖析器預期有未完成表達式的其餘部分。表達式在輸入期間會轉換成內部形式，剖析後的表達式會傳遞給評估器，而結果會列印出來（除非特別設定為不可見）。如果剖析器發現自己處於與語言語法不相容的狀態，就會標示「語法錯誤」，剖析器會重設自己，並從下一個輸入行的開頭繼續輸入。

文字檔案可以使用 parse 函數來解析。特別是，這是在執行 source 函數時完成的，它允許將指令儲存在外部檔案中，並執行它們，就好像它們已在鍵盤上輸入一樣。不過，請注意，在進行任何評估之前，整個檔案都會被解析並進行語法檢查。

字元字串或其向量可以使用 parse 的 text= 參數來解析。這些字串的處理方式完全如同它們是輸入檔案的行。

10.1.2 內部表示法 ¶

已解析的表達式儲存在包含解析樹的 R 物件中。可以在 語言物件 和 表達式物件 中找到這些物件的更完整描述。簡而言之，每個基本 R 表達式都儲存在 函數呼叫形式中，作為一個清單，第一個元素包含函數名稱，其餘元素包含參數，這些參數反過來可能是進一步的 R 表達式。清單元素可以命名，對應於形式參數和實際參數的標記匹配。請注意，所有 R 語法元素都以這種方式處理，例如，賦值 x <- 1 被編碼為 "<-"(x, 1)。

10.1.3 Deparsing ¶

任何 R 物件都可以使用 deparse 轉換成 R 表達式。這通常用於結果輸出，例如標示繪圖。請注意，只有模式為 "expression" 的物件，才能預期在重新剖析 deparse 的輸出後保持不變。例如，數字向量 1:5 會剖析為 "c(1, 2, 3, 4, 5)"，這會重新剖析為呼叫函式 c。在可能的情況下，評估剖析和重新剖析的表達式會產生與評估原始表達式相同的結果，但有幾個例外，大多數涉及一開始並未從文字表示產生之表達式。

10.3.1 常數 ¶

有五種常數：整數、邏輯、數字、複數和字串。

此外，還有四個特殊常數：NULL、NA、Inf 和 NaN。

NULL 用於表示空物件。 NA 用於表示不存在（「Not Available」）的資料值。 Inf 表示無限大，而 NaN 在 IEEE 浮點運算中表示非數字（例如，運算 1/0 和 0/0 的結果）。

邏輯常數為 TRUE 或 FALSE。

數字常數遵循與 C 語言類似的語法。它們包含由零個或多個數字組成的整數部分，後接一個選用的「.」和一個由零個或多個數字組成的分數部分，後接一個選用的指數部分，該部分由一個「E」或「e」、一個選用的符號和一個由一個或多個數字組成的字串組成。分數部分或小數部分可以為空，但不能同時為空。

Valid numeric constants: 1 10 0.1 .2 1e-7 1.2e+7

數字常數也可以是十六進制，以「0x」或「0x」開頭，後面接零個或多個數字、「a-f」或「A-F」。十六進制浮點常數使用 C99 語法支援，例如「0x1.1p1」。

現在有一個獨立的整數常數類別。它們是使用數字末尾的限定詞 L 建立的。例如，123L 會產生整數值，而不是數字值。後綴 L 可用於限定任何非複數數字，目的是建立一個整數。因此，它可以用於由十六進制或科學記號給出的數字。但是，如果值不是有效的整數，則會發出警告並建立數字值。以下顯示有效的整數常數、會產生警告並產生數字常數和語法錯誤的值的範例。

Valid integer constants:  1L, 0x10L, 1000000L, 1e6L
Valid numeric constants:  1.1L, 1e-3L, 0x1.1p-2
Syntax error:  12iL 0x1.1

對於包含不必要的十進位小數點的十進位值會發出警告，例如 1.L。在沒有二進位指數的情況下，十六進制常數中出現小數點是錯誤的。

另請注意，前置符號（+ 或 -）會被視為單元運算子，而不是常數的一部分。

可以在 ?NumericConstants 中找到目前接受格式的最新資訊。

複數常數的形式為十進位數字常數，後面接「i」。請注意，只有純虛數才是實際常數，其他複數會被解析為數字和虛數上的單元或二元運算。

Valid complex constants: 2i 4.1i 1e-2i

字串常數以一對單引號（'''）或雙引號（'"'）為界，並可包含所有其他可列印字元。字串中的引號和其他特殊字元使用跳脫序列來指定

\'

單引號

\"

雙引號

\n

換行（又稱「換行符」，LF）

\r

回車（CR）

\t

跳格字元

\b

退格

\a

鈴聲

\f

換頁

\v

垂直跳格

\\

反斜線本身

\nnn

具有給定八進位碼的字元 - 接受範圍0 ... 7中的一、二或三組數字的序列。

\xnn

具有給定十六進位碼的字元 - 一或二組十六進位數字的序列（輸入0 ... 9 A ... F a ... f）。

\unnnn \u{nnnn}

（支援多位元組區域設定，否則會產生錯誤）。具有給定十六進位碼的 Unicode 字元 - 最多四組十六進位數字的序列。字元必須在目前的區域設定中有效。

\Unnnnnnnn \U{nnnnnnnn}

（支援多位元組區域設定，否則會產生錯誤）。具有給定十六進位碼的 Unicode 字元 - 最多八組十六進位數字的序列。

單引號也可以直接嵌入在雙引號分隔的字串中，反之亦然。

字元字串中不允許出現「空字元」（\0），因此在字串常數中使用\0會終止常數（通常會顯示警告）：會掃描到結束引號之前的其他字元，但會略過這些字元。

10.3.2 識別碼 ¶

識別碼由一連串字母、數字、句點（.）和底線組成。它們不能以數字或底線開頭，也不能以句點後接數字開頭。

字母的定義取決於目前的區域設定：允許的精確字元組由 C 語法 (isalnum(c) || c == ‘.’ || c == ‘_’) 給出，並且會在許多西歐區域設定中包含重音字母。

請注意，預設情況下，ls 函數不會列出以句點開頭的識別碼，而且 ... 和 ..1、..2 等是特殊的。

另請注意，物件可以有非識別碼的名稱。這些通常透過 get 和 assign 存取，儘管在某些沒有歧義的有限情況下，它們也可以用文字字串表示（例如 "x" <- 1）。由於 get 和 assign 不限於識別碼名稱，因此它們不識別下標運算子或替換函數。下列配對不等價

x$a<-1	assign("x$a",1)
x[[1]]	get("x[[1]]")
names(x)<-nm	assign("names(x)",nm)

10.3.3 保留字 ¶

下列識別碼具有特殊含義，不能用於物件名稱

if else repeat while function for in next break
TRUE FALSE NULL Inf NaN
NA NA_integer_ NA_real_ NA_complex_ NA_character_
... ..1 ..2 etc.

10.3.4 特殊運算子 ¶

R 允許使用者定義中綴運算子。這些運算子的形式為字元字串，以「%」字元分隔。字串可以包含任何可列印字元，但「%」除外。字串的跳脫序列在此不適用。

請注意，下列運算子已預先定義

%% %*% %/% %in% %o% %x%

10.3.5 分隔符號 ¶

儘管空白字元（空格、標籤和換頁符，在 Windows 和 UTF-8 區域設定中為其他 Unicode 空白字元⁵）並非嚴格意義上的記號，但在有歧義的情況下，它們用於分隔記號（比較 x<-5 和 x < -5）。

換行符號的功能是記號分隔符號和表達式終止符的組合。如果表達式可以在行尾終止，解析器將假設它會這樣做，否則換行符號將被視為空白。分號（「;」）可用於分隔同一行上的基本表達式。

特殊規則適用於else關鍵字：在複合表達式內，else之前的換行符號會被捨棄，而在最外層，換行符號會終止if結構，而後續的else會導致語法錯誤。這種有點異常的行為發生是因為 R 應該可以在互動模式下使用，然後它必須在使用者按下RET時立即決定輸入表達式是否完整、不完整或無效。

逗號（「,」）用於分隔函數參數和多重索引。

10.3.6 運算子記號 ¶

R 使用下列運算子令牌

+ - * / %% ^	算術
> >= < <= == !=	關係
! & |	邏輯
~	模型公式
-> <-	指定
$	清單索引
:	序列

(幾個運算子在模型公式內有不同的意義)

10.3.7 分組 ¶

普通括號「(」和「)」用於表達式內的明確分組，並用於界定函數定義和函數呼叫的參數清單。

大括號「{」和「}」界定函數定義、條件表達式和反覆運算結構中的表達式區塊。

10.3.8 索引令牌 ¶

陣列和向量的索引使用單引號和雙引號「[]」和「[[]]」執行。此外，索引標籤清單可以使用「$」運算子執行。

10.4.1 函數呼叫 ¶

函數呼叫的形式為函數參照，後面接一組括號中以逗號分隔的引數清單。

function_reference ( arg1, arg2, ...... , argn )

函數參照可以是

• 識別碼（函數名稱）
• 文字字串（同上，但如果函數名稱不是有效的識別碼，則很方便）
• 表達式（應評估為函數物件）

每個引數都可以標記（標記=表達式），或僅為一個簡單的表達式。它也可以是空的，或者可以是特殊符號之一 ...、..2 等等。

標記可以是識別碼或文字字串。

範例

f(x)
g(tag = value, , 5)
"odd name"("strange tag" = 5, y)
(function(x) x^2)(5)

10.4.2 中綴和前綴運算子 ¶

運算子的優先順序（最高優先順序在前）為

::
$ @
^
- +                (unary)
:
%xyz% |>
* /
+ -                (binary)
> >= < <= == !=
!
& &&
| ||
~                  (unary and binary)
-> ->>
<- <<-
=                  (as assignment)

注意 : 在二進制 +/-, 但不在 ^ 之前。因此，1:3-1 是 0 1 2，但 1:2^3 是 1:8。

冪運算子 ‘^’ 和 左賦值加減運算子 ‘<- - = <<-’ 從右至左分組，所有其他運算子從左至右分組。也就是說，2 ^ 2 ^ 3 是 2 ^ 8，而不是 4 ^ 3，而 1 - 1 - 1 是 -1，而不是 1。

請注意運算子 %% 和 %/% 用於整數餘數和除法，其優先順序高於乘法和除法。

儘管它不是嚴格意義上的運算子，但它也需要提到，‘=’ 符號用於標記函數呼叫中的參數，以及在函數定義中指定預設值。

‘$’ 符號在某種意義上是一個運算子，但不允許任意右邊，並在 索引結構 中進行討論。它的優先順序高於任何其他運算子。

一元或二元運算的解析形式與函數呼叫完全相同，其中運算子作為函數名稱，運算元作為函數參數。

括號被記錄為等於一元運算子，名稱為 "("，即使在可以從運算子優先順序推斷出括號的情況下（例如，a * (b + c)）。

請注意， 賦值符號是運算子，就像算術、關係和邏輯運算子一樣。就解析器而言，任何表達式也允許在賦值的目標側（2 + 2 <- 5 就解析器而言是一個有效的表達式。不過，評估器會提出異議）。類似的註解適用於模型公式運算子。

10.4.3 索引結構 ¶

R 有三個索引結構，其中兩個在語法上很相似，但語意有些不同

object [ arg1, ...... , argn ]
object [[ arg1, ...... , argn ]]

object 正式來說可以是任何有效的表達式，但它被理解為表示或評估為一個可子集化的物件。參數通常評估為數字或字元索引，但其他類型的參數也是可能的（特別是 drop = FALSE）。

在內部，這些索引結構分別儲存為函式呼叫，函式名稱為 "[" 和 "[["。

第三個索引結構是

object $ tag

這裡，object 與上述相同，而 tag 是識別碼或文字字串。在內部，它儲存為函式呼叫，名稱為 "$"

10.4.4 複合式 ¶

複合式的形式為

{ expr1 ; expr2 ; ...... ; exprn }

分號可以用換行符號取代。在內部，這儲存為函式呼叫，函式名稱為 "{"，表達式為參數。

10.4.5 流程控制元素 ¶

R 包含下列控制結構作為特殊的語法結構

if ( cond ) expr
if ( cond ) expr1 else expr2
while ( cond ) expr
repeat expr
for ( var in list ) expr

這些結構中的表達式通常會是複合式。

在迴圈結構 (while、repeat、for) 中，可以使用 break（終止迴圈）和 next（跳到下一個迭代）。

在內部，結構儲存為函式呼叫

"if"(cond, expr)
"if"(cond, expr1, expr2)
"while"(cond, expr)
"repeat"(expr)
"for"(var, list, expr)
"break"()
"next"()

10.4.6 函式定義 ¶

一個 函式定義的格式為

function ( arglist ) body

函式主體是一個表達式，通常是複合表達式。arglist 是逗號分隔的項目清單，每個項目可以是識別碼，或格式為「identifier = default」的格式，或特殊符號 ...。default 可以是任何有效的表達式。

請注意，函式引數與清單標籤等不同，不能有給定為文字字串的「奇怪名稱」。

在內部，函式定義儲存為函式呼叫，函式名稱為 function，並有兩個引數，arglist 和 body。arglist 儲存為標記配對清單，其中標籤是引數名稱，而值是預設表達式。