Como fazer a saida do powershell ter mais que 80 carcteres

Para executar um scritp ou comando no powershell que necessite que o retorno do mesmo seja mais que 80 cacteres em uma unica linha pode ser um problema. Normalmente o resultado da execução de um comando é delimitado pelo tamanho da janela do powershell.

Exemplo:

Abaixo é possivel ver que foi adicionado três pontos (...) para demonstrar que tem mais informações nessa linha.

Abaixo é possivel ver que foi adicionado três pontos (...) para demonstrar que tem mais informações
Para resolver o problema e exibir todos os caracteres do comando basta utilizar o trecho de comando abaixo após o comando a ser executado.

Sintaxe:

COMANDO | out-string -Width TAMANHO 

Onde:

COMANDO - Comando do qual será o resultado será exibido.
TAMANHO -  Quantidade de caracteres a serem exibidos.


Abaixo é possível ver o mesmo comando acima com o limite de caracteres aumentado para 200

Converter Data para String no postgresql

Sintaxe:

TO_CHAR(campo_data, 'formato')


Exemplo 1:

SELECT TO_CHAR(CURRENT_DATE,'YYYY')

Nesse exemplo a data será convertida para uma string contendo somente o ano. (Nesse exemplo a palavra chave CURRENT_DATE ela paga  data atual do sistema, mas poderia ser uma coluna no formato data da sua tabela)


Exemplo 2:

SELECT TO_CHAR(CURRENT_DATE,'DD/MM/YYYY')

Nesse exemplo a data será convertida para uma string contendo somente o ano.

Pegar a data atual no postgresql

Sintaxe:

CURRENT_DATE


Exemplo:

SELECT CURRENT_DATE

Nesse exemplo é exibido a data atual.

Vale lembra que o parametro pode ser usados para filtros no WHERE.

Exemplo:

SELECT data, nome FROM alunos WHERE data > CURRENT_DATE

Convertendo string para data no postgresql

Sintaxe:

TO_DATE( cadeira_caracteres, 'FORMAT')

Exemplo:

SELECT TO_DATE('15122018', 'DDMMYYYY')


Nesse exemplo a data a string 15122018 será convertido para uma data.

Pegando informações de disco por linha de comando (cmd)

Uma maneira simples e rapida de pegar algumas informações do disco rigido através do cmd é utilizando o comando wmic diskdrive


Sintaxe:

wmic diskdrive

Programando em Go (Golang) - Map

table, th, td { border: 1px solid black; } O mapa em golang assim como em outras linguagem é uma estrutura de dados onde é guardado um chave e um valor referente a mesma chave.

Exemplo:

O valor zero do mapa é considerado nulo (nil) e sendo assim não é possível adicionar novas chaves e valores no mesmo.

Criação de um mapa

Para criarmos um mapa utilizamos a sintaxe abaixo:

nome_mapa = make (map[tipo_chave]tipo_valor)

Onde:

nome_mapa - Nome do mapa a ser criado.
tipo_chave - Tipo de chave do mapa a ser criado
tipo_valor - Tipo do valor que será referenciado pela chave.

Adição de valores 

Para adicionar um valor a um mapa basta utilizar a sintaxe:

nome_mapa[nome_chave]=valor

Onde:

nome_mapa - Nome do mapa a ser criado.
nome_chave - Nome da chave referência do mapa
valor - Valor a ser referenciado pela chave.

Acesso a um valor 

Para acessarmos o conteúdo de uma chave do mapa basta utilizar a sintaxe abaido:

nome_mapa[nome_chave]

Onde:

nome_mapa - Nome do mapa a ser criado.
nome_chave - Nome da chave referência do mapa

Exemplo:

package main
import "fmt"

func main(){

  //Criação do mapa
  m:=make(map[string]string)

  //Adição de valores
  m["nome"]="Mario"
  m["cpf"]="333.213.333-35"
  
  //Acesso a um valor
  fmt.Println(m["cpf"])

}


Saída do programa acima:

Criação rapida (literal)

Para criarmos um mapa utilizamos a sintaxe abaixo:

nome_mapa = map[tipo_chave]tipo_valor{
chave_1:valor_1, chave_2:valor_2
}

Onde:

