Um momento
Aula 32
Cursos / Aprenda Go / Golang (Curso de Programação)
Slice Literal, Comprimento len e Capacidade cap de Pedaços na Linguagem Golang

Summary

Resumo da Aula sobre Slices Literais em Go

Nesta aula, discutimos os slices literais na linguagem Go.

Conceitos Básicos

  • Um slice é uma referência a um array em Go, que pode ser criado sem precisar definir o número de elementos.
  • Usamos fmt.Printf com %T para determinar o tipo da variável Nomes, que inicialmente é um array de 3 strings.

Demonstração com Código

  1. Tipo de Variável:

    • Um array com 3 strings resulta em 3 string.
    • Ao remover o número de elementos, a variável se torna um slice, representado apenas como slice.
  2. Comprimento e Capacidade:

    • O comprimento de um slice é obtido com a função len(), que retorna o número de elementos.
    • A capacidade de um slice é calculada a partir do primeiro elemento do slice até o final do array referenciado. Isso pode ser obtido com cap().

Exemplos de Código

Comprimento

  • O comprimento de um slice e de um array é o mesmo e é obtido usando len(Nomes).

Capacidade

  • A capacidade é obtida usando cap(), retornando sempre o número de elementos na array original a partir do primeiro elemento do slice.

Manipulação de Slices

  • Ao redefinir o slice, por exemplo, nomes[0:2], o comprimento muda para 2, enquanto a capacidade continua a mesma se o novo slice ainda referenciar a array original.
  • Se for usado nomes[1:], o comprimento permanece 2, mas a capacidade do novo slice é 2, pois considera apenas os elementos a partir do novo índice.

Resumo Final

  • Aprendemos sobre a criação e uso de slices literais.
  • Entendemos a importância do comprimento e da capacidade em slices.
  • A capacidade é sempre contada na array original, começando do primeiro elemento do slice.

Obrigado pela participação e até a próxima aula!

Video Transcript

Nesta aula nós vamos falar de slices literais, pedaços literais na linguagem go. Então vocês já provavelmente já viu isso mas não sabia que era na verdade um pedaço. Então vamos aqui, temos uma array de três elementos de post-trin que a gente já viu antes, ano de José e Maria. Então o que eu quero fazer aqui? Primeiro eu quero demonstrar o tipo dessa variável chamada Nomes. Eu vou fazer o fmit.printf, não é ln, é f. Vou botar esse cara aqui, percentual t, t-maiúsculo, para poder ler o tipo da variável Nomes. Então o percentual t é usado para poder ter o tipo da variável que você especifica aqui. Estou usando printf. Se você quiser saber mais sobre isso, vai na documentação. É sempre bom relembrar a referência da linguagem. Estou aqui no navegador golong.org, você clica em packages, pacotes. Acho que tem uma versão brasileira do Golang, é só buscar golangbr em português. Então pacotes da biblioteca padrão, fmit, é o pacote. Vai aqui embaixo, fmit, clica lá. Aí tem a referência do pacote e tem referência da impressão. E tem várias percentuais no seu que para você saber o que é. No meu caso vou usar o percentual t agora. Ele disse que é a representação do tipo, do valor. Não é certo? Então deixe isso com referência para você ver. Voltando ao código, vamos ver no que dá no terminal gorunslices3.go. Então printf não adiciona linha, quebra de linha, por isso que pareceu aqui. Mas você vê que o tipo é 3 string. Então é realmente um array de 3 elementos de tipo string. Mas o que acontece se a gente tirar o número de elementos que vai declarar, que vai definir? Vamos ver. Antes disso eu vou adicionar a quebra de linha aqui no nosso printf com barra n. Barra n significa quebra de linha. Então ele vai adicionar a quebra de linha lá. Agora olha o tipo, não é mais o 3 string, é só o vazio string. Esse tipo aqui significa um slice, tá certo? Então esse aqui é o chamado slice literal que eu iniciei aqui na própria declaração da variável. Quando você declara um variável e define na mesma hora com slice literal, ele vai criar primeiro aquela array contendo esses elementos e depois ele cria uma slice que faz referência a essa array, tá? Então por isso que o tipo da variável na verdade é um tipo slice, um slice de elementos do tipo string. É certo? É diferente do tipo array que tem realmente o comprimento, o próprio tipo. Tá? Agora vamos falar da comprimento de um pedaço e da capacidade. Você já aprendeu que array tem o comprimento, né? Nesse caso aqui, que a gente tinha aquela array de três elementos, comprimento era 3. O que não é que pega o comprimento? Com a função l e n, né? l e n e o nome é variável. E é dá 3, peravelmente, né? Deixa eu adicionar o 3 aqui de volta. Eu quero pegar esse length e agora pôr no fmt println length igual vírgula, vou colocar length of names lá, que vai dar 3, se a gente sabe. Salva e vou rodar de novo. Então a length, o comprimento é 3, tá? A gente já sabe isso. Mesma coisa para o slice. Se você tirar esse 3 aqui para virar um slice literal, cria array, depois cria um slice que vai referência a array original, o slice está referência na variável, a mais nada na variável nomes. Agora vamos ver qual é a length. Vai ser 3 também. Então o comprimento do slice, da mesma maneira, comprimento da array, número de elementos. Agora vamos falar de capacidade. Capacidade de um slice vai ser o número de elementos da array original, mas você tem que contar do primeiro elemento do slice até o final da original. A gente vai entender isso já já. Então vamos estudar um println para você ver aqui. Para você pegar a capacidade de um slice, você digita cap. Essa função, o slice para a função, vai te dar a capacidade. Deixa eu dar o fmt printf nesse cara aqui. Se você quiser dar o printf em vez do println, você pode usar o %ald, significa um dígito de base 10, e vai ser correspondente a esse cara, porque a capacidade vai ser o inteiro, número inteiro. Deixa eu comentar esses outros. Cap igual aquele. Então o cap vai ser 3, deixa eu adicionar o quebra de linha. Então cap é igual a 3, capacidade 3. Vamos falar já já. Primeiro, se você não entendeu o que aconteceu aqui, eu primeiro puse o %ald para mostrar um dígito de base 10, que corresponde a esse cara aqui do lado da vira. Depois eu puse esse texto cap igual que apareceu aqui. Depois eu puse o quebra de linha barra n, para o cara não aparecer a mesma linha que tinha aparecido. Sem quebra de linha, agora tem quebra de linha. Tá bom? Agora antes do cap, eu vou adicionar o lang, só para ter referência também. Agora para você mostrar o pessoal atual d aqui, tem que pôr o cap correspondente antes desse cara aqui, porque o cap é o final e antes do final vai ser o length de nome. Vígula, tá? Deixa eu mostrar também a array, println, nomes, para você ter referência também. Então temos a array de três elementos tipo string, nesse caso não é um array, o slice. A Ana José Maria, o slice tem length 3, comprimento 3, capacidade 3. A capacidade vai ser o número de elementos que você conta aqui, dos slice até o final da ordem de não. Então, por exemplo, se eu pegar antes de imprimir tudo, pegar nomes e redefinir com nomes, vamos ver aqui. Vou pegar e vou pegar dos elementos zero, a um de dois significa eu vou pegar Ana e José, sempre o índice menos um que o dois não é incluído, tá? Se eu fizer isso, ele vai pegar o slice, vai virar Ana e José. Vamos ver o length e o cap. Então o length virou de 3 para 2, porque a gente só tem dois elementos agora. O cap está o mesmo, tá? O cap você vai pegar o original, conta do começo dos slice, o começo dos slice é Ana. Então, a Ana é esse começo, vai até o final da array, então você conta um, dois, três, então esse é o cap. Agora, o que acontece se eu pegar em vez de zero a dois, pode um até o final. Eu omitir o índice final, então significa eu pegar do José até o final da array que é Maria. Da array original, então vamos ver o que acontece. Agora, o length está na mesma, né? Porque são dois elementos, mas o cap virou de 3 para 2, por quê? Porque você tem que ver a array original, que é essa aqui. Olha o slice, o slice começa do José. Então para calcular o cap, você tem que ir na array original, começar do José e contar até o final da array. Do José até o final vai ser um, dois. Então o cap é dois, tá? Muito importante esse detalhe. Você não pode começar do começo da original, você tem que começar sempre do começo do elemento correspondente ao slice. O slice tem que iniciar com o José, então você tem que começar contando do começo do José, o índice do José na array original. Então vamos revisar o que a gente aprendeu. Aprendemos o slice literal, que é só tirar o número de elementos aqui quando você for definir a sua array. Quando você faz o slice literal, ele cria um array, um array original, e depois cria um pedaço que é referência, que tem referência a array original. Aprendemos sobre o comprimento de um slice, mesma coisa, da array, número de elementos. Aprendemos também sobre esse novo cara chamado capacidade cap, que é meio esquisito na primeira vez que você aprende, que a capacidade de um slice vai ser você conta, ter que sempre olhar na array original, conta do primeiro elemento slice que aparece na array original, daquele índice que conta até o final da array original, e vai ser seu cap. Então por essa aula é só e até a próxima.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: