common utils
npm install @dh-utils/commonReadme in Czech (Readme v Češtině)
The library contains basic functions over various primitive values, data types and data structures.
> The basic primitive values, data types and data structures we work with will be loosely referred in this document as types of values, although this does not exactly correspond to the exact JS specification.
> These JS constructs are meant here as types of values in this library: Array, Boolean, Date, Function, null, Number, Object, RegExp, String, Symbol, undefined.
Basic functions in this library are divided into:
- general functions = work for all types of values
- local functions = work for a specific value type
--------------------
> If you work with variables with different or general value types, use general functions.
Usage general functions:
`` javaScript
import { compare, utilsCommon } from '@dh-utils/common';
compare(0,0); // 0
compare(false, 0); // -1
// or
utilsCommon.compare(0,0); // 0
utilsCommon.compare(false, 0); // -1
`
List of general functions: compare, compareReferences, copy, equal, isArray, isBoolean, isDate, isDefined, isEmpty, isFunction, isNotArray, isNotDefined, isNotEmpty, isNotNull, isNumber, isNull, isObject, isPrimitive, isRegExp, isString, isSymbol, isUndefined,
findOutTheType, notEqual
--------------------
> If you are working with variables with a specific value type, use local functions by type.
Usage local functions by type:
` javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.compare([1,2,3],[1,2,3]) // 0
`
The basic local functions are 4: compare, copy, equal, is
Usage local function compare(a,b):
` javascript
import { utilsString } from '@dh-utils/common';
utilsString.compare("ABC","ABC"); // 0
utilsString.compare("ABC","ZXY"); // -1
`
Usage locale function copy:
` javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.copy([1,2,3]); // [1,2,3]
`
Usage locale function copy:
` javascript
import { utilsString } from '@dh-utils/common';
utilsString.equal("ABC","ZXY"); // false
`
Usage locale function is:
` javascript
import { utilsString } from '@dh-utils/common';
utilsString.is("ABC"); // true
utilsString.is(0); // false
`
List local functions by type:
- Array : compare, copy, equal, is, isEmpty, isNotEmpty
- Boolean : compare, copy, equal, is
- Date : compare, copy, equal, is
- Function : compare, copy, equal, is
- Null : compare, copy, equal, is
- Number : compare, copy, equal, is
- Object : compare, copy, equal, is, isEmpty, isNotEmpty
- RegExp : compare, copy, equal, is
- String : compare, copy, equal, is, isEmpty, isNotEmpty, isNumeric
- Symbol : compare, copy, equal, is
- Undefined : compare, copy, equal, is
--------------------
In exceptional cases, you will want to use basic functions over your specially created types. Yes, it is possible. These general functions compare, copy, equal, is also have a third parameter of the function, with which you can adjust over which types of values you want to perform the basic functionality.
Example: We will have special data structures / special types of values "Car" and "Airplane". These types of values differ by the "model" attribute. The special value type "Car" can therefore have the model = "Honda" or "Suzuki". Therefore, the special value type "Airplane" can have model = "Mig" or "F16":
` javascript
import { compare } from "@dh-utils/common";
// functions over special data structure (value types)
const typeValueAirplane = {
_fce: "Airplane",
compare: function (a, b) {
return a.model.localeCompare(b.model);
},
copy: function(a){/ zde bude fce copy /},
equal: function(a, b){return a.model.toString() === b.model.toString();},
is: function (a) {
return a.type === "airplane";
},
};
const typeValueCar = {
_fce: "Car",
compare: function (a, b) {
return a.model.localeCompare(b.model);
},
copy: function(a){/ zde bude fce copy /},
equal: function(a, b){return a.model.toString() === b.model.toString();},
is: function (a) {
return a.type === "car";
},
};
// special data structure classes
const ClassAirplane = class Airplane {
constructor(model) {
this.type = "airplane";
this.model = model || "empty";
}
};
const ClassCar = class Car {
constructor(model) {
this.type = "car";
this.model = model || "empty";
}
};
// defining objects
const airplaneIljusin = new ClassAirplane("Iljusin");
const carSuzuki = new ClassCar("Suzuki");
const carHonda = new ClassCar("Honda");
const carHonda2 = new ClassCar("Honda");
// defining a list of a specific data structure (type of values)
const listTypeValues = [typeValueAirplane, typeValueCar];
// specific work with functions
compare(airplaneIljusin, carSuzuki, listTypeValues); // -1
compare(carSuzuki, carHonda, listTypeValues); // -1
compare(carHonda, carHonda2, listTypeValues); // 0
`
--------------------
usage :
~~~javascript
import { compare, utilsCommon } from '@dh-utils/common';
compare(0,0); // 0
// or
utilsCommon.compare(0,0); // 0
~~~
usage :
~~~javascript
import { compareReferences, utilsCommon } from '@dh-utils/common';
compareReferences(0,0); // 0
// or
utilsCommon.compareReferences(0,0); // 0
const a = {}, b = a;
compareReferences(a,b); // 0
const a = {}, b = {}
compareReferences(a,b); // 1
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
copy({a:"a",b:"b"}); // {a:"a",b:"b"}
// or
utilsCommon.copy({a:"a",b:"b"}); // {a:"a",b:"b"}
copy([1,2,3,4]); // [1,2,3,4]
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
equal(0,0); // true
// or
utilsCommon.equal(0,0); // true
equal(3,3); // true
equal([0,1,2,3,[0,1,2]],[0,1,2,3,[0,1,2]]); // true
equal([0,1,2,3,[0,1,2]],[0,1,2,3,[0,2,1]]); // false
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
isArray(0); // false
// or
utilsCommon.isArray(0); // false
isArray([1,2,3,4]); // true
isArray(3); // false
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
isBoolean(0); // false
// or
utilsCommon.isBoolean(0); // false
isBoolean(true); // true
isBoolean(false); // true
isBoolean([1,2,3,4]); // false
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
isDate(0); // false
// or
utilsCommon.isDate(0); // false
isDate(new Date()); // true
isDate(3); // false
~~~
usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';
isDefined(0); // true
// or
utilsCommon.isDefined(0); // true
isDefined([1,2,3,4]); // true
isDefined(null); // false
isDefined(undefined); // false
~~~
usage :
~~~javascript
import { isEmpty, utilsCommon } from '@dh-utils/common';
isEmpty(0); // true
// or
utilsCommon.isEmpty(0); // true
isEmpty(null); // true
isEmpty(undefined); // true
isEmpty([]); // true
isEmpty({}); // true
isEmpty(""); // true
isEmpty([1,2,3,4]); // false
isEmpty(42); // false
isEmpty("hellooo"); // false
~~~
usage :
~~~javascript
import { isFunction, utilsCommon } from '@dh-utils/common';
isFunction(0); // false
// or
utilsCommon.isFunction(0); // false
isFunction(()=>{}); // true
isFunction(3); // false
~~~
usage :
~~~javascript
import { isNotArray, utilsCommon } from '@dh-utils/common';
isNotArray(0); // false
// or
utilsCommon.isNotArray(0); // false
isNotArray([1,2,3,4]); // false
isNotArray({}); // true
~~~
usage :
~~~javascript
import { isNotDefined, utilsCommon } from '@dh-utils/common';
isNotDefined(0); // false
// or
utilsCommon.isNotDefined(0); // false
isNotDefined([1,2,3,4]); // true
isNotDefined(null); // false
isNotDefined(undefined); // false
~~~
usage :
~~~javascript
import { isNotEmpty, utilsCommon } from '@dh-utils/common';
isNotDefined(0); // false
// or
utilsCommon.isNotDefined(0); // false
isNotEmpty([1,2,3,4]); // true
isNotEmpty(42); // true
isNotEmpty("hellooo"); // true
isNotEmpty(null); // false
isNotEmpty(undefined); // false
isNotEmpty([]); // false
isNotEmpty({}); // false
isNotEmpty(""); // true
~~~
usage :
~~~javascript
import { isNotNull, utilsCommon } from '@dh-utils/common';
isNotNull(0); // false
// or
utilsCommon.isNotNull(0); // false
isNotNull(null); // false
isNotNull(5); // true
~~~
usage :
~~~javascript
import { isNumber, utilsCommon } from '@dh-utils/common';
isNumber(0); // true
// or
utilsCommon.isNumber(0); // true
isNumber("5"); // false
isNumber(5); // true
~~~
usage :
~~~javascript
import { isNull, utilsCommon } from '@dh-utils/common';
isNull(0); // false
// or
utilsCommon.isNull(0); // false
isNull(null); // true
isNull(5); // false
~~~
usage :
~~~javascript
import { isObject, utilsCommon } from '@dh-utils/common';
isObject(0); // false
// or
utilsCommon.isObject(0); // false
isObject({}); // true
isObject(3); // false
~~~
usage :
~~~javascript
import { isPrimitive, utilsCommon } from '@dh-utils/common';
isPrimitive(0); // true
// or
utilsCommon.isPrimitive(0); // true
isPrimitive("Hellloo"); // true
isPrimitive(3); // true
isPrimitive({}); // false
~~~
usage :
~~~javascript
import { isRegExp, utilsCommon } from '@dh-utils/common';
isRegExp(0); // false
// or
utilsCommon.isRegExp(0); // false
isRegExp(/ab+c/); // true
~~~
usage :
~~~javascript
import { isString, utilsCommon } from '@dh-utils/common';
isString("abc"); // true
// or
utilsCommon.isString("abc"); // true
isString("Hellloo"); // true
isString(3); // false
~~~
usage :
~~~javascript
import { isSymbol, utilsCommon } from '@dh-utils/common';
isSymbol(0); // false
// or
utilsCommon.isSymbol(0); // false
isSymbol(Symbol()); // true
isSymbol(Symbol(42)); // true
isSymbol(Symbol("foo")); // true
~~~
usage :
~~~javascript
import { isUndefined, utilsCommon } from '@dh-utils/common';
isUndefined(0); // false
// or
utilsCommon.isUndefined(0); // false
const prom;
isUndefined(prom); // true
isUndefined(5); // false
~~~
použití :
~~~javascript
import { findOutTheType, utilsCommon } from '@dh-utils/common';
findOutTheType(0); // "number"
findOutTheType("hellooo"); // "string"
// or
utilsCommon.findOutTheType(0); // "number"
utilsCommon.findOutTheType("hellooo"); // "string"
~~~
usage :
~~~javascript
import { notEqual, utilsCommon } from '@dh-utils/common';
notEqual(0,0); // false
// or
utilsCommon.notEqual(0,0); // false
notEqual(3,3); // false
notEqual([0,1,2,3,[0,1,2]],[0,1,2,3,[0,1,2]]); // false
notEqual([0,1,2,3,[0,1,2]],[0,1,2,3,[0,2,1]]); // true
~~~
--------------------
použití :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.NAME // array
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.compare([1,2,3],[1,2,3]) // 0
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.copy([1,2,3,4]); // [1,2,3,4]
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.equal([1,2,3,4],[1,2,3,4]); // true
utilsArray.equal([4,2,3,1],[1,2,3,4]); // false
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.is(5); // false
utilsArray.is([]); // true
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.isEmpty([1, 2, 3]); // false
utilsArray.isEmpty([]); // true
~~~
usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';
utilsArray.isNotEmpty([1, 2, 3]); // false
utilsArray.isNotEmpty([]); // true
~~~
--------------------
použití :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';
utilsBoolean.NAME // boolean
~~~
usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';
utilsBoolean.compare(true,true); // 0
utilsBoolean.compare(false,true); // -1
~~~
usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';
utilsBoolean.copy(true); // true
~~~
usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';
utilsBoolean.equal(true,true); // true
utilsBoolean.equal(false,true); // false
~~~
usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';
utilsBoolean.is(true); // true
utilsBoolean.is(false); // false
~~~
--------------------
použití :
~~~javascript
import { utilsDate } from '@dh-utils/common';
utilsDate.NAME // date
~~~
usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';
let date1 = new Date(2015,5,5);
let date2 = new Date(2015,5,6);
let result = utilsDate.compare(date1,date2); // -1
~~~
usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';
const date = new Date(2016,1,1);
utilsDate.copy(date); // Date(2016,1,1)
~~~
usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';
utilsDate.equal(new Date(2015,5,5),new Date(2015,5,6)); // false
~~~
usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';
utilsDate.is(new Date(2015,5,5)); // true
utilsDate.is(0); // false
~~~
--------------------
použití :
~~~javascript
import { utilsFunction } from '@dh-utils/common';
utilsFunction.NAME // function
~~~
usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';
utilsFunction.compare(()=>"a",()=>"b"); // -1
~~~
usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';
const func = function(a){return a};
utilsFunction.copy(func); // function(a){return a};
~~~
usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';
const func1 = function(){return "func1"};
const func2 = function(){return "func2"};
utilsFunction.equal(func1,func2); // false
~~~
usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';
utilsFunction.is(function(){return "func"}); // true
utilsFunction.is(0); // false
~~~
--------------------
použití :
~~~javascript
import { utilsNull } from '@dh-utils/common';
utilsNull.NAME // null
~~~
usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';
utilsNull.compare(null,null); // 0
~~~
usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';
utilsNull.copy(null); // null
~~~
usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';
utilsNull.equal(null,null); // true
~~~
usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';
utilsNull.is(null); // true
utilsNull.is(0); // false
~~~
--------------------
použití :
~~~javascript
import { utilsNumber } from '@dh-utils/common';
utilsNumber.NAME // number
~~~
usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';
utilsNumber.compare(10,15); // -1
~~~
usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';
utilsNumber.copy(10); // 10
~~~
usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';
utilsNumber.equal(10,10); // true
utilsNumber.equal(5,10); // false
~~~
usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';
utilsNumber.is(10); // true
utilsNumber.is("10"); // false
~~~
--------------------
použití :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.NAME // object
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.compare({name: "John", age: 42},{name: "John", age: 42}); // 0
utilsObject.compare({nameX: "John", age: 42},{name: "John", age: 42}); // 1
utilsObject.compare({name: "JohnX", age: 42},{name: "John", age: 42}); // 1
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.copy({name: "John", age: 42}); // {name: "John", age: 42}
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.equal({name: "John", age: 42}, {name: "John", age: 42}); // true
utilsObject.equal({name: "John", age: 42}, {name: "John", age: 43}); // false
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.is({}); // true
utilsObject.is(0); // false
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.isEmpty({}); // true
utilsObject.isEmpty({a: 0}}); // false
~~~
usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';
utilsObject.isNotEmpty({}); // false
utilsObject.isNotEmpty({a: 0}}); // true
~~~
--------------------
použití :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';
utilsRegExp.NAME // regExp
~~~
usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';
utilsRegExp.compare(/ab+c/,/ab+c/); // 0
utilsRegExp.compare(/ac+c/,/ab+c/); // -1
~~~
usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';
utilsRegExp.copy(/ab+c/); // /ab+c/
~~~
usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';
utilsRegExp.equal(/ab+c/,/ab+c/); // true
utilsRegExp.equal(/ac+c/,/ab+c/); // false
~~~
usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';
utilsRegExp.is(/ab+c/); // true
utilsRegExp.is(0); // false
~~~
--------------------
použití :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.NAME // string
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.compare("ABC","ZXY"); // -1
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.copy("abc"); // abc
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.equal("ABC","ZXY"); // false
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.is("abc"); // true
utilsString.is(0); // false
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.isEmpty("abc"); // false
utilsString.isEmpty(""); // true
~~~
usage :
~~~javascript
import { utilsString } from '@dh-utils/common';
utilsString.isNotEmpty("abc"); // false
utilsString.isNotEmpty(""); // true
~~~
--------------------
použití :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';
utilsSymbol.NAME // symbol
~~~
usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';
// TODO
~~~
usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';
// TODO
~~~
usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';
// TODO
~~~
usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';
// TODO
~~~
--------------------
použití :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';
utilsUndefined.NAME // undefined
~~~
usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';
utilsUndefined.compare(undefined,undefined); // 0
~~~
usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';
utilsUndefined.copy(undefined); // undefined
~~~
usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';
utilsUndefined.equal(undefined,undefined); // true
~~~
usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';
utilsUndefined.is(undefined); // true
utilsUndefined.is(0); // false
~~~
-------------------