สนิม - หน้าที่

ฟังก์ชันเป็นส่วนประกอบของรหัสที่อ่านได้บำรุงรักษาและใช้ซ้ำได้ ฟังก์ชันคือชุดของคำสั่งเพื่อดำเนินงานเฉพาะ ฟังก์ชั่นจัดระเบียบโปรแกรมเป็นบล็อกตรรกะของโค้ด เมื่อกำหนดแล้วฟังก์ชันอาจถูกเรียกใช้เพื่อเข้าถึงรหัส สิ่งนี้ทำให้โค้ดสามารถใช้ซ้ำได้ ยิ่งไปกว่านั้นฟังก์ชั่นช่วยให้อ่านและบำรุงรักษาโค้ดของโปรแกรมได้ง่าย

การประกาศฟังก์ชันจะบอกคอมไพลเลอร์เกี่ยวกับชื่อของฟังก์ชันประเภทการส่งคืนและพารามิเตอร์ นิยามของฟังก์ชันระบุเนื้อความที่แท้จริงของฟังก์ชัน

ซีเนียร์ No	ฟังก์ชั่นและคำอธิบาย
1	Defining a function นิยามฟังก์ชัน TA ระบุสิ่งที่ต้องทำและวิธีการทำงาน
2	Calling or invoking a Function ต้องมีการเรียกใช้ฟังก์ชันเพื่อดำเนินการ
3	Returning Functions ฟังก์ชั่นอาจส่งคืนค่าพร้อมกับการควบคุมกลับไปยังผู้เรียก
4	Parameterized Function พารามิเตอร์เป็นกลไกในการส่งผ่านค่าไปยังฟังก์ชัน

การกำหนดฟังก์ชัน

นิยามฟังก์ชันระบุสิ่งที่จะทำและวิธีการทำงาน ก่อนที่จะใช้ฟังก์ชันจะต้องมีการกำหนด เนื้อความของฟังก์ชันประกอบด้วยรหัสที่ควรดำเนินการโดยฟังก์ชัน กฎสำหรับการตั้งชื่อฟังก์ชันจะคล้ายกับตัวแปร ฟังก์ชันถูกกำหนดโดยใช้fnคำสำคัญ. ไวยากรณ์สำหรับการกำหนดฟังก์ชันมาตรฐานได้รับด้านล่าง

ไวยากรณ์

fn function_name(param1,param2..paramN) {
   // function body
}

การประกาศฟังก์ชันสามารถเลือกพารามิเตอร์ / อาร์กิวเมนต์ได้ พารามิเตอร์ใช้เพื่อส่งผ่านค่าไปยังฟังก์ชัน

ตัวอย่าง - นิยามฟังก์ชันอย่างง่าย

//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

เรียกใช้ฟังก์ชัน

ต้องมีการเรียกใช้ฟังก์ชันเพื่อดำเนินการ กระบวนการนี้เรียกว่าfunction invocation. ควรส่งค่าสำหรับพารามิเตอร์เมื่อเรียกใช้ฟังก์ชัน ฟังก์ชันที่เรียกใช้ฟังก์ชันอื่นเรียกว่าcaller function.

ไวยากรณ์

function_name(val1,val2,valN)

ตัวอย่าง: การเรียกใช้ฟังก์ชัน

fn main(){
   //calling a function
   fn_hello();
}

ที่นี่main ()คือฟังก์ชันผู้โทร

ภาพประกอบ

ตัวอย่างต่อไปนี้กำหนดฟังก์ชัน fn_hello(). ฟังก์ชันจะพิมพ์ข้อความไปยังคอนโซล main()ฟังก์ชั่นเรียกfn_hello ()ฟังก์ชั่น

fn main(){
   //calling a function
   fn_hello();
}
//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

เอาต์พุต

hello from function fn_hello

การส่งคืนค่าจากฟังก์ชัน

ฟังก์ชันอาจส่งคืนค่าพร้อมกับการควบคุมกลับไปยังผู้เรียก ฟังก์ชันดังกล่าวเรียกว่าฟังก์ชันการส่งคืน

ไวยากรณ์

สามารถใช้ไวยากรณ์อย่างใดอย่างหนึ่งต่อไปนี้เพื่อกำหนดฟังก์ชันที่มีชนิดการส่งคืน

ด้วยคำสั่งส่งคืน

// Syntax1
fn function_name() -> return_type {
   //statements
   return value;
}

วากยสัมพันธ์ชวเลขโดยไม่มีคำสั่งส่งคืน

//Syntax2
fn function_name() -> return_type {
   value //no semicolon means this value is returned
}

ภาพประกอบ

fn main(){
   println!("pi value is {}",get_pi());
}
fn get_pi()->f64 {
   22.0/7.0
}

เอาต์พุต

pi value is 3.142857142857143

ฟังก์ชันที่มีพารามิเตอร์

พารามิเตอร์เป็นกลไกในการส่งผ่านค่าไปยังฟังก์ชัน พารามิเตอร์เป็นส่วนหนึ่งของลายเซ็นของฟังก์ชัน ค่าพารามิเตอร์จะถูกส่งไปยังฟังก์ชันระหว่างการเรียกใช้ จำนวนค่าที่ส่งผ่านไปยังฟังก์ชันจะต้องตรงกับจำนวนพารามิเตอร์ที่กำหนดไว้เว้นแต่จะระบุไว้อย่างชัดเจน

พารามิเตอร์สามารถส่งผ่านไปยังฟังก์ชันโดยใช้หนึ่งในเทคนิคต่อไปนี้ -

ผ่านค่า

เมื่อมีการเรียกใช้เมธอดตำแหน่งหน่วยเก็บข้อมูลใหม่จะถูกสร้างขึ้นสำหรับแต่ละพารามิเตอร์ค่า ค่าของพารามิเตอร์จริงจะถูกคัดลอกลงในค่าเหล่านี้ ดังนั้นการเปลี่ยนแปลงที่เกิดขึ้นกับพารามิเตอร์ภายในวิธีการเรียกใช้จึงไม่มีผลต่ออาร์กิวเมนต์

ตัวอย่างต่อไปนี้ประกาศตัวแปร no ซึ่งเริ่มต้นคือ 5 ตัวแปรจะถูกส่งผ่านเป็นพารามิเตอร์ (ตามค่า) ไปยัง mutate_no_to_zero()functionnction ซึ่งเปลี่ยนค่าเป็นศูนย์ หลังจากการเรียกใช้ฟังก์ชันเมื่อการควบคุมกลับไปที่เมธอดหลักค่าจะเหมือนเดิม

fn main(){
   let no:i32 = 5;
   mutate_no_to_zero(no);
   println!("The value of no is:{}",no);
}

fn mutate_no_to_zero(mut param_no: i32) {
   param_no = param_no*0;
   println!("param_no value is :{}",param_no);
}

เอาต์พุต

param_no value is :0
The value of no is:5

ผ่านการอ้างอิง

เมื่อคุณส่งผ่านพารามิเตอร์โดยการอ้างอิงซึ่งแตกต่างจากพารามิเตอร์ค่าตำแหน่งที่เก็บข้อมูลใหม่จะไม่ถูกสร้างขึ้นสำหรับพารามิเตอร์เหล่านี้ พารามิเตอร์อ้างอิงแสดงตำแหน่งหน่วยความจำเดียวกันกับพารามิเตอร์จริงที่ระบุให้กับเมธอด ค่าพารามิเตอร์สามารถส่งผ่านโดยการอ้างอิงโดยนำหน้าชื่อตัวแปรด้วย& .

ในตัวอย่างด้านล่างเรามีตัวแปรnoซึ่งเริ่มต้นคือ 5 การอ้างอิงถึงตัวแปร no จะถูกส่งไปยังmutate_no_to_zero()ฟังก์ชัน ฟังก์ชันทำงานบนตัวแปรดั้งเดิม หลังจากการเรียกใช้ฟังก์ชันเมื่อการควบคุมกลับไปที่เมธอดหลักค่าของตัวแปรดั้งเดิมจะเป็นศูนย์

fn main() {
   let mut no:i32 = 5;
   mutate_no_to_zero(&mut no);
   println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(param_no:&mut i32){
   *param_no = 0; //de reference
}

ตัวดำเนินการ * ใช้เพื่อเข้าถึงค่าที่เก็บไว้ในตำแหน่งหน่วยความจำที่ตัวแปร param_noชี้ไปที่ สิ่งนี้เรียกอีกอย่างว่า dereferencing

ผลลัพธ์จะเป็น -

The value of no is 0.

ส่งสตริงไปยังฟังก์ชัน

ฟังก์ชันmain ()ส่งผ่านวัตถุสตริงไปยังฟังก์ชันdisplay ()

fn main(){
   let name:String = String::from("TutorialsPoint");
   display(name); 
   //cannot access name after display
}
fn display(param_name:String){
   println!("param_name value is :{}",param_name);
}

เอาต์พุต

param_name value is :TutorialsPoint