@designliquido/delegua
Version:
Linguagem de programação simples e moderna usando português estruturado.
139 lines • 5.03 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = {
adicionar: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, elemento) => {
vetor.push(elemento);
return Promise.resolve(vetor);
}
},
concatenar: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, outroVetor) => {
return Promise.resolve(vetor.concat(outroVetor));
}
},
empilhar: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, elemento) => {
vetor.push(elemento);
return Promise.resolve(vetor);
}
},
encaixar: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, inicio, excluirQuantidade, ...items) => {
let elementos = [];
if (excluirQuantidade || excluirQuantidade === 0) {
elementos = !items.length
? vetor.splice(inicio, excluirQuantidade)
: vetor.splice(inicio, excluirQuantidade, ...items);
}
else {
elementos = !items.length ? vetor.splice(inicio) : vetor.splice(inicio, ...items);
}
return Promise.resolve(elementos);
}
},
fatiar: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, inicio, fim) => Promise.resolve(vetor.slice(inicio, fim)),
},
filtrarPor: {
tipoRetorno: 'qualquer[]',
implementacao: async (interpretador, vetor, funcao) => {
if (funcao === undefined || funcao === null) {
return Promise.reject("É necessário passar uma função para o método 'filtrarPor'");
}
const retorno = [];
for (let elemento of vetor) {
if (await funcao.chamar(interpretador, [elemento])) {
retorno.push(elemento);
}
}
return retorno;
}
},
inclui: {
tipoRetorno: 'lógico',
implementacao: (interpretador, vetor, elemento) => Promise.resolve(vetor.includes(elemento))
},
inverter: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor) => Promise.resolve(vetor.reverse())
},
juntar: {
tipoRetorno: 'texto',
implementacao: (interpretador, vetor, separador) => Promise.resolve(vetor.join(separador))
},
mapear: {
tipoRetorno: 'qualquer[]',
implementacao: async (interpretador, vetor, funcao) => {
if (funcao === undefined || funcao === null) {
return Promise.reject("É necessário passar uma função para o método 'mapear'");
}
const retorno = [];
for (let elemento of vetor) {
let resultado = await funcao.chamar(interpretador, [elemento]);
retorno.push(resultado);
}
return retorno;
}
},
ordenar: {
tipoRetorno: 'qualquer[]',
implementacao: async (interpretador, vetor, funcaoOrdenacao) => {
if (funcaoOrdenacao !== undefined && funcaoOrdenacao !== null) {
for (let i = 0; i < vetor.length - 1; i++) {
for (let j = 1; j < vetor.length; j++) {
if ((await funcaoOrdenacao.chamar(interpretador, [vetor[j - 1], vetor[j]])) > 0) {
const aux = vetor[j];
vetor[j] = vetor[j - 1];
vetor[j - 1] = aux;
}
}
}
return vetor;
}
if (!vetor.every((v) => typeof v === 'number')) {
return vetor.sort();
}
return vetor.sort((a, b) => a - b);
}
},
remover: {
tipoRetorno: 'qualquer[]',
implementacao: (interpretador, vetor, elemento) => {
const index = vetor.indexOf(elemento);
if (index !== -1)
vetor.splice(index, 1);
return Promise.resolve(vetor);
}
},
removerPrimeiro: {
tipoRetorno: 'qualquer',
implementacao: (interpretador, vetor) => {
let elemento = vetor.shift();
return Promise.resolve(elemento);
}
},
removerUltimo: {
tipoRetorno: 'qualquer',
implementacao: (interpretador, vetor) => {
let elemento = vetor.pop();
return Promise.resolve(elemento);
}
},
somar: {
tipoRetorno: 'qualquer',
implementacao: (interpretador, vetor) => {
return Promise.resolve(vetor.reduce((acc, item) => acc + (typeof item === 'number' ? item : item.valor), 0));
}
},
tamanho: {
tipoRetorno: 'número',
implementacao: (interpretador, vetor) => Promise.resolve(vetor.length)
}
};
//# sourceMappingURL=primitivas-vetor.js.map