nome_mapa - Nome do mapa a ser criado.
tipo_chave - Tipo de chave do mapa a ser criado
tipo_valor - Tipo do valor que será referenciado pela chave.
chave_1 - Nome da  chave_1
valor_1 - Valor da chave_1

Exemplo:

package main

import "fmt"

func main(){

  //Criação do mapa
  m:=map[string]string{"nome":"Mario", "cpf":"333.213.333-35"}

  //Acesso a um valor
  fmt.Println(m["cpf"])

}


Deletando um valor do mapa

Para deletar um valor do mapa utilizamos a função delete

Sintaxe:

delete(nome_mapa,chave)

Onde:

nome_mapa - Nome do mapa a ter um item deletado
chave - Nome da chave a ser deletada.

Verificação de existência chave

Há caso que é necessário verificar se um elemento existe em um determinado mapa para isso usa sintaxe abaixo:

valor,verificador=nome_mapa[chave]

Onde:

valor - Valor da chave referenciado pela chave

verificador - Nome da variável que receberá o valor true (existe elemento) ou false (não existe o elemento)

Exemplo:

package main

import "fmt"

func main(){

  //Criação do mapa

  m:=map[string]string{"nome":"Mario", "cpf":"333.213.333-35"}

  //Acesso a um valor

  fmt.Println(m["cpf"])

  //Verificação da existencia do elemento

  valor,ok := m["cpf"]

  fmt.Println("O elemento[cpf] valor= ",valor," existe ? ",ok)

  //Remoção da chave cpf

  delete(m,"cpf")

  

  //Verificação da existencia do elemento

  valor,ok = m["cpf"]

  fmt.Println("O elemento[cpf] valor= ",valor," existe ? ",ok)

}

Abaixo é possível ver o resultado da execução do programa acima:

Voltar para menu

Finalizando um aplicação go

    os.Exit(3)

Há momentos que é necessário finalizar uma aplicação por algum motivo qualquer. Em golang utilizamos o método Exit da classe os.

Sintaxe:

os.Exit(codigo)

Onde:

codigo - Código para termino (exemplo:3)

Exemplo:

O programa abaixo finaliza o programa antes de executar o comando defer.

package main

import (
"os"

"fmt"
)

func main (){

 fmt.Println("Inicio\n")
 defer fmt.Println("\nFim\n")
 os.Exit(3)

}

Programando em Go (Golang) - Slice part 2

Adicionando itens a um slice

Para adicionar um novo item a um slice utilizamos a função append. A função append recebe com parâmetro slice, e o valor que será adicionado ao mesmo, sendo que é possível passar mais que um parâmetro de valor para o slice.

Sintaxe:

 append (slice,valor,...,valor_n)

Onde

slice  - Nome do slide a ser atribuído.
valor,...,valor_n - Valores a serem adicionado ao slice

Exemplo: 

No exemplo abaixo vemos dois exemplos onde é possível ver adição de itens a um determinado slice.

package main

import ( "fmt")

func main (){
 var sliceNomes []string


 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))

 //No exemplo abaixo é adicionado um item ao slice sliceNomes

 sliceNomes=append(sliceNomes,"Maria")

 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))

 //No exemplo abaixo é adicionado três itens ao slice sliceNomes

 sliceNomes= append(sliceNomes,"John", "Dany", "Sansa")


 fmt.Printf("\n Total de itens no slice é : %d",len(sliceNomes))


}

Abaixo é possível ver o resultado da execução do programa acima no powershell (pode escolher o cmd também)..

Range


O range é comando utilizado para acessar de maneira mais simples e rápida os valores de um slice em um laço for.
Quando utilizamos o range é tornado para o programador dois valores: um int e outro do tipo de dado de  seu slice, abaixo é possível ver essa ação na sintaxe e exemplo abaixo.


Sintaxe:

for contador,valor :range slice{
 /...Ações a  serem tomadas
}

Onde:

contador - Variável do contador do laço.
valor - Contido na posição explicitada pelo contador dentro do slice.
slice - Slice a ser percorrido



Exemplo:


package main

import "fmt"

var nomes = []string{"Bruce", "Tony","Pietro", "Vanda", "Logan", "Wade"}

func main() {
for i, v := range nomes{
fmt.Printf("[%d] = %s\n", i, v)
}
}

