Functional JavaScript — Useful Higher-Order Functions

JavaScript is partly a functional language.

To learn JavaScript, we got to learn the functional parts of JavaScript.

In this article, we’ll look at how to use closures to create our own higher-order functions.

unary Function

We can create our own unary function that returns a function that only calls one argument.

For example, we can write:

const unary = (fn) =>
  fn.length === 1 ?
  fn :
  (arg) => fn(arg)

We have the fn which is a function.

We check the length property of fn , which returns how many parameters it has.

If it only has one parameter, then we return the fn function.

Otherwise, we return a function that calls fn with only one argument.

This way, we can use functions like parseInt with the map method safely.

For example, we can write:

const nums = ['1', '2', '3'].map(unary(parseInt));

We call the unary function with parseInt so that we can use the callback withn only of parameter to parse the string to an integer.

parseInt takes the value to parse, and the radix as the second argument, so we can’t just pass parseInt straight to map because the radix will be the index of the array entry, which isn’t what we want.

With our unary function, we always call parseInt with only the value passed in.

Therefore, nums is [1, 2, 3] .

#javascript

What is GEEK

Buddha Community

Functional JavaScript — Useful Higher-Order Functions

Higher-Order Functions Beginners Should Be Familiar With.

Higher-order functions are functions that operate on other functions, either by taking them as arguments or by returning them.

There are a lot more higher order functions than what will be covered in this article, but these are good ones to get you up and running as a beginner. These standard array methods are forEach() , filter() , map() and sort() .

  1. **forEach( ): **This is used when you want to operate on or interact with any element inside of an array. Basically works like the_ for loop._

N.B- I’d be using examples to illustrate each method so you can get a clearer picture, and also just printing to the console to keep the examples as simple and basic as possible.

Example: Lets say in an array of a group or friends, and we want to loop through that array and print to the console each element of that array.

Using a for loop ;

const friends = ['Toyin', 'Olumide', 'Fola', 'Tola'];

for ( let i=0; i < friends.length ; i++) {
  cosole.log (friends[i])
};

The action same as above can be achieved using theforEach() method as seen below;

const friends =  ['Toyin', 'Olumide', 'Fola', 'Tola'];

friends.forEach(function(name) {
  console.log(name)
};

What the forEach() method simply does is to take in a function as an argument and loop through each item in the array without using iteration[i].

This is really awesome when the ES6 arrow functions are used, our code is reduced to a single line that is clean and maintainable. As seen below:

const friends =  ['Toyin', 'Olumide', 'Fola', 'Tola'];

friends.forEach(name => console.log (name));

2. **_filter( ) : _**Just like the name implies, it is used to filter out elements of an array that do not meet the conditions set in the callback function passed as an argument. The callback function passed to the filter() method accepts 3 parameters: elementindex, and array , but most times only the element parameter is used.

**Example : **In an array showing a group of friends and their ages, lets say we want to print to the console the friends that can drink assuming the age limit for drinking is 18. Using a for loop without high order functions;

const friends = [
  {name : 'Toyin', age: 24},
  {name : 'Olumide', age: 14},
  {name : 'Fola', age: 12},
  {name : 'David', age: 42}
];
for ( let i=0 ; i<friends.length ; i++) {
   if (friends[i].age > 18) {
    console.log(`${friends[i].name} can drink`);
 }
};

Now using the filter() method :

const friends = [
  {name : 'Toyin', age: 24},
  {name : 'Olumide', age: 14},
  {name : 'Fola', age: 12},
  {name : 'David', age: 42}
];
friends.filter (function (friend) {
  if (friend.age > 18){
   return true;
 } 
});

#functional-programming #beginners-guide #javascript #higher-order-function #es5-vs-es6 #function

Tia  Gottlieb

Tia Gottlieb

1595831640

Functional Programming: Higher Order Functions

A Better Take on JavaScript’s Higher Order Functions.

Image for post

Functional Programming is awesome! It makes programming fun.

Learning to program “functionally” is going to make you a fantastic programmer and you will feel secure with the quality of your work.

Image for post

You will be able to write your programs with fewer bugs and in less time because you will be able to re-use your code.

Within this paradigm, we will focus on one of the most important concepts in functional programming, and that is Higher-Order Functions.


So let’s get started!

In JavaScript, and in many functional programming languages, functions are values.

Let’s take a simple function for example:

function double(x) {
  return x * 2
}

What is super cool about JavaScript is that we can take this function and make it into an anonymous function to pass it around and re-use it by declaring a variable.

let double = function(x) {
    return x * 2
 }

let pancake = double 
pancake(40) // 80

We declared a variable _double _and assigned it to the anonymous function. Then we declared another variable, pancake, and assign it to the same function. Just like strings and numbers, functions too can be assigned to variables.

So, in functional programming, functions are values and they can be assigned to variables and they can also be passed into other functions.

Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher-order functions. — see Eloquent JavaScript

In other words, as pertaining to our example, higher-order functions can be understood as functions being passed into other functions to do awesome things!!!

Sure, that makes sense, right? But what are these good for?

Composition.

The fact that we can take one function and put it into another function allows us to compose a lot of small functions into bigger functions.

Let’s look at how to use one of these higher-order functions. Probably the most basic and useful function is

Filter( )

Image for post

Image for post

Filter() is a function on the array that accepts another function as its argument, which it will use to return a new filtered version of the array.

Let’s make a fun array of something.

const pets = [

  { name: 'Flip flop', species: 'rabbit' },
  { name: 'Dino', species: 'dog' },
  { name: 'Ralph', species: 'fish' },
  { name: 'Chuchi', species: 'cat' },
  { name: 'Ari', species: 'dog' },
  { name: 'Spock', species: 'dog' },
  { name: 'ying yang', species: 'cat' },
]

What we want to do here is to just “filter” out all the dogs.

Our output must include Dino, Ari, and Spock. 😆

Question: How would I do this with a normal loop?

#higher-order-function #javascript #security #programming #code-review #function

Vincent Lab

Vincent Lab

1605017502

The Difference Between Regular Functions and Arrow Functions in JavaScript

Other then the syntactical differences. The main difference is the way the this keyword behaves? In an arrow function, the this keyword remains the same throughout the life-cycle of the function and is always bound to the value of this in the closest non-arrow parent function. Arrow functions can never be constructor functions so they can never be invoked with the new keyword. And they can never have duplicate named parameters like a regular function not using strict mode.

Here are a few code examples to show you some of the differences
this.name = "Bob";

const person = {
name: “Jon”,

<span style="color: #008000">// Regular function</span>
func1: <span style="color: #0000ff">function</span> () {
    console.log(<span style="color: #0000ff">this</span>);
},

<span style="color: #008000">// Arrow function</span>
func2: () =&gt; {
    console.log(<span style="color: #0000ff">this</span>);
}

}

person.func1(); // Call the Regular function
// Output: {name:“Jon”, func1:[Function: func1], func2:[Function: func2]}

person.func2(); // Call the Arrow function
// Output: {name:“Bob”}

The new keyword with an arrow function
const person = (name) => console.log("Your name is " + name);
const bob = new person("Bob");
// Uncaught TypeError: person is not a constructor

If you want to see a visual presentation on the differences, then you can see the video below:

#arrow functions #javascript #regular functions #arrow functions vs normal functions #difference between functions and arrow functions

Willie  Beier

Willie Beier

1595648580

Higher Order Functions in JavaScript

Functional programming is a paradigm that results in cleaner and more concise code, that is easier to maintain, and reduces hard to find bugs. A central concept in functional programming is higher order functions. In JavaScript there a multiple of built in higher order functions.

According to Wikipedia a higher order function does one of the following:

  • takes one or more functions as arguments (i.e. procedural parameters),
  • returns a function as its result.

Filter

Lets get to it. In enterprise grade software, we sometimes want to filter on cute dogs.

const dogs = [

  { name: 'Cocker spaniel', cute: true },
  { name: 'Chihuahua', cute: false },
  { name: 'Malteser', cute: true },
  { name: 'Tax', cute: false }, 
]

We could use a for-loop for this. Where we would iterate over each dog and filter based on the cute boolean.

const cuteDogs = [];
for (let i = 0; i < dogs.length; i++) {
  if (dogs[i].cute)
    cuteDogs.push(dogs[i]);
}

However there is a much simpler solution, that is more elegant, that is using the filter function.

const cuteDogs = dogs.filter(dog => dog.cute);

#javascript #functional-programming #higher-order-function

JavaScript Higher-order Functions - 19

A function expression is another way of creating a function. It makes your code maintainable because each function has its task and it avoids scope pollution - a term used when variables a cluttered within the namespace, thereby making your program more prone to error.

In this tutorial we will learn the function expressions in the following sections:

  1. Basic syntaxes of the function expression
  2. Ways of creating a function pollution
    • Anonymous function
      • Function without function name
      • Self-invoked function
    • Arrow function
  3. Limitations of arrow functions
    • Keywords like this, super, arguments, new.target, and yield can’t be used.
    • Can’t be used as a constructor.
    • Can’t use the syntax of call, apply, and bind methods on arrow functions.

Official website: https://techstackmedia.com

Watch the entire JavaScript Series, including upcoming JavaScipt videos on YouTube: https://www.youtube.com/playlist?list=PLJGKeg3N9Z_Rgxf1Und7Q0u0cSre6kjif

Check out the article: https://techstack.hashnode.dev/javascript-function-expressions.
Next article: https://techstack.hashnode.dev/javascript-higher-order-functions

Become a patron to learn more: https://www.patreon.com/techstackmedia

Techstack Media is in partnership with Skillshare: http://bit.ly/tsm-skillshare.
Learn anything and get the required skill you need to kickstart a long-lasting career.

Website Request: bello@techstackmedia.com

Social Media:
✅ Facebook: https://facebook.com/techstackmedia
✅ Twitter: https://twitter.com/techstackmedia
✅ Instagram: https://instagram.com/techstackmedia
✅ LinkedIn: https://linkedin.com/in/techstackmedia

#javascriptfunctions #functionexpressions #returnstatements #defaultparameters #functionbody #functionscope #javascriptfunction #arrowfunction #functiondeclaration #functionexpression #anonymousfunction #javascript #techstackmedia #codenewbies #learntocode #tutorial #webdev #DEVCommunity #DEVCommunityIN #NodeJS #programming #Hashnode #100DaysOfCode #opensource #techstack #media #womenwhocode #dev #blogging #writing #coding #webdevelopment

#javascript #javascriptfunctions #javascript higher-order functions