# A little fun with Javascript

Just playing around with the spread operator and I found a neat little design pattern I think I am going to work in:

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16``` ```let testArr = [9,1, 2, 6, 3, 4]; const newMax = (arr) => { if(arr.length === 1) { return console.log('end')}; var [a, ...arr] = arr; let max = Math.max(a,...arr); console.log(max ,' >=', ...arr); newMax(arr); } newMax(testArr); //output 9 ' >=' 1 2 6 3 4 6 ' >=' 2 6 3 4 6 ' >=' 6 3 4 6 ' >=' 3 4 4 ' >=' 4 end ```

Seems a fun way to look for edges like in the water trap toy problem? I am not sure, but it will be fun to play around with it.

Another thing that used to annoy me was how you had to use string concatenation. It just looked so ugly. I finally (okay I am late to the party) started using backticks for multi-line parties!

 ```1 2 3 4 5 6 7 8``` ```var motion = `Le mouvement de lacet sur la berge des chutes du fleuve, Le gouffre à l’étambot, La célérité de la rampe, L’énorme passade du courant Mènent par les lumières inouïes Et la nouveauté chimique Le voyageurs entourés des trombes du val Et du strom.` ```

And finally a little more fun with the spread operator (thanks Alex Rauschmayer) but you can make an array only contain unique values in a very clean, native way.

 ```1 2 3 4``` ```const arr = [7, 3, 1, 3, 3, 7]; [...new Set(arr)] //returns [ 7, 3, 1 ] ```

# Publishing an NPM Module Part 6

These are my notes based on the phenomenal tutorial by Kent C. Dodds hosted by egghead.io both of which are my go to sources when I want to learn something new. I highly suggest you sign up for the pro subscription.

## Part 6: Adding ES6 Support

We need to add babel-cli to our dev dependencies:

`\$ npm i -D babel-cli`
```  The Docs
Common uses:
`babel -w ````-o  //watch for file changes and output
babel src -o  // compile entire src dir and concat
babel src -d lib //compile entire src dir and output to lib
babel --ignore  //add this to ignore files i.e. tests``````

Next we will add a build script for babel. Looking in our node_modules/bin we can see babel has been added making it available to npm for scripts. Let’s edit our package.json to include:

`"build": "babel --out-dir dist src”`

Now let’s test it to see what gets generated when we run our script. In your terminal run:

`\$ npm run build`

Look in the dist directory and you will see that it was created and files were moved over. It also added our test files! This is something we don’t want to push to the dist since if we test when we publish, not when we consume. We can solve this by adding an ignore flag:

`“build”: ''babel --out-dir dist --ignore *.test.js src"`

Since this creates a dist directory with files in it, we want to make sure that if we make a change in a filename that the old one is not present in the next build in order to delete the directory cleanly we will add a prebuild script to package.json

`"prebuild": "rm -rf dist”`

However this is only *nix supported in order to allow windows devs to use this we must add a new dev package called rimraf  a cross-platform rm -rf built for node.

`\$ npm i -D rimraf`

replace rm-rf with rimraf:

`"prebuild": "rimraf dist”`

now convert to es6 i.e.:

```

'use strict'
//require external dependencies
import uniqueRandomArray from 'unique-random-array';
import _ from 'lodash';

//define available data
import firstNames from '../data/first-names.json';
import middleNames from '../data/middle-names.json';
import lastNames from '../data/last-names.json';

//random generators
let randomFirstName = uniqueRandomArray(firstNames);
let randomMiddleName = uniqueRandomArray(middleNames);
let randomLastName = uniqueRandomArray(lastNames);

//filter functions
const filteredNames = function (nameList, initial) {
return nameList.filter(function (name) {
return name[0] === initial;
})
};

//methods
const list = ()=>{
let allNames = ["FirstName MiddleName LastName"];
for (var i = 0; i < firstNames.length; i++) {
//Math.floor((Math.random() * 10) + 1);
var tmpName = randomFirstName() + ' ' + randomMiddleName() + ' ' + randomLastName();
allNames.push(tmpName);
}
return allNames;
};

const single = ()=>{
return randomFirstName() + ' ' + randomMiddleName() + ' ' + randomLastName();
};

const startsWithLetter = (f, m, l)=>{
var firstName = _.sample(filteredNames(firstNames, f));
var middleName = _.sample(filteredNames(middleNames, m));
var lastName = _.sample(filteredNames(lastNames, l));
return firstName + ' ' + middleName + ' ' + lastName;
}

const numberOfNames = (number=1, allNames=[])=>{
for (var i = 0; i < number; i++) {
var tmpName = randomFirstName() + ' ' + randomMiddleName() + ' ' + randomLastName();
allNames.push(tmpName);
}
return allNames;
}

//available methods
module.exports = {
list: list,
single: single,
startsWithLetter: startsWithLetter,
numberOfNames: numberOfNames
}```

Now lets run our build script again:

`\$ npm run build`

Now let’s take a look at index.js in dist and notice nothing happened! That is because really all we did was have it copy it over. We did not tell it to do anything! So we need to install some presets to tell babel how to do the transpiling:

`npm i -D babel-preset-es2015 babel-preset-stage-2`
` Learn more about presets`

In order for babel to know about these presets we have added we need to change our package.json to reflect this:

```"babel": {
"presets": [
"es2015",
"stage-2"
]
}```

We need to change our package.json file to point to dist now:

`"main": "dist/index.js",`

While we are here we should update the build script by adding –copy-files:

`"build:main": "babel --copy-files --out-dir dist --ignore *.test.js src",`

Now we need to make sure the build script runs before the publish script. We do this by modifying the .travis.yml file scripts section, after check-coverage add:

`- npm run build`

Now we need to do a little verification on our changes. Let’s run a command to see what will actually be published:

`\$ npm pack   `

A file was generated ending in tgz. Open that up and take a peek. It looks alright, but there are just some extra files in there that we might not need or want. So let’s learn how to limit what gets packed up. We do this by adding a files section to our package.json file:

```"files": [
"dist",
"data",
],```

Now that we are writing in ES6 we want to make sure that all of the other pieces are able to work with the new syntax as well. Let’s start with istanbul. It turns out we need a replacement package for that called nyc.

`\$ npm i -D nyc`

Now we need to update package.json to use this new method:

```
"check-coverage": "nyc check-coverage --statements 100 --branches 100 --functions 100 --lines 100",```

Next in the test with the watch command (-w) we want to add in something that will transpile our code.

`"test:watch": "mocha src/index.test.js --compilers js:babel-register -w",`

Since we are using it we might as well install it!

`npm i -D babel-register`

The tests are getting a little clunky, with a lot of repeated code so we are going to clean things up a bit. by letting the watch test just fire off the regular test adding in a -w flag.

```"test:watch": "npm t -- -w",
"test": "mocha src/index.test.js --compilers js:babel-register",```

Note the double dash in the watch script. This allows you to send in the watch flag to the previous call as if it were in the original.  Since we are cleaning things up let’s go a little farther, but adding a cover script.

`"cover": "nyc --reporter=lcov npm t",`

We now need to adjust our githook.

```"config": {
"ghooks": {
"pre-commit": "npm run cover && npm run check-coverage"
}```

One more spot in .travis.yml we need to make sure we run our cover script so it ends up looking like:

```script:
- npm run cover
- npm run check-coverage
- npm run build```

There we go! We now have an es6 friendly set up!

Next… UMD Build!

```  = Time Saving Idea

= Pro Tip

= Note

= Code Update

= A Closer Look```

# Publishing an NPM Module Part 3

These are my notes based on the phenomenal tutorial by Kent C. Dodds hosted by egghead.io both of which are my go to sources when I want to learn something new. I highly suggest you sign up for the pro subscription.

## Part 3: Setting up Unit Testing

There are tons of testing libraries out there. I am going to stick with the more common ones mocha and chai for now. In later parts I will introduce a few more. In order to use them we should install them!

`\$ npm i -D mocha chai`

the above is the same as ‘npm install mocha chai –save-dev’ only faster!

Create index-test.js in the same directory.

`\$ touch src/index.test.js`

Now looking at our index.js we see we have a few things to test. At least 4 since we do have 4 methods.

```module.exports = {
list: list,
single: single,
startsWithLetter: startsWithLetter,
numberOfNames: numberOfNames
}```

Let’s start building our index.test.js. We will first wrap our initial section in a describe block. This is just a container to describe what we should expect to see tested inside.

```var expect = require('chai').expect;
var rng = require('./index');

describe('Our first tests', function () {

});```

Our list method should return an array containing strings. So let’s test for that!

```describe('tests should be running', function () {
describe('list()', function () {
it('Expect it to return an array of strings', function () {
expect(rng.list()).to.satisfy(isArrayOfStrings);

function isArrayOfStrings(array) {
return array.every(function(item){
return typeof item === 'string';
})
}
});
});
});```

Let’s take a closer look at each part in the above test. We have another describe block, this time focused on the all method. This is a nice way of grouping our tests to keep them focused. The first argument in describe is a string denoting the topic, the second is a function that will contain our actual tests and also could be used to set up mock data if we needed it.

The it is similar to describe in that you first give it a string but this time it will be much more specific. This is what you are actually testing. In this example we want to make sure that the all function returns an array of strings. The second argument is again a function block where we will do the specific test.

One of the benefits of this style of testing is to create very readable tests. Even if you don’t know the nitty gritty you could read the test and it will explain itself. Using expect or should gives you a clear idea of what we are looking for. They are pretty similar, however there are some syntactical differences to be aware of. (read more)

These allow you to chain together natural language assertions. Expect takes the value you want to test and then you chain together what assertions you need to use in order to test. The language used to chain the expect and the test generally do not  provide testing functionality.

```List of Chains:

.to
.be
.been
.is
.that
.which
.and
.has
.have
.with
.at
.of
.same```

These get chained together finally ending in an actual test assertion. For example in my test we see:

`expect(rng.list()).to.satisfy(isArrayOfStrings);`

This means that we expect that when we execute rng.list() that it will satisfy the given truth test. Here our truth test is another function that checks to see if every item in the array has a type of string.  This is very flexible and will help you easily generate tests. The full api can be read here. Here are some of the ones I use most:

### .match(regexp)

• @param { RegExp } RegularExpression
• @param { String } message _optional_

Asserts that the target matches a regular expression.

``expect('foobar').to.match(/^foo/);``

### .instanceof(constructor)

• @param { Constructor } constructor
• @param { String } message _optional_

Asserts that the target is an instance of `constructor`.

``````var Tea = function (name) { this.name = name; }
, Chai = new Tea('chai');

expect(Chai).to.be.an.instanceof(Tea);
expect([ 1, 2, 3 ]).to.be.instanceof(Array);``````

### .equal(value)

• @param { Mixed } value
• @param { String } message _optional_

Asserts that the target is strictly equal (`===`) to `value`. Alternately, if the `deep` flag is set, asserts that the target is deeply equal to `value`.

``````expect('hello').to.equal('hello');
expect(42).to.equal(42);
expect(1).to.not.equal(true);
expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
``````
Now that you are familiar with the basics of testing write a few more tests for your functions. Here is an example of basic testing covereage:
```var expect = require('chai').expect;
var randomNameGenerator = require('./index');

describe('tests should be running', function () {
describe('list()', function () {
it('should be an array of strings', function () {
expect(randomNameGenerator.list()).to.satisfy(isArrayOfStrings);

function isArrayOfStrings(array) {
return array.every(function(item){
return typeof item === 'string';
})
}
});

it('should contain `FirstName MiddleName LastName`', function () {
expect(randomNameGenerator.list()).to.include('FirstName MiddleName LastName');
});
});

describe('single()', function () {
it('should be a string', function () {
expect(randomNameGenerator.single()).to.be.a('string');
});

it('should contain three names', function () {
var arrayOfName = randomNameGenerator.single().split(' ');
expect(arrayOfName).to.have.lengthOf(3);
});
});

describe('startsWithLetter()', function () {
it('should be a string', function () {
expect(randomNameGenerator.startsWithLetter('A', 'C', 'E')).to.be.a('string');
});

it('should contain three names', function () {
var arrayOfName = randomNameGenerator.startsWithLetter('A', 'C', 'E').split(' ');
expect(arrayOfName).to.have.lengthOf(3);
});

it('should start with the passed values for f,m,l of A, C, E', function () {
var arrayOfName = randomNameGenerator.startsWithLetter('A', 'C', 'E').split(' ');
expect(arrayOfName[0][0]).to.equal('A');
expect(arrayOfName[1][0]).to.equal('C');
expect(arrayOfName[2][0]).to.equal('E');
})
});

describe('numberOfNames()', function () {
it('numberOfNames(3) should have a length of three', function () {
var arrayOfNames =  randomNameGenerator.numberOfNames(3);
expect(arrayOfNames).to.have.lengthOf(3);

});

it('numberOfNames() should default to one', function () {
var arrayOfOneName = randomNameGenerator.numberOfNames();
expect(arrayOfOneName).to.have.lengthOf(1);
});
});

});```

Now that we have some basic tests we will create a script to run them. Open package.json and in the scripts section we will change the test to:

`"test": "mocha src/index.test.js -w"`

The -w watches the file system for changes and re-runs the test. There are many more options head to mochajs.org and search for usage:

There we go, we have set up a basic testing framework!

Next… Automating releases

Key:

```  = Time Saving Idea

= Pro Tip

= Note

= Code Update

= A Closer Look```

# Publishing an NPM Module Part 1

These are my notes based on the phenomenal tutorial by Kent C. Dodds hosted by egghead.io both of which are my go to sources when I want to learn something new. I highly suggest you sign up for the pro subscription.

## Part 1 : The Setup

These are my notes based on the phenomenal tutorial by Kent C. Dodds hosted by egghead.io both of which are my go to sources when I want to learn something new. I highly suggest you sign up for the pro subscription. They are focused on a ‘code first’ delivery so you start learning right away. I made these notes to dig a little deeper on some of the topics, but I would not have known where to get started without these two wonderful resources!

I will be using the following icons to denote certain sections.

= Time Saving Idea

= Pro Tip

= Note

= Code Update

= A Closer Look

### Overview

1. Create the git repo
2. Create the library
3. Publish to npm
4. Create test suites
1. Karma
2. Mocha
3. Chai
5. Set up continuous Integration
1. Travis-CI
1. Babel
2. web pack
7. Distribute
1. NPM
2. GITHUB
3. UMD

### Create the GitHub Repo

First head over to github.com to create your account if you don’t already have one. Next create a new repo. You can skip creating the README.md as we will be making our own in the next few moments. Take note of the url for the repo as we are going to add it in as the origin in the following steps.

```\$ echo “# Project name” >> README.md
\$ git init
\$ git commit -m "Initial Commit"
\$ git remote add origin <git url> //i.e. https://github.com/jmichelin/something.git
\$ git push -u origin master```

### Setting up NPM

Install Node

To verify that you have node installed run:

`\$ npm -v`

Head to https://docs.npmjs.com/ and read about init-author.name, init-author-email, init-author-url, init-license and save-exact. These set up defaults making future projects even easier. The save-exact true makes your project configured with an exact version rather than using npm’s default semver range operator. There are more but these are some of the more common ones that tend not to change between projects.

Run the following commands:

```\$ npm set init-author-name 'Name'
\$ npm set init-author-email '<your_email>'
\$ npm set init-author -url '<your_website>'
\$ npm set save-exact true //makes sure you use exact versioning```

let’s look at npmrc:

`\$ cat ~/.npmrc`

You will see all of the defaults you set above saved there in case you ever want to edit them.

`\$ npm adduser`

enter npmjs account name, password and Email, add user creates an auth token that you should keep private.

`\$ npm init`

Accept default name, version, enter a brief description, entry point is the file that will be looked at when you require(‘module-name’); change the entry point to read src/index.js accept default for test, for github repo, enter some keywords, accept default license, and create package.json.

Next…Creating a Library

start thinking about what you might want to make and keep it simple.

# 98 percent of Hack Reactor students land jobs

When it comes to landing a job in tech, coding camps promise to get you there faster. CNBC’s Aditi Roy reports. Suzy Welch, LinkedIn contributing editor, weighs in.

video.cnbc.com

# MakerSquare – Blog – Coding Bootcamp in Austin San Francisco and Los Angeles

Update: I now work for them in New York! I absolutely love this job and this city!

Can’t wait to see them in New York! I love that town even more now!

# YDKJS Types & Grammar

## Chapter 2 “Values”

Javascript has some interesting aspects to arrays, strings and numbers! In this chapter we explore them in a little more detail.

### Arrays

Javascript arrays are not type-enforced. They can contain strings, numbers, objects, even other arrays aka multi-dimensional array.

```var myArray = [ 1, "1", {1:"One"}, ["Juan"] ];
```

Arrays also do not need to have their size predefined. You can just declare and add willy nilly. There is some care when using delete on an array because it will remove the slot, but even if that slot is the last element it does not update the length property of that array. Also watch out for “sparse” arrays by creating empty or missing slots. This can lead to some unintended consequences when dealing with the array values.

Another odd thing is that since arrays are also objects you can have string key/property values added to them, but this does not change the value of the length of that array, unless that value can be coerced into a base-10 number!

```var myArray = [ ];
myArray[0] = 1;
myArray["crazytown"] = 42;

myArray.length == 1; //true
myArray["crazytown"] == 42; //true
myArray.crazytown; //42

//watch out for numbers!

var myOtherArray = [ ];
myOtherArray["42"] = "crazytown";
myOtherArray.length == 43; //true
```

Interesting ES6 built-in called Array.from(…) It can do more that I will have to learn about!

```var arr = Array.from( arguments );
```

### Strings

At first glance one might think that strings are just arrays of characters. Strings have a length property, an indexOf method and even a concat method. So they are the same right? Not so fast! JavaScript strings are immutable, while arrays are! Look at the following:

```myString = "ramen";
myArray = [ "r", "a", "m", "e", "n" ];

myString.length == myArray.length; //true

myString.indexOf( "e" ) == myArray.indexOf("e"); //true

//however watch this

myString[1] = "X";
myArray[1] = "X";

myString; // "ramen"
myArray; // myArray = [ "r", "X", "m", "e", "n" ];
```

If you find yourself treating strings as arrays, consider using just an array. You can always join the array back up if you need to use it as a string.

### Numbers

Unlike many other programming languages javascript has only one flavor of numeric datatype. number. This number contains integer(ish) numbers and fractional decimal numbers. The ish above is because the integers are just not exactly as you would expect. Google has a ton of examples, here is one. Trailing and leading 0’s are removed from decimals 0.42 becomes .42 and 4.200 becomes 4.2 etc.

Another interesting thing is that numbers get access to the Number.prototype methods, like toPrecision() and and toString(). Some caveats when using them. If you tried 42.toString() returns invalid because the initial . is considered to be a part of the 42, you can get around this by using parentheses (42).toString() or 42..toString(). Things have changed a bit for octal literals in ES6 and/or strict mode so that 0363 no longer equates to 243 instead you would use 0o363… very fun.

You can also get whonky stuff like 0.1 + 0.2 === 0.3 returning false… There are ways around this, ES6 has some specific tools for this (see Number.EPSILON). ES6 also has Number.MAX_SAFE_INTEGER (9007199254740991) and Number.MIN_SAFE_INTEGER (-9007199254740991) it also has an isInteger test that you can polyfill by checking typeof num is “number” and its % 1 is 0. It gets deeper with ES6 as you can use .isSafeInteger

Numbers are strange, mmmkay.

### Special Values

I like these. They are special! They are null, undefined, and void . null being an empty value and undefined being a missing value. null is a keyword making it have a sort of protection field around it so you can assign null to something. undefined can be, at least in non-strict mode, you can do bad things like setting undefined to equal something! Just don’t do it!

Void is an interesting one, I have dug around and I don’t think I know why I would use this. I am sure as I get deeper into javascript I will figure it out.

### Special Numbers

NaN, not a number… even though the typeof for a NaN is a number… mmm bad naming conventions. I have learned to think of it as just being a bad number. It happens when you try a mathematical expression using something that is not a number. Another interesting quirk about NaN is that it is not equal to itself! so NaN !== NaN… kooky. Using this we can create an interesting polyfill to check to see if something is NaN.

```if (!Number.isNaN) { //if the browser does not have access to this
Number.isNaN = function (n) {
return n !== n;
}
```

Cool! I will have to make sure I start putting this in!

To Infinities and beyond! Okay not beyond, but right to them! Basically this means you can make a value that is just too big (or too small) for JS to deal with and it assigns it Infinity or -Infinity. This leads us to another special case in javascript…

Zero or 0 or -0?

Javascript has both a 0 and a -0. What makes it even more difficult is that 0 == -0. Another helper function pops up!

```function isNegZero(n) {
n = Number( n );
return (n === 0) && (1 / n === -Infinity);
}
```

Again I think I need to get deeper into code to see why this would matter. For now I will just keep it in the back of my mind.

### Special Equality

When we need to check for these special equalities ES6 gives us a tool to help. Object.is() to the rescue. So now Object.is( 0, -0); returns false! Wahoo! Save Object.is for special occasions where you might need to check this!

## Value vs. Reference

A reference in javascript points to a space in memory so if you have multiple references to this space in memory they do not reference each other. Only the type of the value designates whether the value is assigned by copy or by reference.

Scalar Primitives are always assigned by copy: null, undefined, string, number, boolean and symbol.

Compound values such as objects and functions always create a reference copy on assignment or when passed.

## Event Delegation

What is it? Well I can tell you it is great! Gone are the days of an onMouseOver event watcher on every list item or span on your page. Now you can tell the parents to pay attention to their kids by reminding them to listen to the conversations they little ones are having and reacting appropriately. We do this by using  addEventListener. This brilliant function does just what it says. This one is easier to explain by example, so here goes.

```<div id="parent-div">
<span id="child-1">One</span>
<span id="child-2">Two</span>
<span id="child-3">Three</span>
</div>

<script>
// Get the element, add a click listener...
// e.target is the moused over element!
// If it was a span item
if(e.target && e.target.nodeName == "SPAN") {
// SPAN item found! Output the ID!
console.log("List item ", e.target.id.replace("child-", ""), " was evented!", e);
}
});
</script>
```

It is really as simple as that. Now when any child span is moused over the id number for that child will be sent to the console. You can also use specific classes if you use .matches(“className”). Digging deeper into this has me going down the MouseEvent rabbit hole so I know what my next post will be about! I mean who wouldn’t want to learn about MouseEvent.bubbles! BUBBLES!

# Final Days as Student at MakerSquare

I am on my last day as a Student at MakerSquare, I have been accepted as a Fellow (more on that later) but I thought it might be a good time to do some reflecting. First thing that strikes me is how long it seemed at the start and how quickly the time went by. I swear days turned to minutes and weeks to hours. I am amazed at how much I learned in such a short period of time. It has been exponential!

I am also aware that the bonds I have developed need attention if I want them to last a lifetime. I am making it a priority to stay in contact with those I have grown close to. This is easily my weakest area so I hope I can stay on top of it. I will never forget the late nights coding and watching TNG. Even the frustrating moments and mini-conflicts that popped up only seemed to draw me closer to my fellow learners.

Even though I am staying on for a bit longer I am still very excited to see what happens to them next. It will give me a hint as to my own future, more things to look forward too, more struggles, more life! I love you all and can’t wait to see the great things that I am sure you will all do!