One way to store key/value pairs in JavaScript is by using a basic object which functions like an associative array. By leveraging JSON, you can easily create objects for each localized string, as shown below:

var localizedStrings={
    confirmMessage:{
        'en/US':'Are you sure?',
        'fr/FR':'Est-ce que vous êtes certain?',
        ...
    },

    ...
}

To access the localized version of a string based on locale, you can do so in the following manner:

var locale='en/US';
var confirm=localizedStrings['confirmMessage'][locale];

Drawn from the inspiration of SproutCore, you have the ability to customize properties of text:

'Goodbye'.fr = 'Au revoir';
'Goodbye'.es = 'Adiós';

After setting these properties, you can easily display the appropriate localization based on your region:

var locale = 'fr';
console.log( message[locale] );

After extensively researching various solutions without finding one that met my needs, I stumbled upon a fantastic and versatile approach using T4 templates. For full details, check out the post by Jochen van Wylick here:

Utilizing T4 to localize JavaScript resources based on .resx files

The key benefits include:

1. Central resource management in a single location (.resx files)
2. Support for multiple cultures
3. IntelliSense support for code completion

However, there are some drawbacks as well:

One downside is that the resulting .js file may become large in size. Although it's cached by the browser which eliminates performance issues in our application, this caching can cause problems if the browser fails to locate the requested resource.

---

How does this method work?

Essentially, a T4 template is created to reference the .resx files. Through C# code, each resource string is parsed and added to JavaScript as key-value properties, culminating in a single JavaScript file named Resources.js (names can be customized).

---

T4 template [modify as needed to point to your .resx files location]

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ assembly name="System.Windows.Forms" #>
<#@ import namespace="System.Resources" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.IO" #>
<#@ output extension=".js"#>
<#
 var path = Path.GetDirectoryName(Host.TemplateFile) + "/../App_GlobalResources/";
 var resourceNames = new string[1]
 {
  "Common"
 };

#>
/**
* Resources
* ---------
* This file is auto-generated by a tool
* 2012 Jochen van Wylick
**/
var Resources = {
 <# foreach (var name in resourceNames) { #>
 <#=name #>: {},
 <# } #>
};
<# foreach (var name in resourceNames) {
 var nlFile = Host.ResolvePath(path + name + ".nl.resx" );
 var enFile = Host.ResolvePath(path + name + ".resx" );
 ResXResourceSet nlResxSet = new ResXResourceSet(nlFile);
 ResXResourceSet enResxSet = new ResXResourceSet(enFile);
#>

<# foreach (DictionaryEntry item in nlResxSet) { #>
Resources.<#=name#>.<#=item.Key.ToString()#> = {
 'nl-NL': '<#=("" + item.Value).Replace("\r\n", string.Empty).Replace("'","\\'")#>',
 'en-GB': '<#=("" + enResxSet.GetString(item.Key.ToString())).Replace("\r\n", string.Empty).Replace("'","\\'")#>'
 };
<# } #>
<# } #>

Incorporating into Form/View

To ensure accurate translations, add this snippet in your master page if using WebForms:

<script type="text/javascript">

    var locale = '<%= System.Threading.Thread.CurrentThread.CurrentCulture.Name %>';

</script>

<script type="text/javascript" src="/Scripts/Resources.js"></script>

For ASP.NET MVC users, like myself, the implementation would look like this:

<script type="text/javascript">

    // Setting Locale for JavaScript translations
    var locale = $("meta[name='accept-language']").attr("content");

</script>

<script type="text/javascript" src="/Scripts/Resources.js"></script>

The MetaAcceptLanguage helper mentioned above is from an informative post by Scott Hanselman:

Globalization, Internationalization and Localization in ASP.NET MVC 3, JavaScript and jQuery - Part 1

public static IHtmlString MetaAcceptLanguage<T>(this HtmlHelper<T> html)
{
     var acceptLanguage =
         HttpUtility.HtmlAttributeEncode(
                     Thread.CurrentThread.CurrentUICulture.ToString());

      return new HtmlString(
      String.Format("<meta name=\"{0}\" content=\"{1}\">", "accept-language",
                    acceptLanguage));
 }

Implementation Example

var msg = Resources.Common.Greeting[locale];
alert(msg);

