For learning Google Apps script to automate your tasks, we have to know about its syntax because it uses the JavaScript and functions or its return types In Google Apps Script, functions can have various return types depending on what they are designed to do.

List of common return types used in Apps Script:

AS we know coding become though if you don’t know about its basics know to write functions to automate your tasks you have to know about the different types of functions and its return type here are some return types of Apps script first is Primitive Data Types and Non–Primitive Data Types.

Primitive Data Types:

Primitive data types represent single values and are cannot be changed. They are stored directly in memory and are accessed by value. that will make your work easy. The main primitive data types in JavaScript include:

• Boolean
• Number
• String
• Undefined
• Null

Non-Primitive Data Types:

Non-primitive data types are more complex and can hold multiple values or references to other data types. They are stored indirectly in memory and are accessed by reference.

• Object
• Array
• Function
• Date
• Regular Expression

Boolean:

Returns true or false based on a condition. you have to create a function that will check that if the given condition is true or false then it will give you answer. Mostly they are used as “checkbox” . The above function check that the given parameter is even or odd for example you add 5 in the given code then it will return “False“.

function isEven(number) {
  return number % 2 === 0;
}
// check that given number is even or odd it will return True or False.

Number:

you can use integer data that will returns a numeric value that are easily access and immutable and help in calculation. below you will see the code that will return numeric that you just have to know how to pass parameters. The given code show you simple multiplication of two parameters.

function multiply(a, b) {
  return a * b;
}

String: Returns a textual value

function greet(name) {
  return "Hello, " + name + "!";
}

Array:

Arrays are continues memory locations to store the data you can store a series of numbers string or any kind of data that will Returns an array of values. Array will help you to return a block of memory data, the following code will reserve consecutive memory locations.

function getNumbers() {
  return [1, 2, 3, 4, 5];
}

Object:

you can hide data by creating object in the script that will Returns an object containing key-value pairs.

function createPerson(name, age) {
  return {
    name: name,
    age: age
  };
}

Null: Returns a null value

function noReturnValue() {
  // No return value specified
}

Undefined:

Returns an undefined value (typically used when a function doesn’t explicitly return anything). A example code is given below that might help you to understand the return type.

function doSomething() {
  // Code without a return statement
}

Custom Object:

You can define custom types by creating classes or constructor functions, returning instances of these custom types.

function createPerson(name, age) {
  return new Person(name, age);
}

function Person(name, age) {
  this.name = name;
  this.age = age;
}

To demonstrate the practical use of the return types in Google Apps Script that I mentioned earlier, let’s create a script that uses these return types in simple functions. We’ll then test these functions to ensure they work correctly. The give code will tell you about the above code functionality that will help you to check whether the code is correct or not. you just add the some data instead of the give parameters.

function testFunctions() {
  console.log("Testing isEven(5):", isEven(5)); 
  console.log("Testing multiply(3, 4):", multiply(3, 4)); 
  console.log("Testing greet('John'):", greet('John')); 
  
  console.log("Testing getNumbers():", getNumbers()); 

  var person = createPerson("Alice", 30);
  console.log("Testing createPerson('Alice', 30):", person); 
  console.log("Testing noReturnValue():", noReturnValue()); 
}
testFunctions();

Execution log

After writing the code in Google Apps Script you have to save the code then from the ribbon chose funtion name you want to return. click on Run that will show you the Execution’s log that will tell you about what above code testFunctions() will returns. This will help you to find is the given code is returning correct values , it also show the error list.