# 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="" %} 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.