విధులు మరియు వేరియబుల్స్

పరిచయం

Wave ప్రోగ్రామింగ్ భాష యొక్క ప్రధాన రూపకల్పన తత్వశాస్త్రం తక్కువ-స్థాయి పనితీరు మరియు ఉన్నత-స్థాయి సంగ్రహణ మధ్య సమతుల్యతను కొనసాగిస్తూ సమర్థవంతమైన మరియు సౌకర్యవంతమైన సాఫ్ట్‌వేర్ అభివృద్ధి వాతావరణాన్ని అందించడం. ఈ విభాగం Wave ప్రోగ్రామ్‌ను రూపొందించే అత్యంత ప్రాథమిక అంశాలను పరిచయం చేస్తుంది: విధులు మరియు వేరియబుల్స్.

ఫంక్షన్లు అనేది ప్రోగ్రామ్ యొక్క ఆపరేషన్ మరియు లాజిక్‌ను రూపొందించే కోర్ యూనిట్లు మరియు ప్రక్రియలో అవసరమైన డేటాను నిల్వ చేయడం మరియు నిర్వహించడంలో వేరియబుల్స్ పాత్ర పోషిస్తాయి. ఫంక్షన్‌లు మరియు వేరియబుల్‌లను ఎలా నిర్వచించాలో మరియు ఉపయోగించాలో సరిగ్గా అర్థం చేసుకోవడం ద్వారా, మీరు Wave భాష యొక్క నిర్మాణం మరియు డిజైన్ ఉద్దేశాన్ని మరింత లోతుగా ఉపయోగించుకోవచ్చు.

---

ఫంక్షన్

Waveలో, ఫంక్షన్‌లు స్వతంత్రంగా అమలు చేయగల కోడ్ యొక్క పునర్వినియోగ బ్లాక్‌లు. నిర్దిష్ట చర్యలు లేదా గణనలు ఒకే యూనిట్‌గా వ్యక్తీకరించబడతాయి మరియు ప్రోగ్రామ్ అంతటా అవసరమైనప్పుడు కాల్ చేయవచ్చు.

ఫంక్షన్‌లను ఉపయోగించడం వల్ల పునరావృత కోడ్‌ను తగ్గించవచ్చు మరియు రీడబిలిటీ మరియు మెయింటెనబిలిటీని మెరుగుపరచడానికి తార్కికంగా వేరు చేయవచ్చు. ఇది గణన ప్రాసెసింగ్, ఇన్‌పుట్/అవుట్‌పుట్ మేనేజ్‌మెంట్ మరియు లాజిక్ సెపరేషన్ వంటి వివిధ ప్రయోజనాల కోసం కూడా ఉపయోగించబడుతుంది.

Waveలో, ఒక ఫంక్షన్ కీవర్డ్‌తో నిర్వచించబడింది

ఒక విధిని నిర్వచించండి

Waveలో అత్యంత ప్రాథమిక విధి నిర్వచన రూపం క్రింది విధంగా ఉంది.

fun main() {
    // మీ కోడ్‌ను ఇక్కడ వ్రాయండి
}

main ఫంక్షన్ అనేది ప్రోగ్రామ్ యొక్క ఎగ్జిక్యూషన్ ఎంట్రీ పాయింట్ మరియు Wave ప్రోగ్రామ్‌లో main ఫంక్షన్ తప్పనిసరిగా ఉండాలి. ఈ ఫంక్షన్ నుండి ప్రోగ్రామ్ అమలు ప్రారంభమవుతుంది.

విధులు అవసరమైన విధంగా పారామితులను తీసుకోగలవు మరియు కాలర్‌కు గణన ఫలితాలు లేదా విలువలను కూడా అందించగలవు. రిటర్న్ విలువ ఉంటే, రిటర్న్ రకం ఫంక్షన్ డిక్లరేషన్‌లో పేర్కొనబడుతుంది.

ఉదాహరణ: సాధారణ ఫంక్షన్

కింది ఉదాహరణ రెండు పూర్ణాంకాలను తీసుకొని వాటి మొత్తాన్ని తిరిగి ఇచ్చే సాధారణ ఫంక్షన్.

fun add(a :i32, b :i32) -> i32 {
    return a + b;
}

fun main() {
    var result = add(5, 7);     // ఫంక్షన్ కాల్ జోడించండి
    println(result);            // అవుట్‌పుట్: 12
}

ఈ ఉదాహరణలో, add ఫంక్షన్ రెండు పూర్ణాంకాల పారామితులను తీసుకుంటుంది, a మరియు b, వాటిని జోడించి, ఫలితాన్ని అందిస్తుంది. main ఫంక్షన్ add ఫంక్షన్‌ని పిలుస్తుంది, తిరిగి వచ్చిన విలువను వేరియబుల్‌లో నిల్వ చేస్తుంది మరియు దాన్ని అవుట్‌పుట్ చేస్తుంది.

ఈ విధంగా, ఫంక్షన్‌లు నిర్దిష్ట చర్యలను కలుపుతాయి మరియు వాటిని ప్రోగ్రామ్‌లోని బహుళ భాగాలలో మళ్లీ ఉపయోగించేందుకు అనుమతిస్తాయి.

వేరియబుల్

ప్రోగ్రామ్‌లో డేటాను నిల్వ చేయడానికి మరియు మార్చడానికి వేరియబుల్స్ ఉపయోగించబడతాయి. Wave అనేది వేరియబుల్స్ డిక్లేర్ చేసేటప్పుడు వేరియబుల్ మరియు ఇమ్యుటబుల్ వేరియబుల్స్ మధ్య తేడాను స్పష్టంగా గుర్తించడానికి రూపొందించబడింది, తద్వారా డేటాను మార్చాలనే ఉద్దేశ్యం కోడ్ స్థాయిలో బహిర్గతమవుతుంది.

ఇది ప్రోగ్రామ్ స్థితి మార్పులను మరింత స్పష్టంగా చేస్తుంది మరియు అనుకోకుండా విలువ మార్పుల వల్ల ఏర్పడే లోపాలను తగ్గిస్తుంది.

మార్చగల వేరియబుల్

Waveలో, వేరియబుల్స్ డిఫాల్ట్‌గా మార్చబడతాయి. దీనర్థం ఒకసారి ప్రకటించిన తర్వాత కూడా, ప్రోగ్రామ్ అమలు సమయంలో దాని విలువను మార్చవచ్చు.

మార్చగల వేరియబుల్స్ var కీవర్డ్ ఉపయోగించి ప్రకటించబడతాయి.

var x :i32 = 10;
x = 20;

ఎగువ కోడ్‌లో, x 10 యొక్క ప్రారంభ విలువను కలిగి ఉంది మరియు తర్వాత 20కి మార్చవచ్చు. స్థితి మారవలసిన డేటా కోసం వేరియబుల్ వేరియబుల్స్ ఉపయోగించబడతాయి.

మార్పులేని వేరియబుల్

మీరు ఒక వేరియబుల్‌ను మార్పులేనిదిగా ప్రకటించినప్పుడు, దాని ప్రారంభ విలువను కేటాయించిన తర్వాత దాని విలువ మార్చబడదు. మార్పులేని వేరియబుల్స్ లెట్ కీవర్డ్ ఉపయోగించి ప్రకటించబడతాయి.

let y :i32 = 5;
// y = 10;   // లోపం: మార్పులేని వేరియబుల్స్ వాటి విలువను మార్చలేవు.

మార్పులేని వేరియబుల్స్ ప్రోగ్రామ్‌ల స్థిరత్వం మరియు అంచనాను పెంచడంలో సహాయపడతాయి ఎందుకంటే వాటి విలువలు మారవని హామీ ఇస్తాయి. స్థిరమైన డేటా కోసం మార్పులేని వేరియబుల్‌లను ఉపయోగించమని సిఫార్సు చేయబడింది, దీని విలువ మారవలసిన అవసరం లేదు.

Waveలో, మీరు let కీవర్డ్‌తో mutని ఉపయోగించడం ద్వారా మ్యుటబిలిటీని స్పష్టంగా అనుమతించవచ్చు.

let mut y :i32 = 5;
y = 10;

వేరియబుల్ let గా ప్రకటించబడింది, అయితే దాని విలువ mut కీవర్డ్ ద్వారా మార్చబడుతుంది.

వేరియబుల్ డిక్లరేషన్ ఉదాహరణ

వివిధ రకాలైన మార్చదగిన మరియు మార్పులేని వేరియబుల్‌లను ప్రకటించడానికి క్రింది ఉదాహరణ.

var x :i32 = 10;
let y :f64 = 3.14159;
var name :str = "Wave";
let is_active :bool = true;

ఈ ఉదాహరణలో, x మరియు name మ్యూటబుల్ వేరియబుల్స్ మరియు y మరియు is_active మారని వేరియబుల్స్. Wave var మరియు let మధ్య తేడాను స్పష్టంగా చూపుతుంది, డేటాను మార్చవచ్చో లేదో కోడ్ స్థాయిలో వెల్లడిస్తుంది.

వేరియబుల్ మరియు స్థిరమైన వేరియబుల్స్ మధ్య సరిగ్గా వేరు చేయడం ద్వారా, మీరు డేటా అనుగుణ్యతను కొనసాగిస్తూ మరింత బలమైన మరియు ఊహాజనిత ప్రోగ్రామ్‌ను సృష్టించవచ్చు.