The document describes common JavaScript data structures and methods for manipulating them including arrays, objects, sets, maps and strings. Arrays can be iterated over and manipulated using built-in methods. Objects allow storing keyed collections of data and accessing or modifying properties. Sets and maps provide collection types.
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0 ratings0% found this document useful (0 votes)
10 views
Js How To Create All Things
The document describes common JavaScript data structures and methods for manipulating them including arrays, objects, sets, maps and strings. Arrays can be iterated over and manipulated using built-in methods. Objects allow storing keyed collections of data and accessing or modifying properties. Sets and maps provide collection types.
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4
# [ JavaScript Data Structure ] ( CheatSheet )
Arrays
● Create an array: let myArray = [1, 2, 3, 4, 5];
● Add an element to the end: myArray.push(6); ● Remove the last element: let lastElement = myArray.pop(); ● Add an element to the beginning: myArray.unshift(0); ● Remove the first element: let firstElement = myArray.shift(); ● Find the index of an element: let index = myArray.indexOf(3); ● Remove element by index: myArray.splice(index, 1); ● Copy an array: let arrayCopy = myArray.slice(); ● Merge arrays: let mergedArray = myArray.concat(anotherArray); ● Iterate over elements: myArray.forEach((element) => console.log(element)); ● Map elements to a new array: let squaredArray = myArray.map(x => x * x); ● Filter elements based on condition: let filteredArray = myArray.filter(x => x > 3); ● Check if any element meets a condition: let anyGreaterThanFour = myArray.some(x => x > 4); ● Check if all elements meet a condition: let allGreaterThanZero = myArray.every(x => x > 0); ● Find an element that meets a condition: let found = myArray.find(x => x === 3); ● Sort an array: myArray.sort((a, b) => a - b); ● Reduce to a single value: let sum = myArray.reduce((acc, curr) => acc + curr, 0); ● Destructuring assignment: let [first, second] = myArray; ● Spread operator for array copying and concatenation: let copiedArray = [...myArray]; let combinedArray = [...array1, ...array2]; ● Find the index of an object in an array of objects: let index = myArray.findIndex(obj => obj.id === id); ● Updating an item within an array immutably: myArray = myArray.map(item => item.id === id ? {...item, prop: newValue} : item); ● Array flattening: let flatArray = myArray.flat(); ● Array to object conversion: let arrayToObject = {...myArray}; ● Fill an array: myArray.fill(value, start, end); ● Convert iterable to array: let iterableToArray = Array.from(iterable); ● Array slicing without modifying the original array: let newArray = myArray.slice(startIndex, endIndex);
By: Waleed Mousa
Objects
● Create an object: let myObject = { key: 'value', id: 1 };
● Access a property: let value = myObject.key; ● Set a property: myObject.newKey = 'newValue'; ● Delete a property: delete myObject.key; ● Check if a property exists: let exists = 'key' in myObject; ● Iterate over keys: Object.keys(myObject).forEach(key => console.log(key)); ● Iterate over values: Object.values(myObject).forEach(value => console.log(value)); ● Iterate over entries (key-value pairs): Object.entries(myObject).forEach(([key, value]) => console.log(key, value)); ● Merge objects: let mergedObject = Object.assign({}, object1, object2); ● Clone an object: let clonedObject = { ...myObject }; ● Get property names: let keys = Object.keys(myObject); ● Get property values: let values = Object.values(myObject); ● Freeze an object (making it immutable): Object.freeze(myObject); ● Seal an object (preventing new properties and marking all existing properties as non-configurable): Object.seal(myObject); ● Destructure properties: let { key, id } = myObject; ● Object destructuring: let {key1, key2} = myObject; ● Spread operator for object cloning and merging: let clonedObject = {...myObject}; let mergedObject = {...object1, ...object2}; ● Computed property names: let myObject = {[keyName]: value}; ● Object.entries() and Object.fromEntries() for transformation: let entries = Object.entries(myObject); let newObj = Object.fromEntries(entries); ● Define property with specific descriptors: Object.defineProperty(myObject, 'newKey', {value: 'newValue', writable: true, enumerable: true, configurable: true}); ● Prevent object modifications: Object.preventExtensions(myObject); ● Check if the object is extensible: let isExtensible = Object.isExtensible(myObject); ● Get own property descriptors: let descriptors = Object.getOwnPropertyDescriptors(myObject);
Sets
● Create a set: let mySet = new Set([1, 2, 3, 4, 5]);
● Add an element: mySet.add(6);
By: Waleed Mousa
● Delete an element: mySet.delete(1); ● Check if a set has an element: let hasValue = mySet.has(3); ● Determine size of a set: let size = mySet.size; ● Clear a set: mySet.clear(); ● Iterate over elements: mySet.forEach(value => console.log(value)); ● Convert a set to an array: let arrayFromSet = [...mySet]; ● Create a set from an array (to remove duplicates): let uniqueSet = new Set(myArray); ● Intersection of two sets: let intersection = new Set([...set1].filter(x => set2.has(x))); ● Union of two sets: let union = new Set([...set1, ...set2]); ● Difference between two sets: let difference = new Set([...set1].filter(x => !set2.has(x))); ● Conversion between Set and Array: let mySetArray = Array.from(mySet); let newSet = new Set(myArray); ● Using Set to find unique elements in an array: let unique = [...new Set(array)];
Maps
● Create a map: let myMap = new Map([['key1', 'value1'], ['key2',
'value2']]); ● Set a key-value pair: myMap.set('key3', 'value3'); ● Get a value by key: let value = myMap.get('key1'); ● Check if a map has a key: let hasKey = myMap.has('key2'); ● Delete a key-value pair: myMap.delete('key3'); ● Iterate over entries: myMap.forEach((value, key) => console.log(key, value)); ● Get keys: let keys = myMap.keys(); ● Get values: let values = myMap.values(); ● Get size: let size = myMap.size; ● Clear a map: myMap.clear(); ● Convert a map to an object: let obj = Object.fromEntries(myMap); ● Create a map from an object: let mapFromObj = new Map(Object.entries(obj)); ● Entries iterator: for (let [key, value] of myMap) { console.log(key, value); } ● Iterating over Map with for...of: for (let [key, value] of myMap) { console.log(key, value); }
By: Waleed Mousa
Strings
● Create a string: let myString = 'Hello, World!';
● Concatenate strings: let greeting = 'Hello, ' + 'World!'; ● Template literals: let templateGreeting = `Hello, ${name}!`; ● Access character at a position: let char = myString.charAt(0); ● Substring extraction: let substr = myString.substring(0, 5); ● String slicing: let sliced = myString.slice(-6); ● Split a string into an array: let words = myString.split(' '); ● Replace part of a string: let replaced = myString.replace('World', 'JavaScript'); ● Convert to upper/lower case: let upper = myString.toUpperCase(); let lower = myString.toLowerCase(); ● Trim whitespace: let trimmed = myString.trim(); ● Search for a substring: let position = myString.indexOf('World'); ● Regular expression match: let matches = myString.match(/Hello/); ● Check if string starts/ends with a substring: let starts = myString.startsWith('Hello'); let ends = myString.endsWith('!'); ● String length: let length = myString.length; ● Repeat a string: let repeated = 'ha'.repeat(5); ● Using String.prototype.includes() for substring search: let contains = myString.includes('searchString'); ● String.prototype.startsWith() and String.prototype.endsWith(): let starts = myString.startsWith('start'); let ends = myString.endsWith('end'); ● Dynamic string generation with String.prototype.repeat(): let repeatedString = 'abc'.repeat(3); // 'abcabcabc'