The user tim-montague posted a great overview on the different deep copy techniques on stackoverflow:
In my case I had an array of objects which I wanted to copy without reference, therefore I used the option in the middle.
const copy = JSON.parse(JSON.stringify(myArray))
# Another way using ES6 Syntax
const copy = myArray.map(object => ({ ...object }))
Recently I hat to create an array of objects from another array of objects to change some property names and to enrich it with some values. To iterate over the array I used the map() function. But when trying to return the new object using the brackets {}, the map function instead expects me trying to write a function… Therefore you need to wrap the return object in ()
const aPersons = [{
id: 1,
name: 'max'
}, {
id: 2,
name: 'peter'
}]
const aResult = aPersons.map(person => ({ value: person.id, text: person.name, someboolean: true }))
console.log(aResult)
https://stackoverflow.com/questions/8498592/extract-hostname-name-from-string
const getHostname = (url) => {
// use URL constructor and return hostname
return new URL(url).hostname;
}
let hostname = getHostname("https://google.com");
console.log(hostname); //google.com
These are my notes while doing the course JavaScript Algorithms and Data Structures on https://www.freecodecamp.org. I highly recommend it if you prefer to try things directly rather than watching videos.
let and const
Variables with the var keyword can be overwritten without an error. With E6 the keyword let was introduced to solve this potential issue.
var camper = 'James';
var camper = 'David'; //no error
let camper = 'James';
let camper = 'David'; // throws an error
"use strict";
x = 3.14; // throws an error because x is not declared
Note: The "use strict" enables Strict Mode, which catches common coding mistakes and “unsafe” actions.
const
Same features as let has + read-only.
const FAV_PET = "Cats";
FAV_PET = "Dogs"; // returns error
Note: Use uppercase variable identifiers for immutable values and lowercase or camelCase for mutable values (objects and arrays).
Objects (including arrays and functions) assigned to a variable using const are still mutable!
Using the const declaration only prevents reassignment of the variable identifier. You can not use the variable identifier to point to a different array, but the elements are mutable.
const s = [10, 11, 12];
s = [1, 2, 3]; // throws error, trying to assign a const
s[2] = 45; // works just as it would with an array declared with var or let
s.pop(45); //also works fine
Prevent Object Mutation with function Object.freeze()
Arrow Functions
If you don’t reuse a function you don’t need a name for it, especially when passing a function as an argument to another function.
var magic = function() {
return new Date();
};
/* arrow function syntax */
const magic = () => {
return new Date();
};
/* If there is no function body and only a return, omit the keyword return as well as the backets */
const magic = () => new Date();
Arrow Functions with Parameters
const doubler = (item) => item * 2;
doubler(6); // returns 12
/* If you have a single parameter, omit the parentheses */
const doubler = item => item * 2;
const multiplier = (item, multi) => item * multi;
multiplier(6, 2); // returns 12
Default Parameters
The default parameter is used when the argument is not specified (is undefined).
const hello = (name = "World") => "Hello " + name;
console.log(hello("Mars")); // Hello Mars
console.log(hello()); // Hello World
Rest Parameter
With the rest parameter, you can create functions that take a variable number of arguments. These arguments are stored in an array.
function howMany(...arguments) {
return "You passed " + arguments.length + " arguments.";
}
console.log(howMany(0, 1, 2)); // You passed 3 arguments.
Spread Operator
The spread operator allows us to expand arrays and other expressions in places where multiple parameters or elements are expected. I.e. Math.max() expects comma-separated arguments, but not an array. The spread operator unpacks all contents of an array into a comma-separated list. To pick specific elements, better use array destructuring.
const array = [2, 99, 7, 4];
/* workaround in ES5 */
var max = Math.max.apply(null, array); // returns 99
/* ES6 */
const max = Math.max(...array); // returns 99
Destructuring Assignment
Destructuring assignment is special syntax for neatly assigning values taken directly from an object,
const person = { name: 'Max', age: 30 };
/* ES5 */
const name = person.name; // name = 'Max'
const age = person.age; // age = 30
/* ES6 */
const { name, age } = person; // name = 'Max', age = 30
// It even allows you to assign a new variable name
const { name: personName, age: personAge } = user; // personName = 'Max', personAge = 30
or from an array.
const [a, b,,, c] = [1, 2, 3, 4, 5, 6, 7];
console.log(a, b, c); // 1, 2, 5
// or collect the rest of the elements into a separate array
const [a, b, ...array] = [1, 2, 3, 4, 5, 7];
console.log(a, b); // 1, 2
console.log(array); // [3, 4, 5, 7]
Destructuring Assignment to Pass an Object as a Function’s Parameters.
const stats = {
max: 56.78,
standard_deviation: 4.34,
median: 34.54,
mode: 23.87,
min: -0.75,
average: 35.85
};
const half = ({max, min}) => (max + min) / 2.0;
Template Literals
Template literal is a special type of string that makes creating complex strings easier.
const person = {
name: "Zodiac Hasbro",
age: 56
};
const greeting = `Hello, my name is ${person.name}!
I am ${person.age} years old.`;
console.log(greeting); // prints
// Hello, my name is Zodiac Hasbro!
// I am 56 years old.
Concise Object Literal Declarations
Short way to define object properties.
const createPerson = (name, age, gender) => {
return {
name: name,
age: age,
gender: gender
};
};
/* Eliminates the redundancy of having to write x: x */
const createPerson = (name, age, gender) => ({
name,
age,
gender
});
Concise Declarative Functions
Remove the function keyword and colon when defining functions in objects.
/* ES5 function declaration */
const person = {
name: "Max",
sayHello: function() {
return `Hello! My name is ${this.name}.`;
}
};
/* ES6 */
const person = {
name: "Max",
sayHello() {
return `Hello! My name is ${this.name}.`;
}
};
person.sayHello();
class Syntax to Define a Constructor Function
New syntax to create objects, using the class keyword. The class syntax replaces the constructor function creation. The new keyword is used to instantiate an object.
/* ES5 */
var SpaceShuttle = function(targetPlanet){
this.targetPlanet = targetPlanet;
}
var zeus = new SpaceShuttle('Mars');
/* ES6 */
class SpaceShuttle {
constructor(targetPlanet) {
this.targetPlanet = targetPlanet;
}
}
const zeus = new SpaceShuttle('Mars');
Note: The class syntax should not be confused with a full class-based implementation of an object-oriented paradigm.
getters and setters to Control Access to an Object
class Thermostat {
constructor(temperatureFahrenheit) {
this._temperatureCelsius = 5/9 * (temperatureFahrenheit - 32);
}
//getter
get temperature() {
return this._temperatureCelsius;
}
//setter
set temperature(updateTemperatureCelsius) {
this._temperatureCelsius = updateTemperatureCelsius;
}
}
const thermos = new Thermostat(76); // Setting in Fahrenheit scale
let temp = thermos.temperature; // 24.44 in Celsius
thermos.temperature = 26; // use setter
temp = thermos.temperature; // 26 in Celsius
Note: It is convention to precede the name of a private variable with an underscore _
Module Script
A way to easily share code among JavaScript files. Export parts of a file and import the parts you need, where you need them.
You need to create a script in your HTML document with a type of module.
<script type="module" src="string_functions.js"></script>
const uppercaseString = (string) => string.toUpperCase();
const lowercaseString = (string) => string.toLowerCase();
export {uppercaseString, lowercaseString};
/* import specific functions */
import { uppercaseString, lowercaseString } from './string_functions.js';
uppercaseString("hello");
lowercaseString("WORLD!");
/* import all */
import * as stringFunctions from './string_functions.js';
stringFunctions.uppercaseString("hello");
stringFunctions.lowercaseString("WORLD!");
Promise
Use it to make a promise to do something, usually asynchronously. Promise is a constructor function, so you need to use the new keyword to create one. It takes a function, as its argument, with two parameters – resolve and reject.
When you make a server request it takes some amount of time, and after it completes you usually want to do something with the response from the server. This can be achieved by using the then method. The then method is executed immediately after your promise is fulfilled with resolve.
const makeServerRequest = new Promise((resolve, reject) => {
// responseFromServer represents a response from a server
let responseFromServer;
if(responseFromServer) {
resolve("We got the data");
} else {
reject("Data not received");
}
});
makeServerRequest.then(result => {
console.log(result);
})
makeServerRequest.catch(error => {
console.log(error);
});
These are my notes while doing the course JavaScript Algorithms and Data Structures on https://www.freecodecamp.org. I highly recommend it if you prefer to try things directly rather than watching videos.
Note: In JavaScript arrays are technically a type of object. Therefore arrays are also capable of storing complex objects.
Array functions to manipulate arrays:
/* Modify Array Data with Indexes */
var myArray = [50,40,30];
myArray[0] = 15; // equals [15,40,30]
/* Access Multi-Dimensional Arrays with Indexes */
var myArray = [
[1,2,3],
[4,5,6],
[7,8,9],
[[10,11,12], 13, 14]
];
myArray[3]; // equals [[10,11,12], 13, 14]
myArray[3][0]; // equals [10,11,12]
myArray[3][0][1]; // equals 11
/* Manipulate Arrays with push() -> adding to the end */
var myArray = [1,2,3];
myArray.push(4); // myArray is now [1,2,3,4]
/* Manipulate Arrays with pop() -> removing last element */
var threeArr = [1, 4, 6];
var oneDown = threeArr.pop();
console.log(oneDown); // Returns 6
console.log(threeArr); // Returns [1, 4]
/* Manipulate Arrays with shift() -> removing first element */
var myArray = ["Stimpson", "J", ["cat"]];
var removedFromOurArray = myArray.shift();
console.log(removedFromOurArray); // Returns "Stimpson"
console.log(myArray); // Returns ["J", ["cat"]]
/* Manipulate Arrays with unshift() -> adding to the beginning */
var myArray = ["Stimpson", "J", "cat"];
myArray.shift(); // myArray now equals ["J", "cat"]
myArray.unshift("Happy"); // myArray now equals ["Happy", "J", "cat"]
/* Manipulate Arrays with concat() -> combine arrays into a new one without mutating the original arrays. */
var firstArray = [1, 2, 3];
var secondArray = [4, 5, 6];
var thirdArray = firstArray.concat(secondArray); // thirdArray now equals [ 1, 2, 3, 4, 5, 6 ]
/* Also useable to clone an array (will do a copy by reference!) */
var fourthArray = [].concat(firstArray); // FourthArray now equals [1, 2, 3]
/* Remove & Add Items using splice() -> remove any number of consecutive elements from anywhere in an array. */
/* First parameter: index */
/* Second parameter: number of elements to delete */
let array = ['today', 'was', 'not', 'so', 'great'];
array.splice(2, 2); // array now equals ['today', 'was', 'great']
/* Third parameter: add elements to the array. Useful for quickly switching out an element, or a set of elements, for another. */
const numbers = [10, 11, 12, 12, 15];
numbers.splice(3, 1, 13, 14); // returns [ 10, 11, 12, 13, 14, 15 ]
/* Sort numbers in an array: array.sort(compareFunction) */
arr.sort((a, b) => a-b); // ascending
arr.sort((a, b) => b-a); // descending
Array functions that does not mutate the original array:
/* Copy Array Items Using slice() -> copies or extracts a given number of elements to a new array, leaving the array it is called upon untouched */
let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
let todaysWeather = weatherConditions.slice(1, 3); // todaysWeather equals ['snow', 'sleet'];
/* Copy an Array with the Spread Operator -> allows to easily copy all of an array's elements. Syntax: ... */
let thisArray = [true, true, undefined, false, null];
let thatArray = [...thisArray]; // thatArray equals [true, true, undefined, false, null];
/* Combine Arrays with the Spread Operator */
let fragment = ['to', 'code'];
let sentence = ['learning', ...fragment, 'is', 'fun']; // sentence equals ['learning', 'to', 'code', 'is', 'fun']
/* The reduce() method reduces the array to a single value. It executes a provided function for each value of the array (from left-to-right).*/
/* First parameter: The initialValue, or the previously returned value of the function */
/* Second parameter: The value of the current element */
/* 0 is set as initialValue */
const args = [2, 4, 2];
const arraySum = args.reduce((sum, currentNum) => sum + currentNum, 0); // returns 8
/* map() iterates over each item in an array and returns a new array containing the results of calling the callback function on each element */
const users = [
{ name: 'John', age: 34 },
{ name: 'Amy', age: 20 },
{ name: 'camperCat', age: 10 }
];
const names = users.map(user => user.name); // [ 'John', 'Amy', 'camperCat' ]
Checks:
/* indexOf() checks for the presence of an element -> takes element as parameter. Returns the position (index) or -1 if element does not exist */
let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
fruits.indexOf('dates'); // returns -1
fruits.indexOf('oranges'); // returns 2
fruits.indexOf('pears'); // returns 1, the first index at which the element exists
/* every() checks if every element passes a particular test */
function checkPositive(arr) {
return arr.every(num => num > 0);
}
checkPositive([1, 2, 3, -4, 5]); // false
/* some() checks if any element passes a particular test. */
function checkPositive(arr) {
return arr.some(num => num > 0);
}
checkPositive([1, 2, 3, -4, 5]); // true
And there are several other build in methods like forEach(), filter(), etc.
https://www.w3schools.com/jsref/jsref_obj_array.asp
Note: As already mentioned, arrays are objects, therefore array functions are methods on the array object prototype, i.e. Array.prototype.push()