Tag: Por

Antes de mais nada este é um erro de programação. É importante dizer isso porque costuma ser uma exceção em várias linguagens e as pessoas ficam tentadas em capturar a exceção e fazer alguma. Isto é usar exceção para controle de fluxo, é deixar de validar algo que pode ocorrer de errado para só tratar se der o erro, não faça isto, corrija o erro, mesmo que seja fazer a validação e dar o tratamento antes de dar o erro.

Este erro (não vou falar em exceção aqui, porque mesmo que seja lançada uma, ainda é um erro) ocorre apenas em coleções de dados ou objetos compostos que se comportam como coleções (algumas linguagens de tipagem dinâmica possuem composições implementadas como uma coleção, por exemplo uma classe ou algo parecido é implementada como um dicionário que é uma coleção). Para acessar um elemento da coleção é preciso dizer qual é o elemento desejado, de alguma forma. Esta forma costuma ser chamada de índice, mas em alguns casos pode ser uma chave, e em inglês podem usar o termo subscript. Este valor que indexa o elemento da coleção tende a ser um número, mas nada impede que seja outros tipos de dados, de fato em dicionários é comum ser strings.

Algumas coleções os valores são sequenciais e formam uma faixa clara de dados, por exemplo começa em 0 e termina 9, possuindo uniformemente 10 elementos em sequência, possuem uma forma de array, mesmo que não seja exatamente um. Em coleções mais livres podem ter índices/chaves (o termo mais usado nesses casos) esparsos, ou seja, os valores não estão de forma sequencial, então se for números pode começar em qualquer número e terminar em qualquer outro e não precisa ter todos os números entre eles. O mesmo vale para strings ou outros dados como chave.

for (var i = 1; i <= lista.Count; i++) //erro aqui
for (var i = 1; i < lista.Count; i++) //certo

Uma string é uma coleção de dados, ela é uma sequência de caracteres geralmente começada no caractere de posição 0 e terminando no tamanho menos um, não tente acessar uma caractere que esteja fora desta faixa. É comum a pessoa tentar acessar sem querer fora desta faixa, talvez porque tentou fazer uma busca que não achou a informação (pode retornar -1).

Se considerar que uma tabela ASCII ou algo parecido é uma coleção, pode ocorrer algo semelhante sem dar erro, só resultado ruim. Outro exemplo.

Como é uma coleção esse valor de índice/chave precisa existir nela, se não existir ocorre o erro descrito na pergunta ou alguma variante dele.

Em coleções normais como arrays o termo faixa ou o uso de limites de início e fim é mais usado porque ele certamente tem todos os números de uma faixa, o que você não pode fazer é acessar um número que esteja fora dessa faixa. Não é obrigatória começar em 0, mas se começar não pode usar um valor que seja negativo. E não pode acessar um valor que seja maior do que a quantidade de elementos. Então se começa com 0 não pode ser nem o número que indica o tamanho, nem um número maior que este. Porque se começa do 0, por exemplo se tiver 10 elementos, vai de 0 até 9, então o 10 já não é válido. Se começar em 1, então o 10 seria válido, mas o 11 não, e neste caso o 0 também seria inválido.

letr = (2, 5, 6, 18, 20, 10, 23, 12, 19, 10);
let s = (1, 5, 7, 13, 18, 21, 10, 25, 32, 17, 3);
let x = (0);
let i;
console.log("i = " + i);
for (i = 0; i <= 9; i++) {
    x(i) = r(i);
    console.log("i = " + i);
}
console.log("i = " + i);
for (i = 0; i <= 10; i++) {
    x(i + 10) = s(i);
    console.log("i = " + i);
}
console.log("i = " + i);

O erro pode indicar um valor fora da faixa para baixo ou para cima, não importa.

O erro ocorre de forma muito comum quando o índice que é usado é obtido usado uma fórmula ou é obtido por um dado externo que aquele algoritmo não tem controle. Ou ocorre quando vai acessar um elemento específico ou então quando faz um laço e este laço ou começa no número errado ou tenta terminar depois que já avaliou todos elementos que tinha que analisar.

É comum ocorrer em funções e métodos que tem um laço internamente, um caso muito comum é a Substring().

Tem uma classe que mostra superficialmente como o erro é gerado.

No caso do laço o ideal é usar uma construção da linguagem, se tiver que varrer toda coleção por controle próprio assim não tem muito como errar (desde que a coleção não seja modificada em sua estrutura e não mude a quantidade de elementos existentes). Pode ser um foreach ou um for abstrato que faça isto. Quando usa um for bruto ou while onde o programador controla onde deve parar é que costuma acontecer o erro. O erro mais comum é a pessoa colocar a comparação verificando o fim se o contador é menor ou igual ao tamanho, mas se começa do zero tem que ser menor que tamanho total da coleção.

foreach (var item in lista) WriteLine(item); //assim não tem como dar esse erro

