# Símbolos e operadores

## Principais

* `#` - comentários
* `<#...#>` - comentário com delimitadores
* `` ` `` - indicação de símbolos especiais dentro de aspas
* `-` (hífen) - colocado antes dos nomes dos parâmetros de funções/cmdlets/operadores de letra
* `%` - operador matemático que retorna o resto da divisão (`11 % 5 = 1`)
* `%{}` – substitui o cmdlet `ForEach-Object`
* `;` - símbolo de separação de linhas (para escrever várias linhas de código em uma só)
* `=` - operador de atribuição
* `&{}` – incorpora um scriptblock em uma expressão
* `?` - substitui o cmdlet `Where-Object`
* `:` - para indicar parâmetros de alternância
* `.` – acesso a métodos dinâmicos da classe (`$datatable.Rows.Count`)
* `..` – delimitador de intervalo (`1..4 = @(1,2,3,4)`)
* `::` – acesso a métodos estáticos da classe (`[Console]::WriteLine("PowerShell")`)
* `@` - operador de array:
  * força o valor a ser um array, mesmo que seja de um único elemento ou nulo;
  * pode criar tabelas hash: `@{"Key" = "Value";"Key2"="Value2"}`
  * usado para Splatting, ou seja, passando parâmetros de função como um array ou dicionário (`@arr / @dic`)
* `|` - pipeline (como lambda):
  * `($obj| \cmdlet\) / ($collection[]| \cmdlet\)` - executa o cmdlet para o objeto;
  * `$collection=@()| Foreach-Object{$_}` - loop, onde `$_` é usado como iterador;
  * `($proc = Get-Process Notepad* ) | Stop-Process` - finaliza todos os processos que contêm em seu nome `Notepad` e retorna todos os processos finalizados em `$proc`;
  * `(Get-Process Notepad* ) | Stop-Process` - sem retorno da lista.

## Operadores de comparação

* `-match "#pattern#"` - uso de expressões regulares
* `-is [type]` - verificação de tipos
* `-isNot [type]` - verificação de tipos

Mais sobre operadores de comparação, operadores aritméticos e lógicos:

{% embed url="<https://docs.sherparpa.ru/obuchenie-po-razrabotke-na-platforme-sherpa-rpa/obuchenie-powershell#id-2.-operatory-sravneniya-v-powershell>" %}

## Condições em arrays

* `-$array -\operador de comparação\ $obj` - retorna um array de objetos com os resultados da correspondência de cada elemento com o objeto, ou False (um array não vazio é igual a True para expressões lógicas)
* `-contains` - o array contém o objeto (bool)
* `-notcontains` - o array NÃO contém o objeto (bool)
* `-in` - o objeto está no array (bool)
* `-notin` - o objeto não está no array (bool)

> contains & in diferem na notação $arr -contains $obj / $obj -in $arr

## Parênteses

* `()` – Parênteses:
  * passagem de argumentos,
  * agrupamento de várias instruções (por exemplo),
  * resolução de ambiguidade (as ações entre parênteses são executadas primeiro),
  * criação de arrays.
* `{}` - Chaves:
  * agrupamento de instruções (por exemplo, em um bloco if),
  * incorporação de um script em uma expressão (scriptblock).
* `[]` - Colchetes:
  * acesso a elementos de arrays e tabelas hash,
  * filtro usando expressões regulares,
  * indicação do tipo de dado esperado para a expressão,
  * acesso a namespaces.

## Aspas

* `" "` - permitem colocar dentro o nome de uma variável, e automaticamente converter para seu valor.
* `' '` - permitem colocar dentro o nome de uma variável, mas NÃO convertem para seu valor.

> As aspas suportam múltiplas linhas no código (ENTER move o código para a próxima linha, \`n - quebra de linha na saída).

> As aspas são escapadas com aspas duplas (como em VB) + aspas simples não precisam ser escapadas dentro de aspas duplas e vice-versa.

> Aspas cercadas pelo símbolo @ (antes e depois) são chamadas de HereString e dentro delas todos os caracteres são tratados como texto. No código, após '@"' e antes de '"@' deve haver um ENTER.

## Sinal $

* `$` - variáveis
* `$$` - resultado do último comando executado, por exemplo, `$a="Hello"; $b=$$` resulta em `$b = "Hello"`
* `$^` - início do último comando executado, por exemplo, `$a="Hello"; $b=$^` resulta em `$b = "$a"`.
* `$_ ($PSItem)` - usado para passar valor ao usar o pipeline (`|`).
* `$?` - armazena o status da execução do comando anterior. Retorna True se o comando foi executado com sucesso e False — se houve erro.
* `$()` - usado para destacar uma subexpressão em uma string ao usar aspas duplas. Nesse caso, a expressão entre parênteses é processada primeiro.
* `${}` - permite usar caracteres não padrão no nome da variável. Por exemplo: `${@,&$>?=*} = "Hello, world"`.

## Sequências de escape

PowerShell suporta um conjunto de sequências de caracteres especiais, que são usadas para representar caracteres que não estão na codificação padrão.

> As sequências são geralmente chamadas de sequências de escape.
>
> Sequências de escape começam com o símbolo de barra invertida, chamado de grave (ASCII 96), e são sensíveis a maiúsculas e minúsculas.
>
> O símbolo de barra invertida também pode ser chamado de símbolo de escape.
>
> Sequências de escape são processadas apenas em strings contidas em aspas duplas ou simples.

* `` `0 `` - NULL (não equivalente a $null)
* `` `a `` - Aviso
* `` `b `` - Retrocesso
* `` `e `` - ESC
* `` `f `` - Quebra de página
* `` `n `` - Nova linha
* `` `r `` - Retorno de carro
* `` `t `` - Tabulação horizontal
* `` `u{x} `` - Sequência de escape Unicode
* `` `v `` - Tabulação vertical


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.sherparpa.ru/pt/sherpa-rpa/sherpa-designer/sherpa-designer-otvety-na-chasto-zadavaemye-voprosy/powershell/simvoly-i-operatory.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
