6.5 KiB
title | localeTitle |
---|---|
Algoritmo De Argumentos Opcionales | Algoritmo de Argumentos Opcionais |
Explicação:
Pode ser um pouco complicado entender o que deve ser feito. Quando nós programamos, existem maneiras diferentes de fazer alguma coisa. Independentemente do algoritmo usado, precisamos criar uma função que faça o seguinte:
- Você tem que adicionar dois números recebidos como parâmetros e retornar o resultado.
- Você tem que verificar se ambos os números são realmente números, caso contrário, retorne indefinido e pare a função no momento.
- Você precisa verificar se os argumentos recebidos são um ou dois. Se houver mais, eles devem ser ignorados.
- Se apenas um argumento for recebido, uma função que aceita outro argumento deve ser retornada e, em seguida, a adição deve ser feita.
Dica: 1
Toda vez que você trabalha um argumento, você deve verificar se é realmente um número ou não. Para evitar a repetição do código, você deve criar uma função que lide com essa tarefa.
Dica: 2
Quando for necessário retornar a função, é aconselhável verificar se o primeiro e único argumento é um novo número e basear o código nele.
Dica: 3
No caso de apenas um argumento ser recebido, não se preocupe em como solicitar o segundo, simplesmente faça a definição da função corretamente e tudo funcionará como deveria.
Alerta de spoiler!
Solução abaixo!
Solução de código:
function addTogether() {
// Función para comprobar si un número es realmente un número
// y retornar undefined en caso contrario.
var checkNum = function(num) {
if (typeof num !== 'number') {
return undefined;
} else
return num;
};
// Comprobar si tenemos dos parámetros y si ambos son números
// En caso que no lo sean retornamos undefined
// retornamos la suma
if (arguments.length > 1) {
var a = checkNum(arguments[0]);
var b = checkNum(arguments[1]);
if (a === undefined || b === undefined) {
return undefined;
} else {
return a + b;
}
} else {
// Si solo es encontrado un parámetro retornamos una nueva función para solicitar un segundo parámetro
// Guardamos el primer argumento antes de entrar al scope de la nueva función
var c = arguments[0];
// Comprobamos que sea número de nuevo, debe ser fuera del objeto que retornaremos
// en lugar de undefined.
if (checkNum(c)) {
// // Retornamos la función que espera el segundo parámetro.
return function(arg2) {
// Comprobamos que no sean números.
if (c === undefined || checkNum(arg2) === undefined) {
return undefined;
} else {
// Si lo son, sumamos.
return c + arg2;
}
};
}
}
}
// realizamos el test
addTogether(2,3);
Explicação do código:
- Primeiro, criamos uma função com o único propósito de verificar se um número é realmente um número e retornamos indefinidos, se não for. Use typeof para verificar.
- Verificamos se temos dois parâmetros, se tivermos, verificamos se são números ou não usando a função checkNum .
- Se os parâmetros não forem indefinidos, nós os adicionamos e retornamos a soma. Se um deles é indefinido, retornamos indefinidos.
- No caso de termos apenas um argumento, retornamos uma nova função que espera dois parâmetros. Para isso, armazenamos o segundo parâmetro antes de inserir a função para evitar sobrescrever o argumento.
- Mesmo dentro do primeiro , precisamos verificar se o argumento salvo é um número, se for, retornaremos a função esperando pelo segundo argumento.
- Agora dentro da função que vamos retornar, temos que verificar se o novo parâmetro é um número usando checkNum , se ele estiver indefinido, retornaremos isso e, caso contrário, adicionaremos os números e retornamos o resultado.
Segunda solução:
function addTogether() {
var args = new Array(arguments.length);
// Almacenamos los argumentos en un array.
for(var i = 0; i < args.length; ++i) {
args[i] = arguments[i];
}
// Comprobamos la cantidad de argumentos.
if(args.length == 2){
// Si hay dos argumentos, comprobamos el tipo de ambos
// Utiliza typeof para comprobar el tipo de argumentos. (ambos deben ser números)
if(typeof args[0] !== 'number' || typeof args[1] !=='number' ){
return undefined;
}
return args[0]+args[1];
}
// Cuando solo un argumento es provisto.
if(args.length == 1){
a = args[0];
// Comprobamos el tipo utilizando typeof.
if(typeof a!=='number'){
return undefined;
}
else{
// Hacemos uso de las funciones internas.
return function(b){
// Comprobamos el segundo parámetro.
if(typeof b !=='number'){
return undefined;
}
else
return a+b;
};
}
}
}
// realizamos el test
addTogether(2,3);
Terceira solução:
//jshint esversion: 6
function addTogether() {
var args = Array.from(arguments);
return args.some(n => typeof n !== 'number') ?
undefined:
args.length > 1 ?
args.reduce((acc, n) => acc += n, 0):
(n) => typeof n === "number" ?
n + args[0]:
undefined;
}
// realizamos el test
addTogether(2,3);
Explicação do código:
- Primeiro nós iteramos os argumentos e verificamos que são números e, se não forem, retornamos indefinidos.
- Então nós verificamos se a quantidade de argumentos é maior que 1, se é que adicionamos os argumentos usando
Array.prototype.reduce
- Caso contrário, retornamos uma função que verifica se o parâmetro recebido é um número e o adiciona, se não retornarmos indefinidos.
NOTA: Por favor, adicione seu nome de usuário somente se você adicionou conteúdo relevante ao artigo. (Por favor, não remova nenhum nome existente.)