Grupo de estudos @asdevs

Fellyph Cintra 

@fellyph 

http://www.fellyph.com.br/blog/tutoriais

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.

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")   

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

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")

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

Exemplo

var alertaTraceEx:Function = new function(meuParam:String){    trace("alerta trace :", meuParam)}

alertaTraceEx("Olá mundo[2] !!")

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."

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çãoVamos ao exemplo... 

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

Exemplo 2

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

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

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);}

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    }

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

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.

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.

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

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

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

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.

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

Exemplo arguments.callee

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

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