@dh-utils/common

Readme in Czech (Readme v Češtině)

The library contains basic functions over various primitive values, data types and data structures.

Description

> 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

--------------------

General functions

> 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

--------------------




Local functions by type

> 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




$3


Local function compare (a,b) = compare value type. Returns the values: -1 (a

Usage local function compare(a,b):
` javascript
import { utilsString } from '@dh-utils/common';

utilsString.compare("ABC","ABC"); // 0
utilsString.compare("ABC","ZXY"); // -1
`




$3

Local function copy(a) = creates a copy. In the case of a complex data structure, it is a deep copy.

Usage locale function copy:
` javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.copy([1,2,3]); // [1,2,3]
`




$3

Local function equal (a,b) = compares the value type. Returns values true or false.

Usage locale function copy:
` javascript
import { utilsString } from '@dh-utils/common';

utilsString.equal("ABC","ZXY"); // false
`




$3

Local function is (a) = check if the given variable is of a given value type? Returns values true or 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

--------------------

Working with specific value types

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
`
--------------------

API - General functions




$3

- description : comparison of two values (any)
- return type : {number} -1|0|1
- parametr a : {any}
- parametr b : {any}
- parametr c : {array} sheet type values; specific use

usage :
~~~javascript
import { compare, utilsCommon } from '@dh-utils/common';

compare(0,0); // 0
// or
utilsCommon.compare(0,0); // 0
~~~

$3

- description : comparison of two references
- return type : {number} -1|0|1
- parametr a : {any}
- parametr b : {any}

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
~~~

$3

- description : deep copy
- return type : {any}
- parametr a : {any}

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]
~~~

$3

- description : equal
- return type : {boolean} true|false
- parametr a : {any}
- parametr b : {any}

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
~~~

$3

- description : is the value of the array type?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is the value of the array boolean?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is the value of the date type?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { copy, utilsCommon } from '@dh-utils/common';

isDate(0); // false
// or
utilsCommon.isDate(0); // false

isDate(new Date()); // true
isDate(3); // false
~~~

$3

- description : is the value defined?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is the value empty?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is the value of the function type?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isFunction, utilsCommon } from '@dh-utils/common';

isFunction(0); // false
// or
utilsCommon.isFunction(0); // false

isFunction(()=>{}); // true
isFunction(3); // false
~~~

$3

- description : is not the value of the array type?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is not value defined?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is not value empty?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is not the value null?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isNotNull, utilsCommon } from '@dh-utils/common';

isNotNull(0); // false
// or
utilsCommon.isNotNull(0); // false

isNotNull(null); // false
isNotNull(5); // true
~~~

$3

- description : is a value of type number?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isNumber, utilsCommon } from '@dh-utils/common';

isNumber(0); // true
// or
utilsCommon.isNumber(0); // true

isNumber("5"); // false
isNumber(5); // true
~~~

$3

- description : is a value null?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isNull, utilsCommon } from '@dh-utils/common';

isNull(0); // false
// or
utilsCommon.isNull(0); // false

isNull(null); // true
isNull(5); // false
~~~

$3

- description : is a value of type object?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isObject, utilsCommon } from '@dh-utils/common';

isObject(0); // false
// or
utilsCommon.isObject(0); // false

isObject({}); // true
isObject(3); // false
~~~

$3

- description : is the value a primitive type?
- return type : boolean true|false
- parametr a : {any}

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
~~~

$3

- description : is a value of type a regular expression?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isRegExp, utilsCommon } from '@dh-utils/common';

isRegExp(0); // false
// or
utilsCommon.isRegExp(0); // false

isRegExp(/ab+c/); // true
~~~

$3

- description : is a value of type string?
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { isString, utilsCommon } from '@dh-utils/common';

isString("abc"); // true
// or
utilsCommon.isString("abc"); // true

isString("Hellloo"); // true
isString(3); // false
~~~

$3

- description : is a value of type symbol?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : is a value of type undefined?
- return type : {boolean} true|false
- parametr a : {any}

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
~~~

$3

- description : found type and returning the name as a string
- return type : {string} type as a string
- parametr a : {any}

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"
~~~

$3

- description : not equal
- return type : {boolean} true|false
- parametr a : {any}
- parametr b : {any}

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
~~~

--------------------

⌂ API - Local functions by type Array

⌂ NAME

- popis : constant NAME="array"

použití :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.NAME // array
~~~

$3

- popis : compare two arrays
- return type : {number} -1|0,1
- parametr a : {array}
- parametr b : {array}

usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.compare([1,2,3],[1,2,3]) // 0
~~~

$3

- popis : deep copy array
- return type : {array}
- parametr a : {array}

usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.copy([1,2,3,4]); // [1,2,3,4]
~~~

$3

- popis : equal two arrays
- return type : {boolean} false,true
- parametr a : {array}
- parametr b : {array}

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
~~~

$3

- popis : is a value of type array? same function as utilsCommon.isArray
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.is(5); // false
utilsArray.is([]); // true
~~~

$3

- popis : is an array empty?
- return type : {boolean}
- parametr a : {array}

usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.isEmpty([1, 2, 3]); // false
utilsArray.isEmpty([]); // true
~~~

$3

- popis : is not an array empty?
- return type : {boolean}
- parametr a : {array}

usage :
~~~javascript
import { utilsArray } from '@dh-utils/common';

utilsArray.isNotEmpty([1, 2, 3]); // false
utilsArray.isNotEmpty([]); // true
~~~

--------------------

⌂ API - Local functions by type Boolean

⌂ NAME

- popis : constant NAME="boolean"

použití :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';

utilsBoolean.NAME // boolean
~~~

$3

- popis : compare boolean
- return type : {number} -1|0|1
- parametr a : {boolean}
- parametr b : {boolean}

usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';

utilsBoolean.compare(true,true); // 0
utilsBoolean.compare(false,true); // -1
~~~

$3

- popis : copy boolean
- return type : {boolean}
- parametr target : {boolean}

usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';

utilsBoolean.copy(true); // true
~~~

$3

- popis : equal boolean
- return type : {boolean} false,true
- parametr a : {boolean}
- parametr b : {boolean}

usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';

utilsBoolean.equal(true,true); // true
utilsBoolean.equal(false,true); // false
~~~

$3

- popis : is a value of type boolean? same function as utilsCommon.isBoolean
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsBoolean } from '@dh-utils/common';

utilsBoolean.is(true); // true
utilsBoolean.is(false); // false
~~~

--------------------

⌂ API - Local functions by type Date

⌂ NAME

- popis : constant NAME="date"

použití :
~~~javascript
import { utilsDate } from '@dh-utils/common';

utilsDate.NAME // date
~~~

$3

- popis : compare date
- return type : {number} -1|0|1
- parametr 1 : {date}
- parametr 2 : {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
~~~

$3

- popis : deep copy date
- return type : {date}
- parametr 1 : {date}

usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';

const date = new Date(2016,1,1);
utilsDate.copy(date); // Date(2016,1,1)
~~~

$3

- popis : equal two dates
- return type : {boolean}
- parametr 1 : {date}
- parametr 2 : {date}

usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';

utilsDate.equal(new Date(2015,5,5),new Date(2015,5,6)); // false
~~~

$3

- popis : is a value of type date? same function as utilsCommon.isDate
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsDate } from '@dh-utils/common';

utilsDate.is(new Date(2015,5,5)); // true
utilsDate.is(0); // false
~~~

--------------------

⌂ API - Local functions by type Function

⌂ NAME

- popis : constant NAME="function"

použití :
~~~javascript
import { utilsFunction } from '@dh-utils/common';

utilsFunction.NAME // function
~~~

$3

- popis : compare two functions
- return type : {number} -1,0,1
- parametr a : {function}
- parametr b : {function}

usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';

utilsFunction.compare(()=>"a",()=>"b"); // -1
~~~

$3

- popis : copy function
- return type : {function}
- parametr 1 : {function}

usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';

const func = function(a){return a};
utilsFunction.copy(func); // function(a){return a};
~~~

$3

- popis : equal two functions
- return type : {function}
- parametr 1 : {function}
- parametr 2 : {function}

usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';

const func1 = function(){return "func1"};
const func2 = function(){return "func2"};

utilsFunction.equal(func1,func2); // false
~~~

$3

- popis : is a value of type function? same function as utilsCommon.isFunction
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsFunction } from '@dh-utils/common';

utilsFunction.is(function(){return "func"}); // true
utilsFunction.is(0); // false
~~~

--------------------

⌂ API - Local functions by type Null

⌂ NAME

- popis : constant NAME="null"

použití :
~~~javascript
import { utilsNull } from '@dh-utils/common';

utilsNull.NAME // null
~~~

$3

- popis : compare null
- return type : {number} -1|0|1
- parametr a : {null}
- parametr b : {null}

usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';

utilsNull.compare(null,null); // 0
~~~

$3

- popis : copy null
- return type : {null}
- parametr target : {null}

usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';

utilsNull.copy(null); // null
~~~

$3

- popis : equal boolean
- return type : {boolean} true
- parametr a : {null}
- parametr b : {null}

usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';

utilsNull.equal(null,null); // true
~~~

$3

- popis : is a value null? same function as utilsCommon.isNull
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { utilsNull } from '@dh-utils/common';

utilsNull.is(null); // true
utilsNull.is(0); // false
~~~

--------------------

⌂ API - Local functions by type Number

⌂ NAME

- popis : constant NAME="number"

použití :
~~~javascript
import { utilsNumber } from '@dh-utils/common';

utilsNumber.NAME // number
~~~

$3

- popis : compare number
- return type : {number} -1|0|1
- parametr a : {number}
- parametr b : {number}

usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';

utilsNumber.compare(10,15); // -1
~~~

$3

- popis : copy number
- return type : {number}
- parametr target : {number}

usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';

utilsNumber.copy(10); // 10
~~~

$3

- popis : equal two numbers
- return type : {boolean} false,true
- parametr a : {number}
- parametr b : {number}

usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';

utilsNumber.equal(10,10); // true
utilsNumber.equal(5,10); // false
~~~

$3

- popis : is a value of type number? same function as utilsCommon.isNumber
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsNumber } from '@dh-utils/common';

utilsNumber.is(10); // true
utilsNumber.is("10"); // false
~~~

--------------------

⌂ API - Local functions by type Object

⌂ NAME

- popis : constant NAME="object"

použití :
~~~javascript
import { utilsObject } from '@dh-utils/common';

utilsObject.NAME // object
~~~

$3

- popis : compare objects
- return type : {number} -1|0|1
- parametr a : {object}
- parametr b : {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
~~~

$3

- popis : copy deep bject
- return type : {object}
- parametr target : {object}

usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';

utilsObject.copy({name: "John", age: 42}); // {name: "John", age: 42}
~~~

$3

- popis : equal objects
- return type : {boolean} true
- parametr a : {object}
- parametr b : {object}

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
~~~

$3

- popis : is a value of type object? same function as utilsCommon.isObject
- return type : {boolean} true|false
- parametr a : {any}

usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';

utilsObject.is({}); // true
utilsObject.is(0); // false
~~~

$3

- popis : is an object empty ?
- return type : {boolean} true|false
- parametr a : {object}

usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';

utilsObject.isEmpty({}); // true
utilsObject.isEmpty({a: 0}}); // false
~~~

$3

- popis : is not an object empty ?
- return type : {boolean} true|false
- parametr a : {object}

usage :
~~~javascript
import { utilsObject } from '@dh-utils/common';

utilsObject.isNotEmpty({}); // false
utilsObject.isNotEmpty({a: 0}}); // true
~~~

--------------------

⌂ API - Local functions by type RegExp

⌂ NAME

- popis : constant NAME="regExp"

použití :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';

utilsRegExp.NAME // regExp
~~~

$3

- popis : compare regexp
- return type : {number} -1|0|1
- parametr a : {regexp}
- parametr b : {regexp}

usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';

utilsRegExp.compare(/ab+c/,/ab+c/); // 0
utilsRegExp.compare(/ac+c/,/ab+c/); // -1
~~~

$3

- popis : copy RegExp
- return type : {regexp}
- parametr target : {regexp}

usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';

utilsRegExp.copy(/ab+c/); // /ab+c/
~~~

$3

- popis : equal RegExp
- return type : {boolean} false,true
- parametr a : {regexp}
- parametr b : {regexp}

usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';

utilsRegExp.equal(/ab+c/,/ab+c/); // true
utilsRegExp.equal(/ac+c/,/ab+c/); // false
~~~

$3

- popis : is a value of type regexp? same function as utilsCommon.isRegExp
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsRegExp } from '@dh-utils/common';

utilsRegExp.is(/ab+c/); // true
utilsRegExp.is(0); // false
~~~

--------------------

⌂ API - Local functions by type String

⌂ NAME

- popis : constant NAME="string"

použití :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.NAME // string
~~~

$3

- popis : compare string
- return type : {number} -1|0|1
- parametr a : {string}
- parametr b : {string}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.compare("ABC","ZXY"); // -1
~~~

$3

- popis : copy string
- return type : {boolean}
- parametr target : {boolean}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.copy("abc"); // abc
~~~

$3

- popis : equal string
- return type : {boolean} false,true
- parametr a : {string}
- parametr b : {string}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.equal("ABC","ZXY"); // false
~~~

$3

- popis : is a value of type string? same function as utilsCommon.isString
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.is("abc"); // true
utilsString.is(0); // false
~~~

$3

- popis : is a string empty?
- return type : {boolean}
- parametr a : {string}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.isEmpty("abc"); // false
utilsString.isEmpty(""); // true
~~~

$3

- popis : is not a string empty?
- return type : {boolean}
- parametr a : {string}

usage :
~~~javascript
import { utilsString } from '@dh-utils/common';

utilsString.isNotEmpty("abc"); // false
utilsString.isNotEmpty(""); // true
~~~

--------------------

⌂ API - Local functions by type Symbol

⌂ NAME

- popis : constant NAME="symbol"

použití :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';

utilsSymbol.NAME // symbol
~~~

$3

- popis : compare symbol
- return type : {number} -1|0|1
- parametr a : {symbol}
- parametr b : {boolean}

usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';

// TODO
~~~

$3

- popis : copy symbol
- return type : {symbol}
- parametr target : {symbol}

usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';

// TODO
~~~

$3

- popis : equal symbol
- return type : {boolean} false,true
- parametr a : {symbol}
- parametr b : {symbol}

usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';

// TODO
~~~

$3

- popis : is a value of type symbol? same function as utilsCommon.isSymbol
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsSymbol } from '@dh-utils/common';

// TODO
~~~

--------------------

⌂ API - Local functions by type Undefined

⌂ NAME

- popis : constant NAME="undefined"

použití :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';

utilsUndefined.NAME // undefined
~~~

$3

- popis : compare undefined
- return type : {number} 0
- parametr a : {undefined}
- parametr b : {undefined}

usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';

utilsUndefined.compare(undefined,undefined); // 0
~~~

$3

- popis : copy undefned
- return type : {undefned}
- parametr target : {undefned}

usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';

utilsUndefined.copy(undefined); // undefined
~~~

$3

- popis : equal undefined
- return type : {boolean} true
- parametr a : {undefined}
- parametr b : {undefined}

usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';

utilsUndefined.equal(undefined,undefined); // true
~~~

$3

- popis : is a value of type undefined? same function as utilsCommon.isUndefined
- return type : {boolean}
- parametr a : {any}

usage :
~~~javascript
import { utilsUndefined } from '@dh-utils/common';

utilsUndefined.is(undefined); // true
utilsUndefined.is(0); // false
~~~

-------------------