Any difference between First Class Function and High Order Function

There is a difference. When you say that a language has first-class functions, it means that the language treats functions as values – that you can assign a function into a variable, pass it around etc. Higher-order functions are functions that work on other functions, meaning that they take one or more functions as an argument and can also return a function.

The “higher-order” concept can be applied to functions in general, like functions in the mathematical sense. The “first-class” concept only has to do with functions in programming languages. It’s seldom used when referring to a function, such as “a first-class function”. It’s much more common to say that “a language has/hasn’t first-class function support”.

The two things are closely related, as it’s hard to imagine a language with first-class functions that would not also support higher-order functions, and conversely a language with higher-order functions but without first-class function support.

First class functions are functions that are treated like an object (or are assignable to a variable).

Higher order functions are functions that take at least one first class function as a parameter, or return at least one first class function.

They're different.

First class functions

Values in a language that are handled uniformly throughout are called "first class". They may be stored in data structures, passed as arguments, or used in control structures.

Languages which support values with function types, and treat them the same as non-function values, can be said to have "first class functions".

Higher order functions

One of the consequences of having first class functions is that you should be able to pass a function as an argument to another function. The latter function is now "higher order". It is a function that takes a function as an argument.

The canonical example is "map"

map :: (a -> b) -> [a] -> [b]
map f []     = []
map f (x:xs) = f x : map f xs

That is, it takes a function, and an array, and returns a new array with the function applied to each element.

Functional languages -- languages where functions are the primary means of building programs -- all have first class functions. Most also have higher order functions (very rare exceptions being languages like Excel, which can be said to be functional, but not higher order).

In addition to the previous answers, note that a language with first-class functions automatically enables the expression of higher-order functions (because you can pass functions as parameters like any other value).

On the other hand, you can imagine languages that support higher-order functions, but do not make functions first-class (and where parameters that are functions are treated specially, and different from "ordinary" value parameters).

So the presence of first-class functions (as a language feature) implies the presence of higher-order functions, but not the other way round.

First Class functions can:

Be stored in variables

Be returned from a function.

Be passed as arguments into another function.

High Order Function is a function that returns another function.

For example:

function highOrderFunc() {
  return function () {
    alert('hello');
  };
}

First class functions mean everything you can do with other types(variables, booleans, numbers...), you can do it with functions.

For example Assign them to variables, pass it around, create them on fly.

First class function:

When we pass function as an argument of another function called first class function. The ability to use function as a values known as first class function.

var a = function(parameter){
    return function(){
    }
}
console.log(a())

Higher-Order Function:

A function that receives another function as an argument or that returns a new function or both is called Higher-order functions. Higher-order functions are only possible because of the First-class function.