Javascript Web应用程序翻译不适用于所有浏览器

我有一个支持英语和丹麦语的web应用程序。用户可以通过应用程序中的设置更改语言。语言设置分别以英语和丹麦语的“1”或“2”形式存储在数据库中。包含所有必要翻译的文本文件充当字典，如果选择丹麦语，则所有单词和短语都将根据该字典进行翻译。
在IE中，这一功能非常有效，但在其他浏览器（如Chrome和Firefox）中，只有部分文本被正确翻译，而其余文本则根据浏览器中的语言设置进行翻译。
下面是我的控制器函数（vb.net），它从数据库中获取用户的语言：

Public Function GetCurrentUserLanguageContent() As ActionResult

    Dim language As Integer = sInt(GetSingleValue("SELECT language_id FROM Users WHERE user_id =" & CurrentUser.Userid))

    Dim langCode As String

    If language = 2 Then
        langCode = "da-DK"
    Else
        langCode = "en-GB"
    End If

    Dim languageSet = New With {.LangCode = langCode, .Translations = My.Resources.daDKLang}
    Return languageSet

End Function

我的脚本（JavaScript（技术上称为typescript）和jQuery）如下所示：

interface langDefinition {
LangCode: string;
Translations: string; 
}

class translatedLang {  
dictionary = new Array<string>();
defaultLangauge = "en-GB";
currentLanguage: string;
isDefaultLanguage: boolean;

constructor() {

    try { 
        var self = this;

        $.ajax({
            url: "...",
            dataType: 'json',
            async: false, 
            cache: false,
            success: function (langDef: langDefinition) {
                self.currentLanguage = langDef.LangCode;
                self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
                self.setupDictionary(langDef.Translations); 
                var rnotwhite = /\S/; 
                $('body *').contents().filter(function () {
                    return this.nodeType === 3 && rnotwhite.test($(this).text());
                }).text(function (i, text) {
                        this.replaceWholeText(self.translate(text));
                        //this.nodeValue = text + ' replaced';     // this works, in that it adds 'replaced' to the missing translations
                });
            }
        }); 
    }
    catch (ex) {
        this.isDefaultLanguage = true;
    }
}

private setupDictionary(translations: string): void {
    translations.split(/\r\n/g).forEach((value: string) => {
        var keyValuePair: string[] = value.split(",");
        this.dictionary[keyValuePair[0]] = keyValuePair[1];
    });
}

public translateNewlineString(translationString: string): string {
    return translationString
           .split(/\r\n/g)
           .map((l) => {
                return this.translate(l);
            })
           .join(" ");
}

public translate(translationString: string): string {
    if (this.isDefaultLanguage) {
        return translationString;
    }
    else {
        if (this.dictionary.hasOwnProperty(translationString)) {
            return this.dictionary[translationString];
        }
        else {
            return translationString;
        }
    }
}

$.ajax({
        url: "...",
        dataType: 'json',
        async: false, 
        cache: false,
        success: function (langDef: langDefinition) {
            self.currentLanguage = langDef.LangCode;
            self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
            self.setupDictionary(langDef.Translations); 
            var rnotwhite = /\S/; 
            $('body *').contents().filter(function () {
                return this.nodeType === 3 && rnotwhite.test($(this).text());
            }).text(function (i, text) {
                this.nodeValue = self.translate(text);
            });
        }
    });

接口定义{
语言代码：字符串；
翻译：字符串；
}
类translatedLang{
dictionary=新数组（）；
defaultLangauge=“en GB”；
当前语言：字符串；
isDefaultLanguage:布尔型；
构造函数（）{
试试{
var self=这个；
$.ajax({
网址：“…”，
数据类型：“json”，
async:false，
cache:false，
成功：函数（langDef:langDefinition）{
self.currentLanguage=langDef.LangCode；
self.isDefaultLanguage=self.currentLanguage==self.DefaultLanguage；
self.setupDictionary（langDef.Translations）；
var rnotwhite=/\S/；
$（'body*'）.contents（）.filter（函数（）{
返回this.nodeType===3&&rnotwhite.test（$（this.text（））；
}).文本（功能（i，文本）{
this.replaceWholeText（self.translate（text））；
//this.nodeValue=text+'replaced'；//这样做有效，因为它会在缺少的翻译中添加'replaced'
});
}
}); 
}
捕获（ex）{
this.isDefaultLanguage=true；
}
}
专用设置词典（翻译：字符串）：无效{
translations.split（/\r\n/g）.forEach（（值：string）=>{
var-keyValuePair:string[]=value.split（“，”）；
此.dictionary[keyValuePair[0]=keyValuePair[1]；
});
}
公共translateNewlineString（translationString:string）：字符串{
返回translationString
.split（/\r\n/g）
.map（（l）=>{
返回这个。翻译（l）；
})
.加入（“”）；
}
公共翻译（translationString:string）：字符串{
if（此.isDefaultLanguage）{
返回translationString；
}
否则{
if（this.dictionary.hasOwnProperty（translationString））{
返回这个.dictionary[translationString]；
}
否则{
返回translationString；
}
}
}

}

从setupDictionary函数可以看出，字典文件的格式如下：

英语的，丹麦语的
英语中的其他语言，丹麦语中的其他语言

注意，如果我更改

this.replaceWholeText（self.translate（text））

to

this.nodeValue=text+“已替换”

在AJAX调用中，应该转换的文本被更改为包含“已替换”-这意味着它实际上更改了正确的文本

一次又一次；这一切在IE中都能正常工作，但有些浏览器，比如Chrome，在某些情况下似乎会覆盖我的翻译。

---

有没有办法解决这个问题，或者我需要做一些完全不同的事情？

我自己找到了解决方案；我只需要更改

这个.replaceWholeText（self.translate（text））

to

this.nodeValue=self.translate（文本），因此AJAX调用如下所示：

interface langDefinition {
LangCode: string;
Translations: string; 
}

class translatedLang {  
dictionary = new Array<string>();
defaultLangauge = "en-GB";
currentLanguage: string;
isDefaultLanguage: boolean;

constructor() {

    try { 
        var self = this;

        $.ajax({
            url: "...",
            dataType: 'json',
            async: false, 
            cache: false,
            success: function (langDef: langDefinition) {
                self.currentLanguage = langDef.LangCode;
                self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
                self.setupDictionary(langDef.Translations); 
                var rnotwhite = /\S/; 
                $('body *').contents().filter(function () {
                    return this.nodeType === 3 && rnotwhite.test($(this).text());
                }).text(function (i, text) {
                        this.replaceWholeText(self.translate(text));
                        //this.nodeValue = text + ' replaced';     // this works, in that it adds 'replaced' to the missing translations
                });
            }
        }); 
    }
    catch (ex) {
        this.isDefaultLanguage = true;
    }
}

private setupDictionary(translations: string): void {
    translations.split(/\r\n/g).forEach((value: string) => {
        var keyValuePair: string[] = value.split(",");
        this.dictionary[keyValuePair[0]] = keyValuePair[1];
    });
}

public translateNewlineString(translationString: string): string {
    return translationString
           .split(/\r\n/g)
           .map((l) => {
                return this.translate(l);
            })
           .join(" ");
}

public translate(translationString: string): string {
    if (this.isDefaultLanguage) {
        return translationString;
    }
    else {
        if (this.dictionary.hasOwnProperty(translationString)) {
            return this.dictionary[translationString];
        }
        else {
            return translationString;
        }
    }
}

$.ajax({
        url: "...",
        dataType: 'json',
        async: false, 
        cache: false,
        success: function (langDef: langDefinition) {
            self.currentLanguage = langDef.LangCode;
            self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
            self.setupDictionary(langDef.Translations); 
            var rnotwhite = /\S/; 
            $('body *').contents().filter(function () {
                return this.nodeType === 3 && rnotwhite.test($(this).text());
            }).text(function (i, text) {
                this.nodeValue = self.translate(text);
            });
        }
    });

我自己找到了解决办法；我只需要更改
这个.replaceWholeText（self.translate（text））
to
this.nodeValue=self.translate（文本），因此AJAX调用如下所示：

interface langDefinition {
LangCode: string;
Translations: string; 
}

class translatedLang {  
dictionary = new Array<string>();
defaultLangauge = "en-GB";
currentLanguage: string;
isDefaultLanguage: boolean;

constructor() {

    try { 
        var self = this;

        $.ajax({
            url: "...",
            dataType: 'json',
            async: false, 
            cache: false,
            success: function (langDef: langDefinition) {
                self.currentLanguage = langDef.LangCode;
                self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
                self.setupDictionary(langDef.Translations); 
                var rnotwhite = /\S/; 
                $('body *').contents().filter(function () {
                    return this.nodeType === 3 && rnotwhite.test($(this).text());
                }).text(function (i, text) {
                        this.replaceWholeText(self.translate(text));
                        //this.nodeValue = text + ' replaced';     // this works, in that it adds 'replaced' to the missing translations
                });
            }
        }); 
    }
    catch (ex) {
        this.isDefaultLanguage = true;
    }
}

private setupDictionary(translations: string): void {
    translations.split(/\r\n/g).forEach((value: string) => {
        var keyValuePair: string[] = value.split(",");
        this.dictionary[keyValuePair[0]] = keyValuePair[1];
    });
}

public translateNewlineString(translationString: string): string {
    return translationString
           .split(/\r\n/g)
           .map((l) => {
                return this.translate(l);
            })
           .join(" ");
}

public translate(translationString: string): string {
    if (this.isDefaultLanguage) {
        return translationString;
    }
    else {
        if (this.dictionary.hasOwnProperty(translationString)) {
            return this.dictionary[translationString];
        }
        else {
            return translationString;
        }
    }
}

$.ajax({
        url: "...",
        dataType: 'json',
        async: false, 
        cache: false,
        success: function (langDef: langDefinition) {
            self.currentLanguage = langDef.LangCode;
            self.isDefaultLanguage = self.currentLanguage == self.defaultLangauge;
            self.setupDictionary(langDef.Translations); 
            var rnotwhite = /\S/; 
            $('body *').contents().filter(function () {
                return this.nodeType === 3 && rnotwhite.test($(this).text());
            }).text(function (i, text) {
                this.nodeValue = self.translate(text);
            });
        }
    });