Using a satellite assembly instead of a resx file allows you to fetch all strings on the server in a known language, enabling the creation of a Javascript object containing only the relevant language strings.

We've successfully implemented something similar with the following VB.NET code snippet:

Dim rm As New ResourceManager([resource name], [your assembly])
Dim rs As ResourceSet = 
    rm.GetResourceSet(Thread.CurrentThread.CurrentCulture, True, True)
For Each kvp As DictionaryEntry In rs
    [Output kvp.Key and kvp.Value]
Next

Unfortunately, we have yet to discover a method for achieving this functionality with .resx files.

JSGettext is an amazing tool that enables dynamic loading of GNU Gettext .po files with virtually any backend language. If you want to learn more about using JSGettext with PHP, search for "Dynamic Javascript localization with Gettext and PHP" for a helpful guide (I'd share the link, but unfortunately I can't on this platform).

Edit: Check out this for the correct link.

When approaching this problem, I would recommend utilizing object/array notation for an organized structure:

let messages = {};
messages['error'] ='Oops!';

This method allows for easy swapping of JavaScript files or making an Ajax call to update the list of phrases dynamically.

If you're looking to localize your JavaScript applications, there's a great library available for that purpose: https://github.com/wikimedia/jquery.i18n

This library offers features such as parameter replacement, support for gender (handling he/she), number (including languages with multiple plural forms), and custom grammar rules necessary for certain languages.

All the strings can be found in JSON files for easy storage.

Best of all, the only thing you need is jQuery to use this library!

To ensure localization of JavaScript in a mobile app running HTML5, I took the following steps:

1. Developed separate resource files for each language, such as "en.js" for English, containing various strings required by the app:

        var localString = {
        appName: "your app name",
        message1: "blah blah"
      };

2. Utilized Lazyload to dynamically load the appropriate resource file based on the locale language of the app: https://github.com/rgrove/lazyload

3. Passed the language code through a Query String (particularly when launching the html file from Android using PhoneGap)

4. Implemented the following code to dynamically load the correct resource file:

var lang = getQueryString("language");
localization(lang);
function localization(languageCode) {
    try {
        var defaultLang = "en";
        var resourcesFolder = "values/";
        if(!languageCode || languageCode.length == 0)
            languageCode = defaultLang;
        // var LOCALIZATION = null;
        LazyLoad.js(resourcesFolder + languageCode + ".js", function() {
            if( typeof LOCALIZATION == 'undefined') {
                LazyLoad.js(resourcesFolder + defaultLang + ".js", function() {
                    for(var propertyName in LOCALIZATION) {
                        $("#" + propertyName).html(LOCALIZATION[propertyName]);
                    }
                });
            } else {
                for(var propertyName in LOCALIZATION) {
                    $("#" + propertyName).html(LOCALIZATION[propertyName]);
                }
            }
        });
    } catch (e) {
        errorEvent(e);
    }
}
function getQueryString(name)
{
  name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
  var regexS = "[\\?&]" + name + "=([^&#]*)";
  var regex = new RegExp(regexS);
  var results = regex.exec(window.location.href);
  if(results == null)
    return "";
  else
    return decodeURIComponent(results[1].replace(/\+/g, " "));
}

5. In the html file, referenced the strings as shown below:

    span id="appName"

In my opinion, one way to approach this is by creating English and Spanish scripts as shown below:

en-GB.js
lang = {
    date_message: 'The start date is incorrect',
    ...
};
es-ES.js
lang = {
    date_message: 'Fecha de inicio incorrecta',
    ...
};

On the server-side code behind:

Protected Overrides Sub InitializeCulture()
    Dim sLang As String 
    sLang = "es-ES" 

    Me.Culture = sLang
    Me.UICulture = sLang
    Page.ClientScript.RegisterClientScriptInclude(sLang & ".js", "../Scripts/" & sLang & ".js")

    MyBase.InitializeCulture()
End Sub

The value of sLang can be toggled between "en-GB" and "es-ES" based on the user's selection.

To make use of these scripts in JavaScript:

alert (lang.date_message);

This setup simplifies the process, making it easy to implement.

Adding to the response from diodeus.myopenid.com: Implement a process in your code that generates a file containing a JavaScript array with all necessary strings, and ensure this file is loaded before any other JavaScript code.