Funções são blocos de código reutilizáveis que podem receber parâmetros e retornar valores. Existem duas formas de criar funções: instrução de função e expressão de função. Instrução de função é a forma mais comum e legível, enquanto expressão de função é útil para comportamentos dinâmicos. Dentro das funções, parâmetros podem ser passados por valor ou referência e o objeto arguments fornece informações sobre os parâmetros passados.

1. Grupo de estudos @asdevs Fellyph Cintra @fellyph http://www.fellyph.com.br/blog/tutoriais

2. Funções São uma sequência de ações que podem ser reutilizada em seu código. As funções também são conhecidas como métodos ou comportamentos quando fazem parte de uma classe.

3. Trabalhando com funções Uma chamada de uma função é identificada por seu nome e um parênteses "( )" sem aspas . Dentro dos parênteses informamos os parâmetros que a função vai receber. Por exemplo a função trace() nativa do Flash ela recebe uma String como parâmetro. como no exemplo abaixo : trace("aqui vai o texto que será exibido no output do Flash")

4. Trabalhando com funções Outro exemplo de uso de funções é a função método random() da classe Math. var numeroRandomico:Number = Math.random() Neste caso o método não recebe nenhum paramêtro As funções podem receber nenhum , um ou N parâmetros isso é definido na assinatura da função Existem duas formas de construir uma função

5. Instrução de função (Function statement ) Modo mais convencional de construir funções: Palavra chave function Nome da função Parâmetros Corpo da função function alertaTrace(meuParam:String) { trace("alerta Trace :" , meuParam) } alertaTrace("Olá mundo")

6. Expressões de função (Function expression) A segunda forma de construir uma função(como variável) é dessa maneira: palavra-chave var nome da função operador (:) A classe Function inidicando o tipo da variável atribuição (=) palavra-chave function e parâmetros

7. Exemplo var alertaTraceEx:Function = new function(meuParam:String) { trace("alerta trace :", meuParam) } alertaTraceEx("Olá mundo[2] !!")

8. Instrução de Função x Expressão de Função Filosofia : "Uma expressão de função não é suficiente como uma instrução de função. Ela só pode ser usada como parte de uma instrução, em geral, de atribuição."

9. O uso Prefira instrução de função seu uso é mais legível e deixa o código menos confuso. Expressão de funções são aconcelhaveis para a programação direcionada a comportamento dinâmico. Em outras palavras, quando você atribui uma uma expressão de função a um objeto ele cria uma referência única. Se a função anexada sair do escopo ou não estiver disponível, não será mais possível acessar a expressão de função Vamos ao exemplo...

10. Exemplo dynamic class Test {} var myTest:Test = new Test(); // function expression myTest.functionExp = function () { trace("Function expression") }; myTest.functionExp(); // expressão de função delete myTest.functionExp; myTest.functionExp(); // error //O operador delete funciona apenas em propriedades de objetos

11. Exemplo 2 dynamic class Test {} var myTest:Test = new Test(); // function statement function stateFunc() { trace("Function statement") } myTest.statement = stateFunc; myTest.statement(); // Function statement d delete myTest.statement; delete stateFunc; // no effect stateFunc(); // instução de função myTest.statement(); // error

12. Exemplo 3 statementTest(); // statementTest function statementTest():void { trace("statementTest"); } expressionTest(); // run-time error var expressionTest:Function = function () { trace("expressionTest"); } //As expressões de função não estão disponíveis antes de serem definidas

13. Retornando valores Para retornar valores definimos o tipo que a função irá retornar na assinatura da função: function minhaFuncao():int{ ... Em seguida usamos a instrução return com a variável que iremos passar ou o valor literal. function doubleNum(baseNum:int):int { return (baseNum * 2); }

14. Observação A instrução return encerra a função, de forma que as instruções abaixo de uma instrução return não são executadas, como a seguir: function doubleNum(baseNum:int):int { return (baseNum * 2); trace("after return"); // essa linha não é executada }

15. Funções aninhadas function getNameAndVersion():String { function getVersion():String { return "10"; } function getProductName():String { return "Flash Player"; return (getProductName() + " " + getVersion()); } } trace(getNameAndVersion()); // Flash Player 10

16. Parâmetros de função Trabalhando com paramêtros de função temos a possibilidade de passar os parâmetros por valor ou referência. Paramêtros passados por valor significa que o argumento é em uma variável local para o uso interno da função. Ser passado como referência significa é passado uma referência à variável transmitida.

17. Parâmetros de função No ActionScript 3.0, todos os argumentos são transmitidos por referência. Porque todos os valores são armazenados como objetos. Entretanto, os tipos de dados primitivos, que incluem Boolean, Number, int, uint e String, têm operadores especiais que fazem com que se comportem como se fossem transmitidos por valor.

18. Exemplo 1 function testePrimitivos(xParam:int, yParam:int):void { xParam++; yParam++; trace(xParam, yParam); } var xValue:int = 10; var yValue:int = 15; trace(xValue, yValue); // 10 15 testePrimitivos(xValue, yValue); // 11 16 trace(xValue, yValue);// 10 15

19. Exemplo 2 function passByRef(objParam:Object):void { objParam.x++; objParam.y++; trace(objParam.x, objParam.y); } var objVar:Object = {x:10, y:15}; trace(objVar.x, objVar.y); // 10 15 passByRef(objVar); // 11 16 trace(objVar.x, objVar.y); // 11 16

20. Valores de parâmetro padrão function defaultValues(x:int, y:int = 3, z:int = 5):void { trace(x, y, z); } defaultValues(1); // 1 3 5

21. Objeto arguments Quando a função recebe parâmetros é possivel acessar o objeto arguments que contém informações sobre os parâmetros. arguments.length contém o número de parâmetros transmitidos. arguments.calle fornece referência a função, útil para fazer chamadas recursivas.

22. Exemplo arguments.length function traceArgArray(x:int,y:int, z:int ):void { for (var i:uint = 0; i < arguments.length; i++) { trace(arguments[i]); } } traceArgArray(1, 2, 3); // output: // 1 // 2 // 3

23. Exemplo arguments.callee var fatorial:Function = function (x:uint) { if(x == 0) { return 1; } else { trace(&quot;x :&quot; , x) return (x * arguments.callee(x - 1)); } } trace(&quot;fatorial :&quot;, fatorial(5)); // fatorial : 120

24. O parâmetro ... (rest) Permite passar uma grande quantidade de parâmetros separados por virgula. function traceArgArray(... args):void { for (var i:uint = 0; i < args.length; i++) { trace(args[i]); } } traceArgArray(1, 2, 3); //1 //2 //3