Métodos de texto e de lista

[AlessandroFMello]

Ao longo da última semana, realizei diversos exercícios básicos de programação (aqueles que fazemos quando estamos aprendendo a programar para exercitar a lógica de programação) retirados da lista de exercícios do site Python.org e alguns outros baseados em desafios do HackerRank.

Foram feitos exercícios de estrutura sequencial, estrutura de decisão, estruturas de repetição, de funções, de array, de strings e de operações matemáticas. Não me preocupei com performance ou complexidade de código, meu objetivo no momento era saber se os exercícios básicos poderiam ser feitos com as estruturas presentes atualmente em Delégua.

Inicialmente não houveram intercorrências, pois as estruturas de decisão (se, senão se, senão) e de repetição (para, enquanto) funcionaram bem. Foram encontrados alguns pontos de melhoria nestas estruturas, como em situações que a presença ou não de um ponto e vírgula quebrava a execução do código, ou no método escreva que até então não aceitava múltiplos parâmetros. Também houve situações em que ocorreram alguns bugs que não consegui reproduzir novamente, o mais recorrente deles é acerca da reatribuição de valores à variáveis já existentes. Nestes casos, quando o valor da variável era reatribuído, a execução do programa quebrava e não haviam logs de erros correspondentes.

Comecei a ter problemas com a execução dos exercícios quando estes pediam input do usuário ou alguns métodos de texto e lista específicos. Então, ficou evidente para mim a necessidade de implementação de alguns destes métodos para que a linguagem tenha métodos nativos mais robustos e funcionais e, também, possa evoluir ao ponto de se tornar o que ela propõe: (nas palavas dos desenvolvedores) "... abordagem mais comercial ..., com valor além do educacional."

Algumas das propostas que tenho têm uma implementação mais complexa, pois impactam diretamente na interface web, com é o caso do método entrada() (nome sugerido pelo Leonel Saches), cuja função é se comportar como o método input() da linguagem Python. Outras, não tem um impacto tão gritante, mas tornam nossa vida como desenvolvedores mais fácil e dinâmica, como é o caso dos template literals, do operador condicional ternário do JavaScript e a compreensão de listas do Python.

Abaixo cito os métodos que mais fizeram falta na execução dos exercícios:

obs.: ainda não tenho sugestões de nomes, então utilizarei os nomes nativos dos métodos nas respectivas linguagens.

Métodos de texto:

includes()

• includes() em JS é um método que é passado em um texto e recebe dois parâmetros, o primeiro deles é um segundo texto que será comparado com o que recebeu o método, já o segundo parâmetro é um número e é facultativo. Caso este segundo parâmetro seja passado, ele indica qual o número do caractere em que caractere do texto de referência deve-se iniciar a comparação.

Exemplo em JS:

const texto = 'Ser, ou não ser, eis a questão.';

console.log(texto.includes('Ser'));        // true
console.log(texto.includes('questão'));    // true
console.log(texto.includes('não existe')); // false
console.log(texto.includes('ser', 1));     // true
console.log(texto.includes('SER'));        // false

Repare que o método includes é case-sensitive, ou seja, a incidência de letras maiúsculas e minúsculas importa na hora da comparação. Isto nos leva a necessidade de outros dois métodos para tratar o texto: toUpperCase() e toLowerCase() (em JavaScript) ou upper() e lower() (do Python)

toLowerCase()/toUpperCase()

• toLowerCase() em JS é um método que é passado em um texto para transformar todos os caracteres deste texto em letra minúscula;
• toUpperCase() em JS é um método que é passado em um texto para transformar todos os caracteres deste texto em letra maiúscula;

Exemplo em JS:

const texto = 'Ser, ou não ser, eis a questão.';

console.log(texto.toLowerCase()); // ser, ou não ser, eis a questão.
console.log(texto.toUpperCase()); // SER, OU NÃO SER, EIS A QUESTÃO.

repeat()

• repeat() em JS é um método que é passado em um texto e recebe um número como parâmetro obrigatório. Este método serve para retornar determinado número de cópias do texto em que foi passado.

Exemplo em JS:

const texto = 'Olá, Mundo!';

console.log(texto.repeat(1)); // Olá, Mundo!
console.log(texto.repeat(4)); // Olá, Mundo!Olá, Mundo!Olá, Mundo!Olá, Mundo!
console.log(texto.repeat(2)); // Olá, Mundo!Olá, Mundo!

obs.: mesmo que ache este método extremamente necessário, acredito que é importante implementar a possibilidade de "multiplicar" um texto para que ele seja repetido diversas vezes

Exemplo em Python:

texto = 'Olá, Mundo!'

print(texto * 1); // Olá, Mundo!
print(texto * 4); // Olá, Mundo!Olá, Mundo!Olá, Mundo!Olá, Mundo!
print(texto * 2); // Olá, Mundo!Olá, Mundo!

replace()

• replace() em JS é um método que é passado em um texto e recebe dois parâmetros obrigatórios. O primeiro parâmetro é uma expressão regular ou um texto que equivalem à parte que queremos substituir do texto. Já o segundo parâmetro também é um texto, mas indica pelo que será substituído o fragmento do primeiro parâmetro.

Exemplo em JS:

const texto = 'Olá, Mundo!';

console.log(texto.replace("Mundo", "Delégua")); // Olá, Delégua!

const regex = /\d{3}/g
const texto2= "De323lé995gu4894545a";

console.log(texto2.replace(regex, "2")); // De2lé2gu225a"

slice()

• slice() em JS é um método que é passado em um texto e extrai uma parte deste texto sem modificar o texto original e recebe dois parâmetros. O primeiro parâmetro indica qual o índice do caractere do texto que começará o recorte, o segundo parâmetro indica o índice do caractere do texto em que terminará o recorte. Se o segundo parâmetro for omitido da função, o recorte ocorrerá entre o número do primeiro parâmetro e o último caractere disponível. Caso nenhum parâmetro seja passado a função retorna a frase inteira.

Exemplo em JS:

const texto = 'Olá, Delégua!';

console.log(texto.slice()); // Olá, Delégua!
console.log(texto.slice(5)); // Delégua!
console.log(texto.slice(5, 8)); // Del

split()

• split() em JS é um método que é passado em um texto e transforma ele em um array, o método também recebe dois parâmetros. O primeiro parâmetro é um separador, ele indica onde será dividido o texto. O segundo parâmetro é um limite, ele indica quantas vezes no máximo este texto será dividido.

Exemplo em JS:

const texto = 'Olá, Delégua!';
const texto2 = "Olá|Mundo"