Há casos que está usando um laço mas não acessando o elemento de forma direta mas sim calculando o número usando o contador do laço como parte da fórmula, este um caso híbrido, o problema pode ser no limite do contador ou pode ser na fórmula. Por exemplo, se você usa uma fórmula que pega sempre o “contador mais um”, obviamente não pode ir até o último valor possível na coleção porque o último possível mais um dá um número fora da faixa, por exemplo se a coleção vai de 0 a 9, o contador deve parar em 8, se for no 9 a fórmula resultará em 10 e dará o erro.

Então a solução para o problema é sempre validar certo quando deve parar, nunca deixar passar do número do elemento que não existe na coleção naquele momento. Nunca pressuponha que sabe quantos elementos tem ali, sempre pegue esse número ou use uma construção que garanta isso.

if (n >= 0 && n < opcoes.size()) return opcoes(n)->reproduz();

No caso do acesso ser feito individualmente por um dado calculado ou obtido externamente quase sempre é necessário validar o dado variável e que veio sem controle direto do seu algoritmo. Se não passar na validação de estar entre a faixa inicial (geralmente 0) e a final (geralmente o tamanho da coleção menos um), ou ainda se tem aquela chave, então deve fazer alguma operação alternativa, geralmente retornando um erro ou fazendo algo diferente (em alguns casos até pode lançar uma exceção, mas não costuma ser a melhor opção, mas se forma uma exceção mais específica em alguns casos pode ser interessante, só é mais raro ser o certo).

Só acesse um índice/chave condicionalmente, a não ser que seja 100% garantido que não tem como ser um dado inválido, mas são raros casos assim, como pode ser visto nos códigos e links postados aqui. Esta dica para para qualquer dado não só estes que são índices/chaves, quase todos os bugs ocorrem porque algum dado não está no estado que está esperando e não pode confiar em nada.

O uso de assert(), requires() ou algo semelhante costuma ser uma boa ideia.

Algumas estruturas de dados não lançam erros ou exceções quando a chave não existe, apenas retornam um código de erro que pode ser um nulo. Algumas tem métodos que permitem escolher o que acontece quando tenta acessar uma chave não existente. Cuidado pode parecer certo porque funciona, mas dará resultado ruim.

Tem linguagens que não dão erro, só ferra tudo. C, e C++ em certa medida, são assim.

Se você não está passando uma posição em uma coleção de dados então o erro não acontecerá, então precisa de duas coisas: coleção de dados e posição sendo acessada. A Posição pode ser passada por um operador indexador, muito comum ser colchetes objeto(x), mas outras linguagens podem ter outras notações, JS pode fazer assim objeto.x e ainda é uma posição nessa coleção. Também pode ocorrer em métodos que recebem a posição de uma forma ou de outra, pode ser até um dado que será usado para calcular a posição.

Um teste de mesa manual ou auxiliado pelo IDE (debugger) sempre indicará o que está acontecendo. Você executa passo a passo e analisa o valor do elemento sendo usado e verá que um dele logo no momento que dará o erro está acessando um índice/chave que não existe, por isso é preciso saber todas chaves possíveis ou a faixa do índice possível.

Lembre-se sempre de olhar o dado naquele momento, ele pode não ser o que deseja, pode não conter todos elementos que está esperando, isto pode ser a causa do erro. Se o dado estiver ok então seu algoritmo está pegando um valor que não devia.

Não tem milagre, não tem resposta fácil e rápida, tem que analisar o que está acontecendo. Faça a análise e aprenda programar melhor n o processo. Aprenda se virar por conta própria, você vai precisar.

Este é um erro chato por sempre ocorre em tempo de execução (existem poucas situações que poderia ser evitado em tempo de execução e nem costuma valer o esforço fazer isto).

Não falei, mas já vi erros em que o valor sendo usado era um literal e portanto de total controle do algoritmo sendo escrito ali. Quase sempre o problema não está bem nesse algoritmo, está no dado recebido, provavelmente você esperava receber uma coleção de dados com um número determinado de elementos e por alguma razão não está recebendo isto. Provavelmente o problema está na criação do dado e deve concentrar os esforços em analisá-lo. Você pode melhorar seu algoritmo para lidar com um caso de erro assim, mas quase sempre o resultado melhor fazer o dado vir corretamente já que faz parte do contrato vir assim. Claro, isso pode não ser um bom design, não é robusto, ou para dar robustez complica o código e piora a performance, mas muita gente desenvolve sem pensar nessas coisas (todos que escolhem uma linguagem de tipagem dinâmica). Exemplo.

De uma certa forma pode ser visto como uma variante da divisão por zero. Só ocorre porque está recebendo um valor que não é aceito naquele contexto. Não importa o que faça, a solução sempre está em validar implícita ou explicitamente o dado que será usado como índice/chave antes de usar, tem que ser garantido que ele existe.

Exemplo em C# de código robusto para não deixar acessar um elemento que não existe inadvertidamente.

Exemplos de perguntas que falam deste erro, é quase certo que o seu está coberto em algum.

Vou colocar mais exemplos, tentar usar mais linguagens, outras respostas podem ajudar mais pessoas