One place for hosting & domains

      Strings

      Como Gerenciar Strings no Redis


      Introdução

      O Redis é um datastore ou armazenamento de dados open-source de chave-valor na memória. No Redis, strings são o tipo mais básico de valor que você pode criar e gerenciar. Este tutorial fornece uma visão geral de como criar e recuperar strings, bem como manipular os valores mantidos pelas chaves de string.

      Como Utilizar Este Guia

      Este guia está no formato de referência rápida com trechos de linha de comando independentes. Recomendamos que você pule para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      Os comandos mostrados neste guia foram testados em um servidor Ubuntu 18.04 executando a versão 4.0.9 do Redis. Para configurar um ambiente semelhante, você pode seguir o Passo 1 do nosso guia Como Instalar e Proteger o Redis no Ubuntu 18.04. Vamos demonstrar como esses comandos se comportam executando-os com redis-cli, a interface de linha de comando do Redis. Observe que se você estiver usando uma interface Redis diferente — Redli, por exemplo — a saída exata de certos comandos pode ser diferente.

      Como alternativa, você pode provisionar uma instância de banco de dados Redis gerenciada para testar esses comandos, mas observe que, dependendo do nível de controle permitido pelo seu provedor de banco de dados, alguns comandos neste guia podem não funcionar como descrito. Para provisionar um banco de dados gerenciado na DigitalOcean, siga nossa documentação de produto para Managed Databases. Então, você deve instalar ou o Redli ou configurar um túnel TLS para conectar-se ao banco de dados gerenciado por TLS.

      Criando e Gerenciando Strings

      Chaves que mantêm strings podem conter apenas um valor; você não pode armazenar mais de uma string em uma única chave. No entanto, as strings no Redis são binary-safe, o que significa que uma string do Redis pode conter qualquer tipo de dados, de caracteres alfanuméricos a imagens JPEG. O único limite é que as strings devem ter 512 MB ou menos.

      Para criar uma string, use o comando set. Por exemplo, o seguinte comando set cria uma chave chamada key_Welcome1 que contém a string "Howdy":

      Output

      OK

      Para definir várias strings em um comando, use mset:

      • mset key_Welcome2 "there" key_Welcome3 "partners,"

      Você também pode usar o comando append para criar strings:

      • append key_Welcome4 "welcome to Texas"

      Se a string foi criada com sucesso, o append produzirá um número inteiro igual a quantos caracteres a string possui:

      Output

      (integer) 16

      Note que o append também pode ser usado para alterar o conteúdo das strings. Veja a seção manipulando strings para detalhes sobre isso.

      Recuperando Strings

      Para recuperar uma string, use o comando get:

      Output

      "Howdy"

      Para recuperar várias strings com um comando, use mget:

      • mget key_Welcome1 key_Welcome2 key_Welcome3 key_Welcome4

      Output

      1) "Howdy" 2) "there" 3) "partners," 4) "welcome to Texas"

      Para cada chave passada para o mget que não contém um valor de string ou não existe, o comando retornará nil.

      Manipulando Strings

      Se uma string é composta de um número inteiro, você pode executar o comando incr para incrementá-lo em um:

      Output

      (integer) 4

      Da mesma forma, você pode usar o comando incrby para aumentar o valor de uma string numérica em um incremento específico:

      Output

      (integer) 20

      Os comandos decr e decrby funcionam da mesma maneira, mas diminuem o número inteiro armazenado em uma string numérica:

      Output

      (integer) 19

      Output

      (integer) 3

      Se já existir uma string alfabética, o append acrescentará o valor ao final do valor existente e retornará o novo comprimento da string. Para ilustrar, o comando a seguir acrescenta ", y'all" à string mantida pela chave key_Welcome4, portanto, agora a string exibirá "welcome to Texas, y'all":

      • append key_Welcome4 ", y'all"

      Output

      (integer) 15

      Você também pode acrescentar números inteiros a uma string que contém um valor numérico. O exemplo a seguir acrescenta 45 a 3, o número inteiro mantido em key_1, portanto ele conterá 345. Neste caso, o append também retornará o novo comprimento da string, em vez de seu novo valor:

      Output

      (integer) 3

      Como essa chave ainda possui apenas um valor numérico, você pode executar as operações incr e decr nela. Você também pode acrescentar caracteres alfabéticos a uma string de número inteiro, mas se você fizer isso, a execução de incr e decr na string produzirá um erro, pois o valor da string não será mais um número inteiro.

      Conclusão

      Este guia detalha vários comandos usados para criar e gerenciar strings no Redis. Se houver outros comandos, argumentos ou procedimentos relacionados que você gostaria de ver descritos neste guia, peça ou faça sugestões nos comentários abaixo.

      Para obter mais informações sobre comandos Redis, consulte nossa série de tutoriais Como Gerenciar um Banco de Dados Redis.



      Source link

      Uma introdução ao pacote de Strings em Go


      Introdução

      O pacote stringem Go possui várias funções disponíveis para trabalhar com o string data type​​​. Essas funções nos permitem modificar e manipular strings facilmente. Podemos pensar em funções como ações que realizamos nos elementos do nosso código. Funções integradas são aquelas definidas na linguagem de programação Go e ficam prontamente disponíveis para o nosso uso.

      Neste tutorial, avaliaremos várias funções diferentes que podemos usar para trabalhar com as strings em Go.

      Criando strings em letras maiúsculas e minúsculas

      As funções strings.ToUpper e strings.ToLower vão retornar uma string com todas as letras de uma string original convertidas em letras maiúsculas ou minúsculas. Como as strings são tipos de dados imutáveis, a string retornada será uma nova string. Quaisquer caracteres na string que não sejam letras não serão alterados.

      Para converter a string "Sammy Shark" para ser toda em maiúscula, use a função strings.ToUpper:

      ss := "Sammy Shark"
      fmt.Println(strings.ToUpper(ss))
      

      Output

      SAMMY SHARK

      Para converter para minúsculas:

      fmt.Println(strings.ToLower(ss))
      

      Output

      sammy shark

      Como você está usando o pacote strings, primeiro você precisa importá-lo para um programa. Para converter a string em maiúsculas e minúsculas, o programa todo ficaria da seguinte forma:

      package main
      
      import (
          "fmt"
          "strings"
      )
      
      func main() {
          ss := "Sammy Shark"
          fmt.Println(strings.ToUpper(ss))
          fmt.Println(strings.ToLower(ss))
      }
      

      As funções strings.ToUpper e strings.ToLower facilitam a avaliação e comparação de strings, tornando consistente o uso de maiúsculas e minúsculas de ponta a ponta. Por exemplo, se um usuário escreve seu nome com todas as letras minúsculas, ainda assim conseguiremos saber se o nome dele está em nosso banco de dados, comparando-o com uma versão com todas as letras maiúsculas.

      Funções de busca de string

      O pacote strings tem uma série de funções que ajudam a determinar se uma string contém uma sequência específica de caracteres.

      Função Uso
      strings.HasPrefix Procura a string desde o início
      strings.HasSuffix Procura a string a partir do final
      strings.Contains Procura em qualquer lugar na string
      strings.Count Conta quantas vezes a string aparece

      As funções strings.HasPrefix e strings.HasSuffix permitem que você verifique se uma string começa ou termina com um conjunto específico de caracteres.

      Por exemplo, para verificar se a string "Sammy Shark" começa com Sammy e termina com o Shark:

      ss := "Sammy Shark"
      fmt.Println(strings.HasPrefix(ss, "Sammy"))
      fmt.Println(strings.HasSuffix(ss, "Shark"))
      

      Output

      true true

      Você usaria a função strings.Contains para verificar se "Sammy Shark"contém a sequência Sh:

      fmt.Println(strings.Contains(ss, "Sh"))
      

      Output

      true

      Por fim, para ver quantas vezes a letra S aparece na frase Sammy Shark:

      fmt.Println(strings.Count(ss, "S"))
      

      Output

      2

      Nota: todas as strings em Go diferenciam maiúsculas de minúsculas. Isso significa que Sammy não é o mesmo que sammy.

      Usar um s minúsculo para obter uma contagem do Sammy Shark não é o mesmo que usar o S maiúsculo:

      fmt.Println(strings.Count(ss, "s"))
      

      Output

      0

      Como S é diferente de s, a contagem será 0.

      As funções de string são úteis quando você quer comparar ou pesquisar strings no seu programa.

      Determinando o tamanho da string

      A função integrada len() retorna o número de caracteres em uma string. Essa função é útil para quando você tiver que impor o tamanho mínimo ou máximo de uma senha, por exemplo, ou para truncar strings maiores para que fiquem dentro de certos limites para usar como abreviações.

      Para demonstrar essa função, encontraremos o tamanho de uma string longa:

      import (
          "fmt"
          "strings"
      )
      
      func main() {
              openSource := "Sammy contributes to open source."
              fmt.Println(len(openSource))
      }
      

      Output

      33

      Definimos a variável openSource igual a string "Sammy contributes to open source." e então passamos essa variável para a função len() com len(openSource). Por fim, movemos a função para que faça parte da função fmt.Println() para que pudéssemos ver o resultado do programa na tela.

      Lembre-se de que a função len() contará qualquer caractere vinculado por aspas duplas – incluindo letras, números, espaços em branco e símbolos.

      Funções para a manipulação de string

      As funções strings.Join, strings.Split e strings.ReplaceAll são algumas maneiras adicionais de manipular as strings em Go.

      A função strings.Join é útil para combinar uma fração das strings em uma única e nova string.

      Para criar uma string separada por vírgulas de uma fatia de strings, usaríamos essa função de acordo com o seguinte:

      fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))
      

      Output

      sharks,crustaceans,plankton

      Se quisermos adicionar uma vírgula e um espaço entre os valores da string na nossa nova string, podemos simplesmente reescrever nossa expressão com um espaço em branco após a vírgula: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

      Assim como podemos juntar strings, também podemos dividir as strings. Para fazer isso, podemos usar a função strings.Split e dividir nos espaços:

      balloon := "Sammy has a balloon."
      s := strings.Split(balloon, " ")
      fmt.Println(s)
      

      Output

      [Sammy has a balloon]

      O resultado é uma fatia de strings. Como a função strings.Println foi usada, é difícil distinguir o que seja o resultando apenas olhando para ele. Para verificar que se trata, de fato, de strings, utilize a função fmt.Printf com o verbo %q para citar as strings:

      fmt.Printf("%q", s)
      

      Output

      ["Sammy" "has" "a" "balloon."]

      Outra função útil, além de strings.Split é a strings.Fields. A diferença é que a função strings.Fields irá ignorar todos os espaços em branco e irá dividir apenas os fields em questão em uma string:

      data := "  username password     email  date"
      fields := strings.Fields(data)
      fmt.Printf("%q", fields)
      

      Output

      ["username" "password" "email" "date"]

      A função strings.ReplaceAll pode tomar uma string original e retornar uma string atualizada com algumas substituições.

      Digamos que o balão de Sammy esteja perdido. Como Sammy já não tem esse balão, mudaríamos a substring "has"(tem) da string original balloon (balão) para "had" (tinha) em uma nova string:

      fmt.Println(strings.ReplaceAll(balloon, "has", "had"))
      

      Dentro dos parênteses, primeiro está a variável balloon que armazena a string original; a segunda substring "has" é a que gostaríamos de substituir e a terceira substring "had" é o que iria substituir a segunda substring. Nosso resultado ficaria parecida com a seguinte, depois que incorporarmos isto em um um programa:

      Output

      Sammy had a balloon.

      Usar as funções string strings.Join, strings.Split e strings.ReplaceAll fornecerá a você um maior controle para manipular strings em Go.

      Conclusão

      Este tutorial examinou algumas das funções comuns do pacote string quanto ao tipo de dados de string que você pode usar para trabalhar e manipular strings em seus programas em Go.

      Você pode aprender mais sobre outros tipos de dados em Entendendo os tipos de dados e ler mais sobre strings em Uma introdução para trabalhar com strings.



      Source link

      Uma introdução ao trabalho com Strings em Go


      Uma string é uma sequência de um ou mais caracteres (letras, números, símbolos) que podem ser uma constante ou uma variável. Criadas com o padrão de codificação de caracteres Unicode, as strings são sequências imutáveis, o que significa que elas não podem ser modificadas.

      Como o texto é uma forma tão comum de dados que usamos no dia a dia, o tipo de dados da string é um bloco de construção muito importante da programação.

      Este tutorial sobre a linguagem Go revisará como criar e imprimir strings, como concatenar e replicar strings e como armazenar strings em variáveis.

      Literais de string

      Na linguagem Go, as strings ficam entre sinais de crase (ou diacrítico de acento grave). ` (às vezes chamadas de acento à esquerda) ou aspas duplas ". Dependendo de quais aspas você utilizar, a string terá características diferentes.

      Usar sinais de crase, como em `bar`criará uma literal de string *raw *(bruta). Em uma literal de string bruta, qualquer caractere pode aparecer entre aspas, com a exceção dos sinais de crase. Aqui está um exemplo de uma literal de string bruta:

      `Say "hello" to Go!`
      

      As barras invertidas não possuem significado especial dentro de literais de string brutas. Por exemplo, o n aparecerá como os caracteres existentes, a barra invertida e a letra n – ao contrário do que ocorre com as literais de string interpretadas, em que a letra n efetivamente inseriria uma nova linha.

      As literais de string brutas também podem ser usadas para criar strings de várias linhas:

      `Go is expressive, concise, clean, and efficient.
      Its concurrency mechanisms make it easy to write programs
      that get the most out of multi-core and networked machines,
      while its novel type system enables flexible and modular
      program construction. Go compiles quickly to machine code
      yet has the convenience of garbage collection and the power
      of run-time reflection. It's a fast, statically typed,
      compiled language that feels like a dynamically typed,
      interpreted language.`
      

      As literais de string interpretadas são sequências de caracteres entre aspas duplas, como em "bar". Dentro das aspas, qualquer caractere pode aparecer com a exceção de nova linha e aspas duplas sem sequência de escape.

      "Say "hello" to Go!"
      

      Quase sempre você usará as literais de string interpretadas pois elas permitem o uso de caracteres de escape dentro delas.

      Agora que entende como as strings são formatadas em Go, vamos ver como imprimir strings em programas.

      Imprimindo strings

      Você pode imprimir strings usando o pacote fmt da biblioteca do sistema e chamando a função Println():

      fmt.Println("Let's print out this string.")
      

      Output

      Let's print out this string.

      Você precisa import (importar) os pacotes de sistema ao usá-los, de modo que para imprimir uma string, um progama simples ficaria parecido com este:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Let's print out this string.")
      }
      

      Concatenação de string

      *Concatenação *significa unir strings, de ponta a ponta, para criar uma nova string. Você pode concatenar strings com o operador +. Lembre-se de que quando trabalhar com números, o + será um operador de adição, mas quando usado com strings ele é um operador de união.

      Vamos combinar os literais de string "Sammy" e "Shark" junto com a concatenação através de uma instrução fmt.Println():

      fmt.Println("Sammy" + "Shark")
      

      Output

      SammyShark

      Se quiser um espaço em branco entre as duas strings, simplesmente inclua o espaço em branco dentro de uma string. Neste exemplo, adicione o espaço em branco dentro das aspas após Sammy:

      fmt.Println("Sammy " + "Shark")
      

      Output

      Sammy Shark

      O operador + não pode ser usado entre dois tipos de dados diferentes. Como exemplo, não é possível concatenar strings e números inteiros juntos. Se você tivesse que tentar escrever o seguinte:

      fmt.Println("Sammy" + 27)
      

      Você receberia os seguintes erros:

      Output

      cannot convert "Sammy" (type untyped string) to type int invalid operation: "Sammy" + 27 (mismatched types string and int)

      Se quisesse criar a string "Sammy27", poderia fazer isso colocando o número 27 entre aspas ("27") de modo que não mais seria um número inteiro, mas sim uma string. Converter os números em strings para concatenação pode ser útil ao se lidar com códigos de CEP ou números de telefone. Por exemplo, você não quer fazer uma soma entre um código de país e um código de área, mas quer que eles fiquem juntos.

      Ao combinar duas ou mais strings através de concatenação, você está criando uma nova string que pode usar ao longo do seu programa.

      Armazenando strings e variáveis

      Variáveis são símbolos que você pode usar para armazenar dados no programa. Você pode pensar nelas como uma caixa vazia que pode preencher com dados ou valores. As strings são dados, então você pode usá-las para preencher uma variável. Declarar strings como variáveis pode tornar o trabalho com strings mais fácil durante seus programas em Go.

      Para armazenar uma string dentro de uma variável, basta atribuir uma variável a uma string. Neste caso, declare s como sua variável:

      s := "Sammy likes declaring strings."
      

      Nota: se estiver familiarizado com outras linguagens de programação, você pode ter escrito a variável como sammy. A linguagem Go, entretanto, favorece nomes de variáveis mais curtos. Escolher s para o nome de variável neste caso seria considerado mais apropriado para o estilo no qual a linguagem Go é escrita.

      Agora que tem a variável s definida para essa string específica, você pode imprimir a variável dessa forma:

      fmt.Println(s)
      

      Então, você receberá o seguinte resultado:

      Output

      Sammy likes declaring strings.

      Ao usar variáveis para substituir strings, não será necessário digitar novamente uma string sempre que quiser usá-la, o que tornará o trabalho e a manipulação das strings mais simples dentro dos seus programas.

      Conclusão

      Este tutorial revisou os fundamentos do trabalho com o tipo de dados de string na linguagem de programação Go. Criar e imprimir strings, concatenar e replicar strings e armazenar strings em variáveis fornecerá a você os fundamentos para usar strings nos seus programas em Go.



      Source link