`Knitr` में मैं कैसे जांच कर सकता हूं कि आउटपुट पीडीएफ या वर्ड होगा?




(3)

मैं विशिष्ट सामग्री को शामिल करना चाहूंगा, जिसके आधार पर प्रारूप बनाया जा रहा है। इस विशिष्ट उदाहरण में, मेरी तालिकाएँ MS word आउटपुट में भयानक हैं, लेकिन HTML में बहुत अच्छी हैं। मैं आउटपुट के आधार पर तालिका छोड़ने के लिए कुछ परीक्षण जोड़ना चाहूंगा।

यहाँ कुछ छद्मकोश हैं:

output.format <- opts_chunk$get("output")

if(output.format != "MS word"){
print(table1)
}

मुझे यकीन है कि यह opts_chunk का उपयोग करने का सही तरीका नहीं है, लेकिन यह मेरी समझ की सीमा है कि हुड के नीचे knitr कैसे काम करता है। इसके लिए परीक्षण करने का सही तरीका क्या होगा?


संक्षिप्त जवाब

ज्यादातर मामलों में, opts_knit$get("rmarkdown.pandoc.to") आवश्यक जानकारी पहुँचाती है।

अन्यथा, क्वेरी rmarkdown::all_output_formats(knitr::current_input()) और जाँच करें कि रिटर्न मान में word_document :

