introduzir
Este artigo apresenta principalmente algumas técnicas usadas na função (parte 1). Usando os recursos da função, você pode escrever muito código muito interessante. Este artigo inclui principalmente: modo de retorno de chamada, objeto de configuração, função de retorno, programa de distribuição e currying.
Função de retorno de chamada
No JavaScript, quando uma função A é um dos parâmetros de outra função B, a função A é chamada de função de retorno de chamada, ou seja, a pode ser executado dentro do período da função B (iniciantes, intermediários e finais).
Por exemplo, há uma função que gera nós
A cópia do código é a seguinte:
var complexcomputation = function () { /* manipula internamente e retorne um nó* /};
Há uma declaração de função findnodes para encontrar todos os nós e, em seguida, executar o código através do retorno de chamada.
A cópia do código é a seguinte:
var findNodes = function (retorno de chamada) {
var nós = [];
var node = complexcomputation ();
// Se a função de retorno de chamada estiver disponível, execute -a
if (typeof de retorno de chamada === "function") {
retorno de chamada (nó);
}
nós.push (nó);
nós de retorno;
};
Em relação à definição de retorno de chamada, podemos defini -lo com antecedência para usar:
A cópia do código é a seguinte:
// Defina retorno de chamada
var hide = function (nó) {
node.style.display = "nenhum";
};
// Encontre nós e oculte todos os nós
var hiddennodes = findNodes (oculto);
Você também pode usar definições anônimas diretamente ao ligar, como segue:
A cópia do código é a seguinte:
// Use funções anônimas para definir o retorno de chamada
var blockNodes = findNodes (function (nó) {
node.style.display = 'bloco';
});
Os mais usados são provavelmente as chamadas para o método Ajax da JQuery. Ao definir o retorno de chamada em Done/Faild, podemos processar ainda mais quando a chamada do Ajax for bem -sucedida ou falhar. O código é o seguinte (este código é baseado no jQuery versão 1.8):
A cópia do código é a seguinte:
var menuID = $ ("ul.nav"). primeiro (). att ("id");
var request = $ .ajax ({
url: "script.php",
Tipo: "post",
Dados: {id: menuId},
Datatype: "html"
});
// processamento de retorno de chamada quando a chamada é bem -sucedida
request.done (função (msg) {
$ ("#log"). html (msg);
});
// processamento de retorno de chamada quando a chamada falha
request.fail (função (jqxhr, textstatus) {
alerta ("Solicitação falhou:" + textStatus);
});
Objetos de configuração
Se o parâmetro de uma função (ou método) tiver apenas um parâmetro e o parâmetro for um objeto literal, chamamos esse padrão de padrão de objeto de configuração. Por exemplo, o seguinte código:
A cópia do código é a seguinte:
var conf = {
Nome de usuário: "Shichuan",
Primeiro: "Chuan",
último: "shi"
};
addPerson (conf);
Além disso, você pode usar o valor de conf at Will, que geralmente é usado para o trabalho de inicialização. Por exemplo, o AjaxSetup no jQuery é implementado dessa maneira:
A cópia do código é a seguinte:
// Defina o valor inicial com antecedência
$ .ajaxsetup ({
url: "/xmlhttp/",
Global: Falso,
Tipo: "Post"
});
// então ligue novamente
$ .ajax ({data: myData});
Além disso, muitos plug-ins jQuery também têm essa forma de transmissão de parâmetros, mas também não podem ser transmitidos. Quando eles não passam, o valor padrão será usado.
Função de retorno
Retornar uma função refere -se a uma nova função criada com flexibilidade com base em condições específicas quando o valor de retorno de uma função é outra função ou uma nova função é criada de maneira flexível de acordo com condições específicas. O código de exemplo é o seguinte:
A cópia do código é a seguinte:
var setup = function () {
console.log (1);
Return function () {
console.log (2);
};
};
// Ligue para a função de configuração
var my = setup (); // Saída 1
meu(); // Saída 2
// ou você também pode chamá -lo diretamente
configurar()()();
Ou você pode usar o recurso de fechamento para gravar um número de contador privado na função de configuração e aumentar o contador em cada chamada. O código é o seguinte:
A cópia do código é a seguinte:
var setup = function () {
var count = 0;
Return function () {
retornar ++ contagem;
};
};
// Uso
var next = setup ();
próximo(); // retorna 1
próximo(); // retorna 2
próximo(); // retorna 3
Aplicável
O aplicativo parcial aqui é realmente separar os parâmetros recebidos. Às vezes, uma série de operações pode ter um ou vários parâmetros sempre iguais. Em seguida, podemos definir uma função parcial primeiro e depois executar essa função (os parâmetros diferentes restantes são transmitidos durante a execução).
Por exemplo, o código é o seguinte:
A cópia do código é a seguinte:
var parcialany = (função (APS) {
// Esta função é o resultado de sua própria execução da expressão da função e é atribuída à variável parcialy
função func (fn) {
var argsorig = aps.call (argumentos, 1);
Return function () {
var args = [],
argspartial = aps.call (argumentos),
i = 0;
// Todos os conjuntos de parâmetros originais de variáveis,
// Se o parâmetro for parcial
// caso contrário, use o valor no parâmetro original
para (; i <argsorig.length; i ++) {
args [i] = argsorig [i] === func._
? argspartial.shift ()
: argsorig [i];
}
// Se houver parâmetros extras, adicione ao fim
return fn.apply (this, args.concat (argspartial));
};
}
// para configurações de espaço reservado
func._ = {};
retornar func;
}) (Array.prototype.slice);
Como usá -lo é o seguinte:
A cópia do código é a seguinte:
// Defina funções de processamento
função hexadecimal (r, g, b) {
retornar '#' + r + g + b;
}
// Defina a função parcial, pegue o primeiro parâmetro r de hexadecimal como o valor do parâmetro inalterado ff
var Redmax = parcialany (hexadecimal, 'ff', parcialany._, parcialany._);
// O método de chamada da nova função Redmax é o seguinte, e apenas 2 parâmetros são necessários:
console.log (Redmax ('11 ',' 22 ')); // "#ff1122"
Se você acha que parcialy._ é muito longo, você pode usar __.
A cópia do código é a seguinte:
var __ = parcialany._;
var GreenMax = parcialany (hexadecimal, __, 'ff');
console.log (Greenmax ('33 ',' 44 '));
var bluemax = parcialany (hexadecimal, __, __, 'ff');
console.log (Bluemax ('55 ',' 66 '));
var magentamax = parcialany (hexadecimal, 'ff', __, 'ff');
console.log (Magentamax ('77 '));
Dessa forma, será muito mais simples.
Currying
A curry é uma característica da programação funcional, convertendo o processamento de vários parâmetros no processamento de parâmetros únicos, semelhante às chamadas de cadeia.
Vamos dar um exemplo simples de Add Função:
A cópia do código é a seguinte:
função add (x, y) {
var Oldx = x, Oldy = y;
if (typeof Oldy === "indefinido") {// parcial
Função de retorno (Newy) {
Retornar Oldx + Newy;
}
}
retornar x + y;
}
Dessa forma, existem muitas maneiras de ligar, como:
A cópia do código é a seguinte:
// teste
tipo de add (5); // "função"
add (3) (4); // 7
// Isso também é possível
var add2000 = add (2000);
add2000 (10); // 2010
Em seguida, vamos definir uma função de curry mais geral:
A cópia do código é a seguinte:
// O primeiro parâmetro é a função a ser aplicada e o segundo parâmetro é o número mínimo de parâmetros a serem passados
função curry (func, minargs) {
if (minargs == indefinido) {
minargs = 1;
}
função funcwithargsfrozen (Frozenargs) {
Return function () {
// Processamento de otimização, se não houver parâmetros ao ligar, retorne a própria função
var args = array.prototype.slice.call (argumentos);
var newargs = Frozenargs.concat (args);
if (newargs.length> = minargs) {
retornar func.apply (isto, newargs);
} outro {
retornar funcwithargsfrozen (newargs);
}
};
}
retornar funcwithargsfrozen ([]);
}
Dessa forma, podemos definir nosso comportamento comercial à vontade, como definir adição:
A cópia do código é a seguinte:
var plus = curry (function () {
var resultado = 0;
for (var i = 0; i <argumentos.length; ++ i) {
resultado += argumentos [i];
}
resultado de retorno;
}, 2);
Como usá -lo é real e variado.
A cópia do código é a seguinte:
mais (3, 2) // chamada normal
mais (3) // Aplicar, retornar uma função (o valor de retorno é de 3+ parâmetro valor)
mais (3) (2) // Aplicativo completo (retorno a 5)
Plus () (3) () () (2) // retorna 5
mais (3, 2, 4, 5) // pode receber vários parâmetros
mais (3) (2, 3, 5) // da mesma forma
O seguinte é um exemplo de subtração
A cópia do código é a seguinte:
var menos = curry (função (x) {
var resultado = x;
for (var i = 1; i <argumentos.length; ++ i) {
resultado -= argumentos [i];
}
resultado de retorno;
}, 2);
Ou se você quiser trocar a ordem dos parâmetros, pode defini -lo assim
A cópia do código é a seguinte:
var flip = curry (função (func) {
Return Curry (função (a, b) {
retornar func (b, a);
}, 2);
});
Resumir
As funções no JavaScript têm muitas funções especiais e podem usar características de parâmetros de fechamento e argumentos para implementar muitas técnicas diferentes. No próximo artigo, continuaremos a introduzir as técnicas de uso da função para inicialização.