Forem: Ricardo Molina

Javascript functional programming basic examples

Ricardo Molina — Tue, 19 Dec 2017 10:29:24 +0000

Functional programming:

Is a programming paradigm.

The output value of a function depends only on the arguments that are passed to the function, so calling a function f twice with the same value for an argument x produces the same result f(x) each time.

This is in contrast to procedures depending on a local or global state, which may produce different results at different times when called with the same arguments but a different program state.

Eliminating side effects, i.e., changes in state that do not depend on the function inputs, can make it much easier to understand and predict the behavior of a program, which is one of the key motivations for the development of functional programming.

High-order-functions:

Functions that operate on other functions, either by taking them as arguments or by returning them.

Examples:

filter():

var animals = [
    { name: 'John', species: 'dog' },
    { name: 'Jane', species: 'cat' },
    { name: 'James', species: 'frog' },
    { name: 'Joe', species: 'horse' },
];

// With a for loop:
var dogs = [];
for (var i=0; i<= animals.length; i++) {
    if( animals[i].species === 'dog') 
        dogs.push(animals[i]);
}

// Functional:
var dogs = animals.filter(function(animal) {
    return animal.species === 'dog';
};

// Another way, decoupling:
var isDog = function(animal) {
    return animal.species ==='dog';
}
var dogs = animals.filter(isDog);

map():

var animals = [
    { name: 'John', species: 'dog' },
    { name: 'Jane', species: 'cat' },
    { name: 'James', species: 'frog' },
    { name: 'Joe', species: 'horse' },
];

// With for loop:
var names = [];
for (var i=0; i<= animals.length; i++) {
    if ( animals[i]-species === 'dog') 
        names.push(animals[i].name);
}

// Functional:
var names = animals.map(function(animal) {
    return animal.name + ' is a ' + animal.species;
});

// Which using ES6 arrow functions can be:
var names = animals.map((animal) =>  { animal.name });

reduce():

var orders = [
    { amount: 250 },
    { amount: 400 },
    { amount: 100 },
    { amount: 350 },
];

// For loop:
var  totalAmount = 0;
for (var i=0; i < orders.length; i++) {
    totalAmount += orders[i].amount;
}

// Functional:
var totalAmount = orders.reduce(function(sum, order) {
    return sum + order.amount;
}, 0);

// Which using ES6 arrow functions can be:
var totalAmount = orders.reduce(sum, order) => sum + order.amount, 0);

console.log(totalAmount);

Source: https://www.youtube.com/watch?v=Wl98eZpkp-c

Simple note taking from the command line

Ricardo Molina — Sat, 30 Sep 2017 06:27:25 +0000

This is a simple function that can be called from the command line, just like if it was a regular command. It is a quick way of taking notes and storing them in a text file.

Just add the following lines to your ~/.bashrc:

# My function to take quick notes on useful commands
notes() {
    echo $1 >> $HOME/notes.md
}

It can be used like this:

$ notes "my_command -which -I -want -to remember"

You can read your notes like this:

$ more ~/notes.md

Git: rebasing

Ricardo Molina — Fri, 29 Sep 2017 17:55:42 +0000

Source: https://dev.to/maxwell_dev/the-git-rebase-introduction-i-wish-id-had

Let’s say when you created your branch off of the master branch, the master branch was on commit #1. Every commit in your branch was layered on top of commit #1. When you’re ready to merge your branch, you discover other developers made changes and the most recent commit is commit #5.

Rebasing is taking all your branch’s commits and adding them on top of commit #5 instead of commit #1. If you consider commit #1 as the “base” of your branch, you’re changing that base to the most recent one, commit #5. Hence why it’s called rebasing!

A straightforward rebase has a pretty simple command structure: git rebase <branch>. branch is the one you’re rebasing off of. So here you’d run git rebase master. Assuming there’s no conflicts, that’s all the rebase needs!

The rebase itself technically removes your old commits and makes new commits identical to them, rewriting the repo’s commit history. That means pushing the rebase to the remote repo will need some extra juice. Using git push --forcewill do the trick fine, but a safer option is git push --force-with-lease. The latter will alert you of any upstream changes you hadn’t noticed and prevent the push. This way you avoid overwriting anyone else’s work, so it’s the safer option.

If you’ve dealt with merge conflicts before, rebase conflicts are handled essentially the same way. Running git status will tell you where the conflicts are, and the two conflicting sections of code will be next to each other so you can decide how to fix them.

Once everything is fixed, add and commit the changes like you would a normal merge conflict. Then run git rebase --continue so git can rebase the rest of your commits. It’ll pause for any more conflicts, and once they’re set you just need to push --force-with-lease.

There’s two lesser-used options you could also use. One is git rebase --abort, which would bring you back to before you started the rebase. It’s useful for unexpected conflicts that you can’t rush a decision for. Another is git rebase --skip, which skips over the commit causing the conflict altogether. Unless it’s an unneeded commit and you’re feeling lazy, you likely won’t use it much.