Elegant-standard NPM

Elegant Standard

npm bundle size

GitHub issues

GitHub

GitHub package.json version

JavaScript is often filled with weird surprises that can catch people off guard (often the tradeoff for the incredible flexibility it provides). To combat this, we, at onCreators use an in-house standard called the elegant standard, quite literally called that to emphasize on writing code that elegantly handles any bizarre or unforeseen scenarios in JS.

The Elegant Standard as well as being a standard (set of rules) which developers can follow in order to ensure that their code is better handled is also a library that provides various convenience functions to do the same. On that note, the standard can be broken up into two major parts:-

The Functions
The Rules

Getting Started

The elegant-standard is available as an npm package. So to open, simply open any project that uses npm (or yarn) and install it using:-

npm install --save elegant-standard

Or using yarn

yarn add elegant-standard

Then in your project, import it as either CommonJS or ES6 Modules:-

import elegantly from 'elegant-standard'; // ES6
import {type, check /*etc*/} from 'elegant-standard';

const elegantly = require("elegant-standard"); // CJS
const {type, check /*etc*/} = require('elegant-standard');

The Functions

id	Name	Description
1	type	A better alternative to JavaScript's `typeof`
2	define	A function to handle `undefined` and `null`
3	check	A function that combines `type` and `define`
4	isString	A function to check if an element is a String
5	isUString(isUnemptyString or isUString)	A function to check if an element is a String and it isn't empty
6	isBoolean	A function to check if an element is a Boolean
7	isNumber	A function to check if an element is a Number
8	isRegExp	A function to check if an element is a Reguler Expression
9	isObject	A function to check if an element is an Object
10	isUObject(isUnemptyObject or isUObject)	A function to check if an element is an Object and if the Object has properties
11	isArray	A function to check if an element is an Array
12	isUArray(isUnemptyArray or isUArray)	A function to check if an element is an Array and if it isn't empty
13	isEquivalent	A function to check if two strings are equal while ignoring case
14	isSimilar	A function to check if two string or a string and a number are equivalent
15	isEmail	A function to check if a string is of the format "placeholder@placeholder.placeholder"
16	contains	An `includes` alternative that ignores case
17	test	An alternative to `.test()` that ignores numbers
18	oneOf	A function that allows for running multiple regex tests or string comparisons on a single string and seeing if it passes atleast one of them
19	allOf	A function that allows for running multiple regex tests or string comparisons on a single string and seeing if it passes all of them
20	get	A function that elegantly retrieves items in an array

type

arguments:

element: Any

output: String

source:

function type(element) {
    return Object.prototype.toString.call(element).split(" ")[1].slice(0,  -1).toLowerCase();
}

description:

JavaScript provides a function called typeof to check the type of its variables but the typeof comes with some serious limitations:-

typeof("")        // prints "string"
typeof(1)         // prints "number"
typeof(true)      // prints "boolean"
typeof(undefined) // prints "undefined"

typeof({})        // prints "object"
typeof([])        // prints "object" as well. Wait what?
typeof(null)      // prints "object" again, eh?
typeof(/re/g)     // prints "object" again. Ok now its just printing "object" for everything

This is kind of a problem, so to fix it, developers have been using the far more accurate Object.prototype.toString.call() function instead

Object.prototype.toString.call("")    // prints "[object String]"
Object.prototype.toString.call(1)     // prints "[object Number]"
Object.prototype.toString.call(true)  // prints "[object Boolean]"
Object.prototype.toString.call()      // prints "[object Undefined]"

Object.prototype.toString.call({})    // prints "[object Object]"
Object.prototype.toString.call([])    // prints "[object Array]"
Object.prototype.toString.call(null)  // prints "[object Null]"
Object.prototype.toString.call(/re/g) // prints "[object RegExp]"

Thats so much better, but it could still use some improvement, for one, we shouldn't have to write Object.prototype.toString.call() every time we want to check the type of something. Also lets get rid of the extra "object" and "" and make it lowercase for easier checking.

