Soluzioni alternative per i commenti su più righe?

Io (più o meno) conosco già la risposta a questa domanda. Ma ho pensato che fosse uno che viene chiesto così spesso nell'elenco degli utenti R, che dovrebbe esserci una risposta valida e solida. Per quanto ne so, non esiste una funzionalità di commento su più righe in R. Quindi, qualcuno ha qualche buona soluzione alternativa?

Mentre un bel po 'di lavoro in R di solito comporta sessioni interattive (il che mette in dubbio la necessità di commenti su più righe), ci sono volte in cui ho dovuto inviare script a colleghi e compagni di classe, molti dei quali coinvolgono blocchi di codice non banali. E per le persone che provengono da altre lingue è una domanda abbastanza naturale.

In passato ho usato le virgolette. Poiché le stringhe supportano le interruzioni di riga, eseguire uno script R con

"
Here's my multiline comment.

"
a <- 10
rocknroll.lm <- lm(blah blah blah)
 ...

funziona bene. Qualcuno ha una soluzione migliore?

Questo compare sulla mailing list abbastanza regolarmente, vedi ad esempio questo thread recente su r-help . La risposta di consenso di solito è quella mostrata sopra: che dato che la lingua non ha un supporto diretto, devi neanche farlo

• lavorare con un editor che dispone di comandi da regione a commento e gli editor R più avanzati lo fanno
• utilizzare i if (FALSE)costrutti suggeriti in precedenza, ma si noti che richiede ancora un'analisi completa e deve quindi essere sintatticamente corretto

Puoi farlo facilmente in RStudio :

selezionare il codice e fare clic su CTR+ SHIFT+ C per commentare / rimuovere il commento dal codice.

Un bel trucco per RStudio che ho appena scoperto è quello di usarlo in #'quanto crea una sezione di commento autoespandibile (quando torni a una nuova riga da tale riga o inserisci nuove righe in tale sezione, viene automaticamente commentato).

[Aggiorna] Basato sui commenti.

# An empty function for Comments
Comment <- function(`@Comments`) {invisible()}

#### Comments ####
Comment( `

  # Put anything in here except back-ticks.

  api_idea <- function() {
    return TRUE
  }

  # Just to show api_idea isn't really there...
  print( api_idea )

`)
####

#### Code. ####
foo <- function() {
  print( "The above did not evaluate!")
}
foo()

[Risposta originale]

Ecco un altro modo ... guarda la foto in basso. Taglia e incolla il blocco di codice in RStudio.

I commenti multilinea che rendono più efficace l' uso di un IDE sono una "buona cosa", la maggior parte degli IDE o dei semplici editor non hanno l'evidenziazione del testo all'interno di semplici blocchi commentati; sebbene alcuni autori si siano presi il tempo per assicurare l'analisi all'interno delle stringhe here. Con R non abbiamo commenti su più righe o stringhe qui, ma l'uso di espressioni invisibili in RStudio dà tutta quella bontà.

Finché non ci sono backtick nella sezione che si desidera utilizzare per commenti su più righe, stringhe qui o blocchi di commenti non eseguiti, questo potrebbe essere qualcosa di utile.

#### Intro Notes & Comments ####
invisible( expression( `
{ <= put the brace here to reset the auto indenting...

  Base <- function()
  {      <^~~~~~~~~~~~~~~~ Use the function as a header and nesting marker for the comments
         that show up in the jump-menu.
         --->8---
  }

  External <- function()
  {
    If we used a function similar to:
      api_idea <- function() {

        some_api_example <- function( nested ) {
          stopifnot( some required check here )
        }

        print("Cut and paste this into RStudio to see the code-chunk quick-jump structure.")
        return converted object
      }

    #### Code. ####
    ^~~~~~~~~~~~~~~~~~~~~~~~~~ <= Notice that this comment section isnt in the jump menu!
                                  Putting an apostrophe in isn't causes RStudio to parse as text
                                  and needs to be matched prior to nested structure working again.
    api_idea2 <- function() {

    } # That isn't in the jump-menu, but the one below is...

    api_idea3 <- function() {

    }

  }

    # Just to show api_idea isn't really there...
    print( api_idea )
    }`) )
####

#### Code. ####
foo <- function() {
  print( "The above did not evaluate and cause an error!")
}

foo()

## [1] "The above did not evaluate and cause an error!"

Ed ecco la foto ...

Posso pensare a due opzioni. La prima opzione è usare un editor che permetta di bloccare i commenti e decommentare (es. Eclipse). La seconda opzione consiste nell'usare un'istruzione if. Ma questo ti permetterà solo di "commentare" la sintassi R corretta. Quindi un buon editor è la soluzione preferita.

if(FALSE){
     #everything in this case is not executed

}

Se trovi incredibile che qualsiasi lingua non soddisfi questo.

Questa è probabilmente la soluzione più pulita:

anything="
first comment line
second comment line
"

Oltre a usare il modo eccessivo per commentare i codici multilinea semplicemente installando RStudio, puoi usare Notepad ++ poiché supporta l'evidenziazione della sintassi di R

(Seleziona più righe) -> Modifica -> Commenta / Rimuovi commento -> Attiva / disattiva commento blocco

Nota che devi prima salvare il codice come sorgente .R (evidenziato in rosso)

Uso vim per modificare lo script R.

Diciamo che lo script R è test.R, contenente dire "Riga 1", "Riga 2" e "Riga 3" su 3 righe separate.

Apro test.R dalla riga di comando con Vim digitando "vim test.R". Quindi vado alla prima riga che voglio commentare, digito "Control-V", freccia giù fino all'ultima riga che voglio commentare, digito una I maiuscola cioè "I" per l'inserimento, digita "#", e poi premi il tasto Esc per aggiungere "#" a ogni riga che ho selezionato scorrendo verso il basso. Salvare il file in Vim e quindi uscire da Vim digitando ": wq". Le modifiche dovrebbero essere visualizzate in Rstudio.

Per eliminare i commenti in Vim, inizia dalla prima riga sopra il carattere "#" che vuoi eliminare, fai di nuovo "Control-V", e freccia giù fino all'ultima riga da cui vuoi eliminare un "#". Quindi digita "dd". I segni "#" dovrebbero essere cancellati.

Ci sono secondi di ritardo tra le modifiche al test.R in Vim si riflettono in Rstudio.

In RStudio un modo semplice per farlo è scrivere il tuo commento e una volta che hai usato CTRL + Maiusc + C per commentare la tua riga di codice, quindi usa CTRL + MAIUSC + / per ridisporre il commento su più righe per facilitare la lettura.

In Python fai un commento su più righe con 3 virgolette singole prima e dopo i commenti. Ho provato questo in R e sembra funzionare anche.

Per esempio.

'''
This is a comment
This is a second comment
'''