Voltar para o menu

Pegar o nome do usuário logado com linha de comando

Existem várias maneiras de se obter o usuário no qual você está logado no sistema, para isso apresentaremos algumas maneira abaixo utilizando powerShell e cmd.



Power Shell

Get-WMIObject -class Win32_ComputerSystem | select username

Prompt de comando cmd

Utilizando o prompt (cmd) basta abrir o mesmo executar os comandos dos topicos abaixo.

Através do comando whoami

Através do whoami é obtido somente o nome do usuário.

Sintaxe:

whoami

Através do comando query user

Através do query user são obtidos mais informações como: nome da sessão (SessionName) e hora de logon.

Sintaxe:

query user

Programando em Go (Golang) - Slice part 1

O Slice é um array sem tamano fixo. O Slice quando criado é especificado a quantidade de itens que o mesmo tem, não a quantidade maxima que poderá ter como acontece com o array. Abaixo é possível ver a sintaxe básica para criação de um slice.

Sintaxe:

nome[inicio:fim]

Onde:

• nome - Nome do slice
• inicio - Índice Valor inicial do slice
• fim - Índice do valor final do slince

Exemplo:

package main

import (

"fmt"

)

func main (){

numeros := [8]int{1,2,3,4,5,6,7,8}

selecao:=numeros[1:4]

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

}

Neste exemplo é criado um slice que contém os valores 2,3,4 ou seja ele pegou os valores do índice 1 até o índice 4. Abaixo é possível visualizar o resultado da execução do programa acima.

Um slice não guarda nenhum tipo de dado ele apenas guarda uma parte do array, ou seja se o array for modificado o valor do mesmo também será alterado. Vide o exemplo abaixo:

package main

import (
"fmt"
)

func main (){

numeros := [8]int{1,2,3,4,5,6,7,8}
selecao:=numeros[1:4]

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

fmt.Println("Alteração do valor do índice 2 para 44")

numeros[2]=44 //Nesse trecho é alterado o valor da posição 2 de 3                  //para 44

fmt.Println("Numeros ",numeros)

fmt.Println("Selecao: ",selecao)

}

Abaixo é possível ver a saída do programa acima:

Slice Incompletos

É possível criar slice com a omissão dos inicio e de fim:

Exemplos:

• nome[1:10] - Slice com todos os parâmetros
• nome[:10] - Slice com apenas o parâmetro de fim.
• nome[1:] - Slice com apenas o parâmetro de inicio.
• nome[:] - Slice sem ambos os parâmetros.

Slice literal

Um slice pode literal é como um array sem tamanho

Sintaxe:

nome:=[]tipo{va1,val2,..,valn}

Onde:

• nome - Nome do slice
• tipo - Tipo do slice
• va1,val2,..,valn - Valores

Exemplo:

package main

import (
"fmt"
)

func main (){
 nSliceLiteral := []int{1,2,3,4,5,6,7,8}
 fmt.Println("Numeros ",nSliceLiteral)
}

Slice:  tamanho e capacidade

É possível verificar o tamanho e a capacidade de um slice atraves dos métodos len(s) e cap(s).

Saber o tamanho do slice.

Sintaxe:

len(slice) 

Onde:

• slice - Nome do slice do qual será verificado o tamanho.

Para saber a capacidade de um slice utilizamos o método cap(s)

Sintaxe:

cap(slice) 

Onde:

• slice - Nome do slice do qual será verificado o tamanho.

Exemplo:

package main

import (

"fmt"

)

func main (){

   array := [8]int{1,2,3,4,5,6,7,8}

   sl:=array[0:3]

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Slice com make

É possível criar um slice com metodo make , essa é uma maneira de criar um array dinamico.

Criando slice com tamanho e make

Sintaxe :

 s := make([] tipo, tamanho)

Onde: 

• s - Nome do slice.
• tipo - Tipo do slice.
• tamanho - Tamanho do slice.

Exemplo:

package main

import (

"fmt"

)

func main (){

   sl:= make([]int,2)

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Criando slice com tamanho e capaciade através do make

Sintaxe :

 s := make([] tipo, tamanho,capacidade)

Onde: 

• s - Nome do slice.
• tipo - Tipo do slice.
• tamanho - Tamanho do slice.
• capacidade - Capacidade do slice.

Exemplo:

package main

import (

"fmt"

)

func main (){

   sl:= make([]int,2,5)

   fmt.Println("Numeros ",sl)

   fmt.Printf("Tamanho: %d Capacidade: %d",len(sl),cap(sl))

}

Saída do programa acima:

Voltar para menu

Como pegar o mac de computadores na rede

Caso seja necessário algum dia que seja pego o mac dos computadores em uma rede, basta utilizar o comando arp. Vale lembrar que é necessário abrir o  powershell ou o cmd para executar o comando.cd

MAC de todos computadores de uma rede

Sintaxe:

arp -a

MAC de um IP especifico

Para obter o mac de um determinado IP basta utilizar a sintaxe abaixo:

Sintaxe:

arp -a IP

Onde:

IP - O IP propriamente dito (ex: 10.10.20.1 , 192.168.0.1)

Exemplo:

arp -a 192.168.0.12

Pegando MAC do PC

O comando para pegar o mac do proprio pc é  getmac

Sintaxe

getmac

Programando em Go (Golang) - Arrays

Um array (arranjo) é um estrutura de dados onde é armazenado uma quantidade definida de valores e que podem serem acessados através de um índice.

Sintaxe:

var nome[tamanho] tipo

Onde:

• nome - Nome de variável array
• tamanho - Tamanho do array
• tipo - Tipo do array

No exemplo abaixo é criado um array de string com dez posições.

Exemplo 1: 

var nomes[10]string

Iniciando array com valores

É possível inicializar um array já com seus devidos valores

Sintaxe:

 nome := [tamanho]tipo{valor1,valor2,valorn}

Onde:

• nome - Nome do array.
• tamanho - Tamanho do Array
• valor1,valor2,valorn - Valores do array, lembrando que a quantidade de valor é a mesma citada no campo tamanho.

Exemplo:

idades :=[3]int{12,21,30}

Setar valor a uma posição especifica

É possível setar um valor para uma posição especifica de seu array para isso basta utilizar a sintaxe abaixo:

Sintaxe:

array[posicao]=valor

Onde:

array - Nome do array do qual terá um valor alterado.

posição - Posição no qual o valor será modificado.

valor - Valor a ser inserido na posição indicada pelo campo posição

Exemplo:

package main

import "fmt"

func main() {

var nomes [2]string

nomes[0] = "Mario"

nomes[1] = "Joaquim"

fmt.Println(nomes[0], nomes[1])

}

Acessando o valor de uma posição do array

Para pegar o valor de uma determinada posição do array basta usar a sintaxe abaixo:

Sintaxe:

array[posição]

Onde:

• array - nome do array a ter uma posição acessada.
• posição - Posição a ser acessada.

Exemplo:

Abaixo é possível ver um exemplo ver o acesso ao array, nos campos:   nomes[0], nomes[1]                                         

package main

import "fmt"

func main() {

var nomes [2]string

nomes[0] = "Mario"

nomes[1] = "Joaquim"

fmt.Println(nomes[0], nomes[1])

}

 0

Onservaçõe Finais

Programando em Go (Golang) - Estruturas Struct

Uma estrutura é uma coleção de campos.

Sintaxe:

type nome_estrutura struct {
var_1 tipo_1
var_2 tipo_2
...
var_n tipo_n
}

Onde:

• nome_estrutura - Nome da estrutura.
• var_1, var_2,var_n - Nome dos campos(váriveis) contidas na estrutura.
• tipo_1,tipo_2,tipo_n - Tipo da var_1,var_2,var_n

Uma maneira bem simples de iniciar uma estrutura e passar os valores para mesma através da sintaxe abaixo(nesse exemplo assumintos a estrutura acima:

nome_estrutura{valor1,valor2,..valorn}

Onde:

• nome_estrutura- Nome da estrutura.
• valor1 - Valor a ser adionado em var_1.
• valor2 - Valor a ser adionado em var_2.
• valorn - Valor a ser adionado em var_n.

Onde:

Exemplo.


package main

import "fmt"

type Pessoa struct {
nome string
cpf string
        idade int
}

func main() {
fmt.Println(Pessoa{"Nosbor", "392.231.334-40", 21})
}

Voltar para menu

Programando em Go (Golang) - Ponteiros (pointer)

Assim como em linguagens como C, C++ e Pascal, dente outras, Go também suporte para ponteiros.

A principal função de um ponteiro é apontar para um endereço de memoria, que no caso contém o valor de uma determinada variável.

Sintaxe:

nome_ponteiro *tipo_variavel

Onde:

• nome_ponteiro - Nome do ponteiro
• *tipo_variavel - Tipo do ponteiro.

O operador & gerar um ponteiro para seu operando

Sintaxe:

variavel := valor

ponteiro = &variavel

Onde:

• variavel - variavel(nesse caso operando) para qual o ponteiro apontará o local da memoria.
• valor - Valor a ser alocado na memória.
• ponteiro - Nome do ponteiro a ser utilizado
• &variavel - Nesse trecho é feito a referência de memoria da variavel ao ponteiro através do &.

Exemplo 1:

package main

import "fmt"

func main() {

 nome := "Julho"
 ponteiro := &nome

 fmt.Printf("Menu nome é %s",*ponteiro)

 }

Caso você queira desrreferência um ponteiro basta setar o valor no mesmo através da sintaxe abaixo:

Sintaxe:

*ponteiro = valor

Onde:

ponteiro - Nome do ponteiro que será desrreferênciado.

valor - Novo valor do ponteiro.

Exemplo 2:

package main

import "fmt"

func main() {

 nome := "Julho"
 ponteiro := &nome

 fmt.Printf("Menu nome é %s",*ponteiro)

 *ponteiro="Maria"

 fmt.Printf("Menu nome é %s",*ponteiro)


 }

Ai vem a dúvida por que usar um ponteiro ?

A resposta é simples você deseja que usar a referencia de uma valor de uma determinada variavel e não o valor em si.

Voltar para menu

Programando em Go (Golang) - Defer

A palavra chave defer faz com que uma determinada ação deseja executada somente no final da funçao no caso do retorno.

Sintaxe:

defer ação

Onde:

açao - Ação a ser tomada


Exemplo: No exemplo abaixo a exibição do string mundo só será exibida o final da função.


package main

import "fmt"

func main() {
defer fmt.Println("mundo")

fmt.Println("Olá ")
}


Saida do programa acima.

Vale lembra que pode ser usar mais de um defer dentro de uma função onde se segue o logica "o ultimo a ser executado é o primeiro a ser exibido"

Exemplo:


package main

import "fmt"

func main() {

for i:=0;i<10 font="" i="">
defer fmt.Printf("\n %d * %d = %d",i,2,i*2)
}
}


Sáida:

Voltar para o menu

Programando em Go (Golang) - Loop For

Uma estrutura de laço executa uma determinada ação até que um certo requisito deixe de ser verdadeiro e passe a ser false(falso).
Em Go (golang) existe somente a estrutura de laços for.

For completo

O laço completo é aquele no qual tem todos os três parâmetros do mesmo (inicializador, expressão_condicional, pos_execucao).

Sintaxe básica:

for inicializador; expressao_condicional; pos_execucao{
 //corpo do laço
}

Onde:

• inicializador - Ação incial na primeira integração do for
• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• pos_execucao - ação a se executada toda vez que o laço for integrado
• corpo do laço - Ações que serão executadas dentro do laço.

Observações

Vale lembrar que a variável criada no inicializador existe somente dentro do laço for. Ao contrário de outras linguagens é obrigatório a utilização das chaves { } para delimitar o corpo do laço.

Exemplo:

package main

import "fmt"

func main() {
mult := 2
for i := 0; i < 10; i++ {

fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
}
}

Saída da execução do programa:

For sem inicializador

O laço sem inicializador é aquele no qual tem dois dos três parâmetros do mesmo (expressão_condicional, pos_execucao).

Sintaxe básica:

for ; expressao_condicional; pos_execucao{
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• pos_execucao - ação a se executada toda vez que o laço for integrado
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variavel i do inicializador.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for ; i < 10; i++ {


fmt.Printf("\n%d * %d = %d",i,mult,mult*i)

}
}

For continuo

O laço no qual há apenas o parametro de expressao_condicional.

Sintaxe básica:

for ; expressao_condicional; {
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variável i do inicializador e também o do pos_execução.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for ; i < 10;  {



 fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
         i+=1   
}
}

Usando for como while

Assim como for continuo o for como while tem somente o bloco de condicional

Sintaxe básica:

for ; expressao_condicional; {
 //corpo do laço
}

Onde:

• expressao_condicional - Expressão a ser verificada sempre que há a integração no laço, caso o resultado da mesma seja false o laço é terminado.
• corpo do laço - Ações que serão executadas dentro do laço.

Exemplo:

No exemplo abaixo foi removido a variável i do inicializador e também o do pos_execução.

package main

import "fmt"

func main() {
mult := 2
                   i:=0
for i < 10  {


 fmt.Printf("\n%d * %d = %d",i,mult,mult*i)
         i+=1   
}
}

For infinito

É aquele for que não nenhum de seus blocos.

Sintaxe básica:

for {
 //corpo do laço
}

Voltar para menu

Programando em Go (Golang) - Constantes (constant)

Uma constante é uma variável na qual o conteúdo da mesma não pode ser modificado.
Em Go é possível declarar constantes utilizando a palavra chave const.
As variáveis do tipo constante não podem ser declaradas com utilização do :=

Sintaxe:

const nome_variavel = valor 

Onde:

• const - palavra chave
• nome_variavel - Nome da constante
• valor - Valor da constante.

Exemplo:

 

package main

import "fmt"

const mult = 2

func mutiplicador(x int) int{

return mult*x;
}

func main() {

    multiplicando:=3
    resultado:=mutiplicador(multiplicando)

    fmt.Printf("Multiplicação %d x %d = %d",mult, multiplicando,resultado)

}

 

Anterior                                       Início                                                       Próximo

Programando em Go (Golang) - Condicionais switch

Além do if/else em Go temos outro condicional que está presente em outras linguagens, no caso estou falando do switch. Com o switch é possível fazer uma especie de concatenação de if/else if e else.

Sintaxe:

switch varivel_comparacao:
{
case valor_1:
{
  acao_01
  break
}
case valor_2:
{
  acao_02
  break
}
case valor_3:
{
  acao_03
  break
}
case valor_n:
{
  acao_n 
  break
}
default:
acao_default
}

Onde:

• variavel_comparacao - Variável para comparação e execução dos blocos.
• valor_1,valor_2_valor_3,valor_n - São os possíveis valores de condição.
• acao_1, acao_2, acao_3, acao_n,acao_default - São os possíveis ações de acordo com a validação da variavel_comparacao.
• default - Caso nenhum valor seja aceito nos cases o mesmo o valor default é aceito.

Exemplo 1:

package main

import "fmt"

func main() {

 var resp string

 escolha := 32

switch escolha

{

case 32:

resp="Voce escolhe 32"

break;

case 45:

resp="Voce escolhe 45"

break;

case 65:

resp="Voce escolhe 65"

break;

case 25:

resp="Voce escolhe 25"

break;

default:

resp="Não é os valores acima"

}

fmt.Printf(resp)

}

Switch com case com mais de uma possíbilidade

Outra opção possível para facilitar a quantidade de case é colocar mais de uma condição ao mesmo.

Sintaxe:

switch varivel_comparacao:
{
case valor_1,valor_2:
{
  acao_01
  break
}
case valor_3:
{
  acao_03
  break
}
case valor_n:
{
  acao_n 
  break
}
default:
 acao_default
}

Onde:

• variavel_comparacao - Variável para comparação e execução dos blocos.
• valor_1,valor_2_valor_3,valor_n - São os possíveis valores de condição.
• acao_1, acao_2, acao_3, acao_n,acao_default - São os possíveis ações de acordo com a validação da variavel_comparacao.
• default - Caso nenhum valor seja aceito nos cases o mesmo o valor default é aceito.

Exemplo 2:

package main

import "fmt"

func main() {

 var resp string

 escolha := 32

switch escolha{

case 32,45:

resp="Voce escolhe 32 ou 45"

break;

case 65:

resp="Voce escolhe 65"

break;

case 25:

resp="Voce escolhe 25"

break;

default:

resp="Não é os valores acima";

}

fmt.Printf(resp)

}

Voltar para menu