Security News
Research
Data Theft Repackaged: A Case Study in Malicious Wrapper Packages on npm
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
dbly-linked-list
Advanced tools
Javascript implementation of a doubly linked-list data structure
This is a javascript implementation of a doubly linked list data structure.
In simple terms, a doubly linked list consists of one or more 'nodes'. Each node has a data field (which can contain any data--a primitive value or complex object) and a pointer to the next 'node' and the previous 'node'. This additional pointer to the previous node is what distinguishes a doubly linked list from a singly linked list--a singly linked list only contains a pointer, or reference, to the next node. The major advantage to having pointers to both the next and previous node is that the list can be traversed in both directions, as well as making operations that operate on the 'middle' of the list a bit more efficient since each node has a reference the one before it and the one after it. The idea of having a links to the previous and next nodes is where this data structure got its descriptive name.
This implementation provides basic functionality of adding nodes to the front or back of the list, as well as the ability to insert a node at a given position in the list. It also provides the ability to remove nodes at the front or back of the list, or from any given position.
The find, or search, functionality provides the ability to find the first node containing specified data. It also provides the ability to find a node given a specific position, or index, in the list.
For specific examples and documentation, see the below sections
The main purpose of this project is revisit the basics, and focus on the development process.
I wholehearedly acknowledge that the basic data structure space is populated with well-written code and efficient implementations, and one could easily grab one of those libraries and integrate it in their project. However, the main difference between those libraries/implementations and this one is that this is the best implementation I have ever written. My hope is that someone else will find this useful, but understand, this code is not the goal; this will simply be a useful bi-product of the journey. The underlying motivation is to understand and, more importantly, learn from the process to get to the desired end-state—for me it is all about the joy of the journey.
Although this implementation is designed to be used with Node.js, it could be used in other contexts with minor modifications. This implementation does not have any external dependencies that would preclude it from being used in the browser--just include it with a <script>
tag and it should be good to go. Disclaimer: I have not tested this implementation in any other context/environment; only tested with node.js
Install with npm :
npm install dbly-linked-list --save
Install with yarn :
yarn add dbly-linked-list
Basic usage example below. Note: it does not cover all the available methods, rather just highlights the main functionality to get up and running with this data structure. For a description of all the methods, see the API section.
var LinkedList = require("dbly-linked-list");
var list = new LinkedList();
list.isEmpty();
// --> true
list.insert("data item 1");
list.insert("data item 2");
list.insert("data item 3");
list.insert("data item 4");
// list contains:
// 'data item 1', ... ,'data item 4'
list.isEmpty();
// --> false
list.getSize();
// --> 4
list.insertFirst("data item 0");
// list contains:
// 'data item 0', ... ,'data item 4'
list.getHeadNode().getData();
// --> 'data item 0'
list.remove();
// --> removes 'data item 4'
list.removeFirst();
// --> removes 'data item 0'
list.getHeadNode().getData();
// --> 'data item 1'
list.clear();
list.isEmpty();
// --> true
Available methods for a doubly-linked-list instance:
Returns the first node in the list
Returns the last node in the list
Determines if the list is empty or not. Returns true if is empty, false otherwise.
Returns the size of the list, or number of nodes
Clears the list of all nodes/data
Inserts a node (with the provided data
) to the end of the list
Inserts a node (with the provided data
) to the front of the list
Inserts a node (with the provided data
) at the index
indicated.
Inserts a node (with the dataToInsert
) before the first node containing nodeData
Inserts a node (with the dataToInsert
) after the first node containing nodeData
Merge this list and DoublyLinkedList
into a new list. This method does not change the existing lists, but instead returns a new list.
Removes the tail node from the list
Removes the head node from the list
Removes the node at the index
provided
Removes the first node that contains the nodeData
provided
Returns the index of the first node containing the provided nodeData
. If a node cannot be found containing the provided data, -1 is returned.
Determines whether or not the list contains the provided nodeData
Returns the fist node containing the provided nodeData
. If a node cannot be found containing the provided data, -1 is returned.
Returns the node at the location provided by index
Utility function to iterate over the list and call the fn
provided on each node, or element, of the list. The optional reverse
parameter is a boolean used to specify the direction of iteration (true: tail -> head, false: head -> tail, default: false)
Returns an array of all the data contained in the list
Interrupts and breaks out of the loop induced by forEach()
, making partial iterations possible. An iteration cannot be resumed after having been interrupted.
Available methods for an individual node instance:
Returns the data of the the node
Returns whether or not the node has a pointer to the next node
Returns whether or not the node has a pointer to the previous node
Returns a string represenation of the node. If the data is an object, it returns the JSON.stringify version of the object. Otherwise, it simply returns the data
MIT © Jason Jones
FAQs
Javascript implementation of a doubly linked-list data structure
We found that dbly-linked-list demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.
Security News
The Ultralytics' PyPI Package was compromised four times in one weekend through GitHub Actions cache poisoning and failure to rotate previously compromised API tokens.