if ("word_document" %in% rmarkdown::all_output_formats(knitr::current_input()) {
  # Word output
}

लंबा जवाब

मुझे लगता है कि स्रोत दस्तावेज़ आरएमडी है क्योंकि यह एमएस आउटपुट, पीडीएफ और एचटीएमएल जैसे विभिन्न आउटपुट प्रारूपों के लिए सामान्य / सबसे सामान्य इनपुट प्रारूप है।

इस स्थिति में, knitr विकल्पों का उपयोग अंतिम आउटपुट प्रारूप को निर्धारित करने के लिए नहीं किया जा सकता है क्योंकि यह knitr के दृष्टिकोण से कोई फर्क नहीं पड़ता: सभी आउटपुट प्रारूपों के लिए, knitr का काम एमडी फ़ाइल में इनपुट RMD फ़ाइल को बुनना है। YAML हेडर में निर्दिष्ट आउटपुट फॉर्म में एमडी फाइल का रूपांतरण अगले चरण में pandoc द्वारा किया pandoc

इसलिए, हम अंतिम विकल्प प्रारूप के बारे में जानने के लिए पैकेज विकल्प knitr::opts_knit$get("out.format") उपयोग नहीं कर सकते हैं knitr::opts_knit$get("out.format") लेकिन हमें इसके बजाय YAML हैडर को पार्स करने की आवश्यकता है।

सिद्धांत में अब तक। वास्तविकता थोड़ी अलग है। RStudio का "निट पीडीएफ" / "निट HTML" बटन कॉल rmarkdown::render जिसे बदले में rmarkdown::render कहता है। ऐसा होने से पहले, वास्तविक उत्पादन प्रारूप में rmarkdown.pandoc.to पैकेज विकल्प rmarkdown.pandoc.to करता है। आउटपुट फॉर्मेट के आधार पर मूल्य क्रमशः html , latex या docx होगा।

इसलिए, अगर (और केवल अगर) RStudio के "निट पीडीएफ" / "बुनना HTML" बटन का उपयोग किया जाता है, तो आउटपुट स्वरूप निर्धारित करने के लिए knitr::opts_knit$get("rmarkdown.pandoc.to") का उपयोग किया जा सकता है। यह इस उत्तर और उस ब्लॉग पोस्ट में भी वर्णित है।

समस्या सीधे कॉल rmarkdown.pandoc.to के मामले के लिए अनसुलझी है क्योंकि तब rmarkdown.pandoc.to सेट नहीं है। इस मामले में हम (अनएक्सपोर्टेड) ​​फंक्शन parse_yaml_front_matter को rmarkdown पैकेज से rmarkdown हेडर को पार्स करने के लिए शोषण कर सकते हैं।

[ अद्यतन : rmarkdown रूप में, फ़ंक्शन all_output_formats जोड़ा गया है ( बिल Denney के लिए धन्यवाद यह इंगित करने के लिए)। यह कस्टम फ़ंक्शन को अप्रचलित से नीचे विकसित करता है - उत्पादन के लिए, rmarkdown::all_output_formats उपयोग rmarkdown::all_output_formats ! मैं इस उत्तर के शेष भाग को मूल रूप से शैक्षिक उद्देश्यों के लिए लिखे गए छोड़ देता हूं।]

---
output: html_document
---
```{r}
knitr::opts_knit$get("out.format") # Not informative.

knitr::opts_knit$get("rmarkdown.pandoc.to") # Works only if knit() is called via render(), i.e. when using the button in RStudio.

rmarkdown:::parse_yaml_front_matter(
    readLines(knitr::current_input())
    )$output
```

ऊपर का उदाहरण opts_knit$get("rmarkdown.pandoc.to") के उपयोग (घाव) को opts_knit$get("rmarkdown.pandoc.to") ( opts_knit$get("out.format") ), जबकि parse_yaml_front_matter को नियोजित करने वाली रेखा "आउटपुट" फ़ील्ड में निर्दिष्ट प्रारूप लौटाती है। YAML हेडर की।

parse_yaml_front_matter का इनपुट कैरेक्टर वेक्टर के रूप में स्रोत फ़ाइल है, जैसा कि readLines द्वारा दिया गया है। वर्तमान में current_input() जा रही फ़ाइल का नाम निर्धारित करने के लिए, इस उत्तर में सुझाए अनुसार current_input() का उपयोग किया जाता है।

इससे पहले कि parse_yaml_front_matter का उपयोग एक सरल में किया जा सकता है if कथन को उत्पादन प्रारूप पर सशर्त व्यवहार को लागू करने के लिए, एक छोटे से शोधन की आवश्यकता होती है: ऊपर दिखाए गए कथन में एक सूची वापस आ सकती है यदि इस उदाहरण में आउटपुट के लिए अतिरिक्त YAML पैरामीटर हैं:

---
output: 
  html_document: 
    keep_md: yes
---

निम्न सहायक फ़ंक्शन को इस समस्या को हल करना चाहिए:

getOutputFormat <- function() {
  output <- rmarkdown:::parse_yaml_front_matter(
    readLines(knitr::current_input())
    )$output
  if (is.list(output)){
    return(names(output)[1])
  } else {
    return(output[1])
  }
}

इसका निर्माण जैसे निर्माणों में किया जा सकता है

if(getOutputFormat() == 'html_document') {
   # do something
}

ध्यान दें कि getOutputFormat निर्दिष्ट किए गए केवल पहले आउटपुट प्रारूप का उपयोग करता है, इसलिए निम्न हेडर के साथ केवल html_document लौटाया जाता है:

---
output:
  html_document: default
  pdf_document:
    keep_tex: yes
---

हालांकि, यह बहुत प्रतिबंधक नहीं है। जब RStudio का "निट एचटीएमएल" / "निट पीडीएफ" बटन का उपयोग किया जाता है (आउटपुट प्रकार का चयन करने के लिए इसके बगल में ड्रॉपडाउन मेनू के साथ), RStudio, YAML हेडर को फिर से व्यवस्थित करता है, ताकि चयनित आउटपुट स्वरूप सूची में पहला प्रारूप होगा । एकाधिक आउटपुट फॉर्मेट (AFAIK) केवल तभी प्रासंगिक होते हैं जब rmarkdown::render का उपयोग किया rmarkdown::render output_format = "all" साथ rmarkdown::render । और: इन दोनों ही मामलों में rmarkdown.pandoc.to का उपयोग किया जा सकता है, जो कि वैसे भी आसान है।


1.18 knitr बाद से, आप दो कार्यों का उपयोग कर सकते हैं

knitr::is_html_output()

तथा

knitr::is_latex_output()

बस यहाँ कुछ स्पष्टीकरण जोड़ना चाहते हैं, क्योंकि मैं अक्सर एक ही रमार्कडाउन फाइल (* .Rmd) को कई प्रारूपों (* .html, * .pdf, * .docx) में प्रस्तुत करता हूं, इसलिए यह जानना चाहता हूं कि क्या प्रारूप का प्रारूप है। ब्याज को सामने के मामले में निर्दिष्ट किया जाता है, यमल (यानी "word_document" %in% rmarkdown::all_output_formats(knitr::current_input() ), मैं जानना चाहता हूं कि वर्तमान में कौन सा प्रारूप प्रस्तुत किया जा रहा है। ऐसा करने के लिए आप या तो कर सकते हैं:

  1. सामने वाले पदार्थ में सूचीबद्ध स्वरूपों का पहला तत्व प्राप्त करें: rmarkdown::all_output_formats(knitr::current_input()[1]

  2. डिफ़ॉल्ट आउटपुट स्वरूप नाम प्राप्त करें: rmarkdown::default_output_format(knitr::current_input())$name

उदाहरण के लिए...

---
title: "check format"
output:
  html_document: default
  pdf_document: default
  word_document: default
---

```{r}
rmarkdown::all_output_formats(knitr::current_input())[1]
```

```{r}
rmarkdown::default_output_format(knitr::current_input())$name
```

```{r}
fmt <- rmarkdown::default_output_format(knitr::current_input())$name

if (fmt == "pdf_document"){
  #...
}

if (fmt == "word_document"){
  #...
}
```




knitr