Reusable JavaScript Functions with Parameters and Return Values

Namaste! Pichhli lesson mein aapne JavaScript objects use karke analysis settings ko readable named properties mein organize kiya tha—jaise cloudThreshold, startDate, aur bands. Ab hum un settings aur repeated processing logic ko reusable banane ki taraf badhenge.

Is lesson mein aap JavaScript function likhna, usko call karna, parameters ke through inputs dena, aur return se computed output wapas lena seekhenge. GEE mein yahi pattern baar-baar use hota hai: NDVI calculation, cloud masking, index bands add karna, area statistics banana, aur ek hi processing rule ko many images par apply karna.

---

Function: repeated GIS logic ko ek reusable unit banana

Manual GIS workflow mein sochiye: agar aapko 20 scenes ke liye same NDVI formula apply karna ho, to har scene ke liye formula manually repeat karna inefficient hoga. Agar formula update karna pade, har jagah correction karni padegi.

Programming mein function ek named, reusable block hota hai jo ek specific task karta hai. Aap function ko ek baar define karte hain, phir different input values ke saath repeatedly use karte hain.

Ek simple JavaScript function ka pattern:

function functionName(parameter1, parameter2) {
  // Work happens here.
  return outputValue;
}

Is syntax ke important parts:

Part	Meaning
function	JavaScript keyword jo function define karta hai
functionName	Aapka chosen meaningful name
(parameter1, parameter2)	Inputs ke placeholder names
{ ... }	Function body: actual instructions
return	Computed result caller ko wapas bhejta hai

Function ko define karna aur execute karna do separate baatein hain. Sirf definition likhne se calculation run nahin hoti. Function ko call karna hota hai:

function greet() {
  return 'Welcome to Google Earth Engine';
}

print(greet());

Yahan:

• greet function ka naam hai.
• greet() function call hai.
• return string ko function ke bahar bhejta hai.
• print() us returned value ko Console mein display karta hai.

Parentheses bahut important hain:

print(greet);   // Function itself ka reference.
print(greet()); // Function run hota hai aur result milta hai.

---

Parameters aur arguments: function ko flexible banana

Ek fixed greeting function reusable to hai, lekin har input ke liye useful nahin. Real analysis mein humein function ko different values deni hoti hain—different band names, thresholds, dates, images, ya field attributes.

Isliye functions parameters accept karte hain.

function addNumbers(number1, number2) {
  return number1 + number2;
}

Yahan number1 aur number2 parameters hain. Ye temporary, local placeholder names hain.

Jab hum function call karte hain:

const total = addNumbers(12, 8);

print('Total:', total);

to 12 aur 8 ko arguments kehte hain.

Technical distinction yaad rakhiye:

• Parameters function definition mein placeholders hote hain: number1, number2
• Arguments function call ke time diye gaye actual values hote hain: 12, 8

Function call ke during first argument first parameter mein, second argument second parameter mein aata hai. Isliye order matter karta hai.

function subtractValues(firstValue, secondValue) {
  return firstValue - secondValue;
}

print(subtractValues(10, 3)); // 7
print(subtractValues(3, 10)); // -7

Addition mein order ka output par effect nahin hota, lekin subtraction, division, band order, date order, aur coordinates mein hota hai. Isi liye meaningful parameter names professional GEE scripts mein important hote hain.

---

return: output ko function se bahar bhejna

print() aur return ka role alag hai:

• print() Console mein inspection ke liye value dikhata hai.
• return function ka usable output caller ko deta hai.

Yeh distinction early stage par clear rakhna bahut important hai.

function calculateAverage(value1, value2) {
  const average = (value1 + value2) / 2;
  return average;
}

const fieldAverage = calculateAverage(0.42, 0.58);

print('Field average:', fieldAverage);

calculateAverage(0.42, 0.58) ka evaluated result 0.5 hai. Woh result fieldAverage mein stored hota hai; phir usse further calculations ya printing mein use kiya ja sakta hai.

Ab yeh incomplete function dekhiye:

function calculateAverage(value1, value2) {
  const average = (value1 + value2) / 2;
  print('Average:', average);
}

const fieldAverage = calculateAverage(0.42, 0.58);
print('Stored value:', fieldAverage);

Console pe Average: 0.5 dikh sakta hai, lekin fieldAverage ki value undefined hogi. Reason: function ne value print ki, lekin return nahin ki.

Correct version:

function calculateAverage(value1, value2) {
  const average = (value1 + value2) / 2;
  return average;
}

Ek aur practical rule: return execute hote hi function finish ho jata hai. Isliye calculation aur useful debugging print statements ko return ke pehle rakhiye.

function calculateSum(value1, value2) {
  const sum = value1 + value2;
  return sum;

  // This line will never run.
  // print('Finished');
}

---

Reading: Google ki Earth Engine-oriented explanation

Google ke older examples mein aapko aksar yeh form milega:

var getNDVI = function(image) {
  return image.normalizedDifference(['B4', 'B3']);
};

Iska meaning same function concept hi hai. Yeh function ko variable getNDVI mein store karta hai. Current lessons mein hum mostly readable function declaration syntax use karenge:

function getNdvi(image) {
  return image.normalizedDifference(['B4', 'B3']);
}

Dono styles existing GEE scripts mein milenge. Abhi most important point syntax choice nahin, balki yeh hai: function meaningful input leta hai aur consistent output return karta hai.

---

GIS-relevant example: reusable NDVI calculation

Aap NDVI formula se already familiar hain:

$$NDVI=\frac{NIR-Red}{NIR+Red}$$

Ab same formula ko normal JavaScript numbers ke liye function mein wrap karte hain:

function calculateNdvi(nir, red) {
  const numerator = nir - red;
  const denominator = nir + red;

  return numerator / denominator;
}

const wheatFieldNdvi = calculateNdvi(0.62, 0.18);
const sparseVegetationNdvi = calculateNdvi(0.31, 0.25);

print('Wheat field NDVI:', wheatFieldNdvi);
print('Sparse vegetation NDVI:', sparseVegetationNdvi);

Pehle call mein:

• nir receives 0.62
• red receives 0.18
• function formula calculate karta hai
• returned NDVI approximately 0.55 hai

Doosre call mein same formula unchanged hai, inputs different hain. Is reusability ka main benefit yahi hai.

Parameter names ko nir aur red rakhna value1 aur value2 se better hai, because code formula ki meaning communicate karta hai. GEE scripts mein clean function names aur parameter names debugging aur future reuse ko kaafi easy banate hain.

Function ke parameters local hote hain. nir aur red sirf function body ke andar available hain:

function calculateNdvi(nir, red) {
  return (nir - red) / (nir + red);
}

// print(nir); // Error: nir is not defined.

Aap later function ke bahar same name ka variable bana sakte hain, but currently simplest rule follow kijiye: function input ko function ke andar use kijiye aur required output return kijiye.

---

Video: parameters, arguments, aur return ko visually consolidate kijiye

---

Guided GEE Code Editor practice

Apni current script ki copy save kijiye:

06_functions_parameters_return

Phir yeh code paste karke Run kijiye:

// A reusable function for normal JavaScript numbers.
function calculateNdvi(nir, red) {
  const numerator = nir - red;
  const denominator = nir + red;

  return numerator / denominator;
}

// Same function, different field reflectance values.
const wheatNdvi = calculateNdvi(0.62, 0.18);
const fallowFieldNdvi = calculateNdvi(0.28, 0.24);

print('Wheat NDVI:', wheatNdvi);
print('Fallow field NDVI:', fallowFieldNdvi);

// A reusable function that returns a text label.
function createAnalysisLabel(regionName, startDate, endDate) {
  return regionName + ' | ' + startDate + ' to ' + endDate;
}

const label = createAnalysisLabel(
  'Nashik District',
  '2023-06-01',
  '2023-10-31'
);

print('Analysis label:', label);

Console mein verify kijiye:

• Wheat NDVI approximately 0.55 hoga.
• Fallow field NDVI low positive value hoga.
• label ek single combined string ke form mein return hoga.
• calculateNdvi aur createAnalysisLabel ko define karne se khud output nahin aata; calls aur print() output ko visible banate hain.

Ab ise thoda personalize kijiye:

1. Nashik District ko apne familiar study area ke naam se replace kijiye.
2. calculateNdvi() mein apne kisi known field ya pixel reflectance example ke NIR aur Red values use kijiye.
3. Ek third field result banaiye:

const forestNdvi = calculateNdvi(0.70, 0.12);
print('Forest NDVI:', forestNdvi);

4. Intentional error observation ke liye temporarily second argument hataiye:

print(calculateNdvi(0.62));

Aapko meaningful NDVI result nahin milega because red ko koi value nahin mili. Dono required arguments pass karne ke baad correct call restore kar dijiye.

---

Aaj ka pattern future GEE functions mein kaise dikhega

Abhi aapne JavaScript numbers par NDVI formula use kiya. Actual GEE workflow mein parameter ek Earth Engine image hoga, aur output bhi Earth Engine image hoga:

function makeNdvi(image) {
  return image
    .normalizedDifference(['B8', 'B4'])
    .rename('NDVI');
}

Is function mein:

• image parameter ek input satellite image represent karega.
• normalizedDifference() NDVI calculate karega.
• rename('NDVI') output band ko readable name dega.
• return processed image ko wapas karega.

Abhi is code ko memorise karna goal nahin hai. Important conceptual bridge yeh hai: aaj ka calculateNdvi(nir, red) aur future ka makeNdvi(image) dono same JavaScript function logic follow karte hain. Difference sirf input-output data type ka hai. Module 2 mein aap Earth Engine objects aur server-side processing samjhenge; Module 3 mein isi type ke image functions ko real satellite collections ke saath use karenge.

---

Key takeaways

Aaj aapne reusable functions ka basic working model seekha:

function calculateNdvi(nir, red) {
  return (nir - red) / (nir + red);
}

• Function repeated logic ko ek meaningful name ke andar organize karta hai.
• Function definition khud run nahin hoti; parentheses ke saath call karna hota hai.
• Parameters definition ke placeholders hain.
• Arguments call ke time passed actual values hain.
• Argument order parameter order ke according matter karta hai.
• return computed value ko function ke bahar usable output banata hai.
• print() inspection ke liye hai; woh value return nahin karta.
• Meaningful names—such as calculateNdvi, nir, aur red—future GEE scripts ko readable aur maintainable banate hain.

Next lesson mein hum if, else if, aur else ke through conditional logic likhenge. Usse aap functions ko smarter bana paayenge—for example, cloud threshold ke according processing choice lena, ya NDVI range ke basis par condition class select karna.