const arrayToObject = (array, keyField) =>
   array.reduce((obj, item) => {
     return {...obj, [item[keyField]]: item}
   }, {});

const peopleArray = [{id: 1, name: "John"}, {id:2, name: "Robert"}]

const peopleObject = arrayToObject(peopleArray, "id");

console.log(peopleObject); // {"1":{"id":1,"name":"John"},"2":{"id":2,"name":"Robert"}}

Javascript:

function myFunction() {
  /* Get the text field */
  var copyText = document.getElementById("myInput");

  /* Select the text field */
  copyText.select();
  copyText.setSelectionRange(0, 99999); /*For mobile devices*/

  /* Copy the text inside the text field */
  document.execCommand("copy");

  /* Alert the copied text */
  alert("Copied the text: " + copyText.value);
}

HTML:

<!-- The text field -->
<input type="text" value="Hello World" id="myInput">

<!-- The button used to copy the text -->
<button onclick="myFunction()">Copy text</button>

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
};

"my string should be replace here and here".replaceAll("here","replaced match") // "my string should be replace replaced match and replaced match"

function shuffle(array) {
  var currentIndex = array.length, temporaryValue, randomIndex;

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    // And swap it with the current element.
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}

// How to use the function
var arr = [2, 11, 37, 42];
shuffle(arr);
console.log(arr);

function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

For custom-delimited date formats, you have to pull out the date (or time) components from a DateTimeFormat object (which is part of the ECMAScript Internationalization API), and then manually create a string with the delimiters you want.

To do this, you can use DateTimeFormat#formatToParts:

const d = new Date('2010-08-05')
const dtf = new Intl.DateTimeFormat('en', { year: 'numeric', month: 'short', day: '2-digit' }) 
const [{ value: month },,{ value: day },,{ value: year }] = dtf.formatToParts(d) 

console.log(`${day}-${month}-${year}`)

You can also pull out the parts of a DateTimeFormat one-by-one using DateTimeFormat#format, but note that when using this method, as of March 2020, there is a bug in the ECMAScript implementation when it comes to leading zeros on minutes and seconds (this bug is circumvented by the approach above).

const d = new Date('2010-08-05')
const year = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(d)
const month = new Intl.DateTimeFormat('en', { month: 'short' }).format(d)
const day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(d)

console.log(`${day}-${month}-${year}`)

When working with dates and times, it is usually worth using a library (eg. moment.js) because of the many hidden complexities of the field.

Given this object:

const data = {
    code: 42,
    items: [{
        id: 1,
        name: 'foo'
    }, {
        id: 2,
        name: 'bar'
    }]
};

Let's assume we want to access the name of the second item.

Here is how we can do it step-by-step:

As we can see data is an object, hence we can access its properties using dot notation. The items property is accessed as follows:

data.items

The value is an array, to access its second element, we have to use bracket notation:

data.items[1]

This value is an object and we use dot notation again to access the name property. So we eventually get:

const item_name = data.items[1].name;

Alternatively, we could have used bracket notation for any of the properties, especially if the name contained characters that would have made it invalid for dot notation usage:

const item_name = data['items'][1]['name'];

There are two ways to access properties of an object:

1. Dot notation

const person1 = {
  firstname: 'John',
  lastname: 'Doe'
};
console.log(person1.firstname) //John 

2. Bracket notation

The value between the brackets can be any expression. Therefore, if the property name is stored in a variable, you have to use bracket notation:

const person1 = {
  firstname: 'John',
  lastname: 'Doe'
};
console.log(person1['firstname']) //John 

You can use URLSearchParams.

const urlParams = new URLSearchParams(window.location.search);
const myParam = urlParams.get('myParam');

Reading in sequence

If you want to read the files in sequence, you cannot use forEach indeed. Just use a modern for … of loop instead, in which await will work as expected:

async function printFiles () {
  const files = await getFilePaths();

  for (const file of files) {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }
}

Reading in parallel

If you want to read the files in parallel, you cannot use forEach. Each of the async callback function calls does return a promise, but you're throwing them away instead of awaiting them. Just use map instead, and you can await the array of promises that you'll get with Promise.all:

async function printFiles () {
  const files = await getFilePaths();

  await Promise.all(files.map(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  }));
}

Promise returning functions should never throw, they should return rejections instead. Throwing from a promise returning function will force you to use both a } catch { and a .catch. People using promisified APIs do not expect promises to throw.

// Before promises
function divisionAPI (number, divider, successCallback, errorCallback) {
    if (divider == 0){
        return errorCallback( new Error("Division by zero") )
    }    
        
    successCallback( number / divider )
}


// After promises
function divisionAPI (number, divider) {

    return new Promise(function (fulfilled, rejected) {
        if (divider == 0) {
            return rejected( new Error("Division by zero") )
        }
        fulfilled( number / divider )
     })
}

this ("the context") is a special keyword inside each function and its value only depends on how the function was called, not how/when/where it was defined. It is not affected by lexical scopes like other variables (except for arrow functions, see below). Here are some possibilities:

// 1. Using bind method
function MyConstructor(data, transport) {
    this.data = data;
    transport.on('data', ( function () {
        alert(this.data);
    }).bind(this) );
}
var transport = {
    on: function(event, callback) {
        setTimeout(callback, 1000);
    }
};
var obj = new MyConstructor('foo', transport);


// 2. Storing reference to context/this inside another variable
function MyConstructor(data, transport) {
  var self = this;
  this.data = data;
  transport.on('data', function() {
    alert(self.data);
  });
}


// 3.Arrow function
function MyConstructor(data, transport) {
  this.data = data;
  transport.on('data', () => {
    alert(this.data);
  });
}

While certain asynchronous operations provide synchronous counterparts (so does "Ajax"), it's generally discouraged to use them, especially in a browser context.

There are three different solutions that are all building on top of each other:

1. Promises with async/await (ES2017+, available in older browsers if you use a transpiler or regenerator)
2. Promises with then() (ES2015+, available in older browsers if you use one of the many promise libraries)
3. Callbacks (aka Callback Hell, not recommended )

function getGithubRepository() {
  return new Promise(function (resolve, reject) {
    $.ajax({
      method: "get",
      url: "https://api.github.com/repos/ricardodantas/heroku-scripts"
    })
      .done(function (response) {
        resolve(response);
      })
      .fail(function (error) {
        reject(error);
      });
  });
}

// Promise with then()
getGithubRepository()
  .then(function (result) {
    console.log("Then: Repo name: ", result.name);
  })
  .catch(function (error) {
    console.error(error.statusText);
  });

// Promises with async/await
(async () => {
  try {
    const result = await getGithubRepository();
    console.log("Async/Await Repo name: ", result.name);
  } catch (err) {
    console.log(err);
  }
})();