arraymethods.js
v2.1.0
Published
Useful array methods for 1d, 2d, and 3d arrays!
Downloads
27
Maintainers
Readme
ArrayMethods.js
This npm package includes array methods that make working with 1, 2, and 3 dimensional arrays much easier! I hope you find it useful :)
Table of Contents
- Installation
- Using the package
- Methods for any array
- Exclusive 1d methods
- Exclusive 2d+ methods
- Exclusive 3d+ methods
- Coordinates Class
- ItemConditional Class
- Extras
Installation
To install the arrayMethods.js
package, simply do:
npm install arraymethods.js
Using the Package
Using the package is simple and easy!
const Arrays = require("arraymethods.js");
// or
import Arrays from "arraymethods.js";
All methods and constructors can be found from the Arrays
package.
Methods For Any Array
These methods can be used on ANY array, no matter the dimension!
Table of Contents
- GetDimension - Get the dimension of an array
- Swap - Swap 2 items
- Replace - Replace items
- InsertLeft - Insert an item left of an another item
- InsertRight - Insert an item right of an another item
- SearchQuery - Get all the items that match one or more conditions
- LengthWith - Like searchQuery, but it returns the length with one or more CheckConditions
GetDimension
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.getDimension(array));
// Returns: 1
const array = [["apple", "orange"], ["lemon", "pear"]];
console.log(Arrays.getDimension(array));
// Returns: 2
const array = [
[["apple", "orange"], ["lemon", "pear"]],
[["banana", "avocado"], ["peach", "grape"]]
]
console.log(Arrays.getDimension(array));
// Returns: 3
The getDimension
method returns a number depending on the dimension of the array. Note that any arrays with more dimensions than 3 will return 3, since 4d+ arrays are not supported yet.
Parameters:
- 1d+ array
Returns:
number
Swap
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.swap(array, "apple", "lemon"));
// Returns: ["lemon", "orange", "apple", "pear"]
const array = [["apple", "orange"], ["lemon", "pear"]];
console.log(Arrays.swap(array, {row: 0, column: 0}, {row: 1, column: 0}));
// Returns: [["lemon", "orange"], ["apple", "pear"]]
const array = [["apple", "orange"], ["lemon", "pear"]];
const coordinates1 = new Arrays.Coordinates(0, 0);
const coordinates2 = new Arrays.Coordinates(1, 0);
console.log(Arrays.swap(array, coordinates1, coordinates2));
// Returns: [["lemon", "orange"], ["apple", "pear"]]
The swap
method returns a same-dimensional array, with two specified items swapped.
Parameters:
- 1d+ array
- Item, index, array, object, or [Coordinates][3]
- Item, index, array, object, or [Coordinates][3]
Returns:
SameD array
Replace
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.replace(array, "apple", "lemon"));
// Returns: ["lemon", "orange", "lemon", "pear"]
const array = [["apple", "orange"], ["lemon", "pear"]];
console.log(Arrays.replace(array, {row: 1, column: 0}, "lemon"));
// Returns: [["lemon", "orange"], ["lemon", "pear"]]
const array = [["apple", "orange"], ["lemon", "pear"]];
const coordinates = new Arrays.Coordinates(1, 0);
console.log(Arrays.swap(array, coordinates, "lemon"));
// Returns: [["lemon", "orange"], ["lemon", "pear"]]
The replace
method returns a same-dimensional array, with one or more items replaced.
Parameters:
Returns:
SameD array
InsertLeft
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.insertLeft(array, "orange", "mango"));
// Returns: ["apple", "mango", "orange", "lemon", "pear"]
const array = [["apple", "orange"], ["lemon", "pear"]];
console.log(Arrays.insertLeft(array, {row: 0, column: 1}, "mango"));
// Returns: [["apple", "mango", "orange"], ["lemon", "pear"]]
const array = [["apple", "orange"], ["lemon", "pear"]];
const coordinates = new Arrays.Coordinates(0, 1);
console.log(Arrays.insertLeft(array, coordinates, "mango"));
// Returns: [["apple", "mango", "orange"], ["lemon", "pear"]]
The insertLeft
method returns a same-dimensional array, with one or more items inserted to the left of items specified.
Settings:
{
insertAll: false, // inserts the item to the left of all items that match
replace: false // inserts the item in the place of the item to the left
}
Insert an object like this at the end of the method to choose your settings.
Parameters:
Returns:
SameD array
InsertRight
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.insertRight(array, "apple", "mango"));
// Returns: ["apple", "mango", "orange", "lemon", "pear"]
const array = [["apple", "orange"], ["lemon", "pear"]];
console.log(Arrays.insertRight(array, {row: 0, column: 0}, "mango"));
// Returns: [["apple", "mango", "orange"], ["lemon", "pear"]]
const array = [["apple", "orange"], ["lemon", "pear"]];
const coordinates = new Arrays.Coordinates(0, 0);
console.log(Arrays.insertRight(array, coordinates, "mango"));
// Returns: [["apple", "mango", "orange"], ["lemon", "pear"]]
The insertRight
method returns a same-dimensional array, with one or more items inserted to the right of items specified.
Settings:
{
insertAll: false, // inserts the item to the right of all items that match
replace: false // inserts the item in the place of the item to the right
}
Insert an object like this at the end of the method to choose your settings.
Parameters:
Returns:
SameD array
SearchQuery
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.searchQuery(array, new Arrays.ItemConditional({
includes: "a"
})));
// Returns: ["apple", "orange", "pear"]
const array = [["apple", "orange"], ["mango", "pear"]];
console.log(Arrays.searchQuery(array, new Arrays.ItemConditional({
includes: "g"
})));
// Returns: ["orange", "mango"]
The searchQuery
method returns a 1d array including all the items in the array that pass one or more conditions.
Parameters:
- 1d+ array
- ItemConditional
Returns:
1d array
LengthWith
const array = ["apple", "orange", "orange", "pear"];
console.log(Arrays.lengthWith(array, new Arrays.ItemConditional({
equalto: "orange"
})));
// Returns: 2
const array = [["pear", "orange"], ["lemon", "pear"], ["pear", "mango"]];
console.log(Arrays.lengthWith(array, new Arrays.ItemConditional({
equalto: "pear"
})));
// Returns: 3
The lengthWith
method returns the length of an array, where if n item doesn't pass one or more conditions, it doesn't count towards the length.
Settings:
{
countArrays: false // counts arrays while getting the total length
}
Insert an object like this at the end of the method to choose your settings.
Parameters:
- 1d+ array
- ItemConditional
Returns:
number
Exclusive 1d Methods
These methods are exclusive to traditional 1-dimensional arrays.
Table of Contents
- First - Get the first number of items of an array
- Last - Get the last number of items in an array
- AllIndexesOf - Get a list of indexes of an items
- Distance - Get the distance between 2 items
- Between - Get all the items between 2 items
- Cut - Cut an array into 2 equal parts
First
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.first(array));
// Returns: "apple"
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.first(array, 2));
// Returns: ["apple", "orange"]
The first
method returns either the first item from the array or a 1d array including the first number of items.
Parameters:
- 1d array
- [Optional: 1] The number of first items
Returns:
Item or 1d array
Last
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.last(array));
// Returns: "pear"
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.last(array, 2));
// Returns: ["lemon", "pear"]
The last
method returns either the last item from the array or a 1d array including the last number of items.
Parameters:
- 1d array
- [Optional: 1] The number of last items
Returns:
Item or 1d array
AllIndexesOf
const array = ["apple", "lemon", "pear", "lemon"];
console.log(Arrays.allIndexesOf(array, "lemon"));
// Returns: [1, 3]
The allIndexesOf
method returns a 1d array with all the indexes of a specified item.
Parameters:
- 1d array
- Item
Returns:
1d array
Distance
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.distance(array, "apple", "pear"));
// Returns: 3
The distance
method returns the distance between 2 items in the array.
Parameters:
- 1d array
- Item
- Item
Returns:
number
Between
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.between(array, "apple", "pear"));
// Returns: ["orange", "lemon"]
The between
method returns a 1d array with the items between 2 items in the array.
Parameters:
- 1d array
- Item
- Item
Returns:
1d array
Cut
const array = ["apple", "orange", "lemon", "pear"];
console.log(Arrays.cut(array));
// Returns: [["apple", "orange"], ["lemon", "pear"]]
const array = ["apple", "orange", "mango", "lemon", "pear"];
console.log(Arrays.cut(array));
// Returns: [["apple", "orange", "mango"], ["lemon", "pear"]]
The cut
method returns a 2d array with 2 rows, where each row is one half of the array.
Parameters:
- 1d array
Returns:
2d array
Exclusive 2d+ Methods
These methods are exclusive to 2d arrays and above. Note that all examples will use 2d arrays, but you can still use 3d arrays.
Common Terms
You probably know this already, but just incase:
- A
row
is each array item in a 2d+ array. - A
column
is an array of a specific index in each row. - A
layer
is an array of a specific index in each column.
Table of Contents
- Row - Get a specific row of an array
- Column - Get a specific column of an array
- Columns - Get the number of columns
- FindItem - Find an item using coordinates
- FindCoordinates - Find the coordinates of an item
- FindMultipleCoordinates - Get a list of coordinates of an item
- InsertRowAbove - Insert a row above a specified row
- InsertRowBelow - Insert a row below a specified row
- InsertColumnLeft - Insert a column left of a specified column
- InsertColumnRight - Insert a column right of a specified column
- LocalIndexOf - Get the local index of an item
- AllLocalIndexesOf - Get a list of local indexes of an item
- TotalLength - Get the total length of an array
- SearchRowQuery - Get all the items that match one or more conditions in a specified row
- SearchColumnQuery - Get all the items that match one or more conditions in a specified column
- RowIncludes - Get if a row includes an item
- ColumnIncludes - Get if a column includes an item
- ReplaceInRow - Replace items in a specified row
- ReplaceInColumn - Replace items in a specified column
- ReplaceInAllRows - Replace items in every row
- RowOf - Get the row of an item in an array
- ColumnOf - Get the column of an item in an array
- SortRow - Sort a specified row in an array
- SortColumn - Sort a specified column in an array
- SortAllRows - Sort every row in an array
Row
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.row(array, 0));
// Returns: ["apple", "orange"]
The row
method returns a row in the array.
Parameters:
- 2d+ array
- Index
Returns:
1d+ array
Column
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.column(array, 0));
// Returns: ["apple", "lemon"]
The column
method returns a column in the array.
Parameters:
- 2d+ array
- Index
Returns:
1d+ array
Columns
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.columns(array));
// Returns: 2
const array = [
["apple", "orange"],
["lemon", "pear", "lime"]
];
console.log(Arrays.columns(array, "max"));
// Returns: 3
const array = [
["apple", "orange"],
["lemon", "pear", "lime"]
];
console.log(Arrays.columns(array, "min"));
// Returns: 2
The columns
method returns how many columns are inside the array. If the type is "max", it'll include columns where not every item is defined. If the type is "min", it'll only include columns where every item is defined.
Parameters:
- 2d+ array
- [Optional: "max"] Type
Returns:
number
FindItem
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.findItem(array, [0, 1]));
// Returns: "orange"
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.findItem(array, {row: 0, column: 1}));
// Returns: "orange"
const array = [
["apple", "orange"],
["lemon", "pear"]
];
const coordinates = new Arrays.Coordinates(0, 1);
console.log(Arrays.findItem(array, coordinates));
// Returns: "orange"
The findItem
method returns an item found in the array.
Parameters:
Returns:
Item
FindCoordinates
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.findCoordinates(array, "lemon"));
// Returns: Coordinates { row: 1, column: 0 }
The findCoordinates
method returns a Coordinates constructor of the coordinates of an item in the array.
Parameters:
- 2d+ array
- Item
Returns:
[Coordinates][3]
FindMultipleCoordinates
const array = [
["pear", "orange"],
["lemon", "pear"]
];
console.log(Arrays.findMultipleCoordinates(array, "pear"));
// Returns: [Coordinates { row: 0, column: 0 }, Coordinates { row: 1, column: 1 }]
The findCoordinates
method returns a 1d array of Coordinates constructors of the coordinates of each instance of an item in the array.
Parameters:
- 2d+ array
- Item
Returns:
1d array
InsertRowAbove
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.insertRowAbove(array, 0, ["mango", "kiwi"]));
/* Returns:
[
["mango", "kiwi"],
["apple", "orange"],
["lemon", "pear"]
]
The insertRowAbove
method returns a same-dimensional array with a new row inserted above a specified row.
Settings:
{
replace: false // inserts the row in the place of the row above
}
Parameters:
- 2d+ array
- Index
- 1d+ array
Returns:
SameD array
InsertRowBelow
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.insertRowBelow(array, 0, ["mango", "kiwi"]));
/* Returns:
[
["apple", "orange"],
["mango", "kiwi"],
["lemon", "pear"]
]
The insertRowBelow
method returns a same-dimensional array with a new row inserted below a specified row.
Settings:
{
replace: false // inserts the row in the place of the row above
}
Parameters:
- 2d+ array
- Index
- 1d+ array
Returns:
SameD array
InsertColumnLeft
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.insertColumnLeft(array, 0, ["mango", "kiwi"]));
/* Returns:
[
["mango", "apple", "orange"],
["kiwi", "lemon", "pear"]
]
The insertColumnLeft
method returns a same-dimensional array with a new column inserted to the left of a specified column.
Settings:
{
replace: false // inserts the column in the place of the column to the left
}
Parameters:
- 2d+ array
- Index
- 1d+ array
Returns:
SameD array
InsertColumnRight
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.insertColumnRight(array, 0, ["mango", "kiwi"]));
/* Returns:
[
["apple", "mango", "orange"],
["lemon", "kiwi", "pear"]
]
The insertColumnRight
method returns a same-dimensional array with a new column inserted to the right of a specified column.
Settings:
{
replace: false // inserts the column in the place of the column to the right
}
Parameters:
- 2d+ array
- Index
- 1d+ array
Returns:
SameD array
LocalIndexOf
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.localIndexOf(array, "orange"));
// Returns: 1
The localIndexOf
method returns the index of the item in its most local array.
Parameters:
- 2d+ array
- Item
Returns:
number
AllLocalIndexesOf
const array = [
["pear", "orange"],
["lemon", "pear"]
];
console.log(Arrays.localIndexOf(array, "pear"));
// Returns: [0, 1]
The allLocalIndexesOf
method returns a 1d array of the local index of each instance of a specified item in the array.
Parameters:
- 2d+ array
- Item
Returns:
1d array
TotalLength
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.totalLength(array));
// Returns: 4
The totalLength
method returns the total length of the array. It adds up the length of every single item in the array.
Settings:
{
countArrays: false // counts arrays while getting the total length
}
Insert an object like this at the end of the method to choose your settings.
Parameters:
- 2d+ array
Returns:
number
SearchRowQuery
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.searchRowQuery(array, 0, new Arrays.ItemConditional({
includes: "r"
})));
// Returns: ["orange"]
The searchRowQuery
method returns a 1d+ array including all the items in a specified row that pass one or more conditions.
Parameters:
- 2d+ array
- Index
- ItemConditional
Returns:
1d+ array
SearchColumnQuery
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.searchColumnQuery(array, 0, new Arrays.ItemConditional({
notincludes: "a"
})));
// Returns: ["lemon"]
The searchColumnQuery
method returns a 1d+ array including all the items in a specified column that pass one or more conditions.
Parameters:
- 2d+ array
- Index
- ItemConditional
Returns:
1d+ array
RowIncludes
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.rowIncludes(array, 0, "orange"));
// Returns: true
The rowIncludes
method returns a boolean depending on whether or not a specified row includes an item.
Parameters:
- 2d+ array
- Index
- Item
Returns:
boolean
ColumnIncludes
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.columnIncludes(array, 0, "pear"));
// Returns: false
The columnIncludes
method returns a boolean depending on whether or not a specified column includes an item.
Parameters:
- 2d+ array
- Index
- Item
Returns:
boolean
ReplaceInRow
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.replaceInRow(array, 0, "orange", "kiwi"));
/* Returns:
[
["apple", "kiwi"],
["lemon", "pear"]
];
The replaceInRow
method returns a 2d+ array, with one or more items replaced in a specified row.
Parameters:
- 2d+ array
- Index
- Item
- Item
Returns:
2d+ array
ReplaceInColumn
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.replaceInRow(array, 0, "lemon", "mango"));
/* Returns:
[
["apple", "orange"],
["mango", "pear"]
];
The replaceInRow
method returns a 2d+ array, with one or more items replaced in a specified row.
Parameters:
- 2d+ array
- Index
- Item
- Item
Returns:
2d+ array
ReplaceInAllRows
const array = [
["pear", "orange"],
["lemon", "pear"]
];
console.log(Arrays.replaceInAllRows(array, "pear", "kiwi"));
/* Returns:
[
["kiwi", "orange"],
["lemon", "kiwi"]
];
The replaceInAllRows
method returns a 2d+ array, with one or more items replaced in each row.
Parameters:
- 2d+ array
- Item
- Item
Returns:
2d+ array
RowOf
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.rowOf(array, "orange"));
// Returns: 0
The rowOf
method returns the row of a specified item in the array.
Parameters:
- 2d+ array
- Item
Returns:
number
ColumnOf
const array = [
["apple", "orange"],
["lemon", "pear"]
];
console.log(Arrays.columnOf(array, "pear"));
// Returns: 1
The columnOf
method returns the column of a specified item in the array.
Parameters:
- 2d+ array
- Item
Returns:
number
SortRow
const array = [
[1, 2, 3],
[3, 2, 1]
];
console.log(Arrays.sortRow(array, 0, (a, b) => a - b));
/* Returns:
[
[1, 2, 3],
[1, 2, 3]
]
The sortRow
method returns a same-dimensional array with a specified row sorted.
Parameters:
- 2d+ array
- Index
- Function
Returns:
2d+ array
SortColumn
const array = [
[1, 2, 3],
[3, 2, 1]
];
console.log(Arrays.sortColumn(array, 2, (a, b) => a - b));
/* Returns:
[
[1, 2, 1],
[1, 2, 3]
]
The sortColumn
method returns a same-dimensional array with a specified column sorted.
Parameters:
- 2d+ array
- Index
- Function
Returns:
2d+ array
SortAllRows
const array = [
[5, 4, 6],
[3, 5, 2]
];
console.log(Arrays.sortAllRows(array, (a, b) => a - b));
/* Returns:
[
[4, 5, 6],
[2, 3, 5]
]
The sortAllRows
method returns a same-dimensional array with all rows sorted.
Parameters:
- 2d+ array
- Index
- Function
Returns:
2d+ array
Exclusive 3d+ Methods
These methods are exclusive to 3d arrays. While technically these can work on 4d arrays and above, they may be unstable.
Table of Contents
- Layer - Get a layer in an array
- Layers - Get the number of layers
- InsertLayerLeft - Insert a layer left of a specified layer
- InsertLayerRight - Insert a layer right of a specified layer
- SearchLayerQuery - Get all the items that match one or more conditions in a specified layer
- LayerIncludes - Get if a layer includes an item
- ReplaceInLayer - Replace items in a specified layer
- SortLayer - Sort items in a specified layer
Layer
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.layer(array, 0));
// Returns: ["apple", "lemon", "banana", "peach"]
The layer
method returns a 1d+ array of a specified layer in the array.
Parameters:
- 3d+ array
- Index
Returns:
1d+ array
Layers
const array1 = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
const array2 = [
[
["apple", "orange"],
["lemon", "pear", "kiwi"]
],
[
["banana", "avocado", "lime"],
["peach", "grape"]
]
];
console.log(Arrays.layers(array1));
// Returns: 2
console.log(Arrays.layers(array2, "max"));
// Returns: 3
console.log(Arrays.layers(array2, "min"));
// Returns: 2
The layers
method returns the number of layers in the array. The type (either "min" or "max") works the same way as the columns method.
Parameters:
- 3d+ array
- [Optional: "max"] Type
Returns:
number
InsertLayerLeft
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.insertLayerLeft(array, 1, ["kiwi", "mango", "lime", "durian"]));
/* Returns:
[
[
["apple", "kiwi", "orange"],
["lemon", "mango", "pear"]
],
[
["banana", "lime", "avocado"],
["peach", "durian", "grape"]
]
]
The insertLayerLeft
method returns a 3d+ array with a layer inserted to the left of a specified layer.
Parameters:
- 3d+ array
- Index
- 1d+ array
Returns:
3d+ array
InsertLayerRight
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.insertLayerRight(array, 0, ["kiwi", "mango", "lime", "durian"]));
/* Returns:
[
[
["apple", "kiwi", "orange"],
["lemon", "mango", "pear"]
],
[
["banana", "lime", "avocado"],
["peach", "durian", "grape"]
]
]
The insertLayerRight
method returns a 3d+ array with a layer inserted to the right of a specified layer.
Parameters:
- 3d+ array
- Index
- 1d+ array
Returns:
3d+ array
SearchLayerQuery
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.searchLayerQuery(array, 0, new Arrays.ItemConditional({
includes: "a"
})));
// Returns: ["apple", "banana", "peach"]
The searchLayerQuery
method returns a 1d+ array including all the items in a specified layer that pass one or more conditions.
Parameters:
- 3d+ array
- Index
- ItemConditional
Returns:
1d+ array
LayerIncludes
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.layerIncludes(array, 1, "avocado"));
// Returns: true
The layerIncludes
method returns a boolean depending on whether or not a specified layer includes an item.
Parameters:
- 3d+ array
- Index
- Item
Returns:
boolean
ReplaceInLayer
const array = [
[
["apple", "orange"],
["lemon", "pear"]
],
[
["banana", "avocado"],
["peach", "grape"]
]
];
console.log(Arrays.replaceInLayer(array, 0, "banana", "kiwi"));
/* Returns:
[
[
["apple", "orange"],
["lemon", "pear"]
],
[
["kiwi", "avocado"],
["peach", "grape"]
]
]
The replaceInLayer
method returns a 3d+ array, with one or more items replaced in a specified layer.
Parameters:
- 3d+ array
- Index
- Item
- Item
Returns:
3d+ array
SortLayer
const array = [
[
[1, 2],
[5, 3],
],
[
[6, 2],
[3, 8]
]
];
console.log(Arrays.sortLayer(array, 0, (a, b) => a - b));
/* Returns:
[
[
[1, 2],
[3, 3],
],
[
[5, 2],
[6, 8]
]
]
The sortLayer
method returns a 3d+ array, with a specified layer sorted.
Parameters:
- 3d+ array
- Index
- Item
- Item
Returns:
3d+ array
Coordinates Class
The Coordinates
constructor is easy and useful.
const coordinates1d = new Arrays.Coordinates(0);
// Row = 0
const coordinates2d = new Arrays.Coordinates(0, 0);
// Row = 0, Column = 0
const coordinates3d = new Arrays.Coordinates(0, 0, 0);
// Row = 0, Column = 0, Layer = 0
You can use it in a variety of ways:
FindItemInArray
const array = [
["apple", "orange", "kiwi"],
["mango", "banana", "pear"]
];
const coordinates = new Arrays.Coordinates(1, 1);
console.log(coordinates.findItemInArray(array));
// Returns: "banana"
The findItemInArray
method finds an item in an array based on the coordinates. If it can't find the item, it'll return undefined.
Parameters:
- 1d+ array
Returns:
Item
SetItemInArray
const array = [
["apple", "orange", "kiwi"],
["mango", "banana", "pear"]
];
const coordinates = new Arrays.Coordinates(1, 1);
console.log(coordinates.setItemInArray(array, "plum"));
/* Returns:
[
["apple", "orange", "kiwi"],
["plum", "banana", "pear"]
]
The setItemInArray
method sets an item in an array based on the coordinates.
Parameters:
- 1d+ array
- Item
Returns:
1d+ array
IncreaseLocal
const coordinates = new Arrays.Coordinates(0);
console.log(coordinates.increaseLocal(1));
// Returns: Coordinates { row: 1 }
const coordinates = new Arrays.Coordinates(1, 1);
console.log(coordinates.increaseLocal(1));
// Returns: Coordinates { row: 1, column: 2 }
const coordinates = new Arrays.Coordinates(1, 0, 2);
console.log(coordinates.increaseLocal(1));
// Returns: Coordinates { row: 1, column: 0, layer: 3 }
The increaseLocal
method increases the most local array of the deepest item by an amount.
Parameters:
- Number
Returns:
Coordinates
IncreaseRow
const coordinates = new Arrays.Coordinates(0, 1);
console.log(coordinates.increaseRow(1));
// Returns: Coordinates { row: 1, column: 1 }
The increaseRow
method increases the row of the Coordinates by an amount.
Parameters:
- Number
Returns:
Coordinates
IncreaseColumn
const coordinates = new Arrays.Coordinates(1, 1);
console.log(coordinates.increaseColumn(2));
// Returns: Coordinates { row: 1, column: 3 }
The increaseColumn
method increases the column of the Coordinates by an amount. If the Coordinates doesn't have a column, it'll automatically be set to the amount.
Parameters:
- Number
Returns:
Coordinates
IncreaseLayer
const coordinates = new Arrays.Coordinates(0, 1, 1);
console.log(coordinates.increaseLayer(1));
// Returns: Coordinates { row: 0, column: 1, layer: 2 }
The increaseLayer
method increases the layer of the Coordinates by an amount. If the Coordinates doesn't have a layer, it'll automatically be set to the amount. If the Coordinates doesn't have a column or layer, the column will be set to 0, and the layer will be set to the amount.
Parameters:
- Number
Returns:
Coordinates
IncreaseAll
const coordinates = new Arrays.Coordinates(1, 0, 1);
console.log(coordinates.increaseAll(1));
// Returns: Coordinates { row: 2, column: 1, layer: 2 }
The increseAll
method increases the row, column, and layer by an amount. If the Coordinates doesn't have a column or a layer, they'll automatically be set to the amount.
Parameters:
- Number
Returns:
Coordinates
IncreaseBy
const coordinates1 = new Arrays.Coordinates(1, 2, 3);
const coordinates2 = [3, 2, 1];
console.log(coordinates1.increaseBy(coordinates2));
// Returns: Coordinates { row: 4, column: 4, layer: 4 }
const coordinates1 = new Arrays.Coordinates(1, 2, 3);
const coordinates2 = {row: 3, column: 2, layer: 1};
console.log(coordinates1.increaseBy(coordinates2));
// Returns: Coordinates { row: 4, column: 4, layer: 4 }
const coordinates1 = new Arrays.Coordinates(1, 2, 3);
const coordinates2 = new Arrays.Coordinates(3, 2, 1);
console.log(coordinates1.increaseBy(coordinates2));
// Returns: Coordinates { row: 4, column: 4, layer: 4 }
The increaseBy
method increases the row, column, and layer by another coordinates' row, column, and layer. If the Coordinates doesn't have a column or layer, they'll automatically be set to the other coordinates'.
Parameters:
Returns:
Coordinates
ShiftLeft
const coordinates = new Arrays.Coordinates(0, 1, 2);
console.log(coordinates.shiftLeft());
// Returns: Coordinates { row: 1, column: 2, layer: 0 }
The shiftLeft
method shifts each value 1 place to the left. The row is the value of the column, the column is the value of the layer, and the layer is the value of the row.
Returns:
Coordinates
ShiftRight
const coordinates = new Arrays.Coordinates(0, 1, 2);
console.log(coordinates.shiftRight());
// Returns: Coordinates { row: 2, column: 0, layer: 1 }
The shiftRight
method shifts each value 1 place to the right. The row is the value of the layer, the column is the value of the row, and the layer is the value of the column.
Returns:
Coordinates
LoseColumn
const coordinates = new Arrays.Coordinates(2, 1);
console.log(coordinates.loseColumn());
// Returns: Coordinates { row: 2 }
The loseColumn
method deletes the column from the Coordinates. If there's a layer in the Coordinates, that is deleted as well.
Returns:
Coordinates
LoseLayer
const coordinates = new Arrays.Coordinates(1, 0, 2);
console.log(coordinates.loseLayer());
// Returns: Coordinates { row: 2, column: 0 }
The loseLayer
method deletes the layer from the Coordinates.
Returns:
Coordinates
ToArray
const coordinates = new Arrays.Coordinates(1, 2, 3);
console.log(coordinates.toArray());
// Returns: [1, 2, 3]
The toArray
method converts the Coordinates to an array.
Returns:
Array
ToObject
const coordinates = new Arrays.Coordinates(1, 2, 3);
console.log(coordinates.toObject());
// Returns: { row: 1, column: 2, layer: 3 }
The toObject
method converts the Coordinates to an object.
Returns:
Object
ItemConditional Class
The ItemConditional
constructor is used for searchQuery and similar methods.
const condition = new Arrays.ItemConditional({
equalto: "apple"
});
Here are all the different conditions you can check:
{
equalto: "apple" // checks if the item is equal to this (==)
notequalto: "orange" // checks if the item is not equal to this (!=)
typeequalto: "kiwi" // checks if the item is type equal to this (===)
nottypeequalto: "mango" // checks if the item is not type equal to this (!==)
greaterthan: 68 // checks if the item is greater than this (>)
lessthan: 70 // checks if the item is less than this (<)
greaterthanorequalto: 5 // checks if the item is greater than or equal to this (>=)
lessthanorequalto: 10 // checks if the item is less than or equal to this (<=)
includes: "e" // checks if the item includes this (.includes)
notincludes: "o" // checks if the item doesn't include this (!.includes)
arrayincludes: ["banana", "avocado"] // checks if this array includes the item ([].includes)
arraynotincludes: ["pear", "grape"] // checks if this array doesn't include the item (![].includes)
}
CheckConditions
const condition = new Arrays.ItemConditional({
greaterthan: 68,
lessthan: 70
});
const array = [67, 68, 69, 70, 71, 72];
console.log(condition.checkConditions(array[0]));
// Returns: false
console.log(condition.checkConditions(array[2]));
// Returns: true
The checkConditions
method checks an item against the conditions. The item has to pass all the conditions to return true.
Parameters:
- Item
Returns:
boolean
AddCondition
const condition = new Arrays.ItemConditional({
greaterthan: 68,
lessthan: 70
});
condition.addCondition({
includes: "seed"
});
console.log(condition);
/* Returns: ItemConditional { conditions: {
greaterthan: 68,
lessthan: 70,
includes: "seed"
}}
The addCondition
method adds a condition to the ItemConditional. If the condition of that type already exists, it'll replace it.
Parameters:
- Object
Returns:
void
RemoveCondition
const condition = new Arrays.ItemConditional({
greaterthan: 68,
lessthan: 70,
includes: "seed"
});
condition.removeCondition("includes");
console.log(condition);
/* Returns: ItemConditional { conditions: {
greaterthan: 68,
lessthan: 70
}}
The removeCondition
method removes a condition from the ItemConditional. If the condition of that type doesn't exist, it won't do anything.
Parameters:
- String
Returns:
void
Extras
Other stuff that you might need.
Array Coordinates
You can use an array in some methods to input coordinates.
[0] // Row: 0
[0, 1] // Row: 0, Column: 1
[0, 1, 2] // Row: 0, Column: 1, Layer: 2
You don't need to input the column or layer.
Object Coordinates
You can use an object in some methods to input coordinates.
{ row: 0 } // Row: 0
{ row: 0, column: 1 } // Row: 0, Column: 1
{ row: 0, column: 1, layer: 2 } // Row: 0, Column: 1, Layer: 2
You don't need to input the column or layer.