aquaductape

// exercise if two are values are strictly equal
// without using Equality operators: ==, ===, !=, !==
// or Object.is()
const isObject = (val) => {
  if (!val) return false;
  return (typeof val).match(/object|function/);
};

const strictEquals = (a, b) => {
  // a and b are both objects

aquaductape

Object.defineProperty(Array.prototype, 'windows', {
  // Based on Rust's windows iteration method
  // Unlike regular slice, these slices overlap, or rather panes through the array, hence the name windows
  // If the size is greater than the slice it will not include it.
  value: function(size) {
    const length = this.length;
    const arr = [];

    for (let i = 0; i < length - size + 1; i++) {
      const slice = [];

aquaductape

# Luke's config for the Zoomer Shell

# Enable colors and change prompt:
autoload -U colors && colors
PS1="%B%{$fg[red]%}[%{$fg[yellow]%}%n%{$fg[green]%}@%{$fg[blue]%}%M %{$fg[magenta]%}%~%{$fg[red]%}]%{$reset_color%}$%b "

# History in cache directory:
HISTSIZE=10000
SAVEHIST=10000
HISTFILE=~/.cache/zsh/history

aquaductape

Understanding THIS

my guide is just a reinforcement by different sayings, bunch of quick tips and links on how to eyeball the determination what 'this'.

Determining THIS in Regular Function Expressions

function () { console.log(this) }

1.

  if called in the form of obj.func()
                       "this" === obj
                                 else

aquaductape

const mergeSortBottomUp = arr => {
  const length = arr.length;
  let step = 1;
  while (step < length) {
    let left = 0;
    while (left + step < length) {
      mergeBottomUp(arr, left, step);
      left += step * 2;
    }
    step *= 2;

aquaductape

// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
Object.defineProperty(Array.prototype, 'mySort', {
  // webkit and chrome uses quicksort
  // mozilla uses merge sort
  // For my sort algorithm, it uses merge sort
  // But I also chose chrome's interpretation of callback return boolean value, just because I mainly use chrome
  value: function(callback) {

aquaductape

// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
Object.defineProperty(Array.prototype, 'myReduce', {
  value: function(callback, initialValue) {
    if (typeof callback !== 'function') {
      throw new TypeError(`${callback} is not a function`);
    }

    // throw error if array is empty, even a sparse array
    // use filter(or use myFilter) method to remove empty values

aquaductape

// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
Object.defineProperty(Array.prototype, 'myEvery', {
  // if callback is arrow function then context will be set to outer scope regardless of providing context argument
  value: function(callback, context) {
    if (typeof callback !== 'function') {
      throw new TypeError(`${callback} is not a function`);
    }

    const length = this.length;

aquaductape

// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
Object.defineProperty(Array.prototype, 'mySome', {
  // if callback is arrow function then context will be set to outer scope regardless of providing context argument
  value: function(callback, context) {
    if (typeof callback !== 'function') {
      throw new TypeError(`${callback} is not a function`);
    }

    const length = this.length;

aquaductape

// Array prototype method, however this is not safe, since it is added to the global scope
// definedProperty makes method non-enumerable as well as adding new property to in this case, to Array prototype
Object.defineProperty(Array.prototype, 'myFind', {
  // if callback is arrow function then context will be set to outer scope regardless of providing context argument
  value: function(callback, context) {
    if (typeof callback !== 'function') {
      throw new TypeError(`${callback} is not a function`);
    }

    const length = this.length;