# Paramétrer et obtenir

Sonic Pi a un magasin de mémoire global appelé État du Temps. Les deux choses principales que vous faites avec sont de `set` de l’information et de `get` de l’information. Explorons plus en détails…

## Paramétrer

Pour stocker de l’information dans l’État du Temps, nous avons besoin de deux choses :

1. l’information que nous voulons stocker,
2. un nom unique (clé) pour l’information.

Par exemple, nous voulons stocker le chiffre `3000` avec la clé `:intensity`. C’est possible en utilisant la fonction `set` :

    set :intensity, 3000

Nous pouvons utiliser n’importe quel nom pour notre clé. Si de l’information a déjà été stockée avec cette clé, notre nouveau `set` va l’écraser :

    set :intensity, 1000
    set :intensity, 3000

Dans l’exemple ci-dessus, étant donné que nous stockons deux nombres avec la même clé, le dernier appel à `set` “gagne”, alors le nombre associé à `:intensity` sera `3000` étant donné que le premier appel à `set` est écrasé.

## Obtenir

Pour obtenir de l’information de l’État du Temps, nous avons seulement besoin de la clé que nous avons utilisée pour la `set`, qui est dans notre cas `:intensity`. Nous avons alors seulement besoin d’appeler `get[:intensity]` que nous pouvons voir en affichant le résultat dans le journal :

    print get[:intensity] #=> prints 3000

Notez que l’appel à `get` peut retourner de l’information qui a été `set` dans une exécution précédente. Une fois qu’une pièce d’information a été `set`, elle est disponible jusqu’à ce qu’elle soit écrasée (comme nous l’avons fait avec la valeur de `:intensity` passant de `1000` à `3000` ci-dessus) ou que Sonic Pi soit fermé.

## Fils multiples

L’avantage principal du système d’État du Temps est qu’il peut être utilisé de façon sûre au travers des fils d’exécution ou des boucles en direct. Par exemple, vous pourriez avoir une boucle en direct qui affecte de l’information et une autre qui l’obtient :

    live_loop :setter do
      set :foo, rrand(70, 130)
      sleep 1
    end
    live_loop :getter do
      puts get[:foo]
      sleep 0.5
    end

La chose plaisante avec l’utilisation de `get` et `set` au travers des fils d’exécution de cette façon est que ça produira toujours le même résultat à chaque fois que vous l’exécuterez. Allez-y, essayez-le. Regardez si vous obtenez le journal suivant :

    {run: 0, time: 0.0}
     └─ 125.72265625
    {run: 0, time: 0.5}
     └─ 125.72265625
    {run: 0, time: 1.0}
     └─ 76.26220703125
    {run: 0, time: 1.5}
     └─ 76.26220703125
    {run: 0, time: 2.0}
     └─ 114.93408203125
    {run: 0, time: 2.5}
     └─ 114.93408203125
    {run: 0, time: 3.0}
     └─ 75.6048583984375
    {run: 0, time: 3.5}
     └─ 75.6048583984375

Essayez de l’exécuter quelques fois - vous voyez, c’est toujours la même chose. C’est ce qu’on appelle un comportement déterministe et c’est très important quand nous voulons partager notre musique sous forme de code et que nous savons que la personne qui exécute le code entend exactement ce que nous voulions qu’elle entende (tout comme jouer un MP3 ou flux d’internet sonne de la même façon pour tout ceux qui écoutent).

## Un système d’état simple et déterministe

À la Section 5.6, nous avons discuté de pourquoi l’utilisation des variables à travers les fils peut entraîner des comportements hasardeux. Ceci nous empêche de pouvoir, de façon sûre, reproduire du code comme ceci :

    ## Un exemple de comportement non-déterministe
    ## (du à la concurrence causée pas de multiple
    ## boucles en direct qui manipule la même variable
    ## au même moment).
    ##
    ## Si vous exécutez ce code, vous remarquerez
    ## que la liste qui est imprimée
    ## n'est pas toujours triée!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

Regardons à quoi cela peut ressembler en utilisant `get` and `set` :

    ## Un exemple de comportement déterministe
    ## (malgré l'accès avec concurrence de l'état partagé)
    ## en utilisant le nouveau système d'État du Temps de Sonic Pi.
    ##
    ## Quand ce code est exécuté, la liste qui est
    ## imprimée est toujours triée!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

Remarquez comment le code est pratiquement identique à la version qui utilisait la variable auparavant. Cependant, quand vous exécutez votre code, il agit de la façon que vous vous attendez comme avec n’importe lequel code de Sonic Pi typique - il fait la même chose chaque fois dans ce cas grâce au système d’État du Temps.

Donc, lorsque vous partagez de l’information au travers de boucles en direct et de fils d’exécution, utilisez `get` et `set` au lieu de variables pour un comportement déterministe et reproductible.