console.log(texto.split("")); // ['O', 'l', 'á', ',',' ', 'D', 'e', 'l','é', 'g', 'u', 'a','!']
console.log(texto.split(", ")); // [ 'Olá', 'Delégua!' ]
console.log(texto.split()); // [ 'Olá, Delégua!' ]
console.log(texto.split("", 3)); // [ 'O', 'l', 'á' ]
console.log(texto.split("|"); // [ 'Olá', 'Mundo' ]

Métodos de lista:

entries()

• entries() em JS é um método que é passado em uma lista e retorna um objeto do tipo Array Iterator que contém os pares chave/valor para cada índice do array, endo a chave o índice e o valor o item naquele índice.

Exemplo em JS:

const lista = ['D', 'e', 'l','é', 'g', 'u','a'];

const entradas = lista.entries();

console.log(entradas); // Object [Array Iterator] {}
console.log(entradas.next()); // { value: [ 0, 'D' ], done: false }
console.log(entradas.next()); // { value: [ 1, 'e' ], done: false }
console.log(entradas.next()); // { value: [ 2, 'l' ], done: false }
console.log(entradas.next()); // { value: [ 3, 'é' ], done: false }
console.log(entradas.next()); // { value: [ 4, 'g' ], done: false }
console.log(entradas.next()); // { value: [ 5, 'u' ], done: false }
console.log(entradas.next()); // { value: [ 6, 'a' ], done: false }
console.log(entradas.next()); // { value: undefined, done: true }

Note que é necessário também a implementação de um método next() em caso de um iterador, mas há a posibilidade de, inicialmente, que o métodoentries() retorne apenas as chaves e valores em um objeto.

every()

• entries() em JS é um método que é passado em uma lista e recebe uma função de callback como parâmetro. O método, então, executa esta função para cada elemento presente dentro do array e retorna um booleano verdadeiro caso todos elementos satisfaçam a condição imposta pela função de callback ou falso, casl algum dos elementos não a satisfaça.

Exemplo em JS:

const listaDeIdades = [91, 32, 15, 44];
const listaDeIdades2 = [91, 32, 18, 44];

function checarIdade(idade) {
  return idade >= 18;
}

console.log( listaDeIdades.every(checkarIdade)) // false
console.log( listaDeIdades2.every(checkarIdade)) // true

filter()

• filter() é um método que é passado em uma lista e recebe uma função de callback que testa cada elemento desta lista. O método, então, retorna uma nova lista contendo todos os elementos que satisfazem a condição dada pela função.

Exemplo em JS:

const listaDeIdades = [91, 32, 15, 44, 12, 18, 101];

function checaIdade(idade) {
  return idade >= 18;
}

console.log( listaDeIdades.every(checaIdade)) // [ 91, 32, 44, 18]

find()

• find() é um método que é passado em uma lista e recebe uma função de callback que testa cada elemento desta lista até encontrar algum que satisfaça a condição imposta pela função. O método, então, retorna apenas este primeiro elemento.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

function checarIdade(idade) {
  return idade >= 18;
}

console.log( listaDeIdades.every(checarIdade)) // 91

forEach()

• forEach() é um método que é passado em uma lista e recebe uma função de callback. O método, então, executa esta função para cada elemento presente na lista.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

let somaDasIdades = 0;

function somaTodasIdades(idade) {
  somaDasIdades += idade;
}

listaDeIdades.forEach(somaIdades)

console.log(somaDasIdades) // 313

includes()

• includes() é um método que é passado em uma lista, recebe dois parâmetros e verifica se a lista contêm o elemento passado por parâmetro dada determinada posição. O primeiro parâmetro indica o elemento que queremos verificar se está presente na lista ou não. Já o segundo parâmetro é facultativo e indica o índice da lista onde esta verificação iniciará, se for omitido ele é 0 por padrão.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

console.log(listaDeIdades.includes(101)); // true
console.log(listaDeIdades.includes(15)); // true
console.log(listaDeIdades.includes(15, 3)); // false
console.log(listaDeIdades.includes(94)); // false

join()

• join() é um método que é passado em uma lista e recebe apenas um parâmetro separador. O método, então, junta todos os elementos desta lista em um texto em que cada elemento é separado pelo separador indicado no parâmetro. O separador, se omitido, é uma vírgula por padrão.

Exemplo em JS:

const lista = ['D', 'e', 'l','é', 'g', 'u','a'];

console.log(lista.join()); // D,e,l,é,g,u,a
console.log(lista.join(",")); // D,e,l,é,g,u,a
console.log(lista.join("")); // Delégua
console.log(lista.join(", ")); // D, e, l, é, g, u, a

pop()

• pop() é um método que é passado em uma lista, remove o último elemento desta lista e, então, retorna este elemento.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

console.log(listaDeIdades.pop()) // 101

shift()

• shift() é um método que é passado em uma lista, remove o primeiro elemento desta lista e, então, retorna este elemento.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

console.log(listaDeIdades.shift()) // 15

push()

• push() é um método que é passado em uma lista, adiciona um ou mais elementos ao final da lista e, então, retorna o novo tamanho da lista.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

console.log(listaDeIdades.push(19)) // 8
console.log(listaDeIdades) // [15, 12,  91, 32,44, 18, 101, 19]

console.log(listaDeIdades.push(19,2,16,76,4,3)); // 14
console.log(listaDeIdades) // [15, 12, 91, 32, 44, 18, 101, 19, 19, 2, 16, 76, 4, 3]

reverse()

• reverse() é um método que é passado em uma lista e inverte a ordem dos itens desta lista. O primeiro elemento torna-se o último e vice-versa.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

listaDeIdades.reverse()

console.log(listaDeIdades) // [101, 18, 44, 32,91, 12, 15]

slice()

• slice() é um método que é passado em uma lista e retorna uma cópia de uma lista criada a partir de uma fatia da lista original definida por uma posição de início e fim. O primeiro parâmetro recebido indica o início desta fatia, o segundo parâmetro, que é facultativo, indica o fim deste corte. Se o segundo parâmetro for omitido, o corte ocorre entre o parâmetro de início e o final da lista.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

console.log(listaDeIdades.slice(3)) // [ 32, 44, 18, 101 ]
console.log(listaDeIdades.slice(3, 5)) // [ 32, 44 ]
console.log(listaDeIdades.slice(0, -2)) // [ 15, 12, 91, 32, 44 ]

sort()

• sort() é um método que é passado em uma lista e ordena seus elementos. Ao fim o método retorna a lista ordenada. O método pode receber uma função, que é facultativa, como parâmetro que define a ordenação. Caso esta função seja omitida a ordenação padrão é de acordo com a pontuação de código unicode.

Exemplo em JS:

const listaDeIdades = [15, 12, 91, 32, 44, 18, 101];
console.log(listaDeIdades.sort()); // [ 101, 12, 15, 18, 32, 44, 91 ]

let itens = [
  { nome: 'Eduardo' },
  { nome: 'Santiago' },
  { nome: 'André' },
  { nome: 'Thiago' },
  { nome: 'Matheus' },
  { nome: 'Zélia' }
];
itens.sort(function (a, b) {
  if (a.nome > b.nome) {
    return 1;
  }
  if (a.nome < b.nome) {
    return -1;
  }
  return 0;
});

console.log(itens) // [{ nome: 'André' }, { nome: 'Eduardo' }, { nome: 'Matheus' }, { nome: 'Sharon' }, { nome: 'Thiago' }, { nome: 'Zélia' }]

[leonelsanchesdasilva]

@AlessandroFMello Parabéns pela contribuição. Incrível, em uma só palavra.

Acho que devemos implementar todas as sugestões. Primeiro, farei um mapeamento de nomes e alguns comentários sobre o exposto. Feito isso, abrirei uma issue para cada sugestão, que serão distribuídas livremente entre todos os participantes do projeto.

[leonelsanchesdasilva]

includes() (JS) -> texto.inclui()

Exemplo em Delégua:

var texto = 'Ser, ou não ser, eis a questão.';

escreva(texto.inclui('Ser'));        // verdadeiro
escreva(texto.inclui('questão'));    // verdadeiro
escreva(texto.inclui('não existe')); // falso
escreva(texto.inclui('ser', 1));     // verdadeiro
escreva(texto.inclui('SER'));        // verdadeiro

[leonelsanchesdasilva]

toLowerCase() (JS) -> texto.minusculo() e toUpperCase() -> texto.maiusculo()

var texto = 'Ser, ou não ser, eis a questão.';

escreva(texto.minusculo()); // ser, ou não ser, eis a questão.
escreva(texto.maiusculo()); // SER, OU NÃO SER, EIS A QUESTÃO.

[leonelsanchesdasilva]

Repetição de texto

Aqui sugiro usarmos o operador *, como no Python.

var texto = 'Olá, Mundo!'

escreva(texto * 1); // Olá, Mundo!
escreva(texto * 4); // Olá, Mundo!Olá, Mundo!Olá, Mundo!Olá, Mundo!
escreva(texto * 2); // Olá, Mundo!Olá, Mundo!

[samuelrvg]

Esses novos métodos podem ser incluidos em https://github.com/DesignLiquido/delegua/blob/principal/fontes/bibliotecas/biblioteca-global.ts, até mesmo criando arquivos separados e fazendo essas importações, para ficar mais organizado.

Dependendo, pode ser interessante trazer alguns métodos dos módulos delegua-mátemática e delegua-tempo também.

[leonelsanchesdasilva]

replace() (JS) -> texto.substituir()

var texto = 'Olá, Mundo!';

escreva(texto.substituir("Mundo", "Delégua")); // Olá, Delégua!

Para suportar o segundo exemplo, primeiro devemos implementar o suporte a expressões regulares.

[leonelsanchesdasilva]

slice() (JS) -> texto.subtexto()

var texto = 'Olá, Delégua!';

escreva(texto.subtexto()); // Olá, Delégua!
escreva(texto.subtexto(5)); // Delégua!
escreva(texto.subtexto(5, 8)); // Del

[leonelsanchesdasilva]

split() (JS) -> texto.dividir()

var texto = 'Olá, Delégua!';
var texto2 = "Olá|Mundo"

escreva(texto.dividir("")); // ['O', 'l', 'á', ',',' ', 'D', 'e', 'l','é', 'g', 'u', 'a','!']
escreva(texto.dividir(", ")); // [ 'Olá', 'Delégua!' ]
escreva(texto.dividir()); // [ 'Olá, Delégua!' ]
escreva(texto.dividir("", 3)); // [ 'O', 'l', 'á' ]
escreva(texto.dividir("|"); // [ 'Olá', 'Mundo' ]

[leonelsanchesdasilva]

entries() (JS) -> lista.iterador()

var lista = ['D', 'e', 'l','é', 'g', 'u','a'];

var iterador = lista.iterador();

escreva(iterador); // Iterador [Lista] {}
escreva(entradas.proximo()); // { valor: [ 0, 'D' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 1, 'e' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 2, 'l' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 3, 'é' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 4, 'g' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 5, 'u' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: [ 6, 'a' ], ultimo: falso }
escreva(entradas.proximo()); // { valor: nulo, ultimo: verdadeiro }

[leonelsanchesdasilva]

every() (JS) -> lista.todosEmCondicao(condicao)

const listaDeIdades = [91, 32, 15, 44];
const listaDeIdades2 = [91, 32, 18, 44];

funcao checarIdade(idade) {
  retorna(idade >= 18);
}

escreva(listaDeIdades.todosEmCondicao(checarIdade)) // falso
escreva(listaDeIdades2.todosEmCondicao(checarIdade)) // verdadeiro

[leonelsanchesdasilva]

filter() -> lista.filtrarPor(funcao)

var listaDeIdades = [91, 32, 15, 44, 12, 18, 101];

funcao checarIdade(idade) {
  retorna(idade >= 18);
}

escreva(listaDeIdades.filtrarPor(checarIdade)) // [ 91, 32, 44, 18]

[leonelsanchesdasilva]

find() -> lista.primeiroEmCondicao(condicao)

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

funcao checarIdade(idade) {
  retorna(idade >= 18);
}

escreva(listaDeIdades.primeiroEmCondicao(checarIdade)) // 91

[leonelsanchesdasilva]

forEach() (JS) -> lista.paraCada(funcao)

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];
var somaDasIdades = 0;

funcao somaTodasIdades(idade) {
  somaDasIdades += idade;
}

listaDeIdades.paraCada(somaIdades)

escreva(somaDasIdades) // 313

[leonelsanchesdasilva]

Array.includes() (JS) -> lista.inclui()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

escreva(listaDeIdades.inclui(101)); // verdadeiro
escreva(listaDeIdades.inclui(15)); // verdadeiro
escreva(listaDeIdades.inclui(15, 3)); // falso
escreva(listaDeIdades.inclui(94)); // falso

[leonelsanchesdasilva]

join() (JS) -> lista.juntar()

var lista = ['D', 'e', 'l','é', 'g', 'u','a'];

escreva(lista.juntar()); // D,e,l,é,g,u,a
escreva(lista.juntar(",")); // D,e,l,é,g,u,a
escreva(lista.juntar("")); // Delégua
escreva(lista.juntar(", ")); // D, e, l, é, g, u, a

[leonelsanchesdasilva]

pop() -> lista.desempilhar()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

escreva(listaDeIdades.desempilhar()) // 101

[leonelsanchesdasilva]

shift() (JS) -> lista.removerPrimeiro()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

escreva(listaDeIdades.removerPrimeiro()) // 15

[leonelsanchesdasilva]

push() -> lista.empilhar()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

escreva(listaDeIdades.empilhar(19)) // 8
escreva(listaDeIdades) // [15, 12,  91, 32,44, 18, 101, 19]

escreva(listaDeIdades.empilhar(19,2,16,76,4,3)); // 14
escreva(listaDeIdades) // [15, 12, 91, 32, 44, 18, 101, 19, 19, 2, 16, 76, 4, 3]

[leonelsanchesdasilva]

reverse() -> lista.inverter()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

listaDeIdades.inverter()

escreva(listaDeIdades) // [101, 18, 44, 32,91, 12, 15]

[leonelsanchesdasilva]

slice() (JS) -> lista.fatia()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];

