# Funções

As funções podem ser criadas em um Code Block e chamadas em outro lugar da definição do Dynamo. Isto cria outra camada de controle em um arquivo paramétrico e pode ser visualizado como uma versão com base em texto de um nó personalizado. Neste caso, o Code Block "principal" é facilmente acessível e pode ser localizado em qualquer lugar do gráfico. Não é necessário fio!

### Principal

A primeira linha tem a palavra-chave "def", depois o nome da função e, a seguir, os nomes das entradas entre parênteses. Os contraventamentos definem o corpo da função. Retorne um valor com "return =". Os Code Block que definem uma função não possuem portas de entrada ou saída porque eles são chamados de outros Code Blocks.

!

```
/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};
```

### Secundários

Chame a função com outro Code Block no mesmo arquivo fornecendo o mesmo nome e o mesmo número de argumentos. Funciona da mesma forma que os nós prontos para uso da biblioteca.

!

```
FunctionName(in1,in2);
```

## Exercício: Esfera por Z

> Faça o download do arquivo de exemplo clicando no link abaixo.
>
> É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.

{% file src="/files/4QY76R0v4O1tsfwYGVPr" %}

Neste exercício, vamos criar uma definição genérica que criará esferas com base em uma lista de entrada de pontos. O raio dessas esferas é conduzido pela propriedade Z de cada ponto.

Vamos começar com um intervalo de números de dez valores , de 0 a 100. Conecte-os a um nó **Point.ByCoordinates** para criar uma linha diagonal.

!

Crie um **Bloco de código** e insira a nossa definição.

!

> 1. Use estas linhas de código:
>
>    ```
>    def sphereByZ(inputPt)
>    {
>
>    };
>    ```
>
> O *inputPt* é o nome que atribuímos para representar os pontos que guiarão a função. Por agora, a função não está fazendo nada, mas vamos desenvolver essa função nas etapas a seguir.

!

> 1. Quando a função do **Code Block** é adicionada, colocamos um comentário e uma variável *sphereRadius* que consulta a posição *Z* de cada ponto. Lembre-se de que *inputPt.Z* não precisa de parênteses como um método. Essa é uma *consulta* das propriedades de um elemento existente; portanto, nenhuma entrada é necessária:
>
> ```
> def sphereByZ(inputPt,radiusRatio)
> {
> //get Z Value, ise ot to drive radius of sphere
> sphereRadius=inputPt.Z;
> };
> ```

!

> 1. Agora, vamos recordar a função que criamos em outro **Code Block**. Se clicarmos duas vezes na tela para criar um novo *bloco de código* e digitarmos *sphereB*, notamos que o Dynamo sugere a função *sphereByZ* que foi definida. A função foi adicionada à biblioteca intellisense. Muito legal.

!

> 1. Agora, chamamos a função e criamos uma variável chamada *Pt* para conectar os pontos criados nas etapas anteriores:
>
>    ```
>    sphereByZ(Pt)
>    ```
> 2. Observe que, na saída, temos todos os valores nulos. Por que isso ocorre? Quando definimos a função, estamos calculando a variável *sphereRadius*, mas não definimos o que a função deve ser *retornada* como uma *saída*. Podemos corrigir isso na próxima etapa.

!

> 1. Uma etapa importante: é necessário definir a saída da função adicionando a linha `return = sphereRadius;` à função *sphereByZ*.
> 2. Agora, vemos que a saída do Bloco de código nos fornece as coordenadas Z de cada ponto.

Agora, vamos criar esferas reais editando a função *Principal*.

!

> 1. Primeiro definimos uma esfera com a linha de código: `sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);`
> 2. Em seguida, alteramos o valor de retorno para *sphere* em vez de *sphereRadius*: `return = sphere;` Isso nos fornece algumas esferas gigantes em nossa visualização do Dynamo.

!

> 1\. Para reduzir o tamanho dessas esferas, vamos atualizar o valor sphereRadius adicionando um divisor: `sphereRadius = inputPt.Z/20;` Agora podemos ver as esferas separadas e começar a entender a relação entre o raio e o valor Z.

!

> 1. No nó **Point.ByCoordinates**, alterando a amarra de Lista mais curta para Produto transversal, criamos um eixo de pontos. A função *sphereByZ* ainda está em pleno efeito, de modo que todos os pontos criam esferas com raios com base em valores Z.

!

> 1. E apenas para efeitos de teste, conectamos a lista original de números à entrada X para **Point.ByCoordinates**. Agora temos um cubo de esferas.
> 2. Observação: Se isso levar muito tempo para ser calculado no computador, tente alterar *#10* para algo como *#5*.

Lembre-se: a função *sphereByZ* que foi criada é uma função genérica, para que possamos recuperar a hélice de uma lição anterior e aplicar a função a ela.

!

Uma etapa final: vamos conduzir a relação do raio com um parâmetro definido pelo usuário. Para fazer isso, é necessário criar uma nova entrada para a função e também substituir o divisor *20* por um parâmetro.

!

> 1. Atualize a definição de *sphereByZ* para:
>
>    ```
>    def sphereByZ(inputPt,radiusRatio)
>    {
>    //get Z Value, use it to drive radius of sphere
>    sphereRadius=inputPt.Z/radiusRatio;
>    //Define Sphere Geometry
>    sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
>    //Define output for function
>    return sphere;
>    };
>    ```
> 2. Atualize o **Bloco de código** secundário adicionando uma variável de relação à entrada: `sphereByZ(Pt,ratio);` Conecte um controle deslizante à entrada do **Bloco de código** recém-criado e varie o tamanho dos raios com base na relação de raio.


---

# 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://primer2.dynamobim.org/pt-br/8_coding_in_dynamo/8-1_code-blocks-and-design-script/4-functions.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.
