One place for hosting & domains

      Switch

      Making the Switch from Universal Analytics to Google Analytics 4 (GA4)


      In 2019, Google introduced Google Analytics 4 as an alternative to Universal Analytics. Users were free to choose between using standard analytics properties or jumping to the new version. Now, Google plans to sunset Universal Analytics in 2023 and transition all users to Google Analytics 4.

      If you use Google Analytics and haven’t made the jump yet, you need to understand what Analytics 4 offers and how it’s different from Universal Analytics. Fortunately, you have plenty of time to acquaint yourself with the service and make the change before Universal Analytics ceases to function.

      In this article, we’re going to talk about what Google Analytics 4 does differently from its predecessors. We’ll also show you how to transition your account to Google Analytics 4 and discuss some tips to help you get the most out of the platform. Let’s get to it!

      What’s Happening With Universal Analytics?

      For almost a decade, Universal Analytics has been the standard for measuring performance and engagement for websites. It has also been a vital tool for determining the success of keyword strategies.

      However, the platform was initially designed for an era where we mostly interacted with sites through desktop computers. Although Universal Analytics can also measure mobile and app metrics, it doesn’t offer a unified experience for properties across multiple channels.

      “People expect to interact with businesses when and how they like, such as browsing a brand’s website to research a product and then purchasing it later using the brand’s app. Getting insight into these cross-platform journeys is critical for businesses to predict customer needs and provide great experiences—but it can be very challenging.”

      – Russell Ketchum, Director of Product Management for Google Analytics

      Google Analytics 4 was designed to help remedy that problem and improve privacy standards in collecting measurements. Since its introduction in 2019, it has existed alongside Universal Analytics so that users could choose between both experiences:

      GA4 Setup Assistant

      Now Google plans to retire Universal Analytics, starting on July 1, 2023. Existing analytics properties will stop collecting data on that date. If you’re using Universal Analytics 360, you get a few extra months of data collection, with the service retiring on October 1, 2023:

      Universal Analytics data collection end date message

      That gives you plenty of time to get acquainted with Google Analytics 4 and make the transition. Before we talk about how to do that, let’s go over the changes to the service.

      An Introduction to Google Analytics 4

      For a long time, analytics focused on helping you measure desktop web metrics, with mobile data being almost an afterthought. Google Analytics 4 changes that approach by helping you unify multiple types of properties into singular user journeys:

      GA4 Setup Assistant tags

      With Google Analytics 4, you can see measurements for your websites and apps. You can also gain insights from machine learning algorithms into how to optimize those properties.

      Another key aspect of Google Analytics 4 is that it doesn’t rely solely on cookies. It offers an increased emphasis on user privacy.

      “Universal Analytics was built for a generation of online measurement that was anchored in the desktop web, independent sessions and more easily observable data from cookies. This measurement methodology is quickly becoming obsolete.”

      – Russell Ketchum, Director of Product Management for Google Analytics

      Arguably, one of the main drivers behind the shift in how Google Analytics collects data comes from the General Data Protection Regulation (GDPR). The GDPR has had a massive impact on how websites and platforms can legally collect and store user data.

      Get Content Delivered Straight to Your Inbox

      Subscribe to our blog and receive great content just like this delivered straight to your inbox.

      Cookies have come under fire in recent years due to increased privacy concerns. That means many companies are looking into alternative data collection streams.

      With Google Analytics 4, measurements no longer rely on sessions. The platform is capable of recognizing and measuring multiple types of human interaction “events”, including:

      • Page views
      • Scrolls
      • Outbound clicks
      • In-site searches
      • Video engagement metrics
      • File downloads

      With previous versions of Google Analytics, measuring several metrics involved manually setting up complex events. Now, the platform can automatically tag the events for you, which gives you access to more data from the get-go.

      Finally, Google Analytics 4 brings better funnel reports to the table, including cross-platform analysis. You can use the platform to identify key steps in the customer journey and see where users enter it and drop out. The service also enables you to understand what users are doing in-between steps in the funnel:

      GA4 funnels report

      If you’re moving from Universal Analytics, Google Analytics 4 can seem very different at first glance. However, setting up and configuring a Google Analytics 4 property is relatively simple. Fortunately, the platform offers an onboarding process.

      How to Move from Universal Analytics to Google Analytics 4

      Although we’re talking about transitioning from Universal Analytics to Google Analytics 4, you can use both services simultaneously for now. That means you can still collect data using cookies until Universal Analytics retires in 2023. At the same time, you can begin collecting data from events with Analytics 4.

      Step 1: Create a Google Analytics 4 Property

      Firstly, you’ll want to make sure that you’re not already using Google Analytics 4. If you set up a property after October 14, 2020, it’s likely already using Google Analytics 4. To verify this, access your Google Analytics account and look at your list of properties.

      Properties using Universal Analytics will have a UA prefix in their analytics IDs. Properties using Google Analytics 4 will display G4A designations:

      GA4 properties list

      To get started, select a property using Universal Analytics and access its ADMIN settings. Select the option that says G4A Setup Assistant under the property’s name.

      Now click on the Get Started button under the message that says, I want to create a new Google Analytics 4 property:

      GA4 Setup Assistant not connected message

      After clicking on that button, Google Analytics will show you a brief rundown of the setup steps. The platform will set up a new property for you without deleting your Universal Analytics configurations. It’ll copy data from the Universal Analytics property and enable “enhanced measurements” immediately. That means you can start measuring complex events from the get-go:

      create a new GA4 property

      Click on Create property to get the process started. You’ll return to the GA4 Setup Assistant tab, which will indicate the property is ready.

      Step 2: Configure Your Google Analytics 4 Property

      Now click on See your G4A property to configure its settings:

      successful GA4 connection

      To get started using Google Analytics 4 correctly, you’ll need to configure one or more data streams.

      When you open a new Google Analytics 4 property, the platform will send you to the Setup Assistant page. Here, look for the section that says Collection and select the Tag installation option:

      GA4 Setup Assistant

      The Tag Installation option lets you configure “data streams”. Each Google Analytics property can have streams of information from websites and apps. Typically, you’ll have one stream for the web and one each for iOS and Android devices if you utilize apps:

      GA4 add new data stream

      When you select the Add stream option, the platform will ask you what type of stream you want to set up. If you’re adding a web property, Google Analytics will ask for its URL, the site’s name, and which measurements you want to track:

      set up a new GA4 web stream

      To confirm that you own the website, Google Analytics will ask you to add a tag to it. You can complete this step by adding a JavaScript tag manually or by using Google Tag Manager:

      GA4 add new tag

      Once you verify ownership of the property, Google Analytics will start collecting data from it. Like with Universal Analytics, you’ll be able to track all of that information from the dashboard.

      Once you start setting up custom insights, you’ll get an idea of how big the difference between Universal Analytics and Google Analytics 4 is:

      GA4 User Reports

      If you want to experiment with Google Analytics 4 before setting up a new property, there’s an official demo account that you can use. Additionally, keep in mind that you can switch between Universal Analytics and Google Analytics 4 properties by selecting either option from your list of properties.

      Common Issues With Google Analytics 4

      Although transitioning to Google Analytics 4 is simple, users report some common issues when first using the “new” platform. Let’s talk about some of those issues and how to tackle them!

      Configuring Google Analytics 4 Takes Time

      Google Analytics 4 automatically sets up tracking for several types of events when you configure it for your website. However, the platform really shines when and if you take the time to set up custom events and reports.

      If you don’t configure Google Analytics to track custom events, you’re missing out on what is perhaps the most powerful feature the platform offers. With custom events, you can collect data on the measurements that matter the most to you, all without adding custom code to your site.

      Reports in Google Analytics Are Limited

      Out of the box, reports in Google Analytics 4 are somewhat limited. For the platform to provide you with deeper insights into your customers’ behavior, you need to configure it to track the specific events you want and show that data in the way you need.

      Google Analytics 4 makes this process relatively straightforward, depending on what type of events you want to track. However, even after setting up custom reports, accurate numbers may take a while to show up on your dashboard. This is because Analytics 4 uses machine learning to improve how it reports information.

      There Are Differences in Reports Between Universal Analytics and Google Analytics 4

      One of the most common complaints among new Google Analytics 4 users is that the numbers you see in the dashboard might not match your Universal Analytics property. This difference in data is because both services collect and count data differently. Whereas Universal Analytics relies on cookies and sessions, Analytics 4 tracks events.

      For now, you can rely on metrics from both services to inform your decisions. However, you’ll need to get used to the Analytics 4 approach as we near the retirement date for Universal Analytics.

      Google Analytics 4 Doesn’t Track Bounce Rate

      There is a lot of discussion about whether the way bounce rate is currently measured makes sense or not. Google Analytics 4 does away with bounce rate entirely, and instead, it measures “engagement”:

      GA4 events report

      Engagement reports use a broad range of metrics to provide a comprehensive overview of how users first perceive your website. If you want to continue measuring bounce rate, you can use Universal Analytics while it’s still active.

      What the Future Holds for Google Analytics

      The transition to Google Analytics 4 hasn’t been entirely smooth. Reception to the new platform has been somewhat lukewarm among users. However, if you use Google Analytics, it’s essential to start getting acquainted with Google Analytics 4, even if you plan on using Universal Analytics for the time being.

      In the coming year, Universal Analytics will cease to collect data. You should have a Google Analytics 4 property set up and configured by the time that happens. If you want to get the most out of Google Analytics 4, we also recommend taking the time to configure custom events and reports for your property.

      Analytics tools can help you measure the effectiveness of your Search Engine Optimization (SEO) and marketing strategies. If you don’t have a plan, we can help you with our Pro SEO Marketing Services.

      Analytics & SEO Made Easy

      We take the guesswork (and actual work) out of measuring and growing your website traffic.

      DreamCare website tech support



      Source link

      Como escrever instruções switch em Go


      Introdução

      As instruções condicionais dão aos programadores capacidade para direcionar seus programas a tomarem algumas medidas se uma condição for verdadeira e outra ação se a condição for falsa. Frequentemente, queremos comparar algumas variáveis com vários valores possíveis, tomando diferentes ações em cada circunstância. É possível fazer isso funcionar usando somente as instruções if. No entanto, escrever um software não diz respeito somente a fazer as coisas funcionarem, mas também de comunicar sua intenção para outros desenvolvedores e para si mesmo no futuro. O switch é uma instrução condicional alternativa útil para comunicar as ações tomadas pelos seus programas em Go quando diante de diferentes opções.

      Tudo o que podemos escrever com a instrução switch também pode ser escrito com as instruções if. Neste tutorial, vamos examinar alguns exemplos do que a instrução switch pode fazer, quais instruções if ela substitui e onde ela é mais adequadamente aplicada.

      Estrutura das instruções switch

      A instrução switch é geralmente usada para descrever as ações tomadas por um programa quando atribuímos valores específicos para uma variável. O exemplo a seguir demonstra como realizaríamos isso usando instruções if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              if flav == "strawberry" {
                  fmt.Println(flav, "is my favorite!")
                  continue
              }
      
              if flav == "vanilla" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              if flav == "chocolate" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              fmt.Println("I've never tried", flav, "before")
          }
      }
      

      Isso gerará o seguinte resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Dentro de main, definimos uma fatia com sabores de sorvete. Na sequência, usamos um for loop para iterar por eles. Usamos três instruções if para imprimir diferentes mensagens que indicam preferências por diferentes sabores de sorvete. Cada instrução if deve usar a instrução continue para parar a execução do loop for, de modo que a mensagem padrão no final não seja impressa em relação aos sabores preferidos de sorvete.

      À medida que adicionamos novas preferências de sorvete, temos que continuar adicionando instruções if para lidar com os novos casos. As mensagens duplicadas, como no caso de "vanilla" e "chocolate", devem ter instruções if duplicadas. Para futuros leitores do nosso código (nós mesmos, inclusive), a natureza repetitiva das instruções if atrapalha o entendimento sobre parte importante do que elas estão fazendo — comparando a variável com vários valores e tomando diferentes ações. Além disso, nossa mensagem de fallback fica separada das condicionais, fazendo-a parecer não relacionada. A instrução switch pode nos ajudar a organizar essa lógica melhor.

      A instrução switch começa com a palavra-chave switch e é seguida, em sua forma mais básica, de algumas variáveis com as quais serão feitas comparações. Após a instrução vem um par de chaves ({}) onde várias cláusulas de caso podem aparecer. As cláusulas de caso descrevem as medidas que o seu programa em Go deve adotar quando a variável informada à instrução switch for igual ao valor referenciado pela cláusula de caso. O exemplo a seguir converte o exemplo anterior para que use uma switch em vez de várias instruções if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      O resultado é o mesmo de antes:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Mais uma vez, definimos uma fatia com sabores de sorvete em main e usamos a instrução range para iterar sobre cada sabor. Dessa vez, no entanto, usamos uma instrução switch que irá examinar a variável flav. Usamos duas cláusulas case para indicar as preferências. Já não precisamos de instruções continue, já que apenas uma cláusula case será executada pela instrução switch. Também podemos combinar a lógica duplicada das condicionais "chocolate" e "vanilla", separando cada uma com uma vírgula na declaração da cláusula case. A cláusula default serve como nossa cláusula catch-all [global]. Ela executará em relação a todos os sabores que ainda não foram contabilizados no corpo da instrução switch. Nesse caso, "banana" fará com que default seja executada, imprimindo a mensagem I've never tried banana before (Nunca experimentei o de banana antes).

      Essa forma simplificada de instruções switch lida com o uso mais comum dado a elas: comparar uma variável com várias alternativas. Ela também nos traz conveniência nos locais em que queremos tomar a mesma medida em relação a diversos valores diferentes e algumas outras medidas quando nenhuma das condições listadas forem atendidas pelo uso da palavra-chave default informada.

      Quando essa forma simplificada da switch mostra-se limitada, podemos usar uma forma mais geral da instrução switch.

      Instruções switch gerais

      As instruções switch são úteis para agrupar coleções de condicionais mais complicadas, mostrando que elas estão de alguma maneira relacionadas. Isso é mais comumente usado ao comparar algumas variáveis com uma gama de valores, em vez de valores específicos, como no exemplo anterior. O exemplo a seguir implementa um jogo de adivinhação usando instruções if que poderia ser beneficiado por uma instrução switch:

      package main
      
      import (
          "fmt"
          "math/rand"
          "time"
      )
      
      func main() {
          rand.Seed(time.Now().UnixNano())
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              if guess > target {
                  fmt.Println("Too high!")
                  continue
              }
      
              if guess < target {
                  fmt.Println("Too low!")
                  continue
              }
      
              fmt.Println("You win!")
              break
          }
      }
      

      O resultado variará dependendo do número aleatório selecionado e do quão bem você jogar o jogo. Aqui está o resultado de uma sessão para exemplificar:

      Output

      Enter a guess: 10 Too low! Enter a guess: 15 Too low! Enter a guess: 18 Too high! Enter a guess: 17 You win!

      Nosso jogo de adivinhação precisa de um número aleatório contra o qual fazer as comparações. Portanto, usamos a função rand.Intn do pacote math/rand. Para garantir que obteremos diferentes valores para target toda vez que jogarmos o jogo, usamos o rand.Seed para aplicar um fator de aleatoriedade ao gerador de números aleatórios, com base no momento atual. O argumento 100 para rand.Intn nos dará um número no intervalo de 0-100. Então, usamos um loop for para começar a coletar adivinhações do jogador.

      A função fmt.Scanf nos oferece um meio para ler a entrada do usuário em uma variável de nossa escolha. Ela usa um verbo para a string de formato, a qual converte a entrada do usuário para o tipo que esperamos. O %d aqui significa que esperamos um int e enviamos o endereço da variável guess para que o fmt.Scanf consiga definir tal variável. Após lidar com quaisquer erros de análise, usamos duas instruções if para comparar a adivinhação do usuário com o valor target. A string que elas retornam, junto com o bool [booleano], controla a mensagem exibida para o jogador e também se o jogo fechará.

      Essas instruções if tornam vago o fato de que o intervalo de valores com o qual a variável está sendo comparada são todos relacionados de alguma maneira. À primeira vista, pode ser difícil dizer se perdemos alguma parte do intervalo. O exemplo a seguir refatora o exemplo anterior para usar uma instrução switch como alternativa:

      package main
      
      import (
          "fmt"
          "math/rand"
      )
      
      func main() {
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              switch {
              case guess > target:
                  fmt.Println("Too high!")
              case guess < target:
                  fmt.Println("Too low!")
              default:
                  fmt.Println("You win!")
                  return
              }
          }
      }
      

      Isso gerará um resultado similar ao seguinte:

      Output

      Enter a guess: 25 Too low! Enter a guess: 28 Too high! Enter a guess: 27 You win!

      Nessa versão do jogo de adivinhação, substituímos o bloco de instruções if por uma instrução switch. Omitimos o argumento da expressão para switch porque somente estamos interessados em usar a instrução switch para coletar condicionais juntas. Cada cláusula case contém uma expressão diferente que compara o guess com o target. De maneira similar à primeira vez que substituímos instruções if pela switch, já não precisamos mais de instruções continue, já que apenas uma cláusula case será executada. Por fim, a cláusula default lida com o caso onde o guess == target, uma vez que cobrimos todos os outros valores possíveis com outras duas cláusulas case.

      Nos exemplos que vimos até agora, será executada exatamente uma instrução case. De vez em quando, você pode desejar combinar os comportamentos das várias cláusulas case. As instruções switch fornecem outra palavra-chave para alcançar este comportamento.

      Fallthrough

      As vezes será necessário reutilizar o código que outra cláusula case contém. Nesses casos, é possível pedir ao Go que execute o corpo da próxima cláusula case listada usando a palavra-chave fallthrough. Este próximo exemplo modifica nosso exemplo anterior de sabor de sorvete para refletir com maior precisão nosso entusiasmo por sorvete de morango:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
                  fallthrough
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      Vamos ver este resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! strawberry is great! I've never tried banana before

      Como vimos anteriormente, definimos uma fatia da string para representar sabores e iterar ao longo dela usando um loop for. A instrução switch aqui é idêntica à que já vimos antes, porém com a adição da palavra-chave fallthrough ao final da cláusula case para "strawberry". Isso faz com que o Go execute o corpo de case "strawberry":, primeiro imprimindo a string strawberry is my favorite! (morango é o meu predileto!). Quando encontrar a palavra-chave fallthrough, executará o corpo da próxima cláusula case. Isso faz com que o corpo do case "vanilla", "chocolate" execute, imprimindo strawberry is great! (morango é uma ótimo!).

      A palavra-chave fallthrough não é usada frequentemente pelos desenvolvedores de Go. Normalmente, a reutilização de código realizada usando a palavra-chave fallthrough pode ser obtida de maneira melhor definindo-se uma função com o código comum. Por essas razões, o uso da palavra-chave fallthrough, no geral, é desencorajado.

      Conclusão

      As instruções switch nos ajudam a transmitir para outros desenvolvedores que leem nosso código que em um conjunto de comparações, elas estão de alguma maneira relacionadas. Elas facilitarão muito mais quando tivermos que adicionar comportamentos diferentes se um novo caso for adicionado no futuro e possibilitarão a garantia de que tudo o que esquecermos será devidamente tratato apropriadamente com as cláusulas default. A próxima vez que você se encontrar escrevendo várias instruções if, sendo que todas envolvem a mesma variável, tente reescrevê-las com uma instrução switch — será mais fácil revisar o trabalho quando for hora de considerar algum outro valor alternativo.

      Se quiser aprender mais sobre a linguagem de programação Go, confira toda a série sobre Como codificar na série Go.



      Source link

      Cómo escribir instrucciones switch en Go


      Introducción

      Las instrucciones condicionales brindan a los programadores la capacidad indicar a sus programas que realicen una acción si una condición es verdadera y otra si la condición es falsa. Con frecuencia, nos conviene comparar alguna variable con múltiples valores posibles y realizar diferentes acciones en cada circunstancia. Es posible lograr esto utilizando solo instrucciones if. Sin embargo, escribir software no solo se trata de lograr que las cosas funcionen, sino también de comunicar su intención a usted mismo en el futuro y a otros desarrolladores. switch es una instrucción condicional alternativa útil para comunicar las acciones realizadas por sus programas de Go cuando se les presentan diferentes opciones.

      Todo lo que podamos escribir con la instrucción de switch también se puede escribir con instrucciones if. En este tutorial, veremos algunos ejemplos de lo que puede lograr la instrucción switch, las instrucciones if que sustituye y en que situaciones se aplica de forma más adecuada.

      Estructura de las instrucciones Switch

      Switch se utiliza comúnmente para describir las acciones efectuadas por un programa cuando a una variable se le asignan valores específicos. En el siguiente ejemplo se muestra la forma en que lograríamos esto usando instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              if flav == "strawberry" {
                  fmt.Println(flav, "is my favorite!")
                  continue
              }
      
              if flav == "vanilla" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              if flav == "chocolate" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              fmt.Println("I've never tried", flav, "before")
          }
      }
      

      Esto generará el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Dentro de main, definimos un slice de sabores de helado. Luego usaremos un for loop para iterarlos. Utilizamos tres instrucciones if para imprimir diferentes mensajes que indican preferencias por diferentes sabores de helado. Cada instrucción if debe usar la instrucción continue para detener la ejecución del bucle for, de modo que el mensaje predeterminado al final no se imprima para los sabores de helado preferidos.

      Al añadir nuevas preferencias de helado, debemos seguir agregando instrucciones if para manejar los nuevos casos. En los mensajes duplicados, como en el caso de “vanilla” y “chocolate”, deben estar duplicadas las instrucciones if. Para los futuros lectores de nuestro código (incluidos nosotros), la naturaleza repetitiva de las instrucciones if oculta la parte importante de lo que hacen, (cuando se compara la variable con varios valores y tomando y se toman diferentes acciones). Además, nuestro mensaje de reserva se distingue de los condicionales y hace que parezca que no está relacionado. La instrucción switch puede servirnos para organizar mejor esta lógica.

      La instrucción switch comienza con la palabra clave switch y le sigue, en su forma más básica, alguna variable contra la cual puedan realizarse comparaciones. A esto le sigue un par llaves ({}) en el que pueden aparecer varias_ cláusulas de caso_. Las cláusulas de caso describen las acciones que su programa de Go debe realizar cuando la variable proporcionada a la instrucción switch es igual al valor referido por las cláusulas de caso. El siguiente ejemplo convierte el ejemplo anterior para que utilice switch en lugar de varias instrucciones if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      El resultado es el mismo que el anterior:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Una vez más, definimos un segmento de sabores de helado en main y usamos la instrucción range para iterar cada sabor. Sin embargo, esta vez usamos una instrucción switch que examinará la variable flav. Utilizamos dos cláusulas case para indicar las preferencias. Ya no necesitamos las instrucciones continue porque la instrucción switch solo ejecutará una cláusula case. También podemos combinar la lógica duplicada de los condicionales “chocolate” y “vanilla” separando cada uno con una coma en la declaración de la cláusula case. La cláusula default sirve como cláusula general. Se ejecutará para cualquier sabor que no hayamos tenido en cuenta en el cuerpo de la instrucción switch. En este caso, “banana” hará que se ejecute default, con lo cual se imprimirá el mensaje I've never tried banana before.

      Esta forma simplificada de las instrucciones switch aborda el uso más común para ellas: comparar una variable con varias alternativas. También nos proporciona practicidad cuando queremos realizar la misma acción para varios valores diferentes y cualquier otra acción cuando no se cumple ninguna de las condiciones enumeradas al usar la palabra clave default.

      Cuando esta forma simplificada de switch resulta demasiado limitada, podemos usar una forma más general de la instrucción switch.

      Instrucciones generales de switch

      Las instrucciones switch son útiles para agrupar las colecciones de condicionales más complicadas a fin de mostrar que están de algún modo relacionadas. Esto se utiliza con mayor frecuencia al comparar una variable con un rango de valores, en lugar de valores específicos como en el ejemplo anterior. El siguiente ejemplo implementa un juego de adivinanzas usando instrucciones if que se podrían beneficiar con una instrucción switch:

      package main
      
      import (
          "fmt"
          "math/rand"
          "time"
      )
      
      func main() {
          rand.Seed(time.Now().UnixNano())
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              if guess > target {
                  fmt.Println("Too high!")
                  continue
              }
      
              if guess < target {
                  fmt.Println("Too low!")
                  continue
              }
      
              fmt.Println("You win!")
              break
          }
      }
      

      El resultado puede variar dependiendo del número aleatorio que seleccionó y de lo bien que se desempeñe en el juego. A continuación, se muestra el resultado de una sesión de ejemplo:

      Output

      Enter a guess: 10 Too low! Enter a guess: 15 Too low! Enter a guess: 18 Too high! Enter a guess: 17 You win!

      En nuestro juego de adivinanzas se requiere un número al azar para compararlas, por lo que usamos la función rand.Intn del paquete math/rand. A fin de asegurarnos de obtener valores diferentes para target cada vez que juguemos, usamos rand.Seed para aleatorizar el generador de números aleatorios según la hora actual. El argumento 100 en rand.Intn nos proporcionará un número dentro del rango de 0 a 100. Luego, usaremos un bucle for para comenzar a recopilar adivinanzas del jugador.

      La función fmt.Scanf nos proporciona un medio para leer las entradas del usuario en una variable que elijamos. Se requiere un verbo de cadena de formato que convierta la entrada del usuario al tipo que esperamos. Aquí %d significa que esperamos un int y pasamos la dirección de la variable guess de modo que fmt.Scanf pueda establecer esa variable. Después de manejar cualquier error de análisis, usamos dos instrucciones if para comparar la adivinanza del usuario con el valor target. El string que muestran, junto con bool, controla el mensaje que se presenta al jugador y si el juego se cerrará.

      Estas instrucciones if ocultan el hecho de que el rango de valores con los que se compara la variable están todos relacionados de alguna manera. También puede ser difícil, a simple vista, saber si faltó alguna parte del rango. En el siguiente ejemplo se vuelve a refactorizar el ejemplo anterior para usar una instrucción switch en su lugar:

      package main
      
      import (
          "fmt"
          "math/rand"
      )
      
      func main() {
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              switch {
              case guess > target:
                  fmt.Println("Too high!")
              case guess < target:
                  fmt.Println("Too low!")
              default:
                  fmt.Println("You win!")
                  return
              }
          }
      }
      

      Con esto, se mostrará un resultado similar al siguiente:

      Output

      Enter a guess: 25 Too low! Enter a guess: 28 Too high! Enter a guess: 27 You win!

      En esta versión del juego de adivinanzas, se sustituyó el bloque de instrucciones if por una instrucción switch. Se omite el argumento de la expresión de switch, ya que solo nos interesa recopilar los condicionales juntos utilizando switch. Cada cláusula case contiene una expresión diferente que compara guess con target. Como la primera vez que sustituimos las instrucciones if por switch, ya no necesitamos las instrucciones continue porque solo se ejecutará una cláusula case. Por último, la cláusula default se encarga del caso en el que guess == target, ya que cubrimos todos los demás valores posibles con las otras dos cláusulas case.

      En los ejemplos que vimos hasta el momento, se ejecutará exactamente una instrucción caso. De vez en cuando, es posible que desee combinar los comportamientos de varias cláusulas case. Las instrucciones switch proporcionan otra palabra clave para lograr este comportamiento.

      Fallthrough

      A veces, querrá volver a utilizar el código que otra cláusula case contiene. En estos casos, es posible solicitar que Go ejecute el cuerpo de la siguiente cláusula case enumerada usando la palabra clave fallthrough. En el siguiente ejemplo, se modifica nuestro ejemplo anterior de sabores de helado para reflejar con mayor precisión nuestro entusiasmo por el helado de fresa:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
                  fallthrough
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      Veremos el siguiente resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! strawberry is great! I've never tried banana before

      Como ya lo observamos antes, definimos un segmento string para representar los sabores e iterar este usando un bucle for. La instrucción switch aquí es idéntica a la que vimos antes, pero se agrega la clave fallthrough al final de la cláusula case para “strawberry”. Esto hará que Go ejecute el cuerpo de case “strawberry”:, imprimiendo primero la cadena strawberry is my favorite!. Cuando este encuentre fallthrough, ejecutará el cuerpo de la cláusula case siguiente. Esto hará que el cuerpo de case “vanilla”, “chocolate”: se ejecute e imprima strawberry is great!.

      Los desarrolladores de Go no utilizan la palabra clave fallthrough a menudo. Normalmente, la reutilización del código mediante fallthrough se puede obtener de mejor manera definiendo una función con el código común. Por estas razones, generalmente no se recomienda utilizar fallthrough.

      Conclusión

      Las instrucciones switch nos ayudan a transmitir, a otros desarrolladores que leen nuestro código, que una serie de comparaciones están de alguna manera relacionadas entre sí. Hacen que sea mucho más fácil añadir comportamientos diferentes cuando un nuevo caso se añade en el futuro y permite garantizar que cualquier cosa que se haya olvidado se maneje de manera adecuada también con cláusulas default. La próxima vez que tenga que escribir varias instrucciones if que impliquen todas la misma variable, intente reescribirla con una instrucción switch, le resultará más sencillo volver a trabajar cuando llegue el momento de considerar algún otro valor alternativo.

      Si desea obtener más información acerca del lenguaje de programación de Go, consulte toda la serie sobre Cómo realizar codificaciones en Go.



      Source link