Top ES6+ Features to Adopt in SuiteScript 2.1

Written by Adolfo Garza | Jun 9, 2020 3:15:20 PM

SuiteScript version 2.1 is out of beta and beginning on the 2021.1 release, all SuiteScript 2.x scripts will be running as SuiteScript 2.1 by default, so you had better test your existing scripts for any bugs or declare them as v2.0 and wait until a later time to validate. To change your scripts to use SuiteScript v2.1 all you have to do is change this JSTag: From:

“@NApiVersion 2.x”

To:

“@NApiVersion 2.1”

It’s also worth mentioning that as of May 2020 SuiteScript 2.1 is not available for client scripts nor SuiteCloud Development Framework yet, so bear that in mind.

"let" keyword:

This is basically a super local variable, it’s very useful for using them in for loops. Now you can have multiple nested for loops and declare all of your loop counter variables “i” and not worry about conflicts.

Example

Using var:

var i = 5;
for (var i = 0; i < 10; i++) {
  // after last loop i equals 10
}
// Here i is 10

Using let:

let i = 5;
for (let i = 0; i < 10; i++) {
  // after last loop i equals 10
}
// Here i is 5

For details check out w3schools.

"for of" statement

This is another way to loop through an array, I find it easier to write although it only works on iterables so this means it doesn’t work on objects as opposed to “for in” which works on both objects and arrays.

Example

Considering:

var array = [1];

Using “for in”:

for (let index in array){
     let value = array[index];
     //value equals 1
}

Using “for of”:

for (let value of array){
     //value equals 1
}

This looks more elegant to me, but you be the judge. For details check out w3schools.

String includes() Method

If you are like me and hate the sight of using .search() or regex to check if a string includes some text then you need this in your life.

Example

Considering the following string:

var myString = "Hello world";

Using search method:

var includesWorld = myString.search("world") != -1; //true

Using includes method:

var includesWorld = myString.includes("world"); //true

Amazing! Makes the code more readable. For details check out w3schools.

Array includes() Method

This is the same thing as the previous example with String includes() method. I find it easier and more elegant than using Array indexOf.

Example

Considering the following string:

var myArray = ["banana", "apple", "pear", "watermelon"];

Using indexOf method:

var includesWatermelon = myArray.indexOf("watermelon") != -1; //true

Using includes method:

var includesWatermelon = myArray.includes("watermelon"); //true

For details check out w3schools.

Array every() Method

This method is useful for validating if all of the elements of the array meet certain condition, if one of them doesn't meet the condition then it returns false.

Example

var guestAges = [17,18,21,22,24];
var allAdults = guestAges.every( function (age){ return age >= 18; } );
//allAdults equals false because one of the guest ages is under 18

For details check out w3schools.

Set Object

The set object is a list of unique values of any type. This is very useful for removing duplicates from an Array.

Example

let myArray = [1,2,3,4,4,4,4,4,4,4,4,4,4,4,4,4,5];
let mySet = new Set(myArray); // mySet now equals {1, 2, 3, 4, 5}
let deDuplicatedArray = Array.from(mySet); //deDuplicatedArray now equals [1,2,3,4,5]

Here's another example

let animals = new Set();

animals.add('pig');
animals.add('bear');
animals.add('cat');
animals.add('dog');
console.log(animals.size); // 4
animals.add('bear'); // Adding a duplicate
console.log(animals.size); // Still 4!

It has several methods you can use like: add, size, has, forEach, delete and clear so it makes a powerful tool by itself. Sets also outperforms Arrays so that's another reason to love it. For details check out Alligator.io and Mozilla Docs.

Spread syntax

This is basically used to expand an array or compact several parameters into an array.

Examples

Useful for concatenating two arrays like:

let array1 = ["bear", "wolf"];
let array2 = ["moose", ...array1 ];
//array2 equals ["bear","wolf","moose"]

Or making copies of arrays like:

let array1 = [1, 2, 3];
let array1Copy = array1; //This is a shallow copy
let array1CopySpread = [...array1 ];

array1Copy.push(4); //Pushing to the shallow copy
//array1 equals [1,2,3,4]
//array1Copy equals [1,2,3,4]
//array1CopySpread equals [1,2,3] //The copy using spread remains unmodified

For details and more uses check out Scotch.io and Mozilla Docs.

Template literals (Template strings)

This is a life changer. You can now use backtick characters (`) to have more freedom when defining strings, they also support placeholders and multi-line strings!

Example

Using string concatenation:

var myNumber = 23;			
var myString = 'text line 1\n' +
			   'text line 2\n' + 
			   'text with "double quotes" and \'single quotes\'\n' +
			   'text with variable value of ' + myNumber;

Using template literals:

var myNumber = 23;			
var myString = 
`text line 1
text line 2
text with "double quotes" and 'single quotes'
text with variable value of ${myNumber}`;

The output is the same:

text line 1
text line 2
text with "double quotes" and 'single quotes'
text with variable value of 23

For details and more uses check out Mozilla Docs.

Arrow functions

These functions basically work the same as regular functions but have a more compact syntax.

Example

Regular function:

function hello() {
    return "Hello World!";
}

Arrow function:

hello = () => {
    return "Hello World!";
}

And it can get even shorter:

hello = () => "Hello World!";

Anonymous arrow function with params:

((name)=> `Hello ${name}!`)('stranger'); //"Hello stranger!"

For details and more uses check out w3schools.

Server-side promises

Promises are now supported server-side so you can now write asynchronous code.

Example

https.get.promise({
    url: 'https://jsonplaceholder.typicode.com/todos/1'
})
    .then(function(response){
        log.debug({
            title: 'Response',
            details: response
        });
    })
    .catch(function onRejected(reason) {
        log.debug({
            title: 'Invalid Get Request: ',
            details: reason
        });
    })

You can also create your own Promises now like so:

    let promise = new Promise((resolve) => {
        let response = https.get({url: 'https://jsonplaceholder.typicode.com/todos/1'});
        resolve(response.body);
    });
    
    promise.then(log.debug); //This calls log.debug and uses whatever data is returned as parameter

For details and more uses check out Mozilla Docs.

Async functions (Async/Await)

Async functions provide a way to structure and simplify your asynchronous code. I find this very useful to avoid callback hell that comes with Promises as it can get pretty complex, I have seen some code where there's an unending statements of .then.then.then..... in a row.

Example

async function asyncRequest(){ //<< Note the async keyword next to the function
    let promise = new Promise((resolve) => {
    let response = https.get({url: 'https://jsonplaceholder.typicode.com/todos/1'});
        resolve(response.body);
    });
    
    //promise.then(log.debug); //No longer using this
    let responseBody = await promise; //Using await instead
    log.debug('responseBody', responseBody); //Logs correctly
}

For details and more uses check out Mozilla Docs.

So what do you think? Do you agree with our list? Please share your comments below.

View full post