JavaScript (Galego)

As funcións son a base de basularidade en JavaScript. Utilízanse para reutilizar o código, ocultar información e abstracción. Como regra xeral, as funcións úsanse para especificar o comportamento dos obxectos, aínda que as funcións poden definirse fóra dos obxectos.

As funcións en JavaScript están definidas pola palabra reservada function seguido do nome da función. A súa definición formal é a seguinte:

Diagrama Definición dunha función

Diagrama de definición do Corpo dunha función

function nombre_funcion() { ...}

O nome da función úsase para chamar a función cando sexa necesario. O concepto é o mesmo que coas variables, que son asignadas un nome único para poder usalos dentro do código. Despois do nome da función, inclúense dous parénteses onde indicaremos os parámetros da función. Finalmente, os símbolos { e úsanse para incluír todas as instrucións que pertencen á función.

7.1 obxecto Funcións

As funcións en JavaScript son obxectos. As funcións son obxectos ligados con Function.prototype (que á súa vez ligan con Object.prototype), que inclúe dúas propiedades ocultas: o contexto da función e O código que implementa o seu comportamento.

Cada función en JavaScript créase cunha propiedade protoype. O seu valor é un obxecto cunha propiedade de constructor cuxo valor é a propia función. Isto é diferente da ligazón oculta a Function.prototype. Veremos o significado desta complicada construción máis tarde. Como funcións son obxectos, poden usarse como calquera outro valor. Pódense almacenar en variables, obxectos ou matrices. Pódense pasar como argumentos a outras funcións e poden ser devoltas por outras funcións. Ademais, sendo obxectos, tamén poden ter métodos. O que os fai realmente especiais é que se poden chamar.

7.2 Argumentos e valores de retorno

As funcións máis sinxelas non necesitan ningunha información para producir os seus resultados, aínda que o normal É que precisan datos para producir resultados. As variables que necesitan as funcións son chamadas argumentos. Antes de poder usalos, a función debería indicar cantos argumentos necesita e cal é o nome de cada argumento. Ademais, ao chamar a función, deberían incluírse os valores (ou expresións) que se transmitirán á función. Os argumentos están indicados dentro dos parénteses que van detrás do nome da función e separados cunha coma (,).

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

Seguinte, para usar o valor dos argumentos dentro da función, debe utilizarse o mesmo nome co que se definiron os argumentos: “

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

Dentro da función, o valor da variable n1 será igual ao primeiro valor que se transmite á función e ao valor de A variable n2 será igual ao segundo valor que se aproba.

As funcións non só poden recibir variables e datos, senón que tamén poden devolver os valores Calcularon. Para devolver valores dentro dunha función, úsase a palabra reservada return. Aínda que as funcións poden devolver valores de calquera tipo, só poden devolver un valor cada vez que se executan.

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

Para a función devolve un valor, só é necesario escribir a palabra reservada return xunto co nome da variable que quere devolver. No exemplo anterior, a execución da función alcanza a instrución e nese momento, devolve o valor que contén a variable precioTotal.

Como a función devolve un valor, no punto de que se realice a chamada, indícase o nome dunha variable na que se garda o valor devolto:

Se o nome de calquera variable non está indicado, JavaScript non mostra ningún erro e o valor devolto pola función simplemente está perdido e, polo tanto, non se usará no resto de O programa. Se a función alcanza unha instrución do tipo return, devolve o valor indicado e devolveuse a execución da función. Polo tanto, todas as instrucións que se inclúen despois dun return son ignoradas e por iso a instrución return adoita ser a última das funcións máis.

7.3 chamadas

Chamando a unha función suspender a execución da función actual, pasando o control e os parámetros á nova función.Ademais dos argumentos declarados, todas as funcións reciben dous argumentos extra: this e arguments. O parámetro this é moi importante, a programación orientada a obxectos e o seu valor está determinado polo patrón de chamadas usado. Hai catro patróns de chamadas en JavaScript: o patrón de chamadas method, o patrón de chamadas function, o patrón de chamada constructor e o patrón de chamadas apply

7.3.1 argumentos

O parámetro extra dispoñible nas funcións é a matriz arguments. Dá o acceso á función a todos os argumentos que pasan a chamada, incluídos os argumentos extra que non coinciden cos parámetros definidos na función. Isto fai posible escribir funcións que tomen un 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

Debido a un problema de deseño arguments non é realmente unha matriz, senón un obxecto que se comporta como unha matriz. Ten a propiedade length, pero non inclúe o resto dos métodos de arrays.

7.4 características amonimável autoexcutable

un patrón común en JavaScript son as funcións anónimas de auto-executables. Este patrón é crear unha expresión de función e executala de inmediato.

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

7.5 Funcións como argumentos

En JavaScript, as funcións poden ser asignadas a variables ou pases a outras funcións como argumentos. En frameworks como jQuery, por exemplo, pasar as funcións como argumentos é unha práctica moi común.

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 alcance

O ámbito nunha linguaxe de programación controla a visibilidade e o ciclo de vida das variables e os parámetros. Por exemplo:

A maioría dos idiomas, con sintaxe C, ten un rango de bloque. Todas as variables definidas nun bloque (declaracións definidas entre chaves) non son visibles fóra do bloque. Desafortunadamente, JavaScript non ten esa visibilidade de bloque, aínda que a súa sintaxe pode suxerirlle, e isto pode ser unha fonte de problemas. JavaScript ten un intervalo de funcións: isto significa que os parámetros e variables definidas dentro dunha función non son visibles fóra desta función e que unha variable definida en calquera lugar da función, é visible desde calquera parte dentro da función.

7.7 Funcións de peche

Boas novas sobre a visibilidade, é que as funcións internas poden acceder aos parámetros e as variables das funcións onde foron definidas (con excepción de this e arguments). Antes de definir un obxecto que tiña unha propiedade value e un increment. Supoña que queremos protexer ese valor cambios non autorizados. No canto de inicializar ese obxecto como literal, inicializalo chamando a unha función que devolva un obxecto literal. Definiremos unha variable value e un obxecto de retorno co 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 ten acceso á variable value, pero debido ao seu alcance de función, o resto da aplicación non ten acceso ao seu valor.

7.8 As funcións de chamadas

poden facilitar o traballo con métodos asíncronos. Supoña que o seguinte caso no que facemos unha petición ao servidor:

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

O problema aquí é que esperamos con ansia A resposta do servidor, polo que bloqueamos a execución do script ata obter unha resposta. Unha estratexia moito mellor é facer unha chamada asíncrona, proporcionando unha función de resposta (callback) que se executará cando a resposta estea dispoñible:

request = prepare_the_request();send_request_asynchronously(request, function (response) { display(response);});

7.9 Executions cascade

Algúns métodos non devolven ningún tipo de datos, pode simplemente modificar o estado de algún tipo de datos. Se facemos estes métodos devolve this no canto de undefined, podemos encadenar a execución destes métodos de fervenza. As funcións de fervenza poden permitirnos escribir declaracións 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');

Exercicio 6

Ver Enunciación

Exercicio 7

Declaración de ver

Exercicio 8

Ver Enunciación

Exercicio 9

Ver declaración

Exercicio 10

Ver Enunciación

Deixa unha resposta

O teu enderezo electrónico non se publicará Os campos obrigatorios están marcados con *