Upload
fellyph-cintra
View
702
Download
1
Embed Size (px)
DESCRIPTION
Quarta aula do grupo de estudos do ASDEVS, sobre funções com @fellyph
Citation preview
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