Discussion :

[khubal]

Bonjour et bonne année à tous,

Je souhaite écrire un programme R qui comporte 2 blocs de code par exemple, et ensuite l'exécuter en appelant la fonction source(moncode.R).
Le problème est que comme ça ça exécute tout le code.

Est-ce que vous connaissez un moyen pour exécuter que le 1er bloc de code par exemple ? (A part écrire les 2 blocs dans des fichiers différents)

Merci

[lilly74]

Bonjour et meilleurs vœux à tous!

Avez-vous essayé la fonction browser?
Un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> foo <- function(x) {
+       a <- 3
+       browser()
+       (d <- a+x)
+       }
> foo(4)
Called from: foo(4)
Browse[1]> a
[1] 3
Browse[1]> x
[1] 4
Browse[1]> d
Erreur : objet 'd' introuvable
Browse[1]> c
[1] 7

J’espère que cela correspond à ce que vous cherchez.

Bonne journée

[khubal]

Merci pour ta réponse, mais ça ne correspond pas exactement à ce que je cherche. Ce que je voudrais c'est écrire un script avec des blocs de code A et B, et ensuite pouvoir faire un truc du genre :

source(monscript.R) pour que tout le script se charge, et ensuite je tape un truc du genre codeA() pour que juste la partie codeA de monscript.R s'execute.

J'ai essayé en faisant un script du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
codeA<-function(){
  script du code A
  }
 
codeB<-function(){
  script du code B
  }

Mais le problème est que du coup, toutes les variables définies dans le code A sont définies localement et je ne peux pas m'en resservir dans le codeB

Ou sinon il faudrait que je puisse sauver les variables définies dans les fonctions codeA et codeB.

[lilly74]

Bonsoir,

il me semblait que vous pouviez utiliser browser() de cette façon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> monscript <- function(x , y){
+   # code A
+   (a <- 3 + x)
+   browser()
+   # code B
+   (b <- a * y)
+   }
>   
> monscript(3 , 4)
Called from: monscript(3, 4)
Browse[1]> a
[1] 6
Browse[1]> c
[1] 24

Si vous souhaitez seulement sauver les variables, cela serait quelque chose du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> codeA <- function(x){
+   a <- 3+x
+   save(a, file= "C:\\Users\\utilisateur\\Documents\\a.RData")
+  }
>  codeA(3)  #création de a.RData
>  
>  rm(list=ls())
>  
> codeB <- function(y){
+   load("C:\\Users\\utilisateur\\Documents\\a.RData") # on chargera a.RData à l'appel de codeB()
+   (b <- a*y)
+  }
> 
> codeB(4)
[1] 24

J'espère que cela répond cette fois à votre question

Bonne soirée

[pitipoisson]

Bonjour,

Tu peux faire quelque chose d'approchant en créant deux fonctions :

1. pour tester si un bloc doit être exécuter, d'après une variable globale (nom du bloc)
2. pour définir les variables globales, sourcer le code, puis supprimer les variables globales.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
block <- function(block)
{
    ## Purpose: tester si un block doit être exécuté (retourne TRUE ou FLASE).
    ## ----------------------------------------------------------------------
    ## Arguments: block : nom du block
    ## ----------------------------------------------------------------------
    ## Author: Yves Reecht, Date:  4 janv. 2012, 11:02
 
    return(exists(block) && isTRUE(get(block)))
}
 
 
sourceBlock <- function(file, blocks,...)
{
    ## Purpose: sourcer uniquement les blocs définis, dans le fichier "file".
    ## ----------------------------------------------------------------------
    ## Arguments: file : fichier à sourcer.
    ##            blocks : noms des blocs à exécuter (vecteur de chaînes
    ##                     de caractères).
    ##            ... : arguments optionnels de source()
    ## ----------------------------------------------------------------------
    ## Author: Yves Reecht, Date:  4 janv. 2012, 10:36
 
    on.exit(rm(list=blocks, envir=.GlobalEnv))
 
    invisible(lapply(blocks,
                     function(x)
                 {
                     assign(x, TRUE, envir=.GlobalEnv)
                 }))
 
    source(file=file,...)
}

Tu utilises alors la première comme suit dans le code (fichier test_block.R) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
## Premier bloc d'instructions :
if (block("blockA"))
{
    print("blockA")
 
    tmp <- "test"
}
 
## Second bloc d'instructions :
if (block("blockB"))
{
    print("blockB")
}

Puis la seconde pour sourcer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
> sourceBlock("test_block.R", c("blockB"))
[1] "blockB"
> tmp
Error: object 'tmp' not found
> sourceBlock("test_block.R", c("blockA"))
[1] "blockA"
> tmp
[1] "test"
> sourceBlock("test_block.R", c("blockB", "blockA"))
[1] "blockA"
[1] "blockB"
>

Attention : c'est du bricolage et ça utilise des variables globales =>

• utiliser des noms de blocs qui ne correspondent à aucune variable.
• ne pas s'amuser à assigner manuellement des valeurs aux noms de blocs, mais toujours passer par la fonction (sinon des blocs non souhaités peuvent s'exécuter).

[khubal]

Ok merci, je vais regarder ça