10.3 Correspondência de Padrões

# Correspondência de Padrões

Para passar e recuperar informações para o Time State, é possível usar chaves mais complexas que símbolos básicos como `:foo` e `:bar`. Também pode usar cadeias no formato URL, chamadas de Paths (caminhos) como `"/foo/bar/baz"`. Depois que começãmos a usar paths, nós podemos começar a aproveitar o sofisticado sistema de correspondência de Padrões do Sonic Pi para usar `get` e `sync` com paths 'similares' em vez de 'idênticos'. Vamos dar uma olhada.

## Correspondência com qualquer parte do caminho (path)

Vamos assumir que nós queiramos esperar pelo próximo evento que tem três segmentos no path:

```
sync "/*/*/*"
```

Isto irá corresponder a qualquer evento Time State com exatamente três segmento, independente de seus nomes. Por exemplo:

* `cue "/foo/bar/baz"`
* `cue "/foo/baz/quux"`
* `cue "/eggs/beans/toast"`
* `cue "/moog/synths/rule"`

Entretanto, *não* irá corresponder a paths com menos ou mais segmentos. Os seguintes paths não serão localizados:

* `cue "/foo/bar"`
* `cue "/foo/baz/quux/quaax"`
* `cue "/eggs"`

Cada `*` (asterisco) significa *qualquer conteúdo*. Então nós podemos encontrar paths com somente um segmento com `/*` ou paths com cinco segmentos com `/*/*/*/*/*`

## Encontrando segmentos parciais

Se soubermos como o segmento irá começar ou terminar, nós podemos usar um asterisco `*` junto com o nome parcial do segmento. Por exemplo: `"/foo/b*/baz"` irá corresponder a qualquer path com três segmentos, onde o primeiro é `foo`, o último é `baz` e o segmento do meio pode ser qualquer coisa que comece com `b`. Então irá corresponder a:

* `cue "/foo/bar/baz"`
* `cue "/foo/baz/baz"`
* `cue "/foo/beans/baz"`

Mas não irá corresponder a:

* `cue "/foo/flibble/baz"`
* `cue "/foo/abaz/baz"`
* `cue "/foo/beans/baz/eggs"`

Você pode colocar o `*` no início do segmento para especificar os últimos caracteres de um segmento: `"/foo/*zz/baz"` que iráo corresponder a quaisquer 3 segmentos `cue` ou `set` onde o primeiro segmento for `foo`, o último for `baz` e o segmento do meio termine com `zz`, como `"cue "/foo/whizz/baz"`.

## Encontrando correspondências em segmentos de paths aninhados

As vezes você não sabe quantos segmentos do path você quer achar a correspondência. Nestes casos, você pode usar os poderosos duplos asteriscos: `**` como em `"/foo/**/baz"` que irão corresponder a:

* `cue "/foo/bar/baz"`
* `cue "/foo/bar/beans/baz"`
* `cue "/foo/baz"`
* `cue "/foo/a/b/c/d/e/f/baz"`

## Correspondendo a Letras Sozinhas

Você pode usar o caracter `?` para comparar com um caracter apenas, como em `"/?oo/bar/baz"` que irá corresponder a:


* `cue "/foo/bar/baz"`
* `cue "/goo/bar/baz"`
* `cue "/too/bar/baz"`
* `cue "/woo/bar/baz"`

## Correspondendo a Múltiplas Palavras

Se você sabe que um segmento pode ser uma palavra de um certo conjunto de palavras, você pode usar `{` e `}` para especificar uma lista de opções como em `"/foo/{bar,beans,eggs}/quux"` que irão corresponder aos seguintes padrões:

* `cue "/foo/bar/quux"`
* `cue "/foo/beans/quux"`
* `cue "/foo/eggs/quux"`

## Correspondendo a Múltiplas Letras

Por fim, você pode comparar com uma seleção de letras se você usar `[` e `]` para especificar uma lista de possibilidades como em `"/foo/[abc]ux/baz"` que irá corresponder somente a:

* `cue "/foo/aux/baz"`
* `cue "/foo/bux/baz"`
* `cue "/foo/cux/baz"`


Você também pode utilizar o caracter `-` para especificar sequências de letras. Por exemplo`"/foo/[a-e]ux/baz"` que irá corresponder somente a:

* `cue "/foo/aux/baz"`
* `cue "/foo/bux/baz"`
* `cue "/foo/cux/baz"`
* `cue "/foo/dux/baz"`
* `cue "/foo/eux/baz"`

## Combinando Correspondências

Ao chamar `sync` ou `get` você está livre para combinar localizadores de correspondência em qualquer ordem que você achar necessário para encontrar qualquer evento Time State criado por `cue` ou `set`. Vamos ver um exemplo doido:

```
in_thread do
  sync "/?oo/[a-z]*/**/ba*/{quux,quaax}/"
  sample :loop_amen
end
sleep 1
cue "/foo/beans/a/b/c/d/e/bark/quux/"
```

## Correspondência de Padrões OSC

For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: https://opensoundcontrol.stanford.edu/spec-1_0.html
