DEV Community: Sam Clark

Using sed To Find and Replace

Sam Clark — Thu, 23 May 2019 18:55:41 +0000

Using sed to find and replace

When you need to find and replace a massive amount of modules(think of having to refactor a require to a privately scoped package at your company).

Luckily we're using a nix based system(unless it's windows...then whatever, enjoy windows). We can use sed which is basically going to run commands against a stream. find is basically going to pipe a stream directly into sed, and sed is going to run a simple find/replace scheme(just like we would if we were using vim).

fix foo and move it to point to a private repo:

find ./ -type f -exec sed -i "s/'foo/'@my-org\/foo/g" {} \;

Arity In Functional Javascript

Sam Clark — Thu, 16 May 2019 21:19:16 +0000

Good References:

Understanding Currying in JavaScript – Bits and Pieces

I think most of the time it's easier for me atleast to read someone else's code instead of long drawn out blog posts. Let's take a look at this non-functional JS snippet:


function nfMultiply(a, b, c) {
  return a * b * c;
}

console.log('non-functional', nfMultiply(1, 2, 3));

Arity in essence is the number of functions you can pass into an object. It's all rather confusing, but i think of it as the amount of functions you can curry into one function, let's convert the function above into an arity of 3.

function multiply(a) {
  return b => {
    return c => {
      return a * b * c;
    };
  };
}

console.log('arity breakdown', multiply(1)(2)(3));

If you think about it simply how many times can i fold this function against itself. This becomes useful when we start creating more complex functional javascript statements(I really enjoy using lodash in my node code, and also because it's included in AWS lambdas by default, thus not really bloating it.):

More Advanced

const { has } = require('lodash');

const fakeDataFunc = () => 3;
const fakeObjFunc = () => ({ uncool: 'blue' });

function coolDude(a) {
  return b => {
    return c => {
      return d => {
        return e => {
          return {
            a,
            bTimesC: b * c(),
            d,
            eHas: has(e(), 'cool') ? 'sure does' : 'nope',
          };
        };
      };
    };
  };
}

console.log(
  'testing',
  coolDude('Mutliplied Value times a function is: ')(2)(fakeDataFunc)(
    'and here we generate a ternary if something is in an object:',
  )(fakeObjFunc),
);

You can take the above snippets and kind of meld them to your wishes, and play with them to create Higher Order Functions, enjoy!!!

Horrible Snippets - Check the string

Sam Clark — Thu, 02 May 2019 17:13:20 +0000

Usecase
Let's say you're looking to implement a darklaunch feature, you have some options, you can pass a bunch of env vars(RUN_EVENT_1=true, etc.) OR you can just pass a DARK_LAUNCH flag with some comma separated vars.

const stringydingy = 'foo,bar,baz';

stringydingy.split(',').includes('foo');

if(stringydingy.split(',').includes('foo')) {
  runDarkLaunchDotCalm();
}

Play with it, try it out in your project! Give me feedback on how it can be improved!

Horrible Snippet - Updating an Nested Array With The Spread Operator

Sam Clark — Sat, 20 Apr 2019 00:46:18 +0000

Sometimes I like to just sit there and think of weird ways to accomplish things, and sometimes I come up with ideas like this, I think this could be applied to some Functional JS

// I Really dig this one
const foo = {
  bar: {
    baz: [{ changeMe: 'asdf', notMe: 'asdf' }, { changeMe: 'ffff', notMe: 'asdf' }],
  },
};

const newArr = foo.bar.baz.map(baz => ({ ...baz, changeMe: 'swee' }));

const newData = {
  ...foo,
  bar: {
    baz: newArr,
  },
};

console.log('newData', newData.bar.baz);

Horrible Howto - Attach A Stack To Debug

Sam Clark — Sat, 20 Apr 2019 00:22:35 +0000

So, a few years ago in my infancy of learning how to use Javascript, I came upon a situation where I really wanted to learn how to attach the function name and file name to my functions. At the time, I do not think I really understood the concept of stack traces, and the value of an error.

The Circumstance

Assume if you will the following:

You are early in the development cycle of a cloud function(e.g. lambda)
Deploying your function takes some time, and so every time you do run it, you want as much valid feedback from it.
Because you are deploying a cloud function your ability to inspect it via a debugger is severely limited. You need to be able to show some breakpoints, or at least WHERE your function is breaking.

Here it comes......the debug module....

The basis of the debug module is that we can turn on debugging with an environment variable, and then turn it off! That hits all the check boxes. We don't have to run it in production, and it's somewhat limited.

Starting Out

Let's start by declaring a few variables and debugs per the documentation:

blah.js:

const v = require('debug')('verbose');

v('test');

Now if we were to pass the environment variable DEBUG=verbose, we would end up with something like:

verbose test +0ms

We get a nice timer on the end of it to, with some colors if you're using it locally.

Building the Stack

Unfortunately Javascript does not actually carry a stack globally(much like glibc I have come to find out). The cheapest way to get the stack history is to actually drop the function into an error status. This shouldn't be a problem with our proposed use cases, because we are using this for debugging purposes.

const buildStack = () => {
  const depth = 3;
  if (!this.stackIs) {
    Object.defineProperty(this, 'stackIs', {
      get: function() {
        const orig = Error.prepareStackTrace;
        Error.prepareStackTrace = function(_, stack) {
          return stack;
        };
        const err = new Error();
        Error.captureStackTrace(err, arguments.callee);
        const stack = err.stack;
        Error.prepareStackTrace = orig;
        return stack;
      },
    });
  }

  if (!this.lineIs) {
    Object.defineProperty(this, 'lineIs', {
      get: function() {
        return this.stackIs[depth].getLineNumber();
      },
    });
  }

  if (!this.functionIs) {
    Object.defineProperty(this, 'functionIs', {
      get: function() {
        return this.stackIs[depth].getFunctionName();
      },
    });
  }

  return {
    function: this.functionIs,
    line: this.lineIs,
  };
};

We use the nice revealing pattern to print out an object with where our debug, and voila! We now have really awesome debugging!

Total Snippet here

Sources: stack overflow

Horrible Howto - Get that Middle Initial

Sam Clark — Sat, 20 Apr 2019 00:08:00 +0000

I really just wanted to post my first post, and I had just made this snippet, so I decided to post it here! What the hay!

const formatMiddleInitial = middleName => (middleName ? middleName.charAt(0).toUpperCase() : null);
console.log('stuff', formatMiddleInitial('clark hark'));