internalização de script

1. internalização de script

Morpheus
Minions

(usa Nenhuma)

Enviado em 04/11/2024 - 18:31h



Como é feita a internalização de script para vários idiomas?


  


2. Re: internalização de script

Alexa Bolada
alexabolada

(usa Debian)

Enviado em 04/11/2024 - 18:31h

A internalização de scripts para vários idiomas é uma prática importante quando você deseja que seu aplicativo ou site seja acessível a um público diversificado. Aqui estão algumas dicas sobre como fazer isso no contexto de um projeto em NodeJS e React:

1. **Utilize bibliotecas**: Existem várias bibliotecas que facilitam a internalização, como [i18next](https://www.i18next.com/) para NodeJS e React. Esta biblioteca permite gerenciar traduções e alternar entre idiomas facilmente.

2. **Estrutura de arquivos**: Você pode criar um arquivo JSON ou um conjunto de arquivos de tradução por língua. Por exemplo:

- `locales/en.json` para inglês
- `locales/pt.json` para português

Cada arquivo conterá pares de chave-valor para strings traduzidas.

3. **Configurações no seu código**:

Para configurar o [i18next](https://www.i18next.com/) em um projeto React, você pode seguir os passos abaixo:

```javascript
import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';

i18n
.use(initReactI18next)
.init({
resources: {
en: {
translation: {
welcome: "Welcome",
},
},
pt: {
translation: {
welcome: "Bem-vindo",
},
},


3. Re: internalização de script

Morpheus
Minions

(usa Nenhuma)

Enviado em 04/11/2024 - 18:52h


alexabolada

Como é feita a internalização de shell script?

Mostre um exemplo


4. Re: internalização de script

Alexa Bolada
alexabolada

(usa Debian)

Enviado em 04/11/2024 - 18:52h

A internalização (ou "i18n") em shell scripts envolve a adaptação do script para suportar diferentes idiomas e locais. Isso geralmente é feito através da utilização de variáveis de ambiente e arquivos de tradução.

Um exemplo simples seria usar o comando `gettext`, que é uma ferramenta comum para tradução de strings em scripts. Primeiro, você deve instalar o pacote `gettext` se ainda não estiver disponível:

# apt-get install gettext

Aqui está um exemplo de como você pode fazer isso:

1. Crie um arquivo de origem com as mensagens em inglês. Vamos chamá-lo de `messages.sh`:

[code]
#!/bin/bash

echo "Hello, World!"
echo "This is an internationalized script."
[\/code]

2. Extraia as mensagens:

# xgettext -o messages.pot messages.sh

3. Crie um arquivo de tradução para o português, chamado `messages.pt.po`:

[code]
msgid "Hello, World!"
msgstr "Olá, Mundo!"

msgid "This is an internationalized script."
msgstr "Este é um script internacionalizado."
[\/code]

4. Compile o arquivo de tradução:

# msgfmt -o messages.pt.mo messages.pt.po

5. No seu script, ative o suporte à internalização:

[code]
#!/bin/bash

export LANG=pt_BR.UTF-8
export TEXTDOMAIN=messages
export TEXTDOMAIND


5. Re: internalização de script

Morpheus
Minions

(usa Nenhuma)

Enviado em 04/11/2024 - 23:27h


alexabolada

Como é feita a internalização de shell script?


6. Re: internalização de script

Alexa Bolada
alexabolada

(usa Debian)

Enviado em 04/11/2024 - 23:27h

A internalização de scripts em shell, ou *internationalization* (i18n), refere-se ao processo de tornar um script capaz de suportar múltiplos idiomas e formatos regionais. Isso é importante para que os usuários de diferentes regiões possam entender e utilizar o script de forma eficaz.

Aqui estão algumas práticas comuns para realizar a internalização de shell scripts:

1. **Uso de arquivos de tradução**: Armazene as mensagens e textos a serem exibidos em arquivos separados, um para cada idioma. Você pode usar um formato simples como `.txt` ou algo mais estruturado como `.po` (usado pelo *gettext*).

2. **Utilização do *gettext***: O *gettext* é uma ferramenta poderosa para internacionalização em scripts. Ele permite que você marque strings a serem traduzidas.

Exemplo:

```bash
#!/bin/bash

# Ative o domínio gettext
TEXTDOMAIN="meuscript"
export TEXTDOMAIN

# Marque a string para tradução
echo "$(gettext 'Olá, mundo!')"
```

3. **Configuração de variáveis de ambiente**: Utilize variáveis que definem o idioma, como `LANG` ou `LC_ALL`, para alterar a linguagem de saída.

Para definir a linguagem, você pode usar:

```bash
export LANG=pt_BR.UTF-8
```

4. **Formatos de data e moeda**: Use comandos


7. Re: internalização de script

Morpheus
Minions

(usa Nenhuma)

Enviado em 05/11/2024 - 22:40h

Testei e não funcionou


8. Re: internalização de script

Buckminster
Buckminster

(usa Debian)

Enviado em 06/11/2024 - 13:59h

Você quis dizer "internacionalização".

Como é feita a internacionalização de Shell Script?
Veja a resposta do Chat GPT:

A internacionalização de Shell Script envolve adaptar os scripts para que possam ser facilmente utilizados em diferentes idiomas e regiões, além de lidar com caracteres e formatos específicos de cada local. Isso torna o script mais flexível e utilizável por pessoas em diferentes partes do mundo, sem a necessidade de reescrever ou modificar o código para cada novo idioma ou configuração regional.

Aqui estão algumas práticas comuns para internacionalizar um Shell Script:

### 1. **Uso de Variáveis de Ambiente para Idioma e Localização**
O primeiro passo é garantir que o script respeite as variáveis de ambiente que controlam as configurações de idioma e localidade do sistema, como `LANG`, `LC_ALL`, `LC_MESSAGES`, etc. Isso permite que o script se adapte automaticamente ao idioma e formato de data/hora/moeda do usuário.

- `LANG` define o idioma padrão do sistema.
- `LC_ALL` sobrescreve todas as variáveis de configuração de localidade.
- `LC_MESSAGES` é a variável responsável pela localização de mensagens de texto.

Por exemplo:

export LANG=pt_BR.UTF-8 # Define o idioma para português do Brasil
```

Para garantir que o seu script seja executado de acordo com as configurações de idioma e localidade do sistema, basta verificar essas variáveis e fazer uso delas quando necessário.

### 2. **Mensagens em Texto Adaptáveis**
Para internacionalizar as mensagens exibidas pelo seu script, você pode usar o comando `gettext` ou `printf` em combinação com arquivos de tradução. O `gettext` permite que você forneça traduções diferentes para diferentes idiomas.

A ideia básica é separar o texto em strings que podem ser traduzidas, em vez de ter as mensagens diretamente codificadas no script.

#### Exemplo simples com `gettext`:
1. Instalar `gettext` (se necessário):

sudo apt install gettext # Para distribuições baseadas no Debian
```

2. Criar um arquivo `.pot` com as mensagens a serem traduzidas:

xgettext -o messages.pot meu_script.sh
```

3. Traduzir as mensagens para diferentes idiomas criando arquivos `.po`:
- Para português (brasileiro), crie um arquivo `pt_BR.po` e edite as traduções:
```po
msgid "Hello, World!"
msgstr "Olá, Mundo!"
```

4. Compilar os arquivos `.po` para arquivos `.mo`:

msgfmt pt_BR.po -o pt_BR.mo
```

5. No script, utilize `gettext` para chamar a tradução:

#!/bin/bash

# Defina a localização para português do Brasil
export LANG=pt_BR.UTF-8
export TEXTDOMAINDIR="./locales"
export TEXTDOMAIN="messages"

# Exemplo de uso do gettext
echo "$(gettext 'Hello, World!')"
```

Isso permite que, dependendo do idioma configurado no sistema, as mensagens sejam automaticamente traduzidas.

### 3. **Uso de Arquivos de Configuração**
Em vez de codificar strings diretamente no script, você pode usar arquivos de configuração (por exemplo, `.conf` ou `.ini`) para armazenar mensagens e textos que podem ser facilmente modificados para diferentes idiomas.

O script pode então ler essas mensagens a partir dos arquivos de configuração, o que torna a tradução mais simples sem alterar o código-fonte do script.

### 4. **Trabalhando com Codificação de Caracteres**
A internacionalização também envolve garantir que o script manipule corretamente diferentes codificações de caracteres (como UTF-8). Isso é importante para garantir que o texto seja exibido corretamente em diferentes idiomas, especialmente quando há caracteres especiais, como acentos e caracteres de alfabetos não latinos.

O uso de `UTF-8` como codificação padrão ajuda a evitar problemas com caracteres especiais.

No início do script, você pode definir a codificação:

export LANG=en_US.UTF-8
```

### 5. **Formatação de Data e Hora**
O formato de data e hora varia de uma região para outra. Para tornar o seu script compatível com diferentes localidades, você deve usar ferramentas que respeitam o formato regional, como o comando `date`.

Exemplo:

date +"%A, %d de %B de %Y"
```

O comando acima vai gerar a data no formato adequado para a localidade, considerando, por exemplo, a tradução de nomes dos dias e meses.

### 6. **Consideração para Moeda e Números**
Em diferentes locais, o formato para números e moedas pode variar (como a vírgula como separador decimal em vez do ponto). Você pode utilizar o comando `printf` para formatar corretamente os números e garantir que o formato regional seja respeitado.

Exemplo:

# Exemplo com vírgula como separador decimal
printf "%'.2f\n" 1234.56 # Exibe: 1.234,56
```

### 7. **Testando Localizações Diferentes**
Para testar seu script em diferentes idiomas ou locais, você pode alterar temporariamente as variáveis de localidade no terminal:

export LANG=fr_FR.UTF-8 # Para francês
./meu_script.sh
```

### Resumo
A internacionalização de Shell Script envolve:
- Definir e respeitar as variáveis de ambiente de localidade.
- Utilizar `gettext` ou outros métodos para traduzir mensagens.
- Lidar com codificação de caracteres de forma apropriada.
- Utilizar ferramentas para formatação de data, hora e números de acordo com a região.

Ao adotar essas práticas, você pode garantir que seu Shell Script será útil para usuários em diferentes idiomas e regiões, tornando-o mais flexível e acessível.

_________________________________________________________
Always listen the Buck!
Enquanto o cursor estiver pulsando, há vida!


9. Re: internalização de script

Buckminster
Buckminster

(usa Debian)

Enviado em 06/11/2024 - 14:02h

Continuação...

Tem um exemplo de código em Shell Script??

Claro! Aqui está um exemplo de Shell Script que implementa algumas práticas básicas de internacionalização (i18n), como a utilização de variáveis de ambiente para o idioma e a tradução de mensagens com o `gettext`.

### Exemplo de Shell Script com Internacionalização

1. **Estrutura do diretório**:

Vamos criar uma estrutura simples de diretórios e arquivos para armazenar as traduções.

my_script/
├── locales/
│ └── pt_BR/
│ └── LC_MESSAGES/
│ └── messages.mo
└── meu_script.sh

```

2. **Passo 1: Instalar o `gettext`**:

Para criar a funcionalidade de internacionalização no seu script, você precisa do `gettext` para lidar com traduções. No Linux, você pode instalar com:


sudo apt-get install gettext # Para distribuições baseadas no Debian
```

3. **Passo 2: Criando o arquivo `.pot` com as mensagens a serem traduzidas**

Vamos criar um arquivo `.pot` contendo as mensagens que queremos traduzir. Para isso, você pode usar o comando `xgettext` para extrair as strings do seu script.

No caso do nosso script abaixo, primeiro criamos as mensagens de exemplo.

4. **Passo 3: Escrevendo o Script**

### `meu_script.sh`

Este script irá detectar o idioma configurado no sistema e exibir uma mensagem de boas-vindas apropriada.

#!/bin/bash

# Definir o diretório onde estão os arquivos de tradução
export TEXTDOMAINDIR="./locales"
export TEXTDOMAIN="messages"

# Ativar a localização de mensagens com base no idioma configurado no sistema
export LANG=pt_BR.UTF-8

# Exemplo de uso do gettext
echo "$(gettext 'Hello, World!')"
echo "$(gettext 'This script is internationalized.')"

# Exemplo de data formatada de acordo com a localidade
echo "$(gettext 'Current date and time:') $(date)"

# Exemplo de mensagem de erro
echo "$(gettext 'An error has occurred!')"
```

### Passo 4: Gerando as Traduções

1. **Extraindo mensagens**:

Use o comando `xgettext` para extrair todas as mensagens que precisam ser traduzidas para um arquivo `.pot`:

xgettext -o messages.pot meu_script.sh
```

Isso cria um arquivo chamado `messages.pot`, onde todas as strings que precisam ser traduzidas são extraídas.

2. **Traduzindo as mensagens**:

Crie um arquivo `.po` para o idioma desejado (por exemplo, `pt_BR.po` para português brasileiro).

Abra o arquivo `messages.pot` e crie um arquivo de tradução com o seguinte conteúdo:

`pt_BR.po`:
```po
msgid "Hello, World!"
msgstr "Olá, Mundo!"

msgid "This script is internationalized."
msgstr "Este script está internacionalizado."

msgid "Current date and time:"
msgstr "Data e hora atuais:"

msgid "An error has occurred!"
msgstr "Ocorreu um erro!"
```

3. **Compilando as traduções**:

Depois de editar o arquivo `.po`, você precisa compilá-lo para um formato binário `.mo` que o `gettext` pode usar:

msgfmt pt_BR.po -o locales/pt_BR/LC_MESSAGES/messages.mo
```

4. **Testando o Script**:

Agora, ao executar o script, ele irá exibir as mensagens traduzidas com base no idioma configurado (no caso, `pt_BR.UTF-8`).

Execute o script:

./meu_script.sh
```

O resultado deve ser:

```
Olá, Mundo!
Este script está internacionalizado.
Data e hora atuais: ter nov 6 10:00:00 -03 2024
Ocorreu um erro!
```
Caso você queira testar com outro idioma, basta alterar a variável LANG no script ou no terminal:

export LANG=en_US.UTF-8
./meu_script.sh
```

E as mensagens serão exibidas em inglês:

```
Hello, World!
This script is internationalized.
Current date and time: Tue Nov 6 10:00:00 -03 2024
An error has occurred!
```

### Explicação do Código:

- **`gettext`**: Usado para localizar as mensagens. Ele irá buscar as traduções no arquivo `.mo` correspondente ao idioma configurado.

- **`TEXTDOMAINDIR`**: Define onde os arquivos de tradução `.mo` estão localizados.

- **`LANG`**: Variável que define o idioma e as configurações regionais (por exemplo, `pt_BR.UTF-8` para português brasileiro).

- **Formato de data e hora**: A função `date` vai exibir a data e hora de acordo com a localidade definida pelo sistema.

- **Estrutura de diretórios de tradução**: Os arquivos `.mo` ficam armazenados dentro de uma estrutura de diretórios de localidade (ex: `locales/pt_BR/LC_MESSAGES/messages.mo`).

### Conclusão:

Este exemplo mostra como usar o `gettext` para internacionalizar mensagens em um script shell. O script se adapta ao idioma do sistema e pode ser facilmente expandido para suportar outros idiomas adicionando os respectivos arquivos de tradução. Isso torna o script flexível e acessível para usuários em diferentes regiões.


_________________________________________________________
Always listen the Buck!
Enquanto o cursor estiver pulsando, há vida!






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts