js-simple-strings
v1.3.1
Published
A simple localization system for JS.
Downloads
2
Readme
js-simple-strings
A simple but powerful interface for localizing strings in JavaScript. Also
useful for general strings management, even if not localizing.
Provide any number of json strings objects to the factory function.
All subsequent calls (like getString()
) will search in the first json object
provided for the key, then the next, and so on until the string is found.
Any organizational structure to the json objects is allowed;
a "/" in the key is used to retrieve sub-objects or array elements.
Installation
Using npm:
$ npm i js-simple-strings
Note: add --save
if you are using npm < 5.0.0
In Node.js:
// example:
const enJson = require('en.json');
const esJson = require('es.json');
const { getString } = require('js-simple-strings')([esJson, enJson]);
console.log(getString('my/string/key'));
Usage
js-simple-strings works with a factory function for language initialization, and so any number of languages can be loaded simultaneously using different factory functions.
const enStrings = require('js-simple-strings')(enJson);
const esStrings = require('js-simple-strings')(esJson);
Multiple strings jsons can be provided to allow for fallbacks. For example,
there may be a default language of English and a preferred Spanish file that is
not fully translated. In the example below, as long as a key exists in the
esJson
file, it would be used, and if not, the enJson
file will be used.
const strings = require('js-simple-strings')([esJson, enJson]);
Several functions are exported and can be used.
getString
Takes a string key that points to a value within a passed json file. Slashes are used to denote sub-objects or sub-arrays.
const strings = require('js-simple-strings')({
"my": {
"key": "Hello, World!"
}
});
console.log(strings.getString('my/key'));
// prints "Hello, World!"
Can take a second parameter to provide substitutions for double handlebars.
const strings = require('js-simple-strings')({
"substitution": "Fill in {{this}} or {{that}}"
});
console.log(strings.getString('substitution', {
this: 'something',
that: 'another',
}));
// prints "Fill in something or another"
Substitutions can also be provided via array indices.
const strings = require('js-simple-strings')({
"substitution": "First {{0}} Second {{1}} Third {{2}}"
});
console.log(strings.getString('substitution', ['hi', 'there', 'man']));
// prints "First hi Second there Third man"
Members of an array in the json can be accessed via indices.
const strings = require('js-simple-strings')({
"array": [
"First",
"Second",
"Third"
]
});
console.log(strings.getString('array/0'));
// prints "First"
console.log(strings.getString('array/1'));
// prints "Second"
console.log(strings.getString('array/2'));
// prints "Third"
Members of a json array can be accessed randomly for convenience using the '?' character.
const strings = require('js-simple-strings')({
"array": [
"First",
"Second",
"Third"
]
});
console.log(strings.getString('array/?'));
// randomly prints "First", "Second", or "Third"
console.log(strings.getString('array/?'));
// randomly prints "First", "Second", or "Third"
console.log(strings.getString('array/?'));
// randomly prints "First", "Second", or "Third"
Using the '!' character instead allows distributed randomness – members of a json array will be accessed randomly, but an even distribution is forced.
const strings = require('js-simple-strings')({
"array": [
"First",
"Second",
"Third"
]
});
console.log(strings.getString('array/!'));
// randomly prints "First", "Second", or "Third"
console.log(strings.getString('array/!'));
// randomly prints "First", "Second", or "Third", but not what was printed the
// first time
console.log(strings.getString('array/!'));
// randomly prints "First", "Second", or "Third", whichever wasn't already
// printed
Members of an array in the json can be accessed via bounded indices by preceeding the index with a 'b' character. The index that follows will be clamped within the bounds of the json array.
const strings = require('js-simple-strings')({
"array": [
"First",
"Second",
"Third"
]
});
console.log(strings.getString('array/b-1'));
// prints "First"
console.log(strings.getString('array/b0'));
// prints "First"
console.log(strings.getString('array/b5'));
// prints "Third"
An object type can be given a name
that will return if the object's key is
referenced directly.
const strings = require('js-simple-strings')({
"object": {
"name": "My Object",
}
});
console.log(strings.getString('object'));
// prints "My Object"
console.log(strings.getString('object/name'));
// prints "My Object"
Various errors can be returned.
ERROR-MISSING-STRING: "my/key"
is returned if a key cannot be found.
ERROR-NO-SUB-my/key
is returned if an expected substitution has no key given.
BAD-TYPE: "my/key"
is returned if a key leads directly to an object without a
name
or an array.
getStringCount
Returns the number of elements underneath a json array or object. If the key does not exist, -1 is returned. Otherwise, 1 is returned.
const strings = require('js-simple-strings')({
"array": [
"First",
"Second",
"Third"
],
"object": {
"a": "hello",
"b": "world"
},
"key": "Here we are."
});
console.log(strings.getStringCount('array'));
// prints 3
console.log(strings.getStringCount('object'));
// prints 2
console.log(strings.getStringCount('key'));
// prints 1
console.log(strings.getStringCount('unknown'));
// prints -1
hasString
Returns true if a string of the passed key exists, false otherwise.
const strings = require('js-simple-strings')({
"my": {
"key": "Hello, World!"
}
});
console.log(strings.hasString('my/key'));
// prints true
console.log(strings.hasString('your/key'));
// prints false
capitalize
Capitalizes the first character of the passed string.
const strings = require('js-simple-strings')({
"my": {
"key": "hello, world!"
}
});
console.log(strings.capitalize('hello there'));
// prints "Hello there"
console.log(strings.capitalize(strings.getString('my/key')));
// prints "Hello, world!"
capitalizeFirstOnly
Capitalizes the first character of the passed string and lowercases the rest.
const strings = require('js-simple-strings')({
"my": {
"key": "hello, WORLD!"
}
});
console.log(strings.capitalizeFirstOnly('hello THERE'));
// prints "Hello there"
console.log(strings.capitalizeFirstOnly(strings.getString('my/key')));
// prints "Hello, world!"
findAllStringKeys
Returns all keys in all strings jsons that were passed into the factory function. Can take an optional parent key and only return keys underneath that parent.
const strings = require('js-simple-strings')({
"my": {
"key": "Hello, World!",
"door": "It's locked."
},
"array": [
"First",
"Second",
"Third"
]
});
console.log(strings.findAllStringKeys());
// prints ['my/key', 'my/door', 'array/0', 'array/1', 'array/2']
console.log(strings.findAllStringKeys('my'));
// prints ['my/key', 'my/door']
Why js-simple-strings?
It's super simple and small (with zero dependencies) and does what you need and nothing else. It makes no assumptions about where json files are coming from or how they're formatted, allowing you to make giant CSV-style strings or complex organizations of nested strings.
As long as you provide the jsons in priority order, you can easily support many different languages and locales. A common use case is to put the user's desired language first and fallback languages (like English) afterwards. In that case, if the key exists in their language, it will be used, and otherwise they will at least see your fallback.
Locales are easily supported in this way by providing locales (say en-gb) with only the necessary changes ("tyre" instead of "tire") and then the default locale (like en-us) as the fallback.