การเขียนโปรแกรมเชิงฟังก์ชัน - คู่มือฉบับย่อ

ภาษาโปรแกรมการทำงานได้รับการออกแบบมาเป็นพิเศษเพื่อจัดการกับการคำนวณเชิงสัญลักษณ์และแอปพลิเคชันการประมวลผลรายการ การเขียนโปรแกรมเชิงฟังก์ชันขึ้นอยู่กับฟังก์ชันทางคณิตศาสตร์ ภาษาการเขียนโปรแกรมที่ใช้งานได้ยอดนิยม ได้แก่ Lisp, Python, Erlang, Haskell, Clojure เป็นต้น

ภาษาโปรแกรมที่ใช้งานได้แบ่งออกเป็นสองกลุ่มคือ -

  • Pure Functional Languages- ภาษาที่ใช้งานประเภทนี้รองรับเฉพาะกระบวนทัศน์เชิงหน้าที่เท่านั้น ตัวอย่างเช่น - Haskell

  • Impure Functional Languages- ภาษาที่ใช้งานได้ประเภทนี้สนับสนุนกระบวนทัศน์เชิงฟังก์ชันและการเขียนโปรแกรมรูปแบบที่จำเป็น ตัวอย่างเช่น - LISP

การเขียนโปรแกรมเชิงฟังก์ชัน - ลักษณะเฉพาะ

ลักษณะเด่นที่สุดของการเขียนโปรแกรมเชิงฟังก์ชันมีดังนี้ -

  • ภาษาโปรแกรมการทำงานได้รับการออกแบบโดยใช้แนวคิดของฟังก์ชันทางคณิตศาสตร์ที่ใช้นิพจน์เงื่อนไขและการเรียกซ้ำเพื่อดำเนินการคำนวณ

  • รองรับการเขียนโปรแกรมเชิงฟังก์ชัน higher-order functions และ lazy evaluation คุณสมบัติ

  • ภาษาโปรแกรมที่ใช้งานได้ไม่รองรับการควบคุมโฟลว์เช่นคำสั่งวนซ้ำและคำสั่งเงื่อนไขเช่น If-Else และ Switch Statements พวกเขาใช้ฟังก์ชันและการโทรที่ใช้งานได้โดยตรง

  • เช่นเดียวกับ OOP ภาษาโปรแกรมเชิงฟังก์ชันสนับสนุนแนวคิดที่เป็นที่นิยมเช่น Abstraction, Encapsulation, Inheritance และ Polymorphism

การเขียนโปรแกรมเชิงฟังก์ชัน - ข้อดี

การเขียนโปรแกรมเชิงฟังก์ชันมีข้อดีดังต่อไปนี้ -

  • Bugs-Free Code - ไม่รองรับการเขียนโปรแกรมเชิงฟังก์ชัน stateดังนั้นจึงไม่มีผลข้างเคียงและเราสามารถเขียนรหัสที่ปราศจากข้อผิดพลาดได้

  • Efficient Parallel Programming- ภาษาโปรแกรมที่ใช้งานได้ไม่มีสถานะเปลี่ยนแปลงดังนั้นจึงไม่มีปัญหาการเปลี่ยนแปลงสถานะ เราสามารถตั้งโปรแกรม "ฟังก์ชัน" ให้ทำงานคู่ขนานเป็น "คำสั่ง" ได้ รหัสดังกล่าวสนับสนุนการใช้ซ้ำและทดสอบได้ง่าย

  • Efficiency- โปรแกรมการทำงานประกอบด้วยหน่วยอิสระที่สามารถทำงานพร้อมกันได้ เป็นผลให้โปรแกรมดังกล่าวมีประสิทธิภาพมากขึ้น

  • Supports Nested Functions - โปรแกรมการทำงานรองรับฟังก์ชันซ้อน

  • Lazy Evaluation - โปรแกรมฟังก์ชั่นรองรับ Lazy Functional Constructs เช่น Lazy Lists, Lazy Maps เป็นต้น

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

Functional Programming ใช้ในสถานการณ์ที่เราต้องดำเนินการต่างๆมากมายกับข้อมูลชุดเดียวกัน

  • Lisp ใช้สำหรับแอปพลิเคชันปัญญาประดิษฐ์เช่นการเรียนรู้ของเครื่องการประมวลผลภาษาการสร้างแบบจำลองของคำพูดและการมองเห็นเป็นต้น

  • Embedded Lisp Interpre เพิ่มความสามารถในการเขียนโปรแกรมให้กับระบบบางระบบเช่น Emacs

การเขียนโปรแกรมเชิงฟังก์ชันเทียบกับการเขียนโปรแกรมเชิงวัตถุ

ตารางต่อไปนี้เน้นความแตกต่างที่สำคัญระหว่างการเขียนโปรแกรมเชิงฟังก์ชันและการเขียนโปรแกรมเชิงวัตถุ -

การเขียนโปรแกรมฟังก์ชั่น OOP
ใช้ข้อมูลที่ไม่เปลี่ยนรูป ใช้ข้อมูลที่ไม่แน่นอน
เป็นไปตามรูปแบบการเขียนโปรแกรมที่เปิดเผย เป็นไปตามรูปแบบการเขียนโปรแกรมที่จำเป็น
โฟกัสอยู่ที่:“ สิ่งที่คุณกำลังทำ” โฟกัสอยู่ที่“ คุณกำลังทำอะไรอยู่”
รองรับการเขียนโปรแกรมแบบขนาน ไม่เหมาะสำหรับการเขียนโปรแกรมแบบขนาน
การทำงานของมันไม่มีผลข้างเคียง วิธีการของมันสามารถก่อให้เกิดผลข้างเคียงที่รุนแรง
Flow Control ทำได้โดยใช้การเรียกใช้ฟังก์ชันและการเรียกฟังก์ชันด้วยการเรียกซ้ำ การควบคุมโฟลว์ทำได้โดยใช้คำสั่งลูปและเงื่อนไข
ใช้แนวคิด "การเรียกซ้ำ" เพื่อทำซ้ำการรวบรวมข้อมูล ใช้แนวคิด "Loop" เพื่อทำซ้ำข้อมูลการรวบรวม ตัวอย่างเช่น: สำหรับแต่ละลูปใน Java
ลำดับการดำเนินการของงบไม่สำคัญนัก ลำดับการดำเนินการของงบมีความสำคัญมาก
รองรับทั้ง "Abstraction over Data" และ "Abstraction over Behavior" รองรับเฉพาะ "Abstraction over Data"

ประสิทธิภาพของรหัสโปรแกรม

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

ปัจจัยที่ส่งผลต่อประสิทธิภาพของโปรแกรมประกอบด้วย -

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

ประสิทธิภาพของภาษาโปรแกรมสามารถปรับปรุงได้โดยดำเนินการดังต่อไปนี้ -

  • โดยการลบรหัสที่ไม่จำเป็นหรือรหัสที่ไปประมวลผลซ้ำซ้อน

  • ด้วยการใช้หน่วยความจำที่เหมาะสมและการจัดเก็บแบบไม่ลบเลือน

  • โดยการใช้ส่วนประกอบที่ใช้ซ้ำได้ทุกที่ที่เกี่ยวข้อง

  • โดยใช้การจัดการข้อผิดพลาดและข้อยกเว้นในทุกชั้นของโปรแกรม

  • ด้วยการสร้างโค้ดการเขียนโปรแกรมที่ทำให้ข้อมูลมีความสมบูรณ์และสอดคล้องกัน

  • ด้วยการพัฒนาโค้ดโปรแกรมที่สอดคล้องกับตรรกะและขั้นตอนการออกแบบ

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

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

ภาษาที่ใช้งานต่างกันใช้ไวยากรณ์ที่แตกต่างกันเพื่อเขียนฟังก์ชัน

ข้อกำหนดเบื้องต้นในการเขียนฟังก์ชัน

ก่อนที่จะเขียนฟังก์ชันโปรแกรมเมอร์ต้องทราบประเด็นต่อไปนี้ -

  • ผู้เขียนโปรแกรมควรทราบวัตถุประสงค์ของฟังก์ชัน

  • อัลกอริทึมของฟังก์ชันควรเป็นที่รู้จักสำหรับโปรแกรมเมอร์

  • ผู้เขียนโปรแกรมควรทราบตัวแปรข้อมูลของฟังก์ชันและเป้าหมาย

  • ข้อมูลของฟังก์ชันควรเป็นที่รู้จักสำหรับโปรแกรมเมอร์ที่เรียกโดยผู้ใช้

การควบคุมการไหลของฟังก์ชัน

เมื่อฟังก์ชันถูก "เรียก" โปรแกรมจะ "โอน" ตัวควบคุมเพื่อดำเนินการฟังก์ชันและ "ขั้นตอนการควบคุม" จะเป็นดังนี้ -

  • โปรแกรมไปถึงคำสั่งที่มี "function call"

  • บรรทัดแรกภายในฟังก์ชันจะถูกเรียกใช้งาน

  • คำสั่งทั้งหมดในฟังก์ชันจะดำเนินการจากบนลงล่าง

  • เมื่อเรียกใช้ฟังก์ชันสำเร็จคอนโทรลจะกลับไปที่คำสั่งที่เริ่มต้น

  • ข้อมูลใด ๆ ที่คำนวณและส่งคืนโดยฟังก์ชันจะถูกใช้แทนฟังก์ชันในบรรทัดเดิมของโค้ด

ไวยากรณ์ของฟังก์ชัน

ไวยากรณ์ทั่วไปของฟังก์ชันมีลักษณะดังนี้ -

returnType functionName(type1 argument1, type2 argument2, . . . ) {     
   // function body 
}

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

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

#include <stdio.h> 

int addNum(int a, int b);     // function prototype  

int main() {    
   int sum; 
   sum = addNum(5,6);         // function call 
   printf("sum = %d",sum); 
   return 0; 
}  
int addNum (int a,int b) {    // function definition      
   int result; 
   result = a + b; 
   return result;             // return statement 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Sum = 11

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

มาดูกันว่าฟังก์ชันเดียวกันนี้สามารถกำหนดได้อย่างไรใน Erlang ซึ่งเป็นภาษาการเขียนโปรแกรมเชิงฟังก์ชัน

-module(helloworld).  
-export([add/2,start/0]).   

add(A,B) ->
   C = A + B,  
   io:fwrite("~w~n",[C]).  
start() ->  
   add(5,6).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

11

ฟังก์ชัน Prototype

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

For Example - ภาษาโปรแกรมบางภาษารองรับการสร้างต้นแบบฟังก์ชันและบางภาษาไม่รองรับ

ใน C ++ เราสามารถสร้างฟังก์ชันต้นแบบของฟังก์ชัน 'sum' ได้เช่นนี้ -

int sum(int a, int b)

Note - ภาษาโปรแกรมเช่น Python, Erlang และอื่น ๆ ไม่รองรับการสร้างต้นแบบฟังก์ชันเราจำเป็นต้องประกาศฟังก์ชันทั้งหมด

การใช้ฟังก์ชันต้นแบบคืออะไร?

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

ลายเซ็นของฟังก์ชัน

ลายเซ็นของฟังก์ชันจะคล้ายกับต้นแบบของฟังก์ชันซึ่งจำนวนพารามิเตอร์ประเภทข้อมูลของพารามิเตอร์และลำดับของลักษณะที่ปรากฏควรอยู่ในลำดับที่ใกล้เคียงกัน ตัวอย่างเช่น -

void Sum(int a, int b, int c);         // function 1  
void Sum(float a, float b, float c);   // function 2  
void Sum(float a, float b, float c);   // function 3

Function1 และ Function2 มีลายเซ็นที่แตกต่างกัน Function2 และ Function3 มีลายเซ็นเดียวกัน

Note - การโอเวอร์โหลดฟังก์ชันและการแทนที่ฟังก์ชันซึ่งเราจะกล่าวถึงในบทต่อ ๆ ไปนั้นขึ้นอยู่กับแนวคิดของลายเซ็นฟังก์ชัน

  • ฟังก์ชันโอเวอร์โหลดเป็นไปได้เมื่อคลาสมีหลายฟังก์ชันที่มีชื่อเดียวกัน แต่มีลายเซ็นต่างกัน

  • การลบล้างฟังก์ชันเป็นไปได้เมื่อฟังก์ชันคลาสที่ได้รับมีชื่อและลายเซ็นเดียวกันกับคลาสฐาน

ฟังก์ชั่นมีสองประเภท -

  • ฟังก์ชันที่กำหนดไว้ล่วงหน้า
  • ฟังก์ชันที่ผู้ใช้กำหนดเอง

ในบทนี้เราจะพูดถึงรายละเอียดเกี่ยวกับฟังก์ชัน

ฟังก์ชันที่กำหนดไว้ล่วงหน้า

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

For Example - 'Strcat' ใน C ++ & 'concat' ใน Haskell ใช้เพื่อต่อท้ายสองสตริง 'strlen' ใน C ++ และ 'len' ใน Python ใช้เพื่อคำนวณความยาวสตริง

โปรแกรมพิมพ์ความยาวสตริงใน C ++

โปรแกรมต่อไปนี้แสดงวิธีการพิมพ์ความยาวของสตริงโดยใช้ C ++ -

#include <iostream> 
#include <string.h> 
#include <stdio.h> 
using namespace std;  

int main() {     
   char str[20] = "Hello World"; 
   int len; 
   len = strlen(str); 
   cout<<"String length is: "<<len; 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

String length is: 11

โปรแกรมพิมพ์ความยาวสตริงใน Python

โปรแกรมต่อไปนี้แสดงวิธีการพิมพ์ความยาวของสตริงโดยใช้ Python ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

str = "Hello World"; 
print("String length is: ", len(str))

มันจะสร้างผลลัพธ์ต่อไปนี้ -

('String length is: ', 11)

ฟังก์ชันที่ผู้ใช้กำหนดเอง

ฟังก์ชันที่ผู้ใช้กำหนดเองถูกกำหนดโดยผู้ใช้เพื่อดำเนินการเฉพาะ มีสี่รูปแบบที่แตกต่างกันในการกำหนดฟังก์ชัน -

  • ฟังก์ชันที่ไม่มีอาร์กิวเมนต์และไม่มีค่าส่งคืน
  • ฟังก์ชันที่ไม่มีอาร์กิวเมนต์ แต่เป็นค่าที่ส่งคืน
  • ฟังก์ชันที่มีอาร์กิวเมนต์ แต่ไม่มีค่าส่งคืน
  • ฟังก์ชันที่มีอาร์กิวเมนต์และค่าส่งคืน

ฟังก์ชันที่ไม่มีอาร์กิวเมนต์และไม่มีค่าส่งคืน

โปรแกรมต่อไปนี้แสดงวิธีกำหนดฟังก์ชันโดยไม่มีอาร์กิวเมนต์และไม่มีค่าส่งคืนใน C++ -

#include <iostream> 
using namespace std; 

void function1() { 
   cout <<"Hello World"; 
}  
int main() { 
   function1(); 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Hello World

โปรแกรมต่อไปนี้แสดงให้เห็นว่าคุณสามารถกำหนดฟังก์ชันที่คล้ายกันได้อย่างไร (ไม่มีอาร์กิวเมนต์และไม่มีค่าส่งคืน) ใน Python -

def function1():    
   print ("Hello World") 
    
function1()

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Hello World

ฟังก์ชันที่ไม่มีอาร์กิวเมนต์ แต่เป็นค่าที่ส่งคืน

โปรแกรมต่อไปนี้แสดงวิธีกำหนดฟังก์ชันโดยไม่มีอาร์กิวเมนต์ แต่ส่งคืนค่าเป็น C++ -

#include <iostream> 
using namespace std; 
string function1() { 
   return("Hello World"); 
}  

int main() { 
   cout<<function1(); 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Hello World

โปรแกรมต่อไปนี้แสดงให้เห็นว่าคุณสามารถกำหนดฟังก์ชันที่คล้ายกันได้อย่างไร (โดยไม่มีอาร์กิวเมนต์ แต่เป็นค่าส่งคืน) ใน Python -

def function1(): 
   return "Hello World" 
res = function1() 
print(res)

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Hello World

ฟังก์ชันที่มีอาร์กิวเมนต์ แต่ไม่มีค่าส่งคืน

โปรแกรมต่อไปนี้แสดงวิธีกำหนดฟังก์ชันที่มีอาร์กิวเมนต์ แต่ไม่มีค่าส่งคืนใน C++ -

#include <iostream> 
using namespace std; 
void function1(int x, int y) {    
   int c; 
   c = x+y;  
   cout<<"Sum is: "<<c; 
}  

int main() { 
   function1(4,5); 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Sum is: 9

โปรแกรมต่อไปนี้แสดงวิธีกำหนดฟังก์ชันที่คล้ายกันใน Python -

def function1(x,y): 
   c = x + y 
   print("Sum is:",c) 
function1(4,5)

มันจะสร้างผลลัพธ์ต่อไปนี้ -

('Sum is:', 9)

ฟังก์ชันที่มีอาร์กิวเมนต์และค่าส่งคืน

โปรแกรมต่อไปนี้แสดงวิธีการกำหนดฟังก์ชันใน C ++ โดยไม่มีอาร์กิวเมนต์ แต่เป็นค่าส่งคืน -

#include <iostream> 
using namespace std; 
int function1(int x, int y) {    
   int c; 
   c = x + y;  
   return c;    
} 

int main() {  
   int res; 
   res = function1(4,5); 
   cout<<"Sum is: "<<res; 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Sum is: 9

โปรแกรมต่อไปนี้แสดงวิธีกำหนดฟังก์ชันที่คล้ายกัน (พร้อมอาร์กิวเมนต์และค่าส่งคืน) ใน Python -

def function1(x,y): 
   c = x + y 
   return c  

res = function1(4,5) 
print("Sum is ",res)

มันจะสร้างผลลัพธ์ต่อไปนี้ -

('Sum is ', 9)

หลังจากกำหนดฟังก์ชันแล้วเราต้องส่งอาร์กิวเมนต์เข้าไปเพื่อให้ได้ผลลัพธ์ที่ต้องการ ภาษาโปรแกรมส่วนใหญ่รองรับcall by value และ call by reference วิธีการส่งอาร์กิวเมนต์ไปยังฟังก์ชัน

ในบทนี้เราจะเรียนรู้การทำงานของ "call by value" ในภาษาโปรแกรมเชิงวัตถุเช่น C ++ และภาษาโปรแกรมที่ใช้งานได้เช่น Python

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

โทรตามค่าใน C ++

โปรแกรมต่อไปนี้แสดงวิธีการทำงานของ Call by Value ใน C ++ -

#include <iostream> 
using namespace std; 

void swap(int a, int b) {    
   int temp; 
   temp = a; 
   a = b; 
   b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<a; 
   cout<<"\n"<<"value of b inside the function: "<<b; 
}  
int main() {     
   int a = 50, b = 70;   
   cout<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(a, b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

value of a before sending to function:  50 
value of b before sending to function:  70 
value of a inside the function:  70 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  70

โทรตามค่าใน Python

โปรแกรมต่อไปนี้แสดงวิธีการทำงานของ Call by Value ใน Python -

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 

# Now we can call the swap function 
a = 50 
b = 75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
swap(a,b) 
print "value of a after sending to function: ", a 
print "value of b after sending to function: ",b

มันจะสร้างผลลัพธ์ต่อไปนี้ -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function: : 75 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  75

ในการโทรตามการอ้างอิงไฟล์ original value is changedเนื่องจากเราส่งที่อยู่อ้างอิงของอาร์กิวเมนต์ อาร์กิวเมนต์ที่เป็นจริงและเป็นทางการใช้พื้นที่แอดเดรสเดียวกันดังนั้นการเปลี่ยนแปลงค่าใด ๆ ภายในฟังก์ชันจะแสดงภายในและภายนอกฟังก์ชัน

โทรตามการอ้างอิงใน C ++

โปรแกรมต่อไปนี้แสดงวิธีการทำงานของ Call by Value ใน C ++ -

#include <iostream> 
using namespace std; 

void swap(int *a, int *b) {    
   int temp; 
   temp = *a; 
   *a = *b; 
   *b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<*a; 
   cout<<"\n"<<"value of b inside the function: "<<*b; 
}  
int main() {     
   int a = 50, b = 75;   
   cout<<"\n"<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(&a, &b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function: 50 
value of a after sending to function:  75 
value of b after sending to function:  50

โทรตามการอ้างอิงใน Python

โปรแกรมต่อไปนี้แสดงวิธีการทำงานของ Call by Value ใน Python -

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 
   return(a,b) 
    
# Now we can call swap function 
a = 50 
b =75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
x = swap(a,b) 
print "value of a after sending to function: ", x[0] 
print "value of b after sending to function: ",x[1]

มันจะสร้างผลลัพธ์ต่อไปนี้ -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function:  50 
value of a after sending to function:  75 
value of b after sending to function:  50

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

มีสองวิธีในการโอเวอร์โหลดฟังก์ชัน ได้แก่ -

  • มีจำนวนอาร์กิวเมนต์ต่างกัน
  • มีประเภทอาร์กิวเมนต์ที่แตกต่างกัน

โดยปกติการโอเวอร์โหลดฟังก์ชันจะเกิดขึ้นเมื่อเราต้องดำเนินการเพียงครั้งเดียวโดยมีจำนวนหรือประเภทของอาร์กิวเมนต์ที่แตกต่างกัน

ฟังก์ชันโอเวอร์โหลดใน C ++

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าฟังก์ชันโอเวอร์โหลดใน C ++ ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ -

#include <iostream> 
using namespace std;  
void addnum(int,int); 
void addnum(int,int,int); 

int main() {     
   addnum (5,5); 
   addnum (5,2,8); 
   return 0; 
} 

void addnum (int x, int y) {     
   cout<<"Integer number: "<<x+y<<endl; 
} 

void addnum (int x, int y, int z) {     
   cout<<"Float number: "<<x+y+z<<endl; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Integer number: 10 
Float number: 15

ฟังก์ชันโอเวอร์โหลดใน Erlang

ตัวอย่างต่อไปนี้แสดงวิธีดำเนินการฟังก์ชันโอเวอร์โหลดใน Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

-module(helloworld).  
-export([addnum/2,addnum/3,start/0]).   

addnum(X,Y) ->  
   Z = X+Y,  
   io:fwrite("~w~n",[Z]).  
    
addnum(X,Y,Z) ->  
   A = X+Y+Z,  
   io:fwrite("~w~n",[A]).  
  
start() ->
   addnum(5,5),     addnum(5,2,8).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

10 
15

เมื่อคลาสฐานและคลาสที่ได้รับมีฟังก์ชันสมาชิกที่มีชื่อเดียวกันชนิดส่งคืนเดียวกันและรายการอาร์กิวเมนต์เดียวกันจะกล่าวว่าเป็นการแทนที่ฟังก์ชัน

การแทนที่ฟังก์ชันโดยใช้ C ++

ตัวอย่างต่อไปนี้แสดงวิธีการลบล้างฟังก์ชันใน C ++ ซึ่งเป็นภาษาการเขียนโปรแกรมเชิงวัตถุ -

#include <iostream> 
using namespace std;  

class A {  
   public: 
   void display() {   
      cout<<"Base class"; 
   } 
}; 

class B:public A {  
   public: 
   void display() {   
      cout<<"Derived Class"; 
   } 
}; 

int main() {  
   B obj; 
   obj.display(); 
   return 0;  
}

มันจะสร้างผลลัพธ์ต่อไปนี้

Derived Class

ฟังก์ชันการแทนที่โดยใช้ Python

ตัวอย่างต่อไปนี้แสดงวิธีดำเนินการแทนที่ฟังก์ชันใน Python ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

class A(object): 
   def disp(self): 
      print "Base Class"  
class B(A): 
   def disp(self): 
      print "Derived Class"  
x = A() 
y = B()  
x.disp() 
y.disp()

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Base Class 
Derived Class

ฟังก์ชันที่เรียกตัวเองเรียกว่าฟังก์ชันเรียกซ้ำและเทคนิคนี้เรียกว่าการเรียกซ้ำ คำสั่งการเรียกซ้ำจะดำเนินต่อไปจนกว่าจะมีคำสั่งอื่นป้องกัน

การเรียกซ้ำใน C ++

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการเรียกซ้ำทำงานอย่างไรใน C ++ ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ -

#include <stdio.h> 
long int fact(int n);  

int main() { 
   int n; 
   printf("Enter a positive integer: "); 
   scanf("%d", &n); 
   printf("Factorial of %d = %ld", n, fact(n)); 
   return 0; 
} 
long int fact(int n) { 
   if (n >= 1) 
      return n*fact(n-1); 
   else 
      return 1; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้

Enter a positive integer: 5 
Factorial of 5 = 120

การเรียกซ้ำใน Python

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการเรียกซ้ำทำงานอย่างไรใน Python ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

def fact(n): 
   if n == 1: 
      return n 
   else: 
      return n* fact (n-1)  

# accepts input from user 
num = int(input("Enter a number: "))  
# check whether number is positive or not 

if num < 0: 
   print("Sorry, factorial does not exist for negative numbers") 
else: 
   print("The factorial of " + str(num) +  " is " + str(fact(num)))

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Enter a number: 6
The factorial of 6 is 720

ฟังก์ชันลำดับที่สูงขึ้น (HOF) เป็นฟังก์ชันที่เป็นไปตามเงื่อนไขต่อไปนี้อย่างน้อยหนึ่งข้อ -

  • ใช้ฟังก์ชันหรือมากกว่าเป็นอาร์กิวเมนต์
  • ส่งคืนฟังก์ชันเป็นผลลัพธ์

HOF ใน PHP

ตัวอย่างต่อไปนี้แสดงวิธีการเขียนฟังก์ชันลำดับที่สูงขึ้นใน PHP ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ -

<?php  
$twice = function($f, $v) { return $f($f($v)); 
};  

$f = function($v) { 
   return $v + 3; }; echo($twice($f, 7));

มันจะสร้างผลลัพธ์ต่อไปนี้ -

13

HOF ใน Python

ตัวอย่างต่อไปนี้แสดงวิธีการเขียนฟังก์ชันลำดับที่สูงขึ้นใน Python ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ -

def twice(function): 
   return lambda x: function(function(x))  
def f(x): 
   return x + 3 
g = twice(f)
print g(7)

มันจะสร้างผลลัพธ์ต่อไปนี้ -

13

ชนิดข้อมูลกำหนดประเภทของค่าที่วัตถุสามารถมีได้และการดำเนินการใดที่สามารถทำได้ ควรประกาศชนิดข้อมูลก่อนนำไปใช้ ภาษาโปรแกรมที่แตกต่างกันสนับสนุนประเภทข้อมูลที่แตกต่างกัน ตัวอย่างเช่น,

  • C รองรับถ่าน int ลอยยาว ฯลฯ
  • Python รองรับ String, List, Tuple ฯลฯ

ในแง่กว้างประเภทข้อมูลมีสามประเภท -

  • Fundamental data types- เหล่านี้เป็นชนิดข้อมูลที่กำหนดไว้ล่วงหน้าซึ่งโปรแกรมเมอร์ใช้โดยตรงเพื่อจัดเก็บค่าเดียวตามข้อกำหนดเช่นประเภทจำนวนเต็มประเภทอักขระหรือประเภทลอยตัว ตัวอย่างเช่น - int, char, float เป็นต้น

  • Derived data types- ประเภทข้อมูลเหล่านี้ได้มาโดยใช้ประเภทข้อมูลในตัวซึ่งออกแบบโดยโปรแกรมเมอร์เพื่อจัดเก็บค่าประเภทเดียวกันหลายค่าตามความต้องการ ตัวอย่างเช่น - Array, Pointer, function, list เป็นต้น

  • User-defined data types- ประเภทข้อมูลเหล่านี้ได้มาโดยใช้ชนิดข้อมูลในตัวซึ่งรวมอยู่ในประเภทข้อมูลเดียวเพื่อเก็บค่าหลายค่าประเภทเดียวกันหรือต่างประเภทหรือทั้งสองอย่างตามความต้องการ ตัวอย่างเช่น - Class, Structure ฯลฯ

ประเภทข้อมูลที่รองรับโดย C ++

ตารางต่อไปนี้แสดงประเภทข้อมูลที่ C ++ รองรับ -

ประเภทข้อมูล ขนาด พิสัย
ถ่าน 1 ไบต์ -128 ถึง 127 หรือ 0 ถึง 255
ถ่านที่ไม่ได้ลงนาม 1 ไบต์ 0 ถึง 255
ลงนามถ่าน 1 ไบต์ -128 ถึง 127
int 4 ไบต์ -2147483648 ถึง 2147483647
int ที่ไม่ได้ลงนาม 4 ไบต์ 0 ถึง 4294967295
ลงนาม int 4 ไบต์ -2147483648 ถึง 2147483647
int สั้น ๆ 2 ไบต์ -32768 ถึง 32767
int สั้นที่ไม่ได้ลงนาม 2 ไบต์ 0 ถึง 65,535
ลงนามสั้น int 2 ไบต์ -32768 ถึง 32767
int ยาว 4 ไบต์ -2,147,483,648 ถึง 2,147,483,647
ลงนามยาว int 4 ไบต์ -2,147,483,648 ถึง 2,147,483,647
int ยาวที่ไม่ได้ลงนาม 4 ไบต์ 0 ถึง 4,294,967,295
ลอย 4 ไบต์ +/- 3.4e +/- 38 (~ 7 หลัก)
สองเท่า 8 ไบต์ +/- 1.7e +/- 308 (~ 15 หลัก)
คู่ยาว 8 ไบต์ +/- 1.7e +/- 308 (~ 15 หลัก)

ประเภทข้อมูลที่รองรับโดย Java

ชนิดข้อมูลต่อไปนี้รองรับโดย Java -

ประเภทข้อมูล ขนาด พิสัย
ไบต์ 1 ไบต์ -128 ถึง 127
ถ่าน 2 ไบต์ 0 ถึง 65,536
สั้น 2 ไบต์ -32,7688 ถึง 32,767
int 4 ไบต์ -2,147,483,648 ถึง 2,147,483,647
ยาว 8 ไบต์ -9,223,372,036,854,775,808 ถึง 9,223,372,036,854,775,807
ลอย 4 ไบต์ -2147483648 ถึง 2147483647
สองเท่า 8 ไบต์ + 9.223 * 1018
บูลีน 1 บิต จริงหรือเท็จ

ประเภทข้อมูลที่ Erlang สนับสนุน

ในส่วนนี้เราจะพูดถึงประเภทข้อมูลที่ Erlang รองรับซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้

จำนวน

Erlang รองรับตัวอักษรตัวเลขสองประเภทคือ integer และ float. ดูตัวอย่างต่อไปนี้ที่แสดงวิธีการเพิ่มค่าจำนวนเต็มสองค่า -

-module(helloworld).
-export([start/0]). 
start() -> 
   io:fwrite("~w",[5+4]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

9

อะตอม

อัน atomเป็นสตริงที่ไม่สามารถเปลี่ยนแปลงค่าได้ ต้องขึ้นต้นด้วยตัวอักษรพิมพ์เล็กและมีอักขระที่เป็นตัวเลขและตัวอักษรและอักขระพิเศษได้ เมื่ออะตอมมีอักขระพิเศษจึงควรอยู่ในเครื่องหมายคำพูดเดี่ยว (') ลองดูตัวอย่างต่อไปนี้เพื่อทำความเข้าใจให้ดีขึ้น

-module(helloworld). 
-export([start/0]). 

start()-> 
   io:fwrite(monday).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

monday

Note- ลองเปลี่ยนอะตอมเป็น "วันจันทร์" ด้วยตัวพิมพ์ใหญ่ "M" โปรแกรมจะเกิดข้อผิดพลาด

บูลีน

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

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite(5 =< 9).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

true

บิตสตริง

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

-module(helloworld). 
-export([start/0]). 

start() -> 
   Bin2 = <<15,25>>, 
   P = binary_to_list(Bin2), 
   io:fwrite("~w",[P]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[15,25]

ทูเพิล

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

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5

แผนที่

แผนที่เป็นชนิดข้อมูลผสมที่มีการเชื่อมโยงคีย์ - ค่าจำนวนตัวแปร การเชื่อมโยงคีย์ - ค่าแต่ละรายการในแผนที่เรียกว่าไฟล์association-pair. key และ value ส่วนต่างๆของทั้งคู่เรียกว่า elements. จำนวนคู่ - สมาคมบอกเป็นขนาดของแผนที่ ตัวอย่างต่อไปนี้แสดงวิธีกำหนดแผนที่ 3 การแมปและพิมพ์ขนาด

-module(helloworld).  
-export([start/0]).  
 
start() ->  
   Map1 = #{name => 'abc',age => 40, gender => 'M'},  
   io:fwrite("~w",[map_size(Map1)]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

3

รายการ

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

-module(helloworld).  
-export([start/0]).  

start() ->  
   List1 = [10,15,20,25,30] ,  
   io:fwrite("~w",[length(List1)]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5

Note - ไม่ได้กำหนดประเภทข้อมูล 'สตริง' ใน Erlang

Polymorphism ในแง่ของการเขียนโปรแกรมหมายถึงการนำรหัสเดียวกลับมาใช้ซ้ำหลาย ๆ ครั้ง โดยเฉพาะอย่างยิ่งความสามารถของโปรแกรมในการประมวลผลวัตถุที่แตกต่างกันขึ้นอยู่กับประเภทข้อมูลหรือคลาส

ความหลากหลายเป็นสองประเภท -

  • Compile-time Polymorphism - ความหลากหลายประเภทนี้สามารถทำได้โดยใช้วิธีการโอเวอร์โหลด

  • Run-time Polymorphism - ความหลากหลายประเภทนี้สามารถทำได้โดยใช้วิธีการแทนที่และฟังก์ชันเสมือน

ข้อดีของ Polymorphism

Polymorphism มีข้อดีดังต่อไปนี้ -

  • ช่วยให้โปรแกรมเมอร์สามารถนำโค้ดกลับมาใช้ใหม่ได้กล่าวคือคลาสที่เขียนทดสอบและใช้งานแล้วสามารถนำกลับมาใช้ใหม่ได้ตามต้องการ ประหยัดเวลาได้มาก

  • ตัวแปรเดียวสามารถใช้เพื่อจัดเก็บข้อมูลหลายประเภท

  • ง่ายต่อการดีบักรหัส

ประเภทข้อมูลแบบ Polymorphic

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

function1(void *p, void *q)

ที่ไหน p และ q เป็นตัวชี้ทั่วไปที่สามารถถือได้ int, float (หรืออื่น ๆ ) เป็นค่าอาร์กิวเมนต์

ฟังก์ชัน Polymorphic ใน C ++

โปรแกรมต่อไปนี้แสดงวิธีใช้ฟังก์ชัน polymorphic ใน C ++ ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ

#include <iostream> 
Using namespace std: 

class A {  
   public: 
   void show() {    
      cout << "A class method is called/n"; 
   } 
}; 

class B:public A { 
   public: 
   void show() {   
      cout << "B class method is called/n"; 
   } 
};  

int main() {   
   A x;        // Base class object 
   B y;        // Derived class object 
   x.show();   // A class method is called 
   y.show();   // B class method is called 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

A class method is called 
B class method is called

ฟังก์ชัน Polymorphic ใน Python

โปรแกรมต่อไปนี้แสดงวิธีใช้ฟังก์ชัน polymorphic ใน Python ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้

class A(object): 
   def show(self): 
      print "A class method is called" 
  
class B(A): 
   def show(self): 
      print "B class method is called" 
  
def checkmethod(clasmethod): 
   clasmethod.show()  

AObj = A() 
BObj = B() 
  
checkmethod(AObj) 
checkmethod(BObj)

มันจะสร้างผลลัพธ์ต่อไปนี้ -

A class method is called 
B class method is called

ก stringคือกลุ่มอักขระที่มีช่องว่าง เราสามารถพูดได้ว่ามันเป็นอาร์เรย์หนึ่งมิติของอักขระซึ่งถูกยุติโดยอักขระ NULL ('\ 0') สตริงสามารถถือได้ว่าเป็นคลาสที่กำหนดไว้ล่วงหน้าซึ่งได้รับการสนับสนุนโดยภาษาโปรแกรมส่วนใหญ่เช่น C, C ++, Java, PHP, Erlang, Haskell, Lisp และอื่น ๆ

ภาพต่อไปนี้แสดงให้เห็นว่าสตริง "Tutorial" จะมีลักษณะอย่างไรในหน่วยความจำ

สร้างสตริงใน C ++

โปรแกรมต่อไปนี้เป็นตัวอย่างที่แสดงวิธีการสร้างสตริงใน C ++ ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ

#include <iostream> 
using namespace std; 

int main () {    
   char greeting[20] = {'H', 'o', 'l', 'i', 'd', 'a', 'y', '\0'}; 
   cout << "Today is: "; 
   cout << greeting << endl; 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Today is: Holiday

สตริงใน Erlang

โปรแกรมต่อไปนี้เป็นตัวอย่างที่แสดงวิธีการสร้างสตริงใน Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้

-module(helloworld).  
-export([start/0]).   
start() -> 
   Str = "Today is: Holiday",  
   io:fwrite("~p~n",[Str]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

"Today is: Holiday"

การดำเนินการสตริงใน C ++

ภาษาโปรแกรมที่แตกต่างกันสนับสนุนวิธีการที่แตกต่างกันบนสตริง ตารางต่อไปนี้แสดงวิธีการสตริงที่กำหนดไว้ล่วงหน้าซึ่ง C ++ รองรับ

ส. วิธีการและคำอธิบาย
1

Strcpy(s1,s2)

คัดลอกสตริง s2 ลงในสตริง s1
2

Strcat(s1,s2)

เพิ่มสตริง s2 ที่ท้าย s1
3

Strlen(s1)

ให้ความยาวของสตริง s1
4

Strcmp(s1,s2)

จะคืนค่า 0 เมื่อสตริง s1 & s2 เหมือนกัน
5

Strchr(s1,ch)

ส่งกลับตัวชี้ไปยังอักขระ ch ที่เกิดขึ้นครั้งแรกในสตริง s1
6

Strstr(s1,s2)

ส่งกลับตัวชี้ไปยังสตริง s2 ที่เกิดขึ้นครั้งแรกในสตริง s1

โปรแกรมต่อไปนี้แสดงวิธีการข้างต้นสามารถใช้ใน C ++ -

#include <iostream> 
#include <cstring> 
using namespace std; 

int main () {   
   char str1[20] = "Today is "; 
   char str2[20] = "Monday"; 
   char str3[20]; 
   int  len ;  
   strcpy( str3, str1); // copy str1 into str3 
   cout << "strcpy( str3, str1) : " << str3 << endl;  

   strcat( str1, str2); // concatenates str1 and str2 
   cout << "strcat( str1, str2): " << str1 << endl;  

   len = strlen(str1);  // String length after concatenation 
   cout << "strlen(str1) : " << len << endl; 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

strcpy(str3, str1)   :  Today is 
strcat(str1, str2)   :  Today is Monday 
strlen(str1)         :  15

การทำงานของสตริงใน Erlang

ตารางต่อไปนี้แสดงรายการวิธีการสตริงที่กำหนดไว้ล่วงหน้าที่ Erlang สนับสนุน

ส. วิธีการและคำอธิบาย
1

len(s1)

ส่งคืนจำนวนอักขระในสตริงที่กำหนด
2

equal(s1,s2)

จะคืนค่าจริงเมื่อสตริง s1 & s2 เท่ากับมิฉะนั้นจะส่งคืนเท็จ
3

concat(s1,s2)

เพิ่มสตริง s2 ที่ท้ายสตริง s1
4

str(s1,ch)

ส่งคืนตำแหน่งดัชนีของอักขระ ch ในสตริง s1
5

str (s1,s2)

ส่งคืนตำแหน่งดัชนีของ s2 ในสตริง s1
6

substr(s1,s2,num)

วิธีนี้ส่งคืนสตริง s2 จากสตริง s1 ตามตำแหน่งเริ่มต้นและจำนวนอักขระจากตำแหน่งเริ่มต้น
7

to_lower(s1)

วิธีนี้ส่งคืนสตริงเป็นตัวพิมพ์เล็ก

โปรแกรมต่อไปนี้แสดงวิธีใช้วิธีการข้างต้นใน Erlang

-module(helloworld).  
-import(string,[concat/2]).  
-export([start/0]).  
   start() ->  
   S1 = "Today is ",  
   S2 = "Monday",  
   S3 = concat(S1,S2),  
   io:fwrite("~p~n",[S3]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

"Today is Monday"

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

โปรแกรมสร้างรายการตัวเลขใน Java

รายการไม่ใช่ชนิดข้อมูลใน Java / C / C ++ แต่เรามีวิธีอื่นในการสร้างรายการใน Java กล่าวคือโดยใช้ ArrayList และ LinkedList.

ตัวอย่างต่อไปนี้แสดงวิธีสร้างรายการใน Java ที่นี่เรากำลังใช้วิธีการเชื่อมโยงรายการเพื่อสร้างรายการตัวเลข

import java.util.*; 
import java.lang.*; 
import java.io.*;  

/* Name of the class has to be "Main" only if the class is public. */ 

public class HelloWorld { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> listStrings = new LinkedList<String>(); 
      listStrings.add("1"); 
      listStrings.add("2"); 
      listStrings.add("3"); 
      listStrings.add("4"); 
      listStrings.add("5"); 
  
      System.out.println(listStrings); 
   } 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[1, 2, 3, 4, 5]

โปรแกรมสร้างรายการตัวเลขใน Erlang

-module(helloworld).  
-export([start/0]).   

start() ->  
   Lst = [1,2,3,4,5],  
   io:fwrite("~w~n",[Lst]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[1 2 3 4 5]

แสดงรายการการดำเนินการใน Java

ในส่วนนี้เราจะพูดถึงการดำเนินการบางอย่างที่สามารถทำได้ในรายการใน Java

การเพิ่มองค์ประกอบลงในรายการ

วิธีการเพิ่ม (Object), เพิ่ม (ดัชนี, วัตถุ), addAll () ใช้เพื่อเพิ่มองค์ประกอบลงในรายการ ตัวอย่างเช่น,

ListStrings.add(3, “three”)

การลบองค์ประกอบออกจากรายการ

วิธีการลบ (ดัชนี) หรือลบวัตถุ () ใช้เพื่อลบองค์ประกอบออกจากรายการ ตัวอย่างเช่น,

ListStrings.remove(3,”three”)

Note - ในการลบองค์ประกอบทั้งหมดออกจากรายการจะใช้วิธี clear ()

การดึงองค์ประกอบจากรายการ

เมธอด get () ใช้เพื่อดึงข้อมูลองค์ประกอบจากรายการในตำแหน่งที่ระบุ เมธอด getfirst () & getlast () สามารถใช้ได้ในคลาส LinkedList ตัวอย่างเช่น,

String str = ListStrings.get(2)

การอัปเดตองค์ประกอบในรายการ

วิธี set (ดัชนีองค์ประกอบ) ใช้เพื่ออัพเดตองค์ประกอบที่ดัชนีที่ระบุด้วยองค์ประกอบที่ระบุ ตัวอย่างเช่น,

listStrings.set(2,”to”)

การจัดเรียงองค์ประกอบในรายการ

วิธีการ collection.sort () และ collection.reverse () ใช้เพื่อเรียงลำดับรายการจากน้อยไปมากหรือมากไปหาน้อย ตัวอย่างเช่น,

Collection.sort(listStrings)

การค้นหาองค์ประกอบในรายการ

สามวิธีต่อไปนี้ใช้ตามข้อกำหนด -

Boolean contains(Object) วิธีการส่งคืน true หากรายการมีองค์ประกอบที่ระบุมิฉะนั้นจะส่งคืน false.

int indexOf(Object) วิธีการส่งคืนดัชนีของการเกิดขึ้นครั้งแรกขององค์ประกอบที่ระบุในรายการมิฉะนั้นจะส่งกลับ -1 เมื่อไม่พบองค์ประกอบ

int lastIndexOf(Object) ส่งคืนดัชนีของการเกิดครั้งสุดท้ายขององค์ประกอบที่ระบุในรายการมิฉะนั้นจะคืนค่า -1 เมื่อไม่พบองค์ประกอบ

รายการปฏิบัติการใน Erlang

ในส่วนนี้เราจะพูดถึงการดำเนินการบางอย่างที่สามารถทำได้ในรายการใน Erlang

การเพิ่มสองรายการ

วิธีการผนวก (listfirst, listecond) ใช้เพื่อสร้างรายการใหม่โดยเพิ่มสองรายการ ตัวอย่างเช่น,

append(list1,list2)

การลบองค์ประกอบ

วิธีการลบ (องค์ประกอบชื่อรายการ) ใช้เพื่อลบองค์ประกอบที่ระบุออกจากรายการและส่งคืนรายการใหม่ ตัวอย่างเช่น,

delete(5,list1)

การลบองค์ประกอบสุดท้ายออกจากรายการ

วิธี droplast (listname) ใช้เพื่อลบองค์ประกอบสุดท้ายออกจากรายการและส่งคืนรายการใหม่ ตัวอย่างเช่น,

droplast(list1)

กำลังค้นหาองค์ประกอบ

เมธอด member (element, listname) ถูกใช้เพื่อค้นหาอิลิเมนต์ในรายการหากพบว่าจะส่งคืนค่า true มิฉะนั้นจะส่งกลับเท็จ ตัวอย่างเช่น,

member(5,list1)

รับค่าสูงสุดและต่ำสุด

วิธีการ max (listname) และ min (listname) ใช้เพื่อค้นหาค่าสูงสุดและต่ำสุดในรายการ ตัวอย่างเช่น,

max(list1)

การจัดเรียงองค์ประกอบรายการ

วิธีการเรียงลำดับ (listname) และ reverse (listname) ใช้เพื่อเรียงลำดับรายการจากน้อยไปมากหรือมากไปหาน้อย ตัวอย่างเช่น,

sort(list1)

การเพิ่มองค์ประกอบรายการ

วิธี sum (listname) ใช้เพื่อเพิ่มองค์ประกอบทั้งหมดของรายการและส่งคืนผลรวม ตัวอย่างเช่น,

sum(list1)

เรียงลำดับรายการจากน้อยไปมากและจากมากไปหาน้อยโดยใช้ Java

โปรแกรมต่อไปนี้แสดงวิธีการเรียงลำดับรายการจากน้อยไปหามากโดยใช้ Java -

import java.util.*; 
import java.lang.*; 
import java.io.*;  

public class SortList { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> list1 = new ArrayList<String>(); 
      list1.add("5"); 
      list1.add("3"); 
      list1.add("1"); 
      list1.add("4"); 
      list1.add("2"); 
  
      System.out.println("list before sorting: " + list1); 
  
      Collections.sort(list1); 
  
      System.out.println("list in ascending order: " + list1); 
      Collections.reverse(list1); 
  
      System.out.println("list in dsending order: " + list1); 
   } 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

list before sorting     : [5, 3, 1, 4, 2] 
list in ascending order : [1, 2, 3, 4, 5] 
list in dsending order  : [5, 4, 3, 2, 1]

จัดเรียงรายการจากน้อยไปมากโดยใช้ Erlang

โปรแกรมต่อไปนี้แสดงวิธีการเรียงลำดับรายการจากน้อยไปมากและจากมากไปหาน้อยโดยใช้ Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

-module(helloworld).  
-import(lists,[sort/1]).  
-export([start/0]).   

start() ->  
   List1 = [5,3,4,2,1],  
   io:fwrite("~p~n",[sort(List1)]),

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[1,2,3,4,5]

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

โปรแกรมกำหนดทูเพิลใน C #

โปรแกรมต่อไปนี้แสดงวิธีการกำหนดทูเพิลสี่คำและพิมพ์โดยใช้ C # ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ

using System; 
public class Test { 
   public static void Main() { 
      var t1 = Tuple.Create(1, 2, 3, new Tuple<int, int>(4, 5));   
      Console.WriteLine("Tuple:" + t1);    
   } 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Tuple :(1, 2, 3, (4, 5))

โปรแกรมกำหนดทูเพิลใน Erlang

โปรแกรมต่อไปนี้แสดงวิธีกำหนดทูเพิลสี่คำและพิมพ์โดยใช้ Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้

-module(helloworld).  
-export([start/0]).   

start() -> 
   P = {1,2,3,{4,5}} ,  
   io:fwrite("~w",[P]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

{1, 2, 3, {4, 5}}

ข้อดีของ Tuple

Tuples มีข้อดีดังต่อไปนี้ -

  • สิ่งทอมีขนาดที่ถูกปรับตามธรรมชาติเช่นเราไม่สามารถเพิ่ม / ลบองค์ประกอบไปยัง / จากทูเปิลได้

  • เราสามารถค้นหาองค์ประกอบใดก็ได้ในทูเพิล

  • Tuples เร็วกว่ารายการเนื่องจากมีชุดค่าคงที่

  • Tuples สามารถใช้เป็นคีย์พจนานุกรมได้เนื่องจากมีค่าที่ไม่เปลี่ยนรูปเช่นสตริงตัวเลข ฯลฯ

Tuples vs Lists

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

การดำเนินการกับทูเปิล

ในส่วนนี้เราจะพูดถึงการดำเนินการบางอย่างที่สามารถทำได้กับทูเพิล

ตรวจสอบว่าค่าที่แทรกเป็น Tuple หรือไม่

วิธีการ is_tuple(tuplevalues)ใช้เพื่อพิจารณาว่าค่าที่แทรกเป็นทูเปิลหรือไม่ มันกลับมาtrue เมื่อค่าที่แทรกเป็นทูเปิลมิฉะนั้นจะส่งกลับ false. ตัวอย่างเช่น,

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} , io:fwrite("~w",[is_tuple(K)]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

True

การแปลงรายชื่อเป็นทูเพิล

วิธีการ list_to_tuple(listvalues)แปลงรายการเป็นทูเพิล ตัวอย่างเช่น,

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[list_to_tuple([1,2,3,4,5])]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

{1, 2, 3, 4, 5}

การแปลงทูเพิลเป็นรายการ

วิธีการ tuple_to_list(tuplevalues)แปลงทูเพิลที่ระบุเป็นรูปแบบรายการ ตัวอย่างเช่น,

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[tuple_to_list({1,2,3,4,5})]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[1, 2, 3, 4, 5]

ตรวจสอบขนาดทูเพิล

วิธีการ tuple_size(tuplename)ส่งคืนขนาดของทูเปิล ตัวอย่างเช่น,

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5

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

จะสร้างบันทึกได้อย่างไร?

คำสำคัญ 'record' ใช้เพื่อสร้างเรกคอร์ดที่ระบุด้วยชื่อเรกคอร์ดและฟิลด์ ไวยากรณ์มีดังนี้ -

record(recodname, {field1, field2, . . fieldn})

ไวยากรณ์ที่จะแทรกค่าลงในเรกคอร์ดคือ -

#recordname {fieldName1 = value1, fieldName2 = value2 .. fieldNamen = valuen}

โปรแกรมสร้างบันทึกโดยใช้ Erlang

ในตัวอย่างต่อไปนี้เราได้สร้างบันทึกชื่อ student มีสองฟิลด์กล่าวคือ sname และ sid.

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5}.

โปรแกรมสร้างบันทึกโดยใช้ C ++

ตัวอย่างต่อไปนี้แสดงวิธีสร้างเร็กคอร์ดโดยใช้ C ++ ซึ่งเป็นภาษาโปรแกรมเชิงวัตถุ -

#include<iostream> 
#include<string>
using namespace std; 

class student {
   public: 
   string sname; 
   int sid; 
   15 
}; 

int main() {    
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   return 0;  
}

โปรแกรมเข้าถึงบันทึกค่าโดยใช้ Erlang

โปรแกรมต่อไปนี้แสดงให้เห็นว่าค่าบันทึกการเข้าถึงโดยใช้ Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้ -

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   io:fwrite("~p~n",[S#student.sid]),  
   io:fwrite("~p~n",[S#student.sname]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5 
"Sachin"

โปรแกรมเข้าถึงบันทึกค่าโดยใช้ C ++

โปรแกรมต่อไปนี้แสดงวิธีการเข้าถึงบันทึกค่าโดยใช้ C ++ -

#include<iostream> 
#include<string> 
using namespace std; 

class student {     
   public: 
   string sname; 
   int sid; 
}; 

int main() {     
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   cout<<S.sid<<"\n"<<S.sname;  
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5 
Sachin

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

โปรแกรมปรับปรุงบันทึกค่าโดยใช้ Erlang

โปรแกรมต่อไปนี้แสดงวิธีการอัพเดตค่าเรกคอร์ดโดยใช้ Erlang -

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   S1 = S#student{sname = "Jonny"},  
   io:fwrite("~p~n",[S1#student.sid]),  
   io:fwrite("~p~n",[S1#student.sname]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

5
"Jonny"

โปรแกรมปรับปรุงบันทึกค่าโดยใช้ C ++

โปรแกรมต่อไปนี้แสดงวิธีการอัพเดตค่าเรกคอร์ดโดยใช้ C ++ -

#include<iostream> 
#include<string> 
using namespace std;  

class student {    
   public: 
   string sname; 
   int sid; 
};  

int main() {     
   student S;  
   S.sname = "Jonny"; 
   S.sid = 5; 
   cout<<S.sname<<"\n"<<S.sid; 
   cout<<"\n"<< "value after updating"<<"\n"; 
   S.sid = 10; 
   cout<<S.sname<<"\n"<<S.sid; 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Jonny 
5 
value after updating 
Jonny 
10

แคลคูลัสแลมบ์ดาเป็นโครงร่างที่พัฒนาโดย Alonzo Church ในปี 1930 เพื่อศึกษาการคำนวณด้วยฟังก์ชัน

  • Function creation - คริสตจักรแนะนำสัญกรณ์ λx.Eเพื่อแสดงถึงฟังก์ชันซึ่ง 'x' เป็นอาร์กิวเมนต์ที่เป็นทางการและ 'E' คือเนื้อความที่ใช้งานได้ ฟังก์ชันเหล่านี้สามารถไม่มีชื่อและอาร์กิวเมนต์เดียว

  • Function application - คริสตจักรใช้สัญกรณ์ E1.E2 เพื่อแสดงถึงการประยุกต์ใช้ฟังก์ชัน E1 เพื่อโต้แย้งจริง E2. และฟังก์ชันทั้งหมดอยู่ในอาร์กิวเมนต์เดียว

ไวยากรณ์ของแลมบ์ดาแคลคูลัส

แคลคูลัส Lamdba ประกอบด้วยนิพจน์สามประเภท ได้แก่

E :: = x (ตัวแปร)

| E 1 E 2 (แอปพลิเคชันฟังก์ชัน)

| λx.E (การสร้างฟังก์ชัน)

ที่ไหน λx.E เรียกว่าแลมบ์ดานามธรรมและ E เรียกว่าλ - นิพจน์

การประเมิน Lambda Calculus

แคลคูลัสแลมบ์ดาบริสุทธิ์ไม่มีฟังก์ชันในตัว ให้เราประเมินนิพจน์ต่อไปนี้ -

(+ (* 5 6) (* 8 3))

ที่นี่เราไม่สามารถเริ่มต้นด้วย "+" ได้เพราะมันทำงานกับตัวเลขเท่านั้น มีสองนิพจน์ที่ลดลงได้: (* 5 6) และ (* 8 3)

เราลดอย่างใดอย่างหนึ่งก่อนก็ได้ ตัวอย่างเช่น -

(+ (* 5 6) (* 8 3)) 
(+ 30 (* 8 3)) 
(+ 30 24) 
= 54

β-กฎการลด

เราต้องการกฎการลดเพื่อจัดการกับ

(λx . * 2 x) 4 
(* 2 4) 
= 8

สิ่งนี้เรียกว่าβ-reduction

อาจใช้พารามิเตอร์ที่เป็นทางการหลายครั้ง -

(λx . + x x) 4 
(+ 4 4) 
= 8

เมื่อมีคำศัพท์หลายคำเราสามารถจัดการได้ดังนี้ -

(λx . (λx . + (− x 1)) x 3) 9

ด้านใน x เป็นของภายใน λ และ x ด้านนอกเป็นของด้านนอก

(λx . + (− x 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
= 11

ตัวแปรฟรีและถูกผูกไว้

ในนิพจน์ลักษณะที่ปรากฏของตัวแปรแต่ละตัวจะเป็น "อิสระ" (ถึงλ) หรือ "ผูก" (ถึง a λ)

β-ลดของ (λx . E) y แทนที่ทุก x ที่เกิดขึ้นฟรีใน E ด้วย y. ตัวอย่างเช่น -

การลดอัลฟา

การลดอัลฟาทำได้ง่ายมากและสามารถทำได้โดยไม่ต้องเปลี่ยนความหมายของนิพจน์แลมบ์ดา

λx . (λx . x) (+ 1 x) ↔ α λx . (λy . y) (+ 1 x)

ตัวอย่างเช่น -

(λx . (λx . + (− x 1)) x 3) 9 
(λx . (λy . + (− y 1)) x 3) 9 
(λy . + (− y 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
11

ทฤษฎีบทของ Church-Rosser

ทฤษฎีบทของ Church-Rosser ระบุดังต่อไปนี้ -

  • ถ้า E1 ↔ E2 จะมี E อยู่เช่นนั้น E1 → E และ E2 → E“ การลดลงด้วยวิธีใด ๆ ก็สามารถให้ผลลัพธ์เดียวกันได้ในที่สุด”

  • ถ้า E1 → E2 และ E2 เป็นรูปแบบปกติจะมีการลดลำดับปกติของ E1 เป็น E2 “ การลดคำสั่งปกติจะทำให้เกิดรูปแบบปกติเสมอหากมีอยู่”

การประเมินผลแบบขี้เกียจเป็นกลยุทธ์การประเมินผลซึ่งถือการประเมินผลของนิพจน์จนกว่าจะต้องการค่า หลีกเลี่ยงการประเมินซ้ำ ๆHaskell เป็นตัวอย่างที่ดีของภาษาโปรแกรมที่ใช้งานได้ซึ่งมีพื้นฐานมาจาก Lazy Evaluation

Lazy evaluation ใช้ในฟังก์ชัน Unix map เพื่อปรับปรุงประสิทธิภาพโดยการโหลดเฉพาะหน้าที่ต้องการจากดิสก์ จะไม่มีการจัดสรรหน่วยความจำสำหรับหน้าที่เหลือ

การประเมินความเกียจคร้าน - ข้อดี

  • อนุญาตให้รันไทม์ภาษาทิ้งนิพจน์ย่อยที่ไม่ได้เชื่อมโยงโดยตรงกับผลลัพธ์สุดท้ายของนิพจน์

  • ช่วยลดความซับซ้อนของเวลาของอัลกอริทึมโดยการละทิ้งการคำนวณและเงื่อนไขชั่วคราว

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

  • เหมาะที่สุดสำหรับการโหลดข้อมูลซึ่งจะเข้าถึงได้ไม่บ่อยนัก

การประเมินความเกียจคร้าน - ข้อเสีย

  • มันบังคับให้รันไทม์ของภาษาเก็บการประเมินนิพจน์ย่อยไว้จนกว่าจะต้องการในผลลัพธ์สุดท้ายโดยการสร้าง thunks (วัตถุล่าช้า)

  • บางครั้งก็เพิ่มความซับซ้อนของพื้นที่ของอัลกอริทึม

  • เป็นเรื่องยากมากที่จะพบประสิทธิภาพของมันเนื่องจากมีการแสดงออกมากมายก่อนที่จะดำเนินการ

Lazy Evaluation โดยใช้ Python

rangeวิธีการใน Python เป็นไปตามแนวคิดของ Lazy Evaluation ช่วยประหยัดเวลาในการดำเนินการสำหรับช่วงที่ใหญ่ขึ้นและเราไม่ต้องการค่าทั้งหมดในคราวเดียวดังนั้นจึงช่วยประหยัดการใช้หน่วยความจำด้วย ลองดูตัวอย่างต่อไปนี้

r = range(10) 
print(r) 
range(0, 10) 
print(r[3])

มันจะสร้างผลลัพธ์ต่อไปนี้ -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
3

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

นี่คือรายการของการดำเนินการบางอย่างที่สามารถทำได้ในไฟล์ -

  • การสร้างไฟล์ใหม่
  • เปิดไฟล์ที่มีอยู่
  • การอ่านเนื้อหาไฟล์
  • การค้นหาข้อมูลในไฟล์
  • เขียนลงในไฟล์ใหม่
  • การอัปเดตเนื้อหาเป็นไฟล์ที่มีอยู่
  • การลบไฟล์
  • การปิดไฟล์

การเขียนลงในไฟล์

ในการเขียนเนื้อหาลงในไฟล์เราจะต้องเปิดไฟล์ที่ต้องการก่อน หากไม่มีไฟล์ที่ระบุไฟล์ใหม่จะถูกสร้างขึ้น

มาดูวิธีการเขียนเนื้อหาลงในไฟล์โดยใช้ C ++

ตัวอย่าง

#include <iostream> 
#include <fstream> 
using namespace std;  

int main () {   
   ofstream myfile; 
   myfile.open ("Tempfile.txt", ios::out); 
   myfile << "Writing Contents to file.\n"; 
   cout << "Data inserted into file"; 
   myfile.close(); 
   return 0; 
}

Note -

  • fstream เป็นคลาสสตรีมที่ใช้ควบคุมการอ่าน / เขียนไฟล์

  • ofstream เป็นคลาสสตรีมที่ใช้ในการเขียนเนื้อหาลงในไฟล์

มาดูวิธีการเขียนเนื้อหาลงในไฟล์โดยใช้ Erlang ซึ่งเป็นภาษาโปรแกรมที่ใช้งานได้

-module(helloworld).  
-export([start/0]).   

start() ->
   {ok, File1} = file:open("Tempfile.txt", [write]),  
   file:write(File1,"Writting contents to file"), 
   io:fwrite("Data inserted into file\n").

Note -

  • ในการเปิดไฟล์เราต้องใช้ open(filename,mode).

  • ไวยากรณ์ในการเขียนเนื้อหาลงไฟล์: write(filemode,file_content).

Output - เมื่อเรารันโค้ดนี้“ การเขียนเนื้อหาลงไฟล์” จะถูกเขียนลงในไฟล์ Tempfile.txt. หากไฟล์มีเนื้อหาที่มีอยู่ไฟล์นั้นจะถูกเขียนทับ

อ่านจากไฟล์

ในการอ่านจากไฟล์ก่อนอื่นเราต้องเปิดไฟล์ที่ระบุใน reading mode. ถ้าไฟล์ไม่มีอยู่เมธอดตามลำดับจะคืนค่า NULL

โปรแกรมต่อไปนี้แสดงวิธีการอ่านเนื้อหาของไฟล์ในรูปแบบ C++ -

#include <iostream> 
#include <fstream> 
#include <string> 
using namespace std;  

int main () {
   string readfile; 
   ifstream myfile ("Tempfile.txt",ios::in); 
   
   if (myfile.is_open()) {     
      while ( getline (myfile,readfile) ) {       
         cout << readfile << '\n'; 
      } 
      myfile.close(); 
   } else  
      cout << "file doesn't exist";  
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

Writing contents to file

Note- ในโปรแกรมนี้เราเปิดไฟล์ข้อความในโหมดอ่านโดยใช้“ ios :: in” จากนั้นพิมพ์เนื้อหาบนหน้าจอ เราได้ใช้while วนซ้ำเพื่ออ่านเนื้อหาไฟล์ทีละบรรทัดโดยใช้เมธอด "getline"

โปรแกรมต่อไปนี้แสดงวิธีดำเนินการเดียวกันโดยใช้ Erlang. ที่นี่เราจะใช้ไฟล์read_file(filename) วิธีการอ่านเนื้อหาทั้งหมดจากไฟล์ที่ระบุ

-module(helloworld).  
-export([start/0]).   

start() ->  
   rdfile = file:read_file("Tempfile.txt"),  
   io:fwrite("~p~n",[rdfile]).

มันจะสร้างผลลัพธ์ต่อไปนี้ -

ok, Writing contents to file

ลบไฟล์ที่มีอยู่

เราสามารถลบไฟล์ที่มีอยู่โดยใช้การทำงานของไฟล์ โปรแกรมต่อไปนี้แสดงวิธีการลบไฟล์ที่มีอยู่using C++ -

#include <stdio.h> 

int main () {   
   if(remove( "Tempfile.txt" ) != 0 ) 
      perror( "File doesn’t exist, can’t delete" ); 
   else 
      puts( "file deleted successfully " ); 
   return 0; 
}

มันจะสร้างผลลัพธ์ต่อไปนี้ -

file deleted successfully

โปรแกรมต่อไปนี้แสดงวิธีการดำเนินการเดียวกันใน Erlang. ที่นี่เราจะใช้วิธีdelete(filename) เพื่อลบไฟล์ที่มีอยู่

-module(helloworld).  
-export([start/0]).   

start() ->  
   file:delete("Tempfile.txt").

Output - หากไฟล์“ Tempfile.txt” มีอยู่ไฟล์นั้นจะถูกลบ

การกำหนดขนาดของไฟล์

โปรแกรมต่อไปนี้แสดงวิธีกำหนดขนาดของไฟล์โดยใช้ C ++ ที่นี่ฟังก์ชั่นfseek ตั้งค่าตัวบ่งชี้ตำแหน่งที่เกี่ยวข้องกับสตรีมเป็นตำแหน่งใหม่ในขณะที่ ftell ส่งคืนตำแหน่งปัจจุบันในสตรีม

#include <stdio.h> 

int main () {  
   FILE * checkfile; 
   long size; 
   checkfile = fopen ("Tempfile.txt","rb"); 
   
   if (checkfile == NULL)  
      perror ("file can’t open"); 
   else {   
      fseek (checkfile, 0, SEEK_END);    // non-portable 
      size = ftell (checkfile); 
      fclose (checkfile); 
      printf ("Size of Tempfile.txt: %ld bytes.\n",size); 
   } 
   return 0; 
}

Output - หากไฟล์“ Tempfile.txt” มีอยู่ไฟล์นั้นจะแสดงขนาดเป็นไบต์

โปรแกรมต่อไปนี้แสดงวิธีการดำเนินการเดียวกันใน Erlang ที่นี่เราจะใช้วิธีfile_size(filename) เพื่อกำหนดขนาดของไฟล์

-module(helloworld).  
-export([start/0]).   

start() ->  
   io:fwrite("~w~n",[filelib:file_size("Tempfile.txt")]).

Output- หากไฟล์“ Tempfile.txt” มีอยู่ไฟล์นั้นจะแสดงขนาดเป็นไบต์ มิฉะนั้นจะแสดง“ 0”

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved