Javascript (Português)

As funções são a base de basularidade em JavaScript. Eles são usados para reutilizar o código, ocultar informações e abstração. Como regra geral, as funções são usadas para especificar o comportamento dos objetos, embora as funções possam ser definidas fora dos objetos.

As funções em javascript são definidas pela palavra reservada function, seguido pelo nome da função. Sua definição formal é a seguinte:

Diagrama Definição de uma função

function nombre_funcion() { ...}

O nome da função é usado para chamar essa função quando necessário. O conceito é o mesmo que com as variáveis, que recebem um nome exclusivo para poder usá-los dentro do código. Após o nome da função, dois parênteses estão incluídos onde indicaremos os parâmetros da função. Finalmente, os símbolos { e são usados para incluir todas as instruções pertencentes à função.

7.1 Funções

As funções em javascript são objetos. As funções são objetos vinculados com Function.prototype (que por sua vez links com Object.prototype), que incluem duas propriedades ocultas: o contexto da função e O código que implementa seu comportamento.

Toda função no javascript é criada com uma propriedade protoype. Seu valor é um objeto com uma propriedade construtora cujo valor é a própria função. Isso é diferente do link oculto para Function.prototype. Vamos ver o significado desta construção complicada depois. Como funções são objetos, eles podem ser usados como qualquer outro valor. Eles podem ser armazenados em variáveis, objetos ou matrizes. Eles podem ser passados como argumentos para outras funções e podem ser devolvidos por outras funções. Além disso, sendo objetos, eles também podem ter métodos. O que os torna realmente especiais é que eles podem ser chamados.

7.2 Argumentos e valores de retorno

As funções mais simples não precisam de nenhuma informação para produzir seus resultados, embora a coisa normal é que eles precisam de dados para produzir resultados. As variáveis que as funções precisam são chamadas de argumentos. Antes de poder usá-los, a função deve indicar quantos argumentos você precisa e qual é o nome de cada argumento. Além disso, ao chamar a função, os valores (ou expressões) que serão passados para a função devem ser incluídos. Os argumentos são indicados dentro dos parênteses que vão por trás do nome da função e separam-se com uma vírgula (,).

var s = function suma_y_muestra(n1, n2) { ... }

Em seguida, para usar o valor dos argumentos dentro da função, o mesmo nome deve ser usado com o qual os argumentos foram definidos:

var s = function suma_y_muestra(n1, n2) { var resultado = n1 + n2; console.log("El resultado es " + resultado);}

dentro da função, o valor da variável n1 será igual ao primeiro valor que é passado para a função e valor de A variável n2 será igual ao segundo valor que é passado.

As funções não podem apenas receber variáveis e dados, mas também podem devolver os valores Eles calcularam. Para retornar valores dentro de uma função, a palavra reservada return é usada. Embora as funções possam retornar valores de qualquer tipo, eles só podem retornar um valor sempre que forem executados.

var c = function (precio) { var impuestos = 1.21; var gastosEnvio = 10; var precioTotal = ( precio * impuestos ) + gastosEnvio; return precioTotal;}

Para a função retornar um valor, é necessário gravar a palavra reservada return juntamente com o nome da variável que você deseja retornar. No exemplo anterior, a execução da função atinge a instrução return precioTotal; e nesse momento, retorna o valor que contém a variável precioTotal.

Como a função retorna um valor, no ponto em que a chamada é feita, o nome de uma variável é indicado no qual o valor retornado é salvo:

Se o nome de qualquer variável não for indicado, o JavaScript não mostrará nenhum erro e o valor retornado pela função simplesmente é perdido e, portanto, não será usado no resto de o programa. Se a função atingir uma instrução do tipo return, o valor indicado é retornado e a execução da função é retornada. Portanto, todas as instruções incluídas após um return são ignoradas e, por essa razão, a instrução return é geralmente a última das mais funções.

7.3 Chamadas

Chamando uma função suspende a execução da função atual, passando o controle e os parâmetros para a nova função.Além dos argumentos declarados, todas as funções recebem dois argumentos extras: e arguments. O parâmetro é muito importante, programação orientada a objetos, e seu valor é determinado pelo padrão de chamada usado. Existem quatro padrões de chamada em JavaScript: o padrão de chamada method, o padrão de chamada function, o padrão de chamada constructor e o padrão de chamada apply.

7.3.1 Argumentos

O parâmetro extra disponível nas funções é a matriz arguments. Ele fornece ao acesso à função a todos os argumentos transmitidos na chamada, incluindo os argumentos extras que não correspondem aos parâmetros definidos na função. Isso possibilita a gravação de funções que adotam um número indefinido de parâmetros.

var sum = function() { var i, sum = 0; for (i = 0; i < arguments.length; i += 1) { sum += arguments; } return sum;}; document.writeln(sum(4, 8, 15, 16, 23, 42)); // 108

devido a um problema de design,arguments não é realmente uma matriz, mas um objeto que se comporta como uma matriz. Ele tem a propriedade length, mas não inclui o restante dos métodos de matrizes.

7.4 AMONIMÁVEL Recursos AutoexCutable

Um padrão comum em Javascript são as funções anônimas auto-executáveis. Este padrão é criar uma expressão de função e executá-lo imediatamente.

(function(){ var foo = 'Hola mundo';})(); console.log(foo); // indefinido (undefined)

7.5 Funções como argumentos

No JavaScript, as funções podem ser atribuídas a variáveis ou passa a outras funções como argumentos. Em estruturas, por exemplo, por exemplo, passando funções como argumentos é uma prática muito comum.

var myFn = function(fn) { var result = fn(); console.log(result);}; myFn(function() { return 'hola mundo'; }); // muestra en la consola 'hola mundo' var myOtherFn = function() { return 'hola mundo';}; myFn(myOtherFn); // muestra en la consola 'hola mundo'

7.6 escopo

O escopo em uma linguagem de programação controla a visibilidade e o ciclo de vida das variáveis e parâmetros. Por exemplo:

var foo = function () { var a = 3, b = 5; var bar = function () { var b = 7, c = 11; // En este punto, a es 3, b es 7, y c es 11 a += b + c; // En este punto, a es 21, b es 7, y c es 11 }; // En este punto, a es 3, b es 5, y c es undefined bar(); // En este punto, a es 21, b es 5};

A maioria dos idiomas, com a sintaxe C, tenha um intervalo de blocos. Todas as variáveis definidas em um bloco (declarações definidas entre chaves) não são visíveis fora desse bloco. Infelizmente, o JavaScript não tem essa visibilidade de bloco, mesmo que sua sintaxe possa sugerir, e isso pode ser uma fonte de problemas. JavaScript tem um intervalo de funções: isso significa que os parâmetros e variáveis definidos em uma função não são visíveis fora dessa função, e que uma variável definida em qualquer lugar na função, é visível de qualquer lugar dentro dessa função.

7.7 Funções de fechamento

Boas notícias sobre a visibilidade, é que as funções internas podem acessar os parâmetros e variáveis das funções em que foram definidas (com exceção de this e arguments). Antes de definirmos um objeto que tivéssemos uma propriedade value e um increment. Suponha que desejemos proteger essas mudanças não autorizadas. Em vez de inicializar esse objeto como um literal, vamos inicializá-lo chamando uma função que retorna um objeto literal. Vamos definir uma variável value e um objeto de retorno com o increment e getValue

var myObject = (function () { var value = 0; return { increment: function (inc) { value += typeof inc === 'number' ? inc : 1; }, getValue: function () { return value; } };}());

Neste caso, tanto o método increment como getValue Tenha acesso à variável value, mas devido ao seu escopo de função, o restante do aplicativo não tem acesso ao seu valor.

7.8 Callbacks

As funções podem facilitar o trabalho com métodos assíncronos. Suponha o próximo caso em que fizemos uma petição para o servidor:

request = prepare_the_request();response = send_request_synchronously(request);display(response);

O problema aqui, é que estamos ansiosos para A resposta do servidor, portanto, bloqueamos a execução do script até obter uma resposta. Uma estratégia muito melhor é fazer uma chamada assíncrona, fornecendo uma função de resposta (callback) que será executada quando a resposta estiver disponível:

7.9 Execuções em cascade

Alguns métodos não retornam nenhum tipo de dados, basta modificar o status de algum tipo de dados. Se fizermos esses métodos retornarem this em vez de undefined, podemos encadear a execução desses métodos de cascata. As funções da cachoeira podem nos permitir escrever declarações deste tipo:

getElement('myBoxDiv') .move(350, 150) .width(100) .height(100) .color('red') .border('10px outset') .padding('4px') .appendText("Please stand by") .on('mousedown', function (m) { this.startDrag(m, this.getNinth(m)); }) .on('mousemove', 'drag') .on('mouseup', 'stopDrag') .tip('This box is resizeable');

exercício 6

ver enunciação

Ver declaração

exercício 8

ver enunciação

Exercício 9

Examinha

exercício 10

ver enunciação

Deixe uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *