ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳು - ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿನ ವಿಧಾನಗಳು


ಕಾರ್ಯಗಳು (ಅಥವಾ ವಿಧಾನಗಳು) ಒದಗಿಸಿದ ಸೂಚನೆಗಳ ಪ್ರಕಾರ ಸ್ವತಂತ್ರವಾಗಿ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್‌ನ ಬ್ಲಾಕ್‌ಗಳಾಗಿವೆ. ಸಾಕಷ್ಟು ತಾಂತ್ರಿಕ. ಸಾಮಾನ್ಯ ವ್ಯಕ್ತಿಯ ಪದದಲ್ಲಿ, ಒಂದು ಕಾರ್ಯವನ್ನು ಕೆಲವು ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಳ್ಳುವ ಯಂತ್ರ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಒದಗಿಸಿದ ಸೂಚನೆಗಳ ಪ್ರಕಾರ ಅವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಮತ್ತು ಅಪೇಕ್ಷಿತ .ಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ. ಕಾರ್ಯವನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಕಾರ್ಯದ ಸಿಂಟ್ಯಾಕ್ಸ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ, ಒಂದು ಕಾರ್ಯವನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:

function function_name(parameter1, parameter2, parameter3) {
    statement1;
    statement2;
    statement3;
}

function sum(num1,num2){
	console.log(num1+num2);
}

function diff(num1){
	console.log(num1-10);
}

ಮರುಪರಿಶೀಲಿಸಲು ಅನುಮತಿಸುತ್ತದೆ
  • ಸ್ವತಂತ್ರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ
  • ಸೂಚನೆಯ ಪ್ರಕಾರ ನಿರ್ವಹಿಸುತ್ತದೆ
  • ಬಯಸಿದ .ಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ

ಮೇಲಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ, ಎರಡೂ ಕಾರ್ಯಗಳು ಸೂಚನೆಗಳ ಪ್ರಕಾರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆ.

ಮೊತ್ತ ಕಾರ್ಯವು 2 ಒಳಹರಿವುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (ನಾವು ಅವುಗಳನ್ನು ತಾಂತ್ರಿಕವಾಗಿ ಕರೆಯುವ ನಿಯತಾಂಕಗಳು) ಮತ್ತು ಅವುಗಳನ್ನು ಸೇರಿಸುವುದು.
ವ್ಯತ್ಯಾಸ ಕಾರ್ಯವು ಕೇವಲ 1 ನಿಯತಾಂಕವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದರಿಂದ 10 ಅನ್ನು ತಲಾಧಾರ ಮಾಡುತ್ತದೆ.

ಸರಿ, ನಿಮ್ಮ ಯಂತ್ರಗಳು (ಕಾರ್ಯಗಳು) ನಾವು ಸಿದ್ಧರಿದ್ದೇವೆ ಆದರೆ ಅವುಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ? ನೀವು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿದರೆ ನೀವು ಏನನ್ನೂ ನೋಡುವುದಿಲ್ಲ. ಇದರರ್ಥ ಕಾರ್ಯವು ಕೆಲಸ ಮಾಡಲು ಸಿದ್ಧವಾಗಿದೆ. ಒಳಹರಿವುಗಳನ್ನು ಸೇರಿಸಲು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಪಡೆಯಲು ಸಮಯ.

ಕಾರ್ಯ ಕರೆ

ಯಂತ್ರವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅಥವಾ 'ಕಾರ್ಯವನ್ನು ಕರೆಯಲು' (ತಾಂತ್ರಿಕ ಪದ) ನಾವು ಕಾರ್ಯದ ಹೆಸರನ್ನು ಸರಳವಾಗಿ ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ನಾವು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ನಮೂದಿಸುತ್ತೇವೆ.

sum(5,9);

diff(43);

Output ಟ್ಪುಟ್ ಹಿಂದಿರುಗಿಸುವ ಬಗ್ಗೆ ನಾವು ಮಾತನಾಡಿದ್ದೀರಾ? ಹೌದು, ಆದರೆ ನಾವು ಅದನ್ನು ಇನ್ನೂ ಮಾಡಿಲ್ಲ. Output ಟ್ಪುಟ್ ಅನ್ನು ಹಿಂಪಡೆಯಲು ಮತ್ತು ಅವುಗಳನ್ನು ಕೆಲವು ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಕೆಲಸ ಮಾಡೋಣ. ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದನ್ನು ಸುಲಭಗೊಳಿಸಲು, ನಾವು ಹಿಂದಿನ ಉದಾಹರಣೆಗಳನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತೇವೆ.
function sum(num1,num2){
	return (num1+num2);
}

function diff(num1){
	return (num1-10);
}

ಫಕ್ಶನ್ ಬದಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಬದಲು, ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಸ್ಥಳದಿಂದ ನಾವು return ಟ್ಪುಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿದ್ದೇವೆ. ಈಗ, ನಾವು ಈ output ಟ್ಪುಟ್ ಅನ್ನು ಹೊಸ ವೇರಿಯಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕಾಗಿದೆ.
var total = sum(5,9);
console.log(total);		//or
console.log(sum(5,9));

var total = diff(43);
console.log(total);		//or
console.log(diff(43));

ನಾವು ಕಾರ್ಯಗಳನ್ನು ಏಕೆ ಬಳಸುತ್ತೇವೆ?

ಮರುಬಳಕೆ. ಒಂದು ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ ಅದನ್ನು ವಿಭಿನ್ನ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಅನೇಕ ಬಾರಿ ಕರೆಯಬಹುದು. ಇದು ನಿಮ್ಮ ಸಮಯವನ್ನು ಉಳಿಸುತ್ತದೆ, ಮತ್ತು ಹಲವಾರು ಸಾಲುಗಳನ್ನು ಉಳಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ನೀವು ಮತ್ತೆ ಮತ್ತೆ ಸ್ಯಾಮ್ ಕಾರ್ಯವನ್ನು ಬಳಸಬಹುದು.

ಸೂಚನೆ - ನಾವು DOM ಅನ್ನು ಅಧ್ಯಯನ ಮಾಡುವಾಗ ನಾವು ಹಲವಾರು ಕಾರ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ.