JavaScript Functions తెలుగులో | function, parameters, return

• Function అంటే ఏమిటి, ఎందుకు కావాలి?
• Function ని declare చేయడం మరియు call చేయడం
• Parameters మరియు arguments మధ్య ఉన్న తేడా
• return తో విలువను తిరిగి ఇవ్వడం & return తో function ఆగిపోవడం
• Default parameters (డిఫాల్ట్ విలువలు)
• Function expression మరియు Hoisting (ముందే వాడగలమా?)
• Function లోపలి variables (Scope కి చిన్న పరిచయం)
• Beginners చేసే 6 సాధారణ తప్పులు (Real Node.js error outputs తో)
• సమగ్ర ప్రాక్టీస్ ప్రశ్నలు & సమాధానాలు
• 🧠 ఇంటరాక్టివ్ క్విజ్ (Interactive Telugu Quiz)

ఒకే message ని చాలా చోట్ల print చేయాలనుకోండి. Function లేకపోతే ప్రతిచోటా అదే code రాయాలి. Function తో:

function greet() {
  console.log("నమస్కారం!");
}

greet();
greet();

Code పరిశీలన: ఒక్కసారి రాశాం, రెండుసార్లు వాడాం. రేపు message మార్చాలంటే ఒక్క చోట మార్చితే చాలు, అన్ని చోట్లా మారిపోతుంది. ఇదే function శక్తి!

Function syntax చాలా సూటిగా ఉంటుంది:

function functionName(parameters) {
  // function body: చేయాల్సిన పని
}

Function వాడకంలో రెండు ప్రధాన దశలు ఉంటాయి:

1. 1. Declare (నిర్వచించడం): Function ని తయారు చేయడం. ఇది చాయ్ తయారీ విధానాన్ని పుస్తకంలో రాసి పెట్టడం లాంటిది. ఈ దశలో లోపల ఉన్న code అసలు run అవ్వదు.
2. 2. Call (పిలవడం / Invoke): Function పేరు తర్వాత () రాసి పిలిస్తే, అప్పుడు మాత్రమే అందులోని code run అవుతుంది.

Function పేర్లు ఎలా పెట్టాలి?

Variables కి వర్తించే నియమాలే functions కి కూడా వర్తిస్తాయి (Chapter 3). అదనంగా:

• camelCase వాడండి: calculateTotal, isEven.
• Function ఒక పని చేస్తుంది కాబట్టి, పేరు సాధారణంగా క్రియ (verb) తో మొదలవ్వాలి: greet, getPrice, calculateTax.
• true లేదా false ఇచ్చే functions కి is లేదా has తో మొదలుపెట్టడం మంచి సంప్రదాయం: isEven, hasTicket.

Function ప్రతిసారీ ఒకే పని చేస్తే ప్రయోజనం తక్కువ. చాయ్ లో "ఎన్ని కప్పులు?" అని మార్చినట్లు, function కి విలువలు పంపించి, వాటిని బట్టి వేర్వేరు ఫలితాలు రాబట్టొచ్చు.

function greetUser(name) {
  console.log(`నమస్కారం ${name}!`);
}

greetUser("రవి");
greetUser("సీత");

Parameters vs Arguments

ఈ రెండు పదాలు విద్యార్థులను తరచూ గందరగోళానికి గురిచేస్తాయి. తేడా చాలా సులభం:

greetUser("రవి") అన్నప్పుడు, "రవి" అనే argument, name అనే parameter డబ్బాలో కూర్చుంటుంది. Function లోపల name ని మామూలు variable లాగా వాడొచ్చు.

ఇప్పటివరకు functions కేవలం screen మీద print చేశాయి. కానీ చాలాసార్లు function ఒక ఫలితాన్ని తిరిగి ఇవ్వాలి, దాన్ని మనం వేరే చోట వాడుకోవడానికి. దానికి return వాడతాం. చాయ్ విధానం చివర తయారైన చాయ్ ని మన చేతికి ఇవ్వడం లాంటిది.

function add(a, b) {
  return a + b;
}

const sum = add(10, 20);
console.log(sum);
console.log(add(5, 7));

Code అర్థం చేసుకుందాం:

1. add(a, b) కి రెండు parameters ఉన్నాయి. కామాతో వేరు చేసి ఎన్నైనా రాయొచ్చు.
2. return a + b; అంటే "a + b విలువను తిరిగి ఇవ్వు".
3. add(10, 20) అని call చేస్తే, ఆ expression స్థానంలో 30 వచ్చి కూర్చుంటుంది. అందుకే const sum = add(10, 20) అంటే const sum = 30.
4. తిరిగి వచ్చిన విలువను variable లో దాచొచ్చు (sum), నేరుగా print చేయొచ్చు (console.log(add(5, 7))), లేదా మరో లెక్కలో వాడొచ్చు.

return తో function ఆగిపోతుంది

return కనిపించగానే function అక్కడితో ముగుస్తుంది. దాని కింద ఉన్న code ఏదీ run అవ్వదు.

function test() {
  console.log("A");
  return;
  console.log("B");
}

test();

"B" రాలేదు, ఎందుకంటే return తర్వాత ఉన్న code ఎప్పటికీ run అవ్వదు (దీనినే Unreachable Code అంటారు).

ఈ లక్షణాన్ని if తో కలిపి వాడటం (Early Return Pattern):

function check(n) {
  if (n > 0) {
    return "positive";
  }
  return "not positive";
}

console.log(check(5));
console.log(check(-2));

n = 5 అయితే మొదటి return తో function ముగుస్తుంది, రెండో return వరకు రాదు. else రాయాల్సిన అవసరం కూడా లేకుండా పోయింది!

Return లేని function

return రాయని function ఫలితంగా undefined ఇస్తుంది.

function sayHi() {
  console.log("Hi");
}

const r = sayHi();
console.log(r);

sayHi() screen మీద "Hi" print చేసింది (అది దాని పని), కానీ తిరిగి ఇవ్వడానికి ఏమీ లేదు, అందుకే r లో undefined ఉంది.

ఉదాహరణ 1: సరి సంఖ్యా కాదా? (isEven)

function isEven(n) {
  return n % 2 === 0;
}

console.log(isEven(10));
console.log(isEven(7));

n % 2 === 0 అనేది ఇప్పటికే true లేదా false ఇస్తుంది. దాన్ని నేరుగా return చేసేశాం!

ఉదాహరణ 2: GST తో కలిపిన మొత్తం (calculateTotal)

function calculateTotal(price, gstPercent) {
  const gst = price * gstPercent / 100;
  return price + gst;
}

console.log(calculateTotal(1000, 18));

₹1000 కి 18% GST = ₹180. కలిపి ₹1180. వేరే ధర, వేరే GST తో ఎన్ని సార్లైనా ఇదే function ని వాడొచ్చు.

ఉదాహరణ 3: ఒక function నుంచి ఇంకో function ని పిలవడం (Modularity)

function square(n) {
  return n * n;
}

function sumOfSquares(a, b) {
  return square(a) + square(b);
}

console.log(sumOfSquares(3, 4));

square(3) = 9, square(4) = 16, కలిపి 25. పెద్ద పనిని చిన్న చిన్న functions గా విడగొట్టడం ఒక గొప్ప సాఫ్ట్‌వేర్ ఇంజనీరింగ్ అలవాటు. ప్రతి function ఒక్క పనిని మాత్రమే పరిపూర్ణంగా చేయాలి!

Argument ఇవ్వకపోతే ఒక డిఫాల్ట్ విలువ వాడాలనుకుంటే, parameter పక్కన = తో రాస్తాం:

function greet(name = "అతిథి") {
  console.log(`నమస్కారం ${name}!`);
}

greet();
greet("రవి");

greet() లో argument ఇవ్వలేదు కాబట్టి name లో డిఫాల్ట్ విలువ అయిన "అతిథి" వచ్చింది. greet("రవి") లో ఇచ్చిన విలువను ప్రాధాన్యతతో వాడింది.

ఇప్పటివరకు మనం రాసినది function declaration (function పేరు() {}). ఇంకో పద్ధతి function expression: function ని ఒక variable లో దాచడం.

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

console.log(multiply(4, 5));

ఇక్కడ function కి పేరు లేదు (Anonymous Function). అది multiply అనే variable లో కూర్చుంది, ఆ variable పేరుతోనే call చేస్తున్నాం. చివరలో ; ఉందని గమనించండి (ఎందుకంటే ఇది ఒక variable assignment). Chapter 13 లో దీనికే చిన్న ఆధునిక రూపమైన Arrow Functions నేర్చుకుంటాం.

Hoisting: ముందే వాడగలిగేది

Function declaration ని, దాన్ని రాసిన చోటుకి ముందే call చేయొచ్చు. JavaScript code ని run చేసే ముందు declarations ని పైకి "ఎత్తి" పెడుతుంది. దీన్నే hoisting అంటారు.

console.log(square(4));

function square(n) {
  return n * n;
}

కానీ function expression తో ఇది పని చేయదు:

console.log(cube(3));

const cube = function (n) {
  return n ** 3;
};

కాబట్టి function expression ని ఎప్పుడూ వాడటానికి ముందే రాయండి. Hoisting గురించి Chapter 24 లో మరింత వివరంగా నేర్చుకుందాం.

Function లోపల declare చేసిన variables, ఆ function లోపల మాత్రమే కనిపిస్తాయి. బయట వాడలేం.

function f() {
  const secret = 10;
}

f();
console.log(secret);

ఇది ఒక ఇంటి లోపల ఉన్న వస్తువులు ఇంటి బయట రోడ్డు మీద నుంచి కనిపించనట్లు. దీన్నే scope అంటారు. Chapter 24 లో వివరంగా తెలుసుకుందాం. ఇప్పటికి "function లోపలి variable బయటకు కనిపించదు" అని గుర్తుంచుకోండి. కావాల్సిన విలువను return తో బయటకు పంపండి.

1. వృత్తం వ్యాసార్థం (radius) ఇస్తే దాని వైశాల్యం ఇచ్చే function రాయండి. (వైశాల్యం = π × r × r. Math.PI వాడండి.) radius 5 తో call చేయండి.
2. రెండు సంఖ్యల్లో పెద్దదాన్ని return చేసే maxOfTwo function రాయండి. (15, 42 తో test చేయండి)
3. ఒక సంఖ్య palindrome అవునా కాదా (ముందునుంచి, వెనుకనుంచి ఒకేలా ఉండే సంఖ్య, ఉదా: 121) చెప్పే function రాయండి. 121 మరియు 123 తో test చేయండి.
4. మార్కులు ఇస్తే "Pass" (35 లేదా ఎక్కువ) లేదా "Fail" return చేసే function రాయండి. (72, 20 తో test చేయండి)
5. Celsius ని Fahrenheit గా మార్చే function రాయండి. (F = C × 9 / 5 + 32) 100 మరియు 0 తో test చేయండి.

function circleArea(radius) {
  return Math.PI * radius * radius;
}
console.log(circleArea(5));

function maxOfTwo(a, b) {
  if (a > b) {
    return a;
  }
  return b;
}
console.log(maxOfTwo(15, 42));

function isPalindrome(num) {
  let original = num;
  let reversed = 0;
  while (num > 0) {
    const last = num % 10;
    reversed = reversed * 10 + last;
    num = (num - last) / 10;
  }
  return original === reversed;
}
console.log(isPalindrome(121));
console.log(isPalindrome(123));

function result(marks) {
  if (marks >= 35) {
    return "Pass";
  }
  return "Fail";
}
console.log(result(72));
console.log(result(20));

function toFahrenheit(c) {
  return c * 9 / 5 + 32;
}
console.log(toFahrenheit(100));
console.log(toFahrenheit(0));