Práticas recomendadas para localização e globalização de seqüências de caracteres e rótulos [fechado]

Sou membro de uma equipe com mais de 20 desenvolvedores. Cada desenvolvedor trabalha em um módulo separado (algo em torno de 10 módulos). Em cada módulo, podemos ter pelo menos 50 formulários CRUD, o que significa que atualmente temos cerca de 500 botões adicionar , salvar botões , editar botões etc.

No entanto, como queremos globalizar nosso aplicativo, precisamos traduzir textos em nosso aplicativo. Por exemplo, em todos os lugares, a palavra add deve tornar-se ajouter para os usuários franceses.

O que fizemos até agora é que, para cada visualização na interface do usuário ou na camada de apresentação, temos um dicionário de pares de traduções chave / valor. Em seguida, durante a renderização da visualização, traduzimos textos e strings necessários usando este dicionário. No entanto, esta abordagem, temos vindo a ter algo perto de 500 add em 500 dicionários. Isso significa que violamos o principal DRY.

Por outro lado, se centralizarmos seqüências comuns, como colocar add em um só lugar, e pedir aos desenvolvedores que a usem em todos os lugares, encontraremos o problema de não ter certeza se uma sequência já está definida no dicionário centralizado ou não.

Uma outra opção pode ser não ter dicionário de tradução e usar serviços de tradução on-line como Google Translate, Bing Translator etc.

Outro problema que encontramos é que alguns desenvolvedores, sob o estresse de entregar o projeto no prazo, não conseguem se lembrar das chaves de tradução . Por exemplo, para o texto do botão adicionar, um desenvolvedor usou add enquanto outro desenvolvedor usou new etc.

Qual é a melhor prática ou o método mais conhecido para globalização e localização de recursos de cadeia de caracteres de um aplicativo?

Até onde eu sei, há uma boa biblioteca chamada localeplanetLocalização e Internacionalização em JavaScript. Além disso, acho que é nativo e não tem dependências para outras bibliotecas (por exemplo, jQuery)

Aqui está o site da biblioteca: http://www.localeplanet.com/

Observe também este artigo da Mozilla, você pode encontrar métodos e algoritmos muito bons para tradução no lado do cliente: http://blog.mozilla.org/webdev/2011/10/06/i18njs-internationalize-your-javascript-with- uma ajudinha-do-json-e-o-servidor /

A parte comum de todos esses artigos / bibliotecas é que eles usam uma i18nclasse e um getmétodo (de certa forma também definem um nome de função menor como _) para recuperar / converter o arquivo keypara value. Na minha explicação dos keymeios que string você deseja traduzir e os valuemeios traduzidos string.
Então, você só precisa de um documento JSON para armazenar key's value' e 's.

Por exemplo:

var _ = document.webL10n.get;
alert(_('test'));

E aqui o JSON:

{ test: "blah blah" }

Acredito que o uso de soluções atuais de bibliotecas populares é uma boa abordagem.

Quando você se depara com um problema a ser resolvido (e, francamente, quem não é hoje em dia?), A estratégia básica geralmente adotada por nós é chamada de "dividir e conquistar". É assim:

• Conceitualize o problema específico como um conjunto de subproblemas menores.
• Resolva cada problema menor.
• Combine os resultados em uma solução do problema específico.

Mas “dividir e conquistar” não é a única estratégia possível. Também podemos adotar uma abordagem mais generalista:

• Conceitualize o problema específico como um caso especial de um problema mais geral.
• De alguma forma, resolva o problema geral.
• Adapte a solução do problema geral ao problema específico.

- Eric Lippert

Acredito que já existem muitas soluções para esse problema em linguagens do servidor, como ASP.Net/C#.

Eu descrevi alguns dos principais aspectos do problema

• Problema : precisamos carregar dados apenas para o idioma desejado

  Solução : para esse fim, salvamos os dados em arquivos separados para cada idioma

ex. res.de.js, res.fr.js, res.en.js, res.js (para o idioma padrão)

• Problema: os arquivos de recursos de cada página devem ser separados, para obtermos apenas os dados necessários

  Solução : podemos usar algumas ferramentas que já existem, como https://github.com/rgrove/lazyload

• Problema: precisamos de uma estrutura de par de chave / valor para salvar nossos dados

  Solução : sugiro um objeto javascript em vez de string / string air. Podemos nos beneficiar do intellisense de um IDE

• Problema: os membros gerais devem ser armazenados em um arquivo público e todas as páginas devem acessá-los

  Solução : para esse propósito, crio uma pasta na raiz do aplicativo Web chamada Global_Resources e uma pasta para armazenar o arquivo global para cada subpasta que denominamos 'Local_Resources'

• Problema: cada membro de subsistema / subpasta / módulo deve substituir os membros Global_Resources em seu escopo

  Solução : considerei um arquivo para cada

Estrutura de Aplicação

root/
    Global_Resources/
        default.js
        default.fr.js
    UserManagementSystem/
        Local_Resources/
            default.js
            default.fr.js
            createUser.js
        Login.htm
        CreateUser.htm

O código correspondente para os arquivos:

Global_Resources / default.js

var res = {
    Create : "Create",
    Update : "Save Changes",
    Delete : "Delete"
};

Global_Resources / default.fr.js

var res = {
    Create : "créer",
    Update : "Enregistrer les modifications",
    Delete : "effacer"
};

O arquivo de recurso para o idioma desejado deve ser carregado na página selecionada em Global_Resource - Esse deve ser o primeiro arquivo carregado em todas as páginas.

UserManagementSystem / Local_Resources / default.js

res.Name = "Name";
res.UserName = "UserName";
res.Password = "Password";

UserManagementSystem / Local_Resources / default.fr.js

res.Name = "nom";
res.UserName = "Nom d'utilisateur";
res.Password = "Mot de passe";

UserManagementSystem / Local_Resources / createUser.js

// Override res.Create on Global_Resources/default.js
res.Create = "Create User"; 

UserManagementSystem / Local_Resources / createUser.fr.js

// Override Global_Resources/default.fr.js
res.Create = "Créer un utilisateur";

arquivo manager.js (esse arquivo deve ser carregado por último)

res.lang = "fr";

var globalResourcePath = "Global_Resources";
var resourceFiles = [];

var currentFile = globalResourcePath + "\\default" + res.lang + ".js" ;

if(!IsFileExist(currentFile))
    currentFile = globalResourcePath + "\\default.js" ;
if(!IsFileExist(currentFile)) throw new Exception("File Not Found");

resourceFiles.push(currentFile);

// Push parent folder on folder into folder
foreach(var folder in parent folder of current page)
{
    currentFile = folder + "\\Local_Resource\\default." + res.lang + ".js";

    if(!IsExist(currentFile))
        currentFile = folder + "\\Local_Resource\\default.js";
    if(!IsExist(currentFile)) throw new Exception("File Not Found");

    resourceFiles.push(currentFile);
}

for(int i = 0; i < resourceFiles.length; i++) { Load.js(resourceFiles[i]); }

// Get current page name
var pageNameWithoutExtension = "SomePage";

currentFile = currentPageFolderPath + pageNameWithoutExtension + res.lang + ".js" ;

if(!IsExist(currentFile))
    currentFile = currentPageFolderPath + pageNameWithoutExtension + ".js" ;
if(!IsExist(currentFile)) throw new Exception("File Not Found");

Espero que ajude :)

O jQuery.i18n é um plugin jQuery leve para permitir a internacionalização em suas páginas da web. Ele permite que você empacote seqüências de recursos personalizadas em arquivos '.properties', assim como nos Java Resource Bundles. Ele carrega e analisa pacotes de recursos (.properties) com base no idioma ou idioma fornecido relatado pelo navegador.

Para saber mais sobre isso, consulte Como internacionalizar suas páginas usando o JQuery?