sourcer juste une partie d'un code

Version imprimable

02/01/2012, 13h21
khubal

sourcer juste une partie d'un code

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

Bonjour et meilleurs vœux à tous!

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

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 :)

02/01/2012, 15h16
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:

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.

Bonsoir,

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

Code:

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:

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 :roll:

Bonne soirée :)

Bonjour,

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

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

Code:

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:

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:

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).

07/01/2012, 08h49
khubal

Ok merci, je vais regarder ça :ccool: