Fonte do autor: https://ost.51cto.com/user/posts/16066420
declaração
As funções na programação JavaScript são um ponto muito interessante. As funções JavaScript são muito diferentes de outras linguagens como C e Java. Para alunos que transferem de outras linguagens de programação, pode haver certas "armadilhas", como a diferença entre função função e => função. A ocupação da função função esta palavra-chave, etc.
Esse conhecimento pode ser usado nos casos a seguir, mas não discutirei essas gramáticas por limitações de espaço, apenas discutirei as questões de estilo de diferentes métodos de codificação.
Declaração de ambiente de teste
Ferramenta de teste: DevEco Studio 3.1.1 Release Versão de compilação: 3.1.0.501
Plataforma de teste: máquina virtual HarmonyOS Api9 x86
Idioma de teste: ArkTS (testar apenas parte da gramática JavaScript)
Introdução
Devido à flexibilidade do estilo de programação JavaScript. Uma função de soma simples pode ser expressa em vários estilos diferentes em JavaScript.
O editor irá expressá-lo de muitas maneiras diferentes, como programação funcional, programação orientada a objetos, programação em cadeia orientada a objetos e programação declarativa.
O código a seguir é apenas para o efeito de jogar um tijolo e atrair jade, e não representa o código de desenvolvimento real, nem representa todos os estilos de codificação atuais. Eu apenas falo sobre alguns que conheço. No processo de desenvolvimento real, cada estilo de codificação também terá estilos mais subdivididos.
programação processual
o código
// 过程式编程
function add(...is: number[]) {
// 总和
let sum = 0;
// 求和
for (let index = 0; index < is.length; index++)
sum += is[index];
// 返回总和
return sum;
}
/**
* 使用样例
* console.log(add(11, 22, 33));
*/
interpretar
A programação procedural é o método de programação mais simples, bruto e direto, e a programação procedural é suportada em todas as linguagens de programação convencionais.
A programação procedural geralmente exige que os programadores tenham excelente conhecimento em programação e um profundo conhecimento do negócio para garantir a capacidade de manutenção contínua e a escalabilidade do código.
Não é recomendado usar esse estilo de codificação em partes onde o negócio é incerto, a lógica de implementação muda com frequência e a solução de implementação é instável, porque pode facilmente fazer com que o código fique fora de controle.
No entanto, em termos de implementação de algoritmo, o autor recomenda fortemente que você use esse estilo de codificação. É simples, confiável e economiza muito cérebro do programador.
programação ao curry
o código
// 自动柯里化机，可以自动把函数转化为柯里化风格。
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
} else {
return function (...nextArgs) {
return curried.apply(this, args.concat(nextArgs));
}
}
}
}
// 获得转化后的函数
export const curriedAdd = curry(add2);
/**
* 使用样例
* console.log(curriedAdd(1)(2)); // 3
* console.log(curriedAdd(1, 2)); // 3
* console.log(curriedAdd(1)(2, 3)); // 3
*/
interpretar
Uma característica distintiva da programação curried é o aninhamento contínuo de funções, que é um método de programação muito popular para desenvolvimento front-end. No entanto, o editor se opõe veementemente a esse método de programação pelos seguintes motivos:
- Embora a programação curry melhore a flexibilidade do desenvolvimento, ela também reduz a capacidade de modificação das funções, o que pode afetar todo o corpo em refatorações subsequentes.
- Uma grande característica do currying é o aninhamento de funções, que não está em conformidade com a filosofia de programação "nunca nester". O aninhamento pode reduzir drasticamente a legibilidade.
Se você realmente pretende usar o estilo de programação curried. O editor recomenda que você escreva um comentário completo! ! !
Continuo escrevendo até não precisar ler sua função para saber o que sua função quer fazer, quantos parâmetros ela tem, o que ela quer retornar e em que circunstâncias ela terminará o currying. .
Funções de Estilo de Programação Orientada a Objetos
o código
// 面向对象风格函数
export function count() {
// 总和属性
this._sum = 0;
// 添加方法方法
this.add = (i) => this._sum += i;
// 返回总和方法
this.get = () => this._sum;
// 返回构造对象
return this;
}
/*
// 使用样例
* a = count();
* console.log(a.add(10));
* console.log(a.add(20));
* a.add(30);
* console.log(a.get());
*/
interpretar
Comparado com a programação em cadeia mencionada abaixo, um estilo orientado a objetos mais ortodoxo. O resultado de cada operação é claro e o tipo é claro.Com a ajuda de modernas ferramentas de programação, a eficiência da programação é muito alta.
Função de estilo orientado a objetos, programação em cadeia
o código
//面向对象链式编程风格
// 构造函数
export function count2() {
// 总和属性
this._sum = 0;
// 添加方法
this.add = (is) => ((this._sum += is), this);
// 求和方法
this.get = () => this._sum
// 返回构造对象
return this;
}
/*使用样例
console.log(count().add(10).add(20).add(30).get());
*/
interpretar
A razão pela qual eu a separo da orientação a objetos é porque a programação em estilo de cadeia orientada a objetos pode basicamente substituir a programação curry.
Comparado com o currying, esse estilo de programação é mais plano, mais legível e possui certa escalabilidade.
Então, por que usar curry quando você pode escolher?
Funções de estilo declarativo
o código
// 声明式风格函数
export function sum3(is, get) {
let ans = 0;
// 这里可以使用任何实现方式，可以使用异步等方式实现
is.forEach(element => {
ans += element;
});
// 无论用任何方式实现，最后所有运算结束后都使用get函数作为回调。
get(ans)
}
interpretar
A característica de uma função de estilo declarativo não é a aparência de seu código, mas quais parâmetros ela fornece para os desenvolvedores chamarem. Os desenvolvedores não se importam mais com a ordem de implementação, como implementar, porque como implementar não é nada importante e a ordem de implementação não é importante. Tudo o que você quer são respostas e obter respostas. A implementação pode ser implementada de qualquer maneira e pode ser implementada internamente usando métodos multithread, assíncronos ou outros.
Resumir
A evolução dos estilos de codificação modernos nada mais é do que uma mudança de foco à medida que os problemas que precisam ser resolvidos mudam. Para mudar a atenção dos desenvolvedores, deixe-os colocar mais energia em seus próprios negócios. Não é que quanto mais avançado for o estilo de codificação, mais fácil de usar. O mais importante é escolher o estilo de codificação certo no lugar certo.
Extensão relacionada - desenvolvimento de código baixo
O desenvolvimento low-code é uma tendência que tem recebido muita atenção no campo de desenvolvimento web nos últimos anos. O desenvolvimento de baixo código refere-se ao desenvolvimento de aplicativos ou lógica de negócios usando códigos de programação mínimos, o que permite que até mesmo iniciantes sem experiência em TI ou programação criem rapidamente a funcionalidade necessária.
Embora o desenvolvimento de código baixo ainda não tenha ameaçado o papel dos desenvolvedores tradicionais, não há como negar que a tendência está se movendo em direção ao desenvolvimento de código baixo (ou sem código). Segundo previsão da empresa de pesquisa americana Gartner, até 2024, cerca de 65% dos projetos de desenvolvimento de aplicativos serão desenvolvidos por meio de plataformas low-code. Essa tendência não pode ser ignorada pelos desenvolvedores, e espera-se que a forma como os desenvolvedores trabalham mude gradualmente nos próximos anos.
Nos últimos anos, encontrei vagamente o código baixo, e é relativamente popular no momento, e muitos fabricantes importantes se juntaram um após o outro.
O que é low-code, na minha opinião, é arrastar, zumbir e operação de uma passagem para criar um sistema que pode executar, front-end, back-end e banco de dados, tudo de uma vez. Claro que isso pode ser o objetivo final.
Link: www.jnpfsoft.com/?csdn , se você estiver interessado, experimente também.
A vantagem do JNPF é que ele pode gerar códigos front-end e back-end, o que proporciona grande flexibilidade e pode criar aplicações mais complexas e customizadas. Seu design arquitetônico também permite que os desenvolvedores se concentrem no desenvolvimento da lógica do aplicativo e na experiência do usuário sem se preocupar com os detalhes técnicos subjacentes.