const {type} = require('elegant-standard');

type("")    // prints "string"
type(1)     // prints "number"
type(true)  // prints "boolean"
type()      // prints "undefined"

type({})    // prints "object"
type([])    // prints "array"
type(null)  // prints "null"
type(/re/g) // prints "regexp"

define

arguments:

element: Any
default: Any

output: default (if not null or undefined) else []

source:

function define(el, def) {
  return (
    el !== undefined && el !== null ? el : 
  	def !== undefined && def !== null ? def : 
  	[]
  );
};

description:

undefined and null can sometimes be annoying to work with in JS.

let arr = getArrOfResultsFromServer(); // Error occurs and undefined is returned 

function getLast(arr) {
    return arr[arr.length -1];
}

let last = getLast(arr); // undefined is passed, leading to a bizarre crash

As application developers, its important to try and hide as many errors that occur on our side from the users. So to avoid the above kind of error, the define function was created, which returns some predictable default value (of your choice) in the event that a passed variable is either undefined or null:-

const {define} = require('elegant-standard');

let arr = getArrOfResultsFromServer(); // Error occurs and undefined is returned 

function getLast(arr) {
   	let Arr = define(arr, [null])
    return Arr[Arr.length -1];
}

let last = getLast(arr); 
if (last!==null) {/* use 'last' to do something */}

Note. We are aware that you could also just do

arr || [null]

But this doesn't handle empty strings very well:-

("" || null);     // returns null instead of ""
define("", null); // returns ""

check

arguments:

element: Any
type: String
default: Any

output: default (if not null or undefined) else type default

source:

function check(el, type, def) {
  type = elegantly.type(type)!=="string" ? "array" : type.toLowerCase();
  return (
  	elegantly.type(el)===type ? el :
    def!==undefined && def!==null ? def :
    type==="object" ? {} : 
    type==="array" ? [] :
    null
  );
};

description:

The check function is used to check if an element is a specified type and to return a default in the event that it is not:-

const {check} = require('elegant-standard');

check([1, 2], "array"); // returns [1, 2]
check({}, "array"); // returns []
check([], "object"); // returns {}
check([], "object", null) // returns null;

/*
	Note. if no default is specified, then the following defaults are used:-
	"array" - []
	"object" - {}
	anything else - null
*/

So it is best to think of the check function like a combination of the type and define:-

const {check, type, define} = require('elegant-standard');

let arr = null;

// type and define
if (type(arr)==="array") {
    return arr;
} else {
    return define(arr, []);
}

// check
return check(arr, "array", []);

isString

arguments:

element: Any

output: Boolean

source:

function isString(element) {
    return type(element)==="string";
}

description:

Just a function that shortens type(element)==="string":-

const {type, isString} from 'elegant-standard';

type("")==="string"; // prints true
isString("");        // prints true

isUnemptyString or isUString

arguments:

element: Any

output: Boolean

source:

function isUnemptyString(element) {
    return type(element)==="string" && element!=="";
}
var isUString = isUnemptyString;

description:

A function that checks if an element is a string and isn't empty

const {isString, isUnemptyString, isUString} = require('elegant-standard');

isString("");        // prints true
isUnemptyString(""); // prints false
isUString("");       // prints false
isUString("foo")     // prints true

isBoolean

arguments:

element: Any

output: Boolean

source:

function isBoolean(element) {
    return type(element)==="boolean";
}

description:

Just a function that shortens type(element)==="boolean":-

const {type, isBoolean} from 'elegant-standard';

type(false)==="boolean"; // prints true
isBoolean(false);        // prints true

isNumber

arguments:

element: Any

output: Boolean

source:

function isNumber(element) {
    return type(element)==="number";
}

description:

Just a function that shortens type(element)==="number":-

const {type, isNumber} from 'elegant-standard';

