Connect with us


5 Totally different Methods to Declare Features in jQuery – SitePoint

On this article, we look at a number of methods to outline a block of JavaScript performance.

Selecting which method to declare a JavaScript operate will be complicated for inexperienced persons and there are a number of completely different syntax choices. Every has benefits, disadvantages, and acceptable makes use of that may catch you out.

1. Common JavaScript Features

The primary and most evident method to declare a operate in JavaScript is to make use of a operate declaration. A operate named multiply(), which takes two parameters x and y, multiplies them, and returns the worth will be applied with the next syntax:

operate multiply(x,y) {
  return x * y;

console.log( multiply(2, 2) );

Features outlined on this method (a operate declaration) are hoisted to the highest of the present scope. The console.log() could possibly be positioned earlier than the operate and it might nonetheless work.

2. JavaScript Operate Expressions

The identical operate will be written as an expression which explicitly units a variable:

const multiply = operate(x,y) {
  return x * y;

console.log( multiply(2, 2) );

The operate is not hoisted, so it might solely be used after it has been outlined.

3. Object Literal Technique Definitions

Features are handled the identical as some other worth sort in JavaScript, so you may outline one in one other object. For instance:

const mathLib = {

  PI: 3.14,

  multiply: operate(x, y) {
    return x * y;

  divide: operate(x, y) {
    return x / y;


console.log( mathLib.multiply(2, 2) );

Once more, this object methodology can solely be known as after it has been outlined.

4. ES2015 Arrow Features

Arrow capabilities don’t require the operate key phrase however can solely be assigned to a variable or used anonymously (resembling in a callback or occasion handler). Parameters enclosed in rounded brackets (( )) are adopted by an arrow (=>) to indicate a operate within the subsequent code block:

const multiply = (x, y) => { return x * y; };

console.log( multiply(2, 2) );

Since we solely have one assertion, the return is implicit and the brackets will be omitted for an identical performance with a shorter syntax:

const multiply = (x, y) => x * y;

In circumstances the place the operate has a single parameter, these brackets will also be eliminated:

const sq. = x => x ** 2;

Though brackets are nonetheless required for a single parameter:

const estimatePI = () => 22 / 7;

Arrow capabilities mechanically assign this to the worth within the rapid outer scope so there isn’t a want to make use of .bind(this).

5. jQuery Extension Features

jQuery is a JavaScript library, so creating capabilities is way the identical. Nonetheless, jQuery’s performance will be prolonged by including your individual customized strategies. The jQuery.fn.prolong() methodology extends the jQuery prototype ($.fn) object so new performance will be chained to the primary jQuery() operate.

For instance, the next code defines new verify and uncheck jQuery strategies to switch checkbox enter fields:


  verify: operate() {
    return this.every(operate() {
      this.checked = true;

  uncheck: operate() {
    return this.every(operate() {
      this.checked = false;


$( "enter[type="checkbox"]" ).verify();

Retaining it Useful

Operate syntax is usually a matter of private desire, however attempt to make sure your code stays readable. It could be higher to make use of a operate assertion than confuse your self in a number of weeks time with a intelligent however unreadable mishmash of arrows and brackets.

Click to comment

Leave a Reply

Your email address will not be published. Required fields are marked *