Olá e seja bem vindo a essa luta e ao torero.
Tudo agora, vamos fazer a função push que fará duas tarefas.
Primeiro, dependerá de uma nova transição ou de um novo evento na memória e, em seguida, segundo, ele
assegurará que a memória tenha sempre 100 transições.
Estou vendo 100 porque damos o exemplo de 100 eventos no tutorial anterior, mas na verdade isso será
muito mais do que 100.
Isso será talvez dez mil cem mil que veremos.
Mas, de qualquer forma, esse valor será a capacidade.
Tudo bem.
Então, vamos fazer essa função de empurrar.
Então, como de costume, começamos com a morte para definir uma nova função e, em seguida, damos
um nome a essa função, por isso chamamos push e esta função terá dois argumentos.
Primeiro como eu habitual que se refere ao objeto e ao próximo.
Por que você acha que isso será.
Bem, lembre-se que esta função de pressão será usada para anexar um novo evento à memória.
Nós já temos a memória.
Então, o que precisamos agora é uma variável é um evento que será nossos argumentos ou entrada
e quebraremos essa entrada na memória, que é uma variável do objeto.
Tudo bem.
Então, você pode realmente chamá-lo de evento ou de transição.
Isso é o mesmo e você verá as próximas seções de código.
Qual é exatamente esse evento.
Que forma tem.
agora este evento, esta transição que estamos adicionando à memória é um total de quatro elementos.
Na verdade, posso dizer-lhe
O primeiro é o último estado que está a ser.
O segundo é o novo estado que é Estep nós um.
O terceiro é a última seção que é 80.
A ação que foi exibida e a quarta é a última palavra a última palavra obtida.
Esse é o nosso.
Então, essa é exatamente a forma que esse evento terá.
Tudo bem.
E isso é tudo o que precisamos do evento, porque queremos apenas encerrar o evento na memória
e depois certificar-se de que a memória tenha elementos de capacidade.
Tudo bem, então, vamos dentro da função.
Então, a primeira coisa que faremos é cuidar de você, então, para a memória.
E isso é muito simples porque vamos usar a função de anexar.
Então, isso será direto.
E quando usamos a função de anexar, devemos começar com a lista para a qual queremos gastar algo
e esta lista é, naturalmente, memória.
Então, começamos com a memória e, como a memória é uma variável do objeto, começamos aqui com a
memória autodidata que vamos configurar a memória e então temos que fazer isso e depois a função aberta, que é a
primeira.
Então, curvado e dentro da função aberta, nós inserimos o que queremos gastar na memória, que é
claro, nossa evidência.
Então, até aqui.
E isso irá anexar o novo evento composto dos últimos oito novos estados de última ação e última palavra
para a memória.
Tudo bem.
Então é a primeira coisa feita.
E então a segunda coisa que precisamos fazer é certificar-se de que a memória sempre contém elementos de capacidade.
Então, digamos que a capacidade é agora 100000.
Essa é provavelmente a capacidade que você escolherá porque, em seguida, um milhão de elementos podem tornar
o trem lento.
Então, digamos 100000.
vamos nos certificar de que nossa memória sempre contém 100 000 transições 100 000 eventos e nunca mais.
Agora,
Então, é claro, no início, terá um, então, dois e três, mas, uma vez que ele atinja
100000 eventos. Bem, ele sempre terá 100000 eventos.
Então, para ter certeza disso, precisamos simplesmente fazer uma condição IF com este limite superior que
não queremos passar.
Então, se tivermos a ideia de que usaremos aqui, é que se superarmos o limite. Bem, vamos excluir a primeira transição
do primeiro evento da memória e, portanto, vamos assumir a função principal para levar o comprimento
do memória que é o número de elementos na memória.
Então, aqui na função len, podemos colocar a própria memória na memória.
Então, se o número de elementos dessa memória for maior do que a capacidade, nesse caso, removeremos o primeiro elemento para garantir
que a memória tenha sempre o mesmo número de elementos de capacidade e para fazer o primeiro elemento não há
nada mais simples que nós vai usar outra função que é tão
central para o "byte centric" e, portanto, queremos remover a primeira transição que é a transição mais antiga na memória porque
as últimas transições são as que estamos tensas e, portanto, essas são as
novas transições.
Assim, as primeiras transições são as mais antigas.
E então, aqui, queremos apagar a memória e os registros autodidacta e nós levamos o primeiro elemento da memória que tem
um zero em si que a memória zero. Agora interessante eu tenho um pequeno aviso que diz
que existe uma capacidade indefinida.
Isso porque a capacidade aqui não é a entrada que deve ser a variável de
capacidade anexada ao objeto e, portanto, você precisará adicionar uma auto-capacidade dessa.
E agora o aviso veio.
Agora você entende ainda mais o uso de si mesmo que é realmente se referir ao objeto para assumir
a capacidade do objeto que será criado que é uma instância da classe de memória de repetição.
Tudo bem.
Então, terminamos com esta função de envio.
E agora podemos avançar para a próxima função, que é a função simples que
levará algumas amostras aleatórias desta memória nos últimos elementos de capacidade e isso vai melhorar muito.
O processo de limpeza profunda.
Tudo bem.
Então vamos fazer isso no próximo tutorial.
E até então eu.