type(1)==="number"; // prints true
isNumber(1);        // prints true

isRegExp

arguments:

element: Any

output: Boolean

source:

function isRegExp(element) {
    return type(element)==="regexp";
}

description:

Just a function that shortens type(element)==="regexp":-

const {type, isRegExp} from 'elegant-standard';

type(/12/ig)==="regexp"; // prints true
isRegExp(/12/ig);        // prints true

isObject

arguments:

element: Any

output: Boolean

source:

function isObject(element) {
    return type(element)==="object";
}

description:

Just a function that shortens type(element)==="object":-

const {type, isObject} from 'elegant-standard';

type({})==="object"; // prints true
isObject({});        // prints true

isUnemptyObject or isUObject

arguments:

element: Any

output: Boolean

source:

function isUnemptyObject(element) {
    return type(element)==="object" && Object.entries(element).length>0;
}
var isUObject = isUnemptyObject;

description:

A function that checks if an element is an object and isn't empty. (i.e has properties)

const {isObject, isUnemptyObject, isUObject} = require('elegant-standard');

isObject({});            // prints true
isUnemptyObject({});     // prints false
isUObject({});           // prints false
isUObject({foo: "bar"}); // prints true

isArray

arguments:

element: Any

output: Boolean

source:

function isArray(element) {
    return type(element)==="array";
}

description:

Just a function that shortens type(element)==="object":-

const {type, isArray} from 'elegant-standard';

type([])==="array"; // prints true
isArray([]);        // prints true

isUnemptyArray or isUArray

arguments:

element: Any

output: Boolean

source:

function isUnemptyArray(element) {
    return type(element)==="array" && element.length>0;
}
var isUArray = isUnemptyArray;

description:

A function that checks if an element is an array and isn't empty.

const {isArray, isUnemptyArray, isUArray} = require('elegant-standard');

isArray([]);        // prints true
isUnemptyArray([]); // prints false
isUArray([]);       // prints false
isUArray([1]);      // prints true

isEquivalent

arguments:

str1: String
str2: String

output: Boolean

source:

function isEquivalent(str1, str2) {
    return isString(str1) && isString(str2) 
        ? str1.toUpperCase()===str2.toUpperCase()
        : false;
}

description:

A function that checks if two strings are equal ignoring their cases.

const {isEquivalent} = require('elegant-standard');

"hello".toUpperCase()==="HellO".toUpperCase(); // prints true
isEquivalent("hello", "HellO"); // prints true
isEquivalent("1", 1);           // prints false (both elements have to be strings)

isSimilar

arguments:

element1: String or Number
element2: String or Number

output: Boolean

source:

function isSimilar(_element1, _element2){
    var element1 = isNumber(_element1) ? String(_element1) : _element1;
    var element2 = isNumber(_element2) ? String(_element2) : _element2;
    return isString(element1) && isString(element2) 
        ? element1.toUpperCase()===element2.toUpperCase()
        : false; 
}

description:

A function that does the same thing as isEquivalent but also checks if any number passed matches the other string value when converted. (Needless to say you can also compare just numbers, though it isn't recommended)

const {isSimilar} = require('elegant-standard');

"hello".toUpperCase()==="HellO".toUpperCase(); // prints true
isSimilar("hello", "HellO"); // prints true
isSimilar("1", 1);           // prints true
isSimilar(1, 1)              // prints true (Recommended just use 1===1 instead)

isEmail

arguments

element: String

output: Boolean

source:

function isEmail(element) {
    return isString(element) ? /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/.test(el) : false;
}

description:

A function that checks if a string matches the format "placeholder@placeholder.placeholder":-

const {isEmail} = require('elegant-standard');

/^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/.test("nsakhilesh02@gmail.com") // prints true
isEmail("nsakhilesh02@gmail.com")       // prints true

contains

arguments

element1: String or Array
element2: Any

output: Boolean

source:

function contains(element1, element2) {
    if (isString(element1) && isString(element2)) {
        return element1.toUpperCase().includes(element2.toUpperCase());
    }
    
    if (isArray(element1)) {
        var el2 = isString(element2) ? element2.toUpperCase() : element2;
        for (let i=0; i<element1.length; i++) {
        	var el1 = isString(element1[i]) ? element1[i].toUpperCase() : element1[i];
            if (el1===el2) {
                return true;
            }
        }
    }
    return false;
}

description:

Checks if a string exists inside another string or if an item exists in an array while ignoring cases.

const {contains} = require('elegant-standard');

contains("hello", "HELL")        // prints true
contains(["foo","bar"], "FOO")   // prints true
contains(["foo","bar"], "FOO")   // prints true
contains([1, "hello"], "HELLO")  // prints true
contains([1, 2], 1);             // prints true
contains(["hello"], "HELL")      // prints false

test
arguments:
- str: String
- re: RegExp
output: Boolean
source:
```
function test(str, re) {
    return isString(str) && isRegExp(re) && re.test(str);
}
```
description:
While JavaScript regular expressions can perform tests as well, they also allow for testing of numbers:-
```
/12/i.test(12); // prints true
```
Some developers might want to avoid this, and only want to test strings, the test function does exactly this:-
```
const {test} = require('elegant-standard');

test(12, /12/i);   // prints false
test("12", /12/i); // prints true
```

oneOf

arguments

str: String
arr: Array of regular expressions

output: Boolean

source:

function oneOf(str, arr) {
    if (!isString(str)) {
        return false;
    }
    
    if (isArray(arr)) {
        for (let i=0; i<arr.length; i++) {
            if (isRegExp(arr[i]) && arr[i].test(str)) {
                return true;
            } else if (isString(arr[i]) && arr[i]===str) {
                return true;
            }
        }
    }
    return false;
}

description:

A function that checks if a string passes one of an array of regular expression tests or is equal to one of the strings in the array:-

const {oneOf} = require('elegant-standard');

oneOf("hello", ["hello", "world"]);        // prints true
oneOf("hello", [/world/i, /hell/i]);       // prints true
oneOf("hello world", [/world/i, /hell/i]); // prints true

allOf

arguments

str: String
arr: Array of regular expressions

output: Boolean

source:

function allOf(str, arr) {
  if (!isString(str) || !isUArray(arr)) {
      return false;
  }
  var matchesAll = 0;
    
   for (var i = 0; i < arr.length; i++) {
     if (isRegExp(arr[i]) && arr[i].test(str)) {
       matchesAll += 1;
     } else if (isString(arr[i]) && arr[i] === str) {
       matchesAll += 1;
     }
   }

  return matchesAll === arr.length;
};

description:

A function that checks if a string passes all of an array of regular expression tests or is equal to all the strings in an array:-

const {allOf} = require('elegant-standard');

allOf("hello", ["hello", "world"]);        // prints false
allOf("hello", [/world/i, /hell/i]);       // prints false
allOf("hello world", [/world/i, /hell/i]); // prints true

get

arguments:

arr: Array
index: Number
default: Any

output: Item in Array

source

function get(arr, index, def) {
    return !isNumber(index) ? 
      def !== undefined && def !== null ? def : 
      null : 
      index < arr.length && index >= 0 ? arr[index] : 
      def !== undefined && def !== null ? def : 
      null;
}

description:

A function that elegantly gets items from an array. (if an index is out of the range of the array, it will return a default value or null)

const {get} = require('elegant-standard');

let arr = [1, 2, 3];
arr[3]; // Error: Crash
get(arr, 3); // returns null
get(arr, 3, -1); // returns -1

The Rules

Coming soon...

License

This library is licensed under the MIT License - check the LICENSE file for more details.

javascript

@everything-registry/sub-chunk-1566

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago

5 years ago