escreva(listaDeIdades.fatia(3)) // [ 32, 44, 18, 101 ]
escreva(listaDeIdades.fatia(3, 5)) // [ 32, 44 ]
escreva(listaDeIdades.fatia(0, -2)) // [ 15, 12, 91, 32, 44 ]

[leonelsanchesdasilva]

sort() (JS) -> lista.ordenar()

var listaDeIdades = [15, 12, 91, 32, 44, 18, 101];
escreva(listaDeIdades.ordenar()); // [ 101, 12, 15, 18, 32, 44, 91 ]

var itens = [
  { nome: 'Eduardo' },
  { nome: 'Santiago' },
  { nome: 'André' },
  { nome: 'Thiago' },
  { nome: 'Matheus' },
  { nome: 'Zélia' }
];
itens.ordenar(funcao (a, b) {
  se (a.nome > b.nome) {
    retorna 1;
  }
  se (a.nome < b.nome) {
    retorna -1;
  }
  retorna 0;
});

escreva(itens) // [{ nome: 'André' }, { nome: 'Eduardo' }, { nome: 'Matheus' }, { nome: 'Sharon' }, { nome: 'Thiago' }, { nome: 'Zélia' }]

[leonelsanchesdasilva]

Égua está discutindo o suporte em eguatech/egua#165. O que for definido lá fará parte apenas do dialeto Égua Clássico.