O que é uma runa?

O que é uma rune in Go?

Eu tenho pesquisado no Google, mas Golang apenas diz em uma linha: runeé um apelido paraint32 .

Mas como os números inteiros são usados ​​ao redor, como trocar casos?

A seguir, uma caixa de troca de funções. O que é tudo <=e -?

E por que não switchtem argumentos?

&&deve significar e mas o que é r <= 'z'?

func SwapRune(r rune) rune {
    switch {
    case 'a' <= r && r <= 'z':
        return r - 'a' + 'A'
    case 'A' <= r && r <= 'Z':
        return r - 'A' + 'a'
    default:
        return r
    }
}

A maioria deles é de http://play.golang.org/p/H6wjLZj6lW

func SwapCase(str string) string {
    return strings.Map(SwapRune, str)
}

Eu entendo que isso está mapeando runepara stringque ele possa retornar a string trocada. Mas eu não entendo como exatamente runeou bytefunciona aqui.

Literais de runa são apenas valores inteiros de 32 bits ( no entanto, são constantes não tipadas, para que seu tipo possa ser alterado ). Eles representam pontos de código unicode. Por exemplo, o literal da runa 'a'é realmente o número97 .

Portanto, seu programa é praticamente equivalente a:

package main

import "fmt"

func SwapRune(r rune) rune {
    switch {
    case 97 <= r && r <= 122:
        return r - 32
    case 65 <= r && r <= 90:
        return r + 32
    default:
        return r
    }
}

func main() {
    fmt.Println(SwapRune('a'))
}

Deveria ser óbvio, se você observar o mapeamento Unicode, que é idêntico ao ASCII nesse intervalo. Além disso, 32 é de fato o deslocamento entre o ponto de código em maiúsculas e minúsculas do caractere. Então, adicionando 32a 'A', você obtém 'a'e vice-versa.

Nas notas de versão do Go lang: http://golang.org/doc/go1#rune

Rune é um tipo. Ocupa 32 bits e deve representar um CodePoint Unicode . Como analogia, o conjunto de caracteres em inglês codificado em 'ASCII' possui 128 pontos de código. Assim, é capaz de caber dentro de um byte (8 bits). A partir dessa suposição (incorreta), C tratava caracteres como 'bytes' e 'strings' como 'sequência de caracteres' .charchar*

Mas adivinhem. Existem muitos outros símbolos inventados por humanos além dos símbolos 'abcde ...'. E há tantos que precisamos de 32 bits para codificá-los.

Em golang, então a stringé uma sequência de bytes. No entanto, como vários bytes podem representar um ponto de código da runa, um valor de sequência também pode conter runas. Portanto, pode ser convertido em a []runeou vice-versa.

O pacote unicode http://golang.org/pkg/unicode/ pode dar uma amostra da riqueza do desafio.

Tentei manter minha linguagem simples para que um leigo entendesse rune.

Uma runa é um personagem. É isso aí.

É um único personagem. É um personagem de qualquer alfabeto, de qualquer idioma, de qualquer lugar do mundo.

Para obter uma string, usamos

double-quotes ""

OU

back-ticks ``

Uma string é diferente de uma runa. Nas runas usamos

single-quotes ''

Agora uma runa também é um pseudônimo para int32... O quê?

A razão pela qual rune é um alias int32é porque vemos que, com esquemas de codificação como abaixo

cada personagem é mapeado para algum número e, portanto, é o número que estamos armazenando. Por exemplo, um mapeia para 97 e quando armazenamos esse número, é apenas o número e, assim, runa é um alias para int32. Mas não é apenas qualquer número. É um número com 32 'zeros e uns' ou '4' bytes. (Nota: UTF-8 é um esquema de codificação de 4 bytes)

Como as runas se relacionam com as strings?

Uma string é uma coleção de runas. No código a seguir:

    package main

    import (
        "fmt"
    )

    func main() {
        fmt.Println([]byte("Hello"))
    }

Tentamos converter uma string em um fluxo de bytes. A saída é:

[72 101 108 108 111]

Podemos ver que cada um dos bytes que compõem essa string é uma runa.

Eu não tenho reputação suficiente para postar um comentário na resposta de fabrizioM , então terei que postá-lo aqui.

A resposta de Fabrizio está amplamente correta e ele certamente capturou a essência do problema - embora haja uma distinção que deve ser feita.

Uma string NÃO é necessariamente uma sequência de runas. É um invólucro sobre uma 'fatia de bytes', uma fatia sendo um wrapper sobre uma matriz Go. Que diferença isso faz?

Um tipo de runa é necessariamente um valor de 32 bits, o que significa que uma sequência de valores de tipos de runas necessariamente terá algum número de bits x * 32. As strings, sendo uma sequência de bytes, têm um comprimento de x * 8 bits. Se todas as strings estivessem realmente em Unicode, essa diferença não teria impacto. Como as seqüências de caracteres são fatias de bytes , o Go pode usar ASCII ou qualquer outra codificação de bytes arbitrária.

Literais de string, no entanto, precisam ser gravados na fonte codificada em UTF-8.

Fonte de informação: http://blog.golang.org/strings

(Tenho a sensação de que as respostas acima ainda não indicam as diferenças e as relações entre stringe[]rune muito claramente, por isso, tentaria adicionar outra resposta com exemplo.)

Como @Strangeworka resposta disse, stringe[]rune são silenciosos diferentes.

Diferenças - string& []rune:

• string valueé uma fatia de bytes somente leitura. E, uma string literal é codificada em utf-8. Cada char na stringverdade leva de 1 a 3 bytes, enquanto cada um runeleva 4 bytes
• Pois string, both len()e index são baseados em bytes.
• Pois []rune, both len()e index são baseados em runa (ou int32).

Relacionamentos - string& []rune:

• Quando você converte de stringpara []rune, cada caractere utf-8 nessa sequência se torna a rune.
• Da mesma forma, na conversão reversa, ao converter de []runepara string, cada runeum se torna um caracter utf-8 no string.

Dicas:

• Você pode converter entre stringe []rune, mas eles ainda são diferentes, tanto no tipo quanto no tamanho geral.

(Eu adicionaria um exemplo para mostrar isso mais claramente.)

Código

string_rune_compare.go:

// string & rune compare,
package main

import "fmt"

// string & rune compare,
func stringAndRuneCompare() {
    // string,
    s := "hello你好"

    fmt.Printf("%s, type: %T, len: %d\n", s, s, len(s))
    fmt.Printf("s[%d]: %v, type: %T\n", 0, s[0], s[0])
    li := len(s) - 1 // last index,
    fmt.Printf("s[%d]: %v, type: %T\n\n", li, s[li], s[li])

    // []rune
    rs := []rune(s)
    fmt.Printf("%v, type: %T, len: %d\n", rs, rs, len(rs))
}

func main() {
    stringAndRuneCompare()
}

Executar:

vá executar string_rune_compare.go

Resultado:

hello你好, type: string, len: 11
s[0]: 104, type: uint8
s[10]: 189, type: uint8

[104 101 108 108 111 20320 22909], type: []int32, len: 7

Explicação:

• A cadeia hello你好tem comprimento 11, porque os primeiros 5 caracteres cada um levam apenas 1 byte, enquanto os últimos 2 caracteres chineses levam 3 bytes.

  • Portanto, total bytes = 5 * 1 + 2 * 3 = 11
  • Como len()a string é baseada em bytes, a primeira linha impressalen: 11
  • Como o índice na string também é baseado em bytes, as duas linhas a seguir imprimem valores do tipo uint8(já que byteé um tipo de alias de uint8, em movimento).

• Ao converter stringpara []rune, ele encontrou 7 utf8 chars, assim 7 runas.

  • Como len()on []runeé baseado em runa, a última linha é impressa len: 7.
  • Se você operar []runevia índice, ele acessará a base na runa.
    Como cada runa é de um utf8 char na string original, também é possível dizer que a len()operação de ambos e o índice []runesão baseadas em utf8 chars.

Todo mundo já cobriu a parte relacionada às runas, então não vou falar sobre isso.

No entanto, há também uma pergunta relacionada a switchnão ter argumentos. Isso ocorre simplesmente porque em Golang, switchsem uma expressão, é uma maneira alternativa de expressar a lógica if / else. Por exemplo, escrevendo isso:

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

é o mesmo que escrever isso:

t := time.Now()
if t.Hour() < 12 {
    fmt.Println("It's before noon")
} else {
    fmt.Println("It's after noon")
}

Você pode ler mais aqui .

Uma runa é um valor int32 e, portanto, é um tipo de Go usado para representar um ponto de código Unicode. Um ponto de código Unicode ou uma posição de código é um valor numérico geralmente usado para representar caracteres Unicode únicos;