Erlang - คู่มือฉบับย่อ

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

Erlang เวอร์ชันแรกได้รับการพัฒนาโดย Joe Armstrong, Robert Virding และ Mike Williams ในปี 1986 เดิมเป็นภาษาเฉพาะของ Ericsson ต่อมาได้รับการเผยแพร่เป็นภาษาโอเพ่นซอร์สในปี พ.ศ. 2541 Erlang พร้อมกับ OTP ซึ่งเป็นชุดของมิดเดิลแวร์และไลบรารีใน Erlang ได้รับการสนับสนุนและดูแลโดยหน่วยผลิตภัณฑ์ OTP ที่ Ericsson และเรียกกันอย่างแพร่หลายว่าErlang/OTP.

ทำไมต้อง Erlang?

ควรใช้ Erlang เพื่อพัฒนาแอปพลิเคชันของคุณหากคุณมีข้อกำหนดดังต่อไปนี้ -

  • แอปพลิเคชันจำเป็นต้องจัดการกิจกรรมพร้อมกันจำนวนมาก

  • ควรกระจายได้ง่ายผ่านเครือข่ายคอมพิวเตอร์

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

  • แอปพลิเคชันควรปรับขนาดได้ ซึ่งหมายความว่าควรมีความสามารถในการขยายข้ามเซิร์ฟเวอร์หลายเครื่องโดยมีการเปลี่ยนแปลงเพียงเล็กน้อยหรือไม่มีเลย

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

  • แอปพลิเคชันควรตอบสนองต่อผู้ใช้ภายในกรอบเวลาที่เข้มงวด

เว็บไซต์อย่างเป็นทางการของ Erlang คือ https://www.erlang.org/.

ก่อนที่คุณจะสามารถเริ่มทำงานกับ Erlang ได้คุณต้องตรวจสอบให้แน่ใจว่าคุณมี Erlang เวอร์ชันที่ทำงานได้อย่างสมบูรณ์บนระบบ ส่วนนี้จะกล่าวถึงการติดตั้ง Erlang และการกำหนดค่าตามมาในเครื่อง windows เพื่อเริ่มต้นกับ Erlang

ตรวจสอบให้แน่ใจว่าเป็นไปตามข้อกำหนดของระบบต่อไปนี้ก่อนดำเนินการติดตั้ง

System Requirements

หน่วยความจำ RAM 2 GB (แนะนำ)
พื้นที่ดิสก์ ไม่มีข้อกำหนดขั้นต่ำ ควรมีพื้นที่เก็บข้อมูลเพียงพอสำหรับจัดเก็บแอปพลิเคชันซึ่งจะสร้างโดยใช้ Erlang
เวอร์ชันระบบปฏิบัติการ Erlang สามารถติดตั้งบน Windows, Ubuntu / Debian, Mac OS X

กำลังดาวน์โหลด Erlang

ในการดาวน์โหลด Erlang หนึ่งต้องไปที่ URL ต่อไปนี้ - www.erlang.org/downloads

หน้านี้มีการดาวน์โหลดที่หลากหลายและขั้นตอนที่จำเป็นในการดาวน์โหลดและติดตั้งภาษาบนแพลตฟอร์ม Linux และ Mac

คลิกที่ 'OTP 18.3 Windows 32-bit Binary File' เพื่อเริ่มดาวน์โหลดไฟล์การติดตั้ง Erlang Windows

การติดตั้ง Erlang

ขั้นตอนต่อไปนี้แสดงรายละเอียดวิธีการติดตั้ง Erlang บน Windows -

Step 1- เปิดตัวติดตั้งที่ดาวน์โหลดมาในส่วนก่อนหน้านี้ หลังจากโปรแกรมติดตั้งเริ่มทำงานให้คลิกเรียกใช้

Step 2 - คลิกถัดไปบนหน้าจอต่อไปนี้เพื่อยอมรับส่วนประกอบเริ่มต้นซึ่งจะถูกติดตั้ง

Step 3 - ยอมรับเส้นทางการติดตั้งเริ่มต้นแล้วคลิกถัดไป

Step 4 - ยอมรับรายการ Start Menu เริ่มต้นซึ่งจะถูกสร้างขึ้นแล้วคลิกถัดไป

Step 5 - หลังจากการติดตั้งเสร็จสิ้นให้คลิกปิดเพื่อทำการติดตั้ง

การกำหนดค่า Erlang

หลังจากการติดตั้งเสร็จสิ้นจำเป็นต้องดำเนินการกำหนดค่าต่อไปนี้เพื่อให้แน่ใจว่า Erlang เริ่มทำงานกับระบบ

ระบบปฏิบัติการ เอาต์พุต
Windows ต่อท้ายสตริง; C: \ Program Files (x86) \ erl7.2.1 \ bin หรือ C: \ Program Files \ erl7.2.1 \ bin ต่อท้ายตัวแปรระบบ PATH

หากคุณเปิดพรอมต์คำสั่งแล้วพิมพ์ erlคุณควรจะได้รับพรอมต์คำสั่ง erl

ขอแสดงความยินดีตอนนี้คุณได้กำหนดค่า erl บนแล็ปท็อปของคุณเรียบร้อยแล้ว

การติดตั้งปลั๊กอินบน IDE ยอดนิยม

Erlang เป็นภาษาโปรแกรมยังมีอยู่ใน IDE ยอดนิยมเช่น Eclipse and IntelliJ. มาดูกันว่าเราจะรับปลั๊กอินที่จำเป็นใน IDE เหล่านี้ได้อย่างไรเพื่อให้คุณมีทางเลือกมากขึ้นในการทำงานกับ Erlang

การติดตั้งใน Eclipse

Step 1 - เปิด Eclipse แล้วคลิกรายการเมนู Help → Install New Software.

Step 2 - เข้าสู่ลิงค์ Work with as https://download.erlide.org/update

จากนั้นคลิกเพิ่ม

Step 3 - จากนั้นคุณจะได้รับแจ้งให้ป้อนชื่อสำหรับปลั๊กอินป้อนชื่อเป็น Erlide. คลิกตกลง

Step 4- Eclipse จะสแกนลิงค์ที่ให้มาและรับปลั๊กอินที่จำเป็น ตรวจสอบปลั๊กอินแล้วคลิกถัดไป

Step 5- ในกล่องโต้ตอบถัดไป Eclipse จะแสดงส่วนประกอบทั้งหมดที่จะติดตั้ง คลิกถัดไป

Step 6- ในกล่องโต้ตอบถัดไป Eclipse จะขอให้ตรวจสอบส่วนประกอบที่กำลังติดตั้ง คลิกถัดไป

Step 7- ในกล่องโต้ตอบถัดไปคุณต้องยอมรับข้อตกลงใบอนุญาต สุดท้ายคลิกปุ่มเสร็จสิ้น

จากนั้นการติดตั้งจะเริ่มขึ้นและเมื่อเสร็จสิ้นระบบจะแจ้งให้คุณรีสตาร์ท Eclipse

เมื่อ Eclipse ถูกรีสตาร์ทเมื่อคุณสร้างโปรเจ็กต์คุณจะสามารถเห็น Erlang เป็นตัวเลือกได้เช่นกัน

การติดตั้งใน IntelliJ

โปรดทำตามขั้นตอนต่อไปเพื่อติดตั้ง IntelliJ ในคอมพิวเตอร์ของคุณ

Step 1 - เปิด IntelliJ แล้วคลิก Configure → Plugins

Step 2- พิมพ์ Erlang ในช่องค้นหา คุณจะได้รับปลั๊กอิน Erlang ทางด้านขวามือของหน้าจอ คลิกปุ่มติดตั้ง

Step 3 - หลังจากติดตั้งปลั๊กอิน Erlang แล้วคุณจะได้รับแจ้งให้รีสตาร์ท IDE

เมื่อคุณรีสตาร์ท IDE และพยายามสร้างโปรเจ็กต์ใหม่คุณจะเห็นตัวเลือกในการสร้างโปรเจ็กต์ Erlang

เพื่อที่จะเข้าใจไวยากรณ์พื้นฐานของ Erlang ก่อนอื่นเรามาดูง่ายๆ Hello World โปรแกรม.

ตัวอย่าง

% hello world program
-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello, world!\n").

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • เครื่องหมาย% ใช้เพื่อเพิ่มความคิดเห็นให้กับโปรแกรม

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

  • ฟังก์ชันการส่งออกถูกใช้เพื่อให้สามารถใช้ฟังก์ชันใด ๆ ที่กำหนดไว้ภายในโปรแกรมได้ เรากำลังกำหนดฟังก์ชันที่เรียกว่า start และในการใช้ฟังก์ชัน start เราต้องใช้คำสั่ง export /0 หมายความว่าฟังก์ชัน 'start' ของเรายอมรับพารามิเตอร์ 0

  • ในที่สุดเราก็กำหนดฟังก์ชันเริ่มต้นของเรา ที่นี่เราใช้โมดูลอื่นที่เรียกว่าioซึ่งมีฟังก์ชันอินพุตเอาต์พุตที่จำเป็นทั้งหมดใน Erlang เราใช้ไฟล์fwrite ฟังก์ชันเพื่อส่งออก“ Hello World” ไปยังคอนโซล

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

Hello, world!

รูปแบบทั่วไปของคำชี้แจง

ใน Erlang คุณได้เห็นว่ามีสัญลักษณ์ต่าง ๆ ที่ใช้ในภาษา Erlang มาดูสิ่งที่เราได้เห็นจากโปรแกรม Hello World แบบง่ายๆ -

  • สัญลักษณ์ยัติภังค์ (–)โดยทั่วไปจะใช้ร่วมกับโมดูลคำสั่งนำเข้าและส่งออก สัญลักษณ์ยัติภังค์ใช้เพื่อให้ความหมายของแต่ละคำสั่งตามนั้น ดังนั้นตัวอย่างจากโปรแกรม Hello world จะแสดงในโปรแกรมต่อไปนี้ -

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

แต่ละคำสั่งถูกคั่นด้วยจุด (.)สัญลักษณ์. แต่ละคำสั่งใน Erlang จำเป็นต้องลงท้ายด้วยตัวคั่นนี้ ตัวอย่างจากโปรแกรม Hello world ดังที่แสดงในโปรแกรมต่อไปนี้ -

io:fwrite("Hello, world!\n").

  • เครื่องหมายทับ (/) สัญลักษณ์ถูกใช้ร่วมกับฟังก์ชันเพื่อกำหนดจำนวนพารามิเตอร์ที่ฟังก์ชันยอมรับ

-export([start/0]).

โมดูล

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

การกำหนดโมดูล

โมดูลถูกกำหนดด้วยตัวระบุโมดูล ไวยากรณ์และตัวอย่างทั่วไปมีดังนี้

ไวยากรณ์

-module(ModuleName)

ModuleName จะต้องเหมือนกับชื่อไฟล์ลบนามสกุล .erl. มิฉะนั้นการโหลดโค้ดจะไม่ทำงานตามที่ตั้งใจไว้

ตัวอย่าง

-module(helloworld)

โมดูลเหล่านี้จะกล่าวถึงรายละเอียดในบทต่อ ๆ ไปนี่เป็นเพียงเพื่อให้คุณมีความเข้าใจพื้นฐานว่าควรกำหนดโมดูลอย่างไร

คำชี้แจงการนำเข้าใน Erlang

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

ตัวอย่าง

-import (modulename, [functionname/parameter]).

ที่ไหน

  • Modulename - นี่คือชื่อของโมดูลที่ต้องนำเข้า

  • functionname/parameter - ฟังก์ชั่นในโมดูลที่ต้องนำเข้า

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

ตัวอย่าง

% hello world program
-module(helloworld).
-import(io,[fwrite/1]).
-export([start/0]).

start() ->
   fwrite("Hello, world!\n").

ในโค้ดด้านบนเราใช้คีย์เวิร์ด import เพื่อนำเข้าไลบรารี 'io' และโดยเฉพาะไฟล์ fwriteฟังก์ชัน ดังนั้นเมื่อใดก็ตามที่เราเรียกใช้ฟังก์ชัน fwrite เราไม่ต้องพูดถึงio ชื่อโมดูลทุกที่

คำสำคัญใน Erlang

คำหลักเป็นคำสงวนใน Erlang ซึ่งไม่ควรใช้เพื่อวัตถุประสงค์อื่นใดนอกเหนือจากวัตถุประสงค์ที่มีไว้เพื่อ ต่อไปนี้เป็นรายการคำหลักใน Erlang

หลังจาก และ และนอกจากนี้ยังมี วงดนตรี
เริ่ม bnot บอ bsl
bsr bxor กรณี จับ
เงื่อนไข div จบ สนุก
ถ้า ปล่อย ไม่ ของ
หรือ หรืออื่น ๆ รับ rem
ลอง เมื่อไหร่ xor

ความคิดเห็นใน Erlang

ข้อคิดเห็นใช้ในการจัดทำเอกสารรหัสของคุณ ความคิดเห็นบรรทัดเดียวระบุได้โดยใช้ไฟล์%สัญลักษณ์ที่ตำแหน่งใดก็ได้ในเส้น ต่อไปนี้เป็นตัวอย่างเดียวกัน -

ตัวอย่าง

% hello world program
-module(helloworld).
% import function used to import the io module
-import(io,[fwrite/1]).
% export function used to ensure the start function can be accessed.
-export([start/0]).

start() ->
   fwrite("Hello, world!\n").

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

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

หลังจากดำเนินการคำสั่งเชลล์จะพิมพ์พรอมต์อื่นออกมาคราวนี้สำหรับ Command Number 2 (เนื่องจากหมายเลขคำสั่งเพิ่มขึ้นทุกครั้งที่ป้อนคำสั่งใหม่)

ฟังก์ชันต่อไปนี้เป็นฟังก์ชันที่ใช้บ่อยที่สุดในเชลล์ Erlang

  • b() - พิมพ์การผูกตัวแปรปัจจุบัน

  • Syntax - ข ().

  • For example- ต่อไปนี้เป็นตัวอย่างวิธีการใช้ฟังก์ชัน ก่อนอื่นเรียกตัวแปรStr ถูกกำหนดซึ่งมีค่า abcd. แล้วb() ใช้เพื่อแสดงตัวแปรที่ผูกไว้ทั้งหมด

  • f() - ลบการผูกตัวแปรปัจจุบันทั้งหมด

  • Syntax - ฉ ()

  • For example- ต่อไปนี้เป็นตัวอย่างวิธีการใช้ฟังก์ชัน ก่อนอื่นให้กำหนดตัวแปรที่เรียกว่า Str ซึ่งมีค่า abcd จากนั้น f () จะถูกใช้เพื่อลบการโยงตัวแปร Str จากนั้น b () จะถูกเรียกเพื่อให้แน่ใจว่าการผูกได้ถูกลบออกเรียบร้อยแล้ว

  • f(x) - ลบการผูกสำหรับตัวแปรเฉพาะ

  • Syntax- f (x) โดยที่ x - คือตัวแปรที่ต้องลบการโยงออก

  • For example- ต่อไปนี้เป็นตัวอย่างวิธีการใช้ฟังก์ชัน ก่อนอื่นให้กำหนดตัวแปรที่เรียกว่า Str และ Str1 จากนั้น f (Str) จะถูกใช้เพื่อลบการโยงตัวแปร Str จากนั้น b () จะถูกเรียกเพื่อให้แน่ใจว่าการผูกได้ถูกลบออกเรียบร้อยแล้ว

  • h() - พิมพ์รายการประวัติของคำสั่งทั้งหมดที่ดำเนินการในเชลล์

  • Syntax - h ()

  • For example - ตัวอย่างของคำสั่ง h () ซึ่งพิมพ์ประวัติของคำสั่งที่ดำเนินการในเชลล์จะแสดงในภาพหน้าจอต่อไปนี้

  • history(N)- ตั้งค่าจำนวนคำสั่งก่อนหน้าเพื่อเก็บไว้ในรายการประวัติเป็น N จำนวนก่อนหน้าจะถูกส่งกลับ ตัวเลขเริ่มต้นคือ 20

  • Syntax- ประวัติ (N). โดยที่ N - คือจำนวนที่ต้อง จำกัด รายการประวัติคำสั่ง

  • For example - ตัวอย่างคำสั่ง history (N) แสดงในภาพหน้าจอต่อไปนี้

  • e(N)- ทำซ้ำคำสั่ง N ถ้า N เป็นค่าบวก ถ้ามันเป็นลบเอ็นTHคำสั่งก่อนหน้าจะถูกทำซ้ำ (เช่น (จ -1) ซ้ำคำสั่งก่อนหน้า)

  • Syntax- จ (N) ที่ไหน, N - เป็นคำสั่งที่เอ็นTHตำแหน่งในรายการ

  • For example- ตัวอย่างของคำสั่ง e (N) แสดงอยู่ด้านล่าง เนื่องจากเราได้ดำเนินการคำสั่ง e (-1) มันจะดำเนินการคำสั่งก่อนหน้าซึ่งเป็นประวัติ (5)

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

คุณอาจต้องการจัดเก็บข้อมูลประเภทข้อมูลต่างๆเช่นสตริงอักขระอักขระแบบกว้างจำนวนเต็มจุดลอยตัวบูลีนเป็นต้นระบบปฏิบัติการจะจัดสรรหน่วยความจำและตัดสินใจว่าจะจัดเก็บข้อมูลใดในส่วนที่สงวนไว้ หน่วยความจำ.

ประเภทข้อมูลในตัว

Erlang นำเสนอประเภทข้อมูลในตัวที่หลากหลาย ต่อไปนี้เป็นรายการประเภทข้อมูลที่กำหนดไว้ใน Erlang -

  • Number - ใน Erlang มีตัวอักษรตัวเลข 2 ประเภทคือจำนวนเต็มและจำนวนเต็ม

  • Atom- อะตอมเป็นค่าคงที่ตามตัวอักษรซึ่งมีชื่อ อะตอมจะต้องอยู่ในเครื่องหมายคำพูดเดี่ยว (') หากไม่ได้ขึ้นต้นด้วยตัวอักษรตัวพิมพ์เล็กหรือหากมีอักขระอื่นที่ไม่ใช่อักขระที่เป็นตัวเลขและตัวอักษรขีดล่าง (_) หรือ @

  • Boolean - ชนิดข้อมูลบูลีนใน Erlang คืออะตอมที่สงวนไว้สองอะตอม: จริงและเท็จ

  • Bit String - สตริงบิตใช้เพื่อจัดเก็บพื้นที่ของหน่วยความจำที่ไม่ได้พิมพ์

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

  • Map- แผนที่เป็นชนิดข้อมูลผสมที่มีการเชื่อมโยงคีย์ - ค่าจำนวนตัวแปร การเชื่อมโยงคีย์ - ค่าแต่ละรายการในแผนที่เรียกว่าคู่การเชื่อมโยง ส่วนสำคัญและค่าของทั้งคู่เรียกว่าองค์ประกอบ จำนวนคู่ของการเชื่อมโยงเป็นขนาดของแผนที่

  • List- รายการคือประเภทข้อมูลแบบผสมที่มีจำนวนคำที่แปรผัน แต่ละคำในรายการเรียกว่าองค์ประกอบ จำนวนองค์ประกอบเป็นความยาวของรายการ

Note- คุณจะแปลกใจที่คุณไม่เห็นประเภท String ที่ใดก็ได้ในรายการด้านบน นั่นเป็นเพราะไม่มีชนิดข้อมูลสตริงที่กำหนดไว้เฉพาะใน Erlang แต่เราจะดูว่าเราสามารถทำงานกับสตริงในบทต่อไปได้อย่างไร

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

จำนวน

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

Example

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

start() ->
   io:fwrite("~w",[1+1]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

2

อะตอม

อะตอมควรขึ้นต้นด้วยอักษรตัวพิมพ์เล็กและสามารถประกอบด้วยอักขระตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ตัวเลขขีดล่าง (_) และเครื่องหมาย“ at” (@). นอกจากนี้เรายังสามารถใส่อะตอมในเครื่องหมายคำพูดเดี่ยว

ตัวอย่างวิธีการใช้ชนิดข้อมูลอะตอมจะแสดงในโปรแกรมต่อไปนี้ ในโปรแกรมนี้เรากำลังสร้างอะตอมซึ่งเรียกว่า atom1

Example

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

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

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

atom1

บูลีน

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

Example

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

start() ->
   io:fwrite(2 =< 3).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

true

บิตสตริง

ตัวอย่างวิธีการใช้ชนิดข้อมูล Bit String แสดงในโปรแกรมต่อไปนี้ โปรแกรมนี้กำหนด Bit String ประกอบด้วย 2 บิต binary_to_list เป็นฟังก์ชัน inbuilt ที่กำหนดใน Erlang ซึ่งสามารถใช้ในการแปลง Bit String เป็นรายการ

Example

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

start() ->
   Bin1 = <<10,20>>,
   X = binary_to_list(Bin1),
   io:fwrite("~w",[X]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

[10,20]

ทูเพิล

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

เรากำลังกำหนดไฟล์ Tuple Pซึ่งมี 3 เทอม tuple_size เป็นฟังก์ชัน inbuilt ที่กำหนดไว้ใน Erlang ซึ่งสามารถใช้เพื่อกำหนดขนาดของทูเปิล

Example

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

start() -> 
   P = {john,24,{june,25}} , 
   io:fwrite("~w",[tuple_size(P)]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

3

แผนที่

ตัวอย่างวิธีใช้ชนิดข้อมูลแผนที่จะแสดงในโปรแกรมต่อไปนี้

เรากำลังกำหนดไฟล์ Map M1ซึ่งมี 2 การแมป map_size เป็นฟังก์ชัน inbuilt ที่กำหนดไว้ใน Erlang ซึ่งสามารถใช้เพื่อกำหนดขนาดของแผนที่

Example

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

start() -> 
   M1 = #{name=>john,age=>25}, 
   io:fwrite("~w",[map_size(M1)]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

2

รายการ

ตัวอย่างวิธีใช้ชนิดข้อมูลรายการจะแสดงในโปรแกรมต่อไปนี้

เรากำลังกำหนดไฟล์ List Lซึ่งมี 3 รายการ ความยาวเป็นฟังก์ชัน inbuilt ที่กำหนดไว้ใน Erlang ซึ่งสามารถใช้เพื่อกำหนดขนาดของรายการได้

Example

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

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

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

3

ใน Erlang ตัวแปรทั้งหมดถูกผูกไว้กับคำสั่ง '=' ตัวแปรทั้งหมดต้องเริ่มต้นด้วยอักขระตัวพิมพ์ใหญ่ ในภาษาโปรแกรมอื่น ๆ จะใช้เครื่องหมาย '=' สำหรับการมอบหมายงาน แต่ไม่ใช่ในกรณีของ Erlang ตามที่ระบุไว้ตัวแปรถูกกำหนดโดยใช้คำสั่ง '='

สิ่งสำคัญอย่างหนึ่งที่ควรทราบใน Erlang คือตัวแปรไม่เปลี่ยนรูปซึ่งหมายความว่าเพื่อให้ค่าของตัวแปรเปลี่ยนไปจำเป็นต้องทำลายและสร้างใหม่อีกครั้ง

ตัวแปรพื้นฐานต่อไปนี้ใน Erlang อธิบายไว้ในบทสุดท้าย -

  • Numbers- ใช้แทนจำนวนเต็มหรือจำนวนทศนิยม ตัวอย่างคือ 10

  • Boolean - แสดงถึงค่าบูลีนซึ่งอาจเป็นจริงหรือเท็จก็ได้

  • Bit String- สตริงบิตใช้เพื่อจัดเก็บพื้นที่ของหน่วยความจำที่ไม่ได้พิมพ์ ตัวอย่างคือ << 40,50 >>

  • Tuple- ทูเพิลเป็นชนิดข้อมูลผสมที่มีจำนวนคำศัพท์คงที่ ตัวอย่างคือ {40,50}

  • Map- แผนที่เป็นชนิดข้อมูลผสมที่มีการเชื่อมโยงคีย์ - ค่าจำนวนตัวแปร การเชื่อมโยงคีย์ - ค่าแต่ละรายการในแผนที่เรียกว่าคู่การเชื่อมโยง ตัวอย่างคือ {type => person, age => 25}

  • List- รายการคือประเภทข้อมูลแบบผสมที่มีจำนวนคำที่แปรผัน ตัวอย่างคือ [40,40]

การประกาศตัวแปร

ไวยากรณ์ทั่วไปของการกำหนดตัวแปรมีดังนี้ -

ไวยากรณ์

var-name = var-value

ที่ไหน

  • var-name - นี่คือชื่อของตัวแปร

  • var-value - นี่คือค่าที่ผูกไว้กับตัวแปร

ต่อไปนี้เป็นตัวอย่างของการประกาศตัวแปร -

ตัวอย่าง

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

start() -> 
   X = 40, 
   Y = 50, 
   Result = X + Y, 
   io:fwrite("~w",[Result]).

ในตัวอย่างข้างต้นเรามี 2 ตัวแปรตัวหนึ่งคือ X ซึ่งถูกผูกไว้กับค่า 40 และตัวถัดไปคือ Y ซึ่งถูกผูกไว้กับค่า 50 ตัวแปรอื่นที่เรียกว่า Result จะถูกผูกไว้กับการเพิ่ม X และ Y

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

90

การตั้งชื่อตัวแปร

ตามที่กล่าวไว้ชื่อตัวแปรต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่ มาดูตัวอย่างตัวแปรที่ประกาศเป็นตัวพิมพ์เล็ก

ตัวอย่าง

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

start() -> 
   X = 40, 
   Y = 50, 
   result = X + Y, 
   io:fwrite("~w",[Result]).

หากคุณพยายามรวบรวมโปรแกรมข้างต้นคุณจะได้รับข้อผิดพลาดเวลาคอมไพล์ดังต่อไปนี้

เอาต์พุต

helloworld.erl:8: variable 'Result' is unbound

ประการที่สองตัวแปรทั้งหมดสามารถกำหนดได้เพียงครั้งเดียว มาดูตัวอย่างการกำหนดตัวแปรมากกว่าหนึ่งครั้ง

ตัวอย่าง

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

start() -> 
   X = 40, 
   Y = 50, 
   X = 60, 
   io:fwrite("~w",[X]).

หากคุณพยายามรวบรวมโปรแกรมข้างต้นคุณจะได้รับข้อผิดพลาดเวลาคอมไพล์ดังต่อไปนี้

เอาต์พุต

helloworld.erl:6: Warning: variable 'Y' is unused
helloworld.erl:7: Warning: no clause will ever match
helloworld.erl:7: Warning: the guard for this clause evaluates to 'false'

ตัวแปรการพิมพ์

ในส่วนนี้เราจะพูดถึงวิธีการใช้ฟังก์ชันต่างๆของตัวแปรการพิมพ์

การใช้ฟังก์ชัน io: fwrite

คุณจะได้เห็นสิ่งนี้ (io: fwrite) ที่ใช้ในโปรแกรมทั้งหมดข้างต้น fwrite ฟังก์ชันเป็นส่วนหนึ่งของโมดูล 'io' หรือ Erlang ซึ่งสามารถใช้เพื่อส่งออกค่าของตัวแปรในโปรแกรม

ตัวอย่างต่อไปนี้แสดงพารามิเตอร์อีกสองสามตัวที่สามารถใช้กับคำสั่ง fwrite

ตัวอย่าง

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

start() -> 
   X = 40.00, 
   Y = 50.00, 
   io:fwrite("~f~n",[X]), 
   io:fwrite("~e",[Y]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

40.000000
5.00000e+1

ควรสังเกตคำแนะนำต่อไปนี้เกี่ยวกับโปรแกรมข้างต้น

  • ~ - อักขระนี้เป็นสัญลักษณ์ว่าต้องมีการจัดรูปแบบบางอย่างสำหรับเอาต์พุต

  • ~f- อาร์กิวเมนต์คือทศนิยมซึ่งเขียนเป็น [-] ddd.ddd โดยที่ความแม่นยำคือจำนวนหลักหลังจุดทศนิยม ความแม่นยำเริ่มต้นคือ 6 และต้องไม่น้อยกว่า 1

  • ~n - นี่คือการ println ไปยังบรรทัดใหม่

  • ~e- อาร์กิวเมนต์คือ float ซึ่งเขียนเป็น [-] d.ddde + -ddd โดยที่ความแม่นยำคือจำนวนตัวเลขที่เขียน ความแม่นยำเริ่มต้นคือ 6 และต้องไม่น้อยกว่า 2

ตัวดำเนินการคือสัญลักษณ์ที่บอกให้คอมไพเลอร์ดำเนินการจัดการทางคณิตศาสตร์หรือตรรกะเฉพาะ

Erlang มีตัวดำเนินการประเภทต่อไปนี้ -

  • ตัวดำเนินการเลขคณิต
  • ตัวดำเนินการเชิงสัมพันธ์
  • ตัวดำเนินการทางตรรกะ
  • ตัวดำเนินการ Bitwise

ตัวดำเนินการเลขคณิต

ภาษา Erlang สนับสนุนตัวดำเนินการเลขคณิตปกติเป็นภาษาใดก็ได้ ต่อไปนี้เป็นตัวดำเนินการทางคณิตศาสตร์ที่มีอยู่ใน Erlang

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
+ การเพิ่มตัวถูกดำเนินการสองตัว 1 + 2 จะให้ 3
- ลบตัวถูกดำเนินการที่สองจากตัวแรก 1 - 2 จะให้ -1
* การคูณของตัวถูกดำเนินการทั้งสอง 2 * 2 จะให้ 4
/ การหารตัวเศษด้วยตัวส่วน 2/2 จะให้ 1
rem ส่วนที่เหลือของการหารจำนวนแรกด้วยตัวที่สอง 3 rem 2 จะให้ 1
div องค์ประกอบ div จะดำเนินการหารและส่งกลับองค์ประกอบจำนวนเต็ม 3 หาร 2 จะให้ 1

ตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการเชิงสัมพันธ์อนุญาตให้เปรียบเทียบวัตถุ ต่อไปนี้เป็นตัวดำเนินการเชิงสัมพันธ์ที่มีอยู่ใน Erlang

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
== ทดสอบความเท่าเทียมกันระหว่างสองวัตถุ 2 = 2 จะให้เป็นจริง
/ = ทดสอบความแตกต่างระหว่างสองวัตถุ 3 / = 2 จะให้เป็นจริง
< ตรวจสอบว่าวัตถุด้านซ้ายน้อยกว่าตัวถูกดำเนินการด้านขวาหรือไม่ 2 <3 จะให้เป็นจริง
= < ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ 2 = <3 จะให้เป็นจริง
> ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายมีค่ามากกว่าตัวถูกดำเนินการด้านขวาหรือไม่ 3> 2 จะให้เป็นจริง
> = ตรวจสอบว่าวัตถุทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ 3> = 2 จะให้เป็นจริง

ตัวดำเนินการทางตรรกะ

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

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
หรือ นี่คือโอเปอเรเตอร์“ หรือ” เชิงตรรกะ จริงหรือจริงจะให้จริง
และ นี่คือโอเปอเรเตอร์“ และ” เชิงตรรกะ จริงเท็จจะให้เท็จ
ไม่ นี่คือโอเปอเรเตอร์ "ไม่ใช่" เชิงตรรกะ ไม่เท็จจะให้จริง
xor นี่คือโอเปอเรเตอร์“ xor” เอกสิทธิ์เฉพาะทางตรรกะ จริง x หรือเท็จจะให้จริง

ตัวดำเนินการ Bitwise

Erlang มีตัวดำเนินการสี่บิต ต่อไปนี้เป็นตัวดำเนินการระดับบิตที่มีอยู่ใน Erlang

แสดงตัวอย่าง

ซีเนียร์ ตัวดำเนินการและคำอธิบาย
1

band

นี่คือโอเปอเรเตอร์“ และ” แบบบิต
2

bor

นี่คือโอเปอเรเตอร์“ หรือ” แบบบิต
3

bxor

นี่คือ "xor" แบบบิตหรือเฉพาะตัวหรือโอเปอเรเตอร์
4

bnot

นี่คือตัวดำเนินการปฏิเสธแบบบิต

ต่อไปนี้เป็นตารางความจริงที่แสดงตัวดำเนินการเหล่านี้ -

น q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

ลำดับความสำคัญของตัวดำเนินการ

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

ตัวดำเนินการ ความสัมพันธ์
:
#
ไม่ใช่ไม่ใช่
/, *, div, rem, band และ เชื่อมโยงด้านซ้าย
+, -, บอร์, bxor หรือ, xor เชื่อมโยงด้านซ้าย
==, / =, = <, <,> =,>

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

ในขณะที่การดำเนินการตามคำชี้แจง

เนื่องจากไม่มีคำสั่ง while โดยตรงใน Erlang จึงต้องใช้เทคนิคการเรียกซ้ำที่มีอยู่ใน Erlang เพื่อดำเนินการใช้คำสั่ง while

เราจะพยายามติดตามการใช้งาน while loop เช่นเดียวกับที่ใช้ในภาษาโปรแกรมอื่น ๆ ต่อไปนี้เป็นขั้นตอนทั่วไปที่จะตามมา

ลองดูตัวอย่างวิธีที่เราสามารถใช้การเรียกซ้ำเพื่อใช้งานไฟล์ while วนใน Erlang

ตัวอย่าง

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

while(L) -> while(L,0). 
while([], Acc) -> Acc;

while([_|T], Acc) ->
   io:fwrite("~w~n",[Acc]), 
   while(T,Acc+1). 
   
   start() -> 
   X = [1,2,3,4], 
   while(X).

ประเด็นสำคัญต่อไปนี้จำเป็นต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • กำหนดฟังก์ชันเรียกซ้ำที่เรียกว่า while ซึ่งจะจำลองการใช้งาน while loop ของเรา

  • ป้อนรายการค่าที่กำหนดในตัวแปร X ให้กับฟังก์ชัน while ของเราดังตัวอย่าง

  • ฟังก์ชัน while รับค่าแต่ละรายการและเก็บค่ากลางในตัวแปร 'Acc'

  • จากนั้นลูป while จะถูกเรียกซ้ำสำหรับแต่ละค่าในรายการ

ผลลัพธ์ของโค้ดด้านบนจะเป็น -

เอาต์พุต

0
1
2
3

สำหรับคำชี้แจง

เนื่องจากไม่มีทางตรง for คำสั่งที่มีอยู่ใน Erlang เราต้องใช้เทคนิคการเรียกซ้ำที่มีอยู่ใน Erlang เพื่อดำเนินการ a for การใช้คำสั่ง

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

ลองดูตัวอย่างวิธีที่เราสามารถใช้การเรียกซ้ำเพื่อใช้งานไฟล์ for วนใน Erlang

ตัวอย่าง

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

for(0,_) -> 
   []; 
   
   for(N,Term) when N > 0 -> 
   io:fwrite("Hello~n"), 
   [Term|for(N-1,Term)]. 
   
start() -> 
   for(5,1).

ประเด็นสำคัญต่อไปนี้จำเป็นต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • เรากำลังกำหนดฟังก์ชันแบบเรียกซ้ำซึ่งจะจำลองการใช้งานไฟล์ for loop.

  • เรากำลังใช้ตัวป้องกันภายในฟังก์ชัน 'for' เพื่อให้แน่ใจว่าค่าของ N หรือขีด จำกัด เป็นค่าบวก

  • เราเรียกใช้ฟังก์ชัน for ซ้ำโดยลดค่าของ N ในการเรียกซ้ำแต่ละครั้ง

ผลลัพธ์ของโค้ดด้านบนจะเป็น -

เอาต์พุต

Hello
Hello
Hello
Hello
Hello

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

ต่อไปนี้เป็นรูปแบบทั่วไปของโครงสร้างการตัดสินใจทั่วไปที่พบในภาษาโปรแกรมส่วนใหญ่ -

ภาษาโปรแกรม Erlang จัดเตรียมข้อความประกอบการตัดสินใจประเภทต่อไปนี้

ซีเนียร์ คำชี้แจงและคำอธิบาย
1

ถ้าคำสั่ง

อัน if statement ประกอบด้วยนิพจน์บูลีนตามด้วยหนึ่งคำสั่งหรือมากกว่า
2

หลายนิพจน์

if นิพจน์ยังช่วยให้สามารถประเมินนิพจน์หลายรายการพร้อมกันได้
3

ซ้อนกันหากคำสั่ง

คุณสามารถใช้ if หรือ else if คำสั่งภายในอื่น if หรือ else if คำสั่ง (s)
4

คำชี้แจงกรณี

สามารถใช้เพื่อดำเนินการนิพจน์ตามผลลัพธ์ของคำสั่ง case

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

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

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

ไวยากรณ์

FunctionName(Pattern1… PatternN) ->
Body;

ที่ไหน

  • FunctionName - ชื่อฟังก์ชันคืออะตอม

  • Pattern1… PatternN- แต่ละอาร์กิวเมนต์เป็นรูปแบบ จำนวนอาร์กิวเมนต์ N คือ Arity ของฟังก์ชัน ฟังก์ชันถูกกำหนดโดยเฉพาะโดยชื่อโมดูลชื่อฟังก์ชันและ arity นั่นคือสองฟังก์ชันที่มีชื่อเดียวกันและอยู่ในโมดูลเดียวกัน แต่มีฟังก์ชันที่แตกต่างกันสองฟังก์ชันที่แตกต่างกัน

  • Body - เนื้อหาของประโยคประกอบด้วยลำดับของนิพจน์ที่คั่นด้วยลูกน้ำ (,):

โปรแกรมต่อไปนี้เป็นตัวอย่างง่ายๆของการใช้ฟังก์ชัน -

ตัวอย่าง

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

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
start() -> 
   add(5,6).

ควรสังเกตคำแนะนำต่อไปนี้เกี่ยวกับโปรแกรมข้างต้น -

  • เรากำลังกำหนดสองฟังก์ชันหนึ่งเรียกว่า add ซึ่งรับพารามิเตอร์ 2 ตัวและอีกตัวคือ start ฟังก์ชัน

  • ฟังก์ชันทั้งสองถูกกำหนดด้วยฟังก์ชันการส่งออก หากเราไม่ทำเช่นนี้เราจะไม่สามารถใช้ฟังก์ชันได้

  • ฟังก์ชันหนึ่งสามารถเรียกใช้ภายในฟังก์ชันอื่นได้ ที่นี่เรากำลังเรียกใช้ฟังก์ชันเพิ่มจากฟังก์ชันเริ่มต้น

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

11

ฟังก์ชันที่ไม่ระบุตัวตน

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

ตัวอย่าง

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

start() -> 
   Fn = fun() -> 
      io:fwrite("Anonymous Function") end, 
   Fn().

จำเป็นต้องสังเกตประเด็นต่อไปนี้เกี่ยวกับตัวอย่างข้างต้น -

  • ฟังก์ชัน anonymous ถูกกำหนดด้วย fun() คำสำคัญ.

  • ฟังก์ชันถูกกำหนดให้กับตัวแปรที่เรียกว่า Fn

  • ฟังก์ชันถูกเรียกผ่านชื่อตัวแปร

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

Anonymous Function

ฟังก์ชันที่มีหลายอาร์กิวเมนต์

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

ในตัวอย่างต่อไปนี้การสาธิตฟังก์ชันถูกกำหนดโดยมีหลายอาร์กิวเมนต์สำหรับแต่ละนิยามฟังก์ชัน

ตัวอย่าง

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

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

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

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

11
17

ฟังก์ชั่นกับ Guard Sequences

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

ไวยากรณ์ของฟังก์ชันที่มีลำดับการป้องกันจะแสดงในโปรแกรมต่อไปนี้

ไวยากรณ์

FunctionName(Pattern1… PatternN) [when GuardSeq1]->
Body;

ที่ไหน

  • FunctionName - ชื่อฟังก์ชันคืออะตอม

  • Pattern1… PatternN- แต่ละอาร์กิวเมนต์เป็นรูปแบบ จำนวนอาร์กิวเมนต์ N คือ Arity ของฟังก์ชัน ฟังก์ชันถูกกำหนดโดยเฉพาะโดยชื่อโมดูลชื่อฟังก์ชันและ arity นั่นคือสองฟังก์ชันที่มีชื่อเดียวกันและอยู่ในโมดูลเดียวกัน แต่มีฟังก์ชันที่แตกต่างกันสองฟังก์ชันที่แตกต่างกัน

  • Body - เนื้อหาของประโยคประกอบด้วยลำดับของนิพจน์ซึ่งคั่นด้วยเครื่องหมายจุลภาค (,)

  • GuardSeq1 - นี่คือนิพจน์ที่ได้รับการประเมินเมื่อมีการเรียกใช้ฟังก์ชัน

โปรแกรมต่อไปนี้เป็นตัวอย่างง่ายๆของการใช้ฟังก์ชันที่มีลำดับการป้องกัน

ตัวอย่าง

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

add(X) when X>3 -> 
   io:fwrite("~w~n",[X]). 

start() -> 
   add(4).

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

4

หากฟังก์ชันเพิ่มถูกเรียกเป็น add(3)โปรแกรมจะส่งผลให้เกิดข้อผิดพลาด

โมดูลคือฟังก์ชันมากมายที่จัดกลุ่มใหม่ในไฟล์เดียวภายใต้ชื่อเดียว นอกจากนี้ต้องกำหนดฟังก์ชันทั้งหมดใน Erlang ในโมดูล

ฟังก์ชันพื้นฐานส่วนใหญ่เช่นตัวดำเนินการทางคณิตศาสตร์ตรรกะและบูลีนมีให้ใช้งานอยู่แล้วเนื่องจากโมดูลเริ่มต้นถูกโหลดเมื่อโปรแกรมทำงาน ฟังก์ชันอื่น ๆ ที่กำหนดไว้ในโมดูลที่คุณจะใช้จะต้องถูกเรียกใช้ด้วยแบบฟอร์มModule:Function (ข้อโต้แย้ง).

การกำหนดโมดูล

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

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

ไวยากรณ์

-module(modulename)

ที่ไหน modulenameคือชื่อของโมดูล ต้องเป็นบรรทัดแรกของโค้ดในโมดูล

โปรแกรมต่อไปนี้แสดงตัวอย่างของโมดูลที่เรียกว่า helloworld.

ตัวอย่าง

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

start() -> 
   io:fwrite("Hello World").

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

Hello World

คุณสมบัติของโมดูล

แอตทริบิวต์ของโมดูลกำหนดคุณสมบัติบางอย่างของโมดูล แอตทริบิวต์โมดูลประกอบด้วยแท็กและค่า

ไวยากรณ์ทั่วไปของแอตทริบิวต์คือ -

ไวยากรณ์

-Tag(Value)

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

ตัวอย่าง

-module(helloworld). 
-author("TutorialPoint"). 
-version("1.0"). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello World").

โปรแกรมข้างต้นกำหนดแอตทริบิวต์ที่กำหนดเอง 2 รายการเรียกว่าผู้เขียนและเวอร์ชันซึ่งประกอบด้วยผู้เขียนโปรแกรมและหมายเลขเวอร์ชันของโปรแกรมตามลำดับ

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

Hello World

คุณสมบัติที่สร้างไว้ล่วงหน้า

Erlang มีคุณลักษณะที่สร้างไว้ล่วงหน้าซึ่งสามารถเชื่อมต่อกับโมดูลได้ ลองมาดูพวกเขา

ส่งออก

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

ไวยากรณ์

export([FunctionName1/FunctionArity1,.,FunctionNameN/FunctionArityN])

ที่ไหน

  • FunctionName - นี่คือชื่อของฟังก์ชันในโปรแกรม

  • FunctionArity - นี่คือจำนวนพารามิเตอร์ที่เกี่ยวข้องกับฟังก์ชัน

ตัวอย่าง

-module(helloworld). 
-author("TutorialPoint"). 
-version("1.0"). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello World").

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

Hello World

นำเข้า

แอตทริบิวต์การนำเข้าใช้เพื่ออิมพอร์ตฟังก์ชันจากโมดูลอื่นเพื่อใช้เป็นโลคัล

ไวยากรณ์

-import (modulename , [functionname/parameter]).

ที่ไหน

  • Modulename - นี่คือชื่อของโมดูลที่ต้องนำเข้า

  • functionname/parameter - ฟังก์ชันในโมดูลที่ต้องนำเข้า

ตัวอย่าง

-module(helloworld). 
-import(io,[fwrite/1]). 
-export([start/0]). 

start() -> 
   fwrite("Hello, world!\n").

ในโค้ดด้านบนเราใช้คีย์เวิร์ด import เพื่อนำเข้าไลบรารี 'io' และเฉพาะฟังก์ชัน fwrite ดังนั้นเมื่อใดก็ตามที่เราเรียกใช้ฟังก์ชัน fwrite เราไม่ต้องพูดถึงชื่อโมดูล io ทุกที่

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

Hello, world!

การเรียกซ้ำเป็นส่วนสำคัญของ Erlang ก่อนอื่นมาดูกันว่าเราจะใช้การเรียกซ้ำอย่างง่ายได้อย่างไรโดยใช้โปรแกรมแฟกทอเรียล

ตัวอย่าง

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

fac(N) when N == 0 -> 1; 
fac(N) when N > 0 -> N*fac(N-1). 

start() -> 
   X = fac(4), 
   io:fwrite("~w",[X]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • ก่อนอื่นเราจะกำหนดฟังก์ชันที่เรียกว่า fac (N)

  • เราสามารถกำหนดฟังก์ชันการเรียกซ้ำได้โดยเรียก fac (N) แบบเรียกซ้ำ

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

24

แนวทางปฏิบัติในการเรียกซ้ำ

ในส่วนนี้เราจะเข้าใจรายละเอียดเกี่ยวกับการเรียกซ้ำประเภทต่างๆและการใช้งานใน Erlang

การเรียกซ้ำความยาว

แนวทางที่เป็นประโยชน์มากขึ้นในการเรียกซ้ำสามารถดูได้จากตัวอย่างง่ายๆที่ใช้เพื่อกำหนดความยาวของรายการ รายการสามารถมีได้หลายค่าเช่น [1,2,3,4] ลองใช้การเรียกซ้ำเพื่อดูว่าเราจะได้ความยาวของรายการได้อย่างไร

Example

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

len([]) -> 0; 
len([_|T]) -> 1 + len(T). 

start() -> 
   X = [1,2,3,4], 
   Y = len(X), 
   io:fwrite("~w",[Y]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • ฟังก์ชั่นแรก len([]) ใช้สำหรับเงื่อนไขกรณีพิเศษหากรายการว่างเปล่า

  • [H|T] รูปแบบเพื่อจับคู่กับรายการขององค์ประกอบตั้งแต่หนึ่งรายการขึ้นไปเนื่องจากรายการความยาวหนึ่งจะถูกกำหนดเป็น [X|[]] และรายการความยาวสองจะถูกกำหนดเป็น [X|[Y|[]]]. โปรดทราบว่าองค์ประกอบที่สองคือรายการเอง ซึ่งหมายความว่าเราจำเป็นต้องนับหนึ่งเท่านั้นและฟังก์ชันสามารถเรียกตัวเองในองค์ประกอบที่สองได้ กำหนดให้แต่ละค่าในรายการนับเป็นความยาว 1

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

4

การเรียกซ้ำหาง

หากต้องการทำความเข้าใจว่าการเรียกซ้ำหางทำงานอย่างไรมาทำความเข้าใจว่าโค้ดต่อไปนี้ในส่วนก่อนหน้าทำงานอย่างไร

Syntax

len([]) -> 0; 
len([_|T]) -> 1 + len(T).

คำตอบของ 1 + len (Rest) ต้องการคำตอบของ len (Rest) จึงจะพบ ฟังก์ชั่น len (Rest) นั้นต้องการผลลัพธ์ของการเรียกใช้ฟังก์ชันอื่น การเพิ่มจะซ้อนกันจนกว่าจะพบรายการสุดท้ายจากนั้นจะคำนวณผลลัพธ์สุดท้ายเท่านั้น

การเรียกซ้ำหางมีจุดมุ่งหมายเพื่อกำจัดการดำเนินการที่ซ้อนกันนี้โดยการลดจำนวนลงเมื่อเกิดขึ้น

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

ลองดูตัวอย่างของการเรียกหางซ้ำ -

Example

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

tail_len(L) -> tail_len(L,0). 
tail_len([], Acc) -> Acc; 
tail_len([_|T], Acc) -> tail_len(T,Acc+1). 

start() -> 
   X = [1,2,3,4], 
   Y = tail_len(X), 
   io:fwrite("~w",[Y]).

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

Output

4

ทำซ้ำ

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

มาดูตัวอย่างกันว่าจะเป็นอย่างไร -

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

duplicate(0,_) -> 
   []; 
duplicate(N,Term) when N > 0 ->
   io:fwrite("~w,~n",[Term]),
   [Term|duplicate(N-1,Term)]. 
start() -> 
   duplicate(5,1).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

1,
1,
1,
1,
1,

รายการการกลับรายการ

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

ตัวอย่าง

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

tail_reverse(L) -> tail_reverse(L,[]).

tail_reverse([],Acc) -> Acc; 
tail_reverse([H|T],Acc) -> tail_reverse(T, [H|Acc]).

start() -> 
   X = [1,2,3,4], 
   Y = tail_reverse(X), 
   io:fwrite("~w",[Y]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

[4,3,2,1]

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • เราใช้แนวคิดของตัวแปรชั่วคราวอีกครั้งเพื่อจัดเก็บแต่ละองค์ประกอบของรายการในตัวแปรที่เรียกว่า Acc

  • เราก็โทร tail_reverse วนซ้ำ แต่คราวนี้เรามั่นใจว่าองค์ประกอบสุดท้ายถูกใส่ในรายการใหม่ก่อน

  • จากนั้นเราจะเรียกใช้ tail_reverse ซ้ำสำหรับแต่ละองค์ประกอบในรายการ

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

Integer- ตัวอย่างวิธีใช้ชนิดข้อมูลตัวเลขเป็นจำนวนเต็มจะแสดงในโปรแกรมต่อไปนี้ โปรแกรมนี้แสดงการเพิ่มจำนวนเต็ม 2 จำนวน

ตัวอย่าง

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

start() -> 
   io:fwrite("~w",[1+1]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

2

Float- ตัวอย่างวิธีการใช้ประเภทข้อมูลตัวเลขเป็นทศนิยมจะแสดงในโปรแกรมต่อไปนี้ โปรแกรมนี้แสดงการเพิ่มจำนวนเต็ม 2 จำนวน

ตัวอย่าง

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

start() -> 
   io:fwrite("~w",[1.1+1.2]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

2.3

การแสดงตัวเลขลอยและเลขชี้กำลัง

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

ตัวอย่าง

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

start() -> 
   io:fwrite("~f~n",[1.1+1.2]), 
   io:fwrite("~e~n",[1.1+1.2]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

2.300000
2.30000e+0

สิ่งสำคัญต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • เมื่อระบุอ็อพชัน ~ f หมายความว่าอาร์กิวเมนต์เป็นโฟลตซึ่งเขียนเป็น [-]ddd.dddโดยที่ความแม่นยำคือจำนวนหลักหลังจุดทศนิยม ความแม่นยำเริ่มต้นคือ 6

  • เมื่อระบุอ็อพชัน ~ e หมายความว่าอาร์กิวเมนต์เป็นโฟลตซึ่งเขียนเป็น [-]d.ddde+-dddโดยที่ความแม่นยำคือจำนวนตัวเลขที่เขียน ความแม่นยำเริ่มต้นคือ 6

ฟังก์ชันทางคณิตศาสตร์สำหรับตัวเลข

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

ซีเนียร์ ฟังก์ชันและคำอธิบายทางคณิตศาสตร์
1

บาป

วิธีนี้จะคืนค่าไซน์ของค่าที่ระบุ
2

cos

วิธีนี้ส่งคืนโคไซน์ของค่าที่ระบุ
3

ผิวสีแทน

วิธีนี้จะคืนค่าแทนเจนต์ของค่าที่ระบุ
4

asin

เมธอดจะส่งคืนอาร์กไซน์ของค่าที่ระบุ
5

acos

เมธอดส่งคืนค่าอาร์คโคซีนของค่าที่ระบุ
6

atan

วิธีการคืนค่าอาร์กแทนเจนต์ของค่าที่ระบุ
7 ประสบการณ์

เมธอดจะส่งคืนเลขชี้กำลังของค่าที่ระบุ
8

บันทึก

เมธอดจะส่งคืนลอการิทึมของค่าที่ระบุ
9

หน้าท้อง

วิธีนี้จะส่งคืนค่าสัมบูรณ์ของจำนวนที่ระบุ
10

ลอย

วิธีการแปลงตัวเลขเป็นค่าลอย
11

Is_float

วิธีการตรวจสอบว่าตัวเลขเป็นค่าลอยหรือไม่
12

Is_Integer

วิธีการตรวจสอบว่าตัวเลขเป็นค่าจำนวนเต็มหรือไม่

สตริงลิเทอรัลถูกสร้างขึ้นใน Erlang โดยการใส่ข้อความสตริงในใบเสนอราคา ต้องสร้างสตริงใน Erlang โดยใช้เครื่องหมายคำพูดคู่เช่น“ Hello World”

ต่อไปนี้เป็นตัวอย่างของการใช้สตริงใน Erlang -

ตัวอย่าง

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

start() ->
   Str1 = "This is a string", 
   io:fwrite("~p~n",[Str1]).

ตัวอย่างข้างต้นสร้างตัวแปรสตริงที่เรียกว่า Str1. สตริง "นี่คือสตริง" ถูกกำหนดให้กับตัวแปรและแสดงตามนั้น

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

“This is a string”

ต่อไปเราจะกล่าวถึงต่างๆ operations available for Strings. โปรดทราบว่าสำหรับการดำเนินการสตริงคุณต้องรวมไลบรารีสตริงด้วย

ซีเนียร์ No วิธีการและคำอธิบายสตริง
1

เลน

วิธีนี้จะส่งกลับความยาวของสตริงเฉพาะ
2

เท่ากัน

เมธอดส่งคืนค่าบูลีนว่าสตริงหนึ่งเท่ากับสตริงอื่นหรือไม่
3

concat

เมธอดเชื่อมต่อ 2 สตริงและส่งคืนสตริงที่ต่อกัน
4

chr

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

str

วิธีการส่งคืนตำแหน่งดัชนีของสตริงย่อยในสตริง
6

สถานีย่อย

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

ซ้าย

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

เหลือด้วยอักขระต่อท้าย

วิธีนี้จะส่งคืนสตริงย่อยจากด้านซ้ายของสตริงตามจำนวนอักขระ แต่มีตัวเลือกในการรวมอักขระต่อท้ายหากจำนวนมากกว่าความยาวของสตริง

ไวยากรณ์

left(str1,number,$character)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องการแยกสตริงย่อย

  • Number - นี่คือจำนวนอักขระที่ต้องมีอยู่ในสตริงย่อย

  • $Character - อักขระที่จะรวมเป็นอักขระต่อท้าย

ส่งคืนค่า

ส่งคืนสตริงย่อยจากสตริงเดิมโดยยึดตามด้านซ้ายมือของสตริงและตัวเลข

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

-module(helloworld). 
-import(string,[left/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello", 
   Str2 = left(Str1,10,$.), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

"hello....."

ขวา

วิธีนี้จะส่งคืนสตริงย่อยจากด้านขวาของสตริงตามจำนวนอักขระ

ไวยากรณ์

right(str1,number)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องการแยกสตริงย่อย

  • Number - นี่คือจำนวนอักขระที่ต้องมีอยู่ในสตริงย่อย

ส่งคืนค่า

ส่งคืนสตริงย่อยจากสตริงเดิมโดยยึดตามด้านขวามือของสตริงและตัวเลข

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

-module(helloworld). 
-import(string,[right/2]). 
-export([start/0]). 

start() -> 
   Str1 = "hello World", 
   Str2 = right(Str1,2), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

“ld”

เหมาะสมกับอักขระต่อท้าย

วิธีนี้จะส่งคืนสตริงย่อยจากด้านขวาของสตริงตามจำนวนอักขระ แต่มีตัวเลือกในการรวมอักขระต่อท้ายหากจำนวนมากกว่าความยาวของสตริง

ไวยากรณ์

right(str1,number,$character)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องการแยกสตริงย่อย

  • Number - นี่คือจำนวนอักขระที่ต้องมีอยู่ในสตริงย่อย

  • $Character - อักขระที่จะรวมเป็นอักขระต่อท้าย

ส่งคืนค่า

ส่งคืนสตริงย่อยจากสตริงเดิมโดยยึดตามด้านขวามือของสตริงและตัวเลข

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

-module(helloworld). 
-import(string,[right/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello", 
   Str2 = right(Str1,10,$.), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

".....hello"

to_lower

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

ไวยากรณ์

to_lower(str1)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องแปลงเป็นตัวพิมพ์เล็ก

ส่งคืนค่า

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

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

-module(helloworld). 
-import(string,[to_lower/1]). 
-export([start/0]). 

start() -> 
   Str1 = "HELLO WORLD", 
   Str2 = to_lower(Str1), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

"hello world"

to_upper

วิธีการคืนค่าสตริงในตัวพิมพ์ใหญ่

ไวยากรณ์

to_upper(str1)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องแปลงเป็นตัวพิมพ์ใหญ่

  • Return Value - ส่งคืนสตริงในตัวพิมพ์ใหญ่

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

-module(helloworld). 
-import(string,[to_upper/1]). 
-export([start/0]). 

start() -> 
   Str1 = "hello world", 
   Str2 = to_upper(Str1), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

"HELLO WORLD"

sub_string

ส่งคืนสตริงย่อยของ String เริ่มต้นที่ตำแหน่งเริ่มต้นไปยังจุดสิ้นสุดของสตริงหรือถึงและรวมตำแหน่ง Stop

ไวยากรณ์

sub_string(str1,start,stop)

พารามิเตอร์

  • str1 - นี่คือสตริงที่ต้องการส่งคืนสตริงย่อย

  • start - นี่คือตำแหน่งเริ่มต้นของสตริงย่อย

  • stop - นี่คือตำแหน่งหยุดของสตริงย่อย

ส่งคืนค่า

ส่งคืนสตริงย่อยของ String เริ่มต้นที่ตำแหน่งเริ่มต้นไปยังจุดสิ้นสุดของสตริงหรือถึงและรวมตำแหน่ง Stop

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

-module(helloworld). 
-import(string,[sub_string/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello world", 
   Str2 = sub_string(Str1,1,5), 
   io:fwrite("~p~n",[Str2]).

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

"hello"

รายการเป็นโครงสร้างที่ใช้ในการจัดเก็บชุดข้อมูล ใน Erlang รายการถูกสร้างขึ้นโดยการใส่ค่าในวงเล็บเหลี่ยม

ต่อไปนี้เป็นตัวอย่างง่ายๆในการสร้างรายการตัวเลขใน Erlang

ตัวอย่าง

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

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

ผลลัพธ์ของตัวอย่างข้างต้นจะเป็น -

เอาต์พุต

[1 2 3]

ให้เราพูดคุยเกี่ยวกับ various methods available for Lists. โปรดทราบว่าต้องนำเข้าไลบรารีรายการเพื่อให้วิธีการเหล่านี้ทำงานได้

ซีเนียร์ No วิธีการและคำอธิบาย
1

ทั้งหมด

ส่งคืนค่าจริงหาก Pred (Elem) ส่งกลับค่าจริงสำหรับองค์ประกอบทั้งหมด Elem ในรายการมิฉะนั้นจะเป็นเท็จ
2

ใด ๆ

ส่งคืนค่าจริงหาก Pred (Elem) ส่งกลับค่าจริงสำหรับอย่างน้อยหนึ่งองค์ประกอบ Elem ในรายการ
3

ผนวก

ส่งกลับรายการใหม่ List3 ซึ่งสร้างจากองค์ประกอบของ List1 ตามด้วยองค์ประกอบของ List2
4

ลบ

ลบองค์ประกอบออกจากรายการและส่งคืนรายการใหม่
5

droplast

วางองค์ประกอบสุดท้ายของรายการ
6

ซ้ำกัน

ส่งคืนรายการที่มี N สำเนาของคำว่า Elem
7

ล่าสุด

ส่งคืนองค์ประกอบสุดท้ายของรายการ
8

สูงสุด

ส่งคืนองค์ประกอบของรายการที่มีค่าสูงสุด
9

สมาชิก

ตรวจสอบว่ามีองค์ประกอบอยู่ในรายการหรือไม่
10

นาที

ส่งคืนองค์ประกอบของรายการที่มีค่าต่ำสุด
11

ผสาน

ส่งคืนรายการที่เรียงลำดับจากการรวมรายการย่อยทั้งหมดของ ListOfLists
12

ที่ n

ส่งกลับองค์ประกอบที่ N ของรายการ
13

nthtail

ส่งกลับหางที่ N ของรายการ
14

ย้อนกลับ

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

เรียงลำดับ

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

รายการย่อย

ส่งคืนรายการย่อยขององค์ประกอบ
17

ผลรวม

ส่งคืนผลรวมขององค์ประกอบในรายการ

Erlang มีวิธีการมากมายเมื่อทำงานกับ I / O มีคลาสที่ง่ายกว่าในการจัดเตรียมฟังก์ชันต่อไปนี้สำหรับไฟล์ -

  • การอ่านไฟล์
  • การเขียนไฟล์
  • ดูว่าไฟล์เป็นไฟล์หรือไดเร็กทอรี

วิธีการใช้งานไฟล์ใน Erlang

ลองสำรวจการทำงานของไฟล์ที่ Erlang มีให้ สำหรับวัตถุประสงค์ของตัวอย่างเหล่านี้เราจะสมมติว่ามีไฟล์ที่เรียกว่าNewFile.txt ซึ่งประกอบด้วยบรรทัดข้อความต่อไปนี้

Example1

Example2

Example3

ไฟล์นี้จะใช้สำหรับการดำเนินการอ่านและเขียนในตัวอย่างต่อไปนี้

การอ่านเนื้อหาของไฟล์ทีละบรรทัด

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

ไวยากรณ์

  • การเปิดไฟล์ - เปิด (ไฟล์, โหมด)
  • การอ่านไฟล์ - อ่าน (FileHandler, NumberofBytes)

พารามิเตอร์

  • File - นี่คือตำแหน่งของไฟล์ที่ต้องเปิด

  • Mode - นี่คือโหมดที่ต้องเปิดไฟล์

ต่อไปนี้เป็นโหมดที่ใช้ได้ -

  • Read - ไฟล์ซึ่งต้องมีอยู่ถูกเปิดขึ้นเพื่ออ่าน

  • Write- เปิดไฟล์เพื่อเขียน มันถูกสร้างขึ้นหากไม่มีอยู่จริง หากไฟล์มีอยู่และหากไม่รวมการเขียนกับการอ่านไฟล์จะถูกตัดทอน

  • Append- ไฟล์จะถูกเปิดขึ้นเพื่อเขียนและไฟล์จะถูกสร้างขึ้นหากไม่มีอยู่ ทุกการดำเนินการเขียนไปยังไฟล์ที่เปิดด้วยผนวกจะเกิดขึ้นที่ส่วนท้ายของไฟล์

  • Exclusive- ไฟล์เมื่อเปิดขึ้นเพื่อเขียนจะถูกสร้างขึ้นหากไม่มีอยู่ หากไฟล์มีอยู่การเปิดจะส่งคืน {error, มี}

  • FileHandler- นี่คือหมายเลขอ้างอิงของไฟล์ หมายเลขอ้างอิงนี้เป็นหมายเลขที่จะส่งคืนเมื่อไฟล์file:open ใช้การดำเนินการ

  • NumberofByte - นี่คือจำนวนไบต์ของข้อมูลที่ต้องอ่านจากไฟล์

ส่งคืนค่า

  • Open(File,Mode) - ส่งคืนหมายเลขอ้างอิงไปยังไฟล์หากการดำเนินการสำเร็จ

  • read(FileHandler,NumberofBytes) - ส่งคืนข้อมูลการอ่านที่ร้องขอจากไฟล์

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

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

start() -> 
   {ok, File} = file:open("Newfile.txt",[read]),
   Txt = file:read(File,1024 * 1024), 
   io:fwrite("~p~n",[Txt]).

Output - เมื่อเราเรียกใช้โปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

Example1

ตอนนี้ให้เราพูดถึงวิธีการอื่น ๆ สำหรับการใช้งานไฟล์ -

ซีเนียร์ วิธีการและคำอธิบาย
1

file_read

พร้อมใช้งานเพื่อให้สามารถอ่านเนื้อหาทั้งหมดของไฟล์ได้ในครั้งเดียว
2

เขียน

ใช้เพื่อเขียนเนื้อหาลงในไฟล์
3

สำเนา

ใช้เพื่อสร้างสำเนาของไฟล์ที่มีอยู่
4

ลบ

วิธีนี้ใช้เพื่อลบไฟล์ที่มีอยู่
5

list_dir

วิธีนี้ใช้เพื่อแสดงรายการเนื้อหาของไดเร็กทอรีเฉพาะ
6

make_dir

วิธีนี้ใช้เพื่อสร้างไดเร็กทอรีใหม่
7

เปลี่ยนชื่อ

วิธีนี้ใช้เพื่อเปลี่ยนชื่อไฟล์ที่มีอยู่
8

file_size

วิธีนี้ใช้เพื่อกำหนดขนาดของไฟล์
9

is_file

วิธีนี้ใช้เพื่อตรวจสอบว่าไฟล์นั้นเป็นไฟล์จริงหรือไม่
10

is_dir

วิธีนี้ใช้เพื่อตรวจสอบว่าไดเร็กทอรีเป็นไดเร็กทอรีจริงหรือไม่

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

โปรแกรมต่อไปนี้เป็นตัวอย่างของการใช้อะตอมใน Erlang โปรแกรมนี้ประกาศ 3 อะตอม atom1, atom_1 และ 'atom 1' ตามลำดับ ดังนั้นคุณจะเห็นวิธีต่างๆที่สามารถประกาศอะตอมได้

ตัวอย่าง

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

start() -> 
   io:fwrite(atom1), 
   io:fwrite("~n"), 
   io:fwrite(atom_1), 
   io:fwrite("~n"), 
   io:fwrite('atom 1'), 
   io:fwrite("~n").

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

atom1

atom_1

atom 1

มาดูวิธีการบางอย่างใน Erlang เพื่อทำงานกับอะตอม

ซีเนียร์ วิธีการและคำอธิบาย
1

is_atom

วิธีนี้ใช้เพื่อตรวจสอบว่าคำศัพท์นั้นเป็นอะตอมหรือไม่
2

atom_to_list

วิธีนี้ใช้ในการแปลงอะตอมเป็นรายการ
3

list_to_atom

วิธีนี้ใช้ในการแปลงรายการเป็นอะตอม
4

atom_to_binary

วิธีนี้ใช้ในการแปลงอะตอมเป็นค่าไบนารี
5

binary_to_atom

วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นค่าอะตอม

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

ตัวอย่างวิธีใช้ชนิดข้อมูลแผนที่จะแสดงในโปรแกรมต่อไปนี้

เรากำลังกำหนดแผนที่ M1 ซึ่งมีการแมป 2 แบบ map_size เป็นฟังก์ชัน inbuilt ที่กำหนดไว้ใน Erlang ซึ่งสามารถใช้เพื่อกำหนดขนาดของแผนที่

ตัวอย่าง

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

start() -> 
   M1 = #{name=>john,age=>25}, 
   io:fwrite("~w",[map_size(M1)]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้

เอาต์พุต

2

บางส่วนของวิธีการอื่น ๆ สำหรับแผนที่มีดังนี้

ซีเนียร์ วิธีการและคำอธิบาย
1

from_list

วิธีนี้ใช้เพื่อสร้างแผนที่จากรายการ
2

หา

วิธีนี้ใช้เพื่อค้นหาว่ามีคีย์ใดอยู่ในแผนที่หรือไม่
3

ได้รับ

วิธีนี้ใช้เพื่อรับค่าของคีย์เฉพาะในแผนที่
4

is_key

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

คีย์

วิธีนี้ใช้เพื่อคืนคีย์ทั้งหมดจากแผนที่
6

ผสาน

วิธีนี้ใช้เพื่อรวม 2 แผนที่
7

ใส่

วิธีนี้ใช้เพื่อเพิ่มคู่ค่าคีย์ลงในแผนที่
8

ค่า

วิธีนี้ใช้เพื่อส่งคืนค่าทั้งหมดจากแผนที่
9

ลบ

วิธีนี้ใช้เพื่อลบค่าคีย์ออกจากแผนที่

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

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

เรากำลังกำหนดไฟล์ Tuple Pซึ่งมี 3 เทอม tuple_size เป็นฟังก์ชัน inbuilt ที่กำหนดไว้ใน Erlang ซึ่งสามารถใช้เพื่อกำหนดขนาดของ Tuple

ตัวอย่าง

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

start() ->
   P = {john,24,{june,25}} , 
   io:fwrite("~w",[tuple_size(P)]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้

เอาต์พุต

3

มาดูการดำเนินการเพิ่มเติมที่มีให้สำหรับทูเพิล

ซีเนียร์ วิธีการและคำอธิบาย
1

is_tuple

วิธีนี้ใช้เพื่อกำหนดว่าคำที่ให้มานั้นเป็นทูเปิล
2

list_to_tuple

วิธีนี้คือการแปลงรายการเป็นทูเปิล
3

tuple_to_list

วิธีนี้คือการแปลงทูเพิลเป็นรายการ

Erlang มีสิ่งอำนวยความสะดวกพิเศษในการสร้างบันทึก ระเบียนเหล่านี้ประกอบด้วยเขตข้อมูล ตัวอย่างเช่นคุณสามารถกำหนดระเบียนส่วนบุคคลซึ่งมี 2 ฟิลด์ฟิลด์หนึ่งคือ id และอีกฟิลด์คือฟิลด์ชื่อ ใน Erlang คุณสามารถสร้างอินสแตนซ์ต่างๆของเรกคอร์ดนี้เพื่อกำหนดบุคคลหลายคนด้วยชื่อและรหัสต่างๆ

มาสำรวจกันว่าเราจะทำงานกับระเบียนได้อย่างไร

การสร้างบันทึก

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

ไวยากรณ์

record(recordname , {Field1,Field2 ..Fieldn})

พารามิเตอร์

  • recordname - นี่คือชื่อที่กำหนดให้กับบันทึก

  • Field1,Field2 ..Fieldn - นี่คือรายการของช่องต่างๆที่ประกอบขึ้นเป็นบันทึก

ส่งคืนค่า

ไม่มี

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

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name="John",id = 1}.

ตัวอย่างข้างต้นแสดงคำจำกัดความของระเบียนที่มี 2 ฟิลด์หนึ่งคือ id และอีกฟิลด์คือชื่อ นอกจากนี้ยังมีการสร้างบันทึกด้วยวิธีต่อไปนี้ -

ไวยากรณ์

#recordname {fieldName1 = value1, fieldName2 = value2 .. fieldNameN = valueN}

โดยที่คุณกำหนดค่าให้กับฟิลด์ที่เกี่ยวข้องเมื่อมีการกำหนดอินสแตนซ์ของเรกคอร์ด

การเข้าถึงคุณค่าของบันทึก

ในการเข้าถึงฟิลด์และค่าของเรกคอร์ดหนึ่ง ๆ ควรใช้ไวยากรณ์ต่อไปนี้

ไวยากรณ์

#recordname.Fieldname

พารามิเตอร์

  • recordname - นี่คือชื่อที่กำหนดให้กับบันทึก

  • Fieldname - นี่คือชื่อของฟิลด์ที่จำเป็นต้องเข้าถึง

ส่งคืนค่า

ค่าที่กำหนดให้กับฟิลด์

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

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name = "John",id = 1}, 
   io:fwrite("~p~n",[P#person.id]), 
   io:fwrite("~p~n",[P#person.name]).

เอาต์พุต

ผลลัพธ์ของโปรแกรมข้างต้นมีดังนี้

1
“John”

การอัปเดตค่าของระเบียน

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

ไวยากรณ์

#recordname.Fieldname = newvalue

พารามิเตอร์

  • recordname - นี่คือชื่อที่กำหนดให้กับบันทึก

  • Fieldname - นี่คือชื่อของฟิลด์ที่จำเป็นต้องเข้าถึง

  • newvalue - นี่คือค่าใหม่ที่ต้องกำหนดให้กับฟิลด์

ส่งคืนค่า

ระเบียนใหม่ที่มีค่าใหม่ที่กำหนดให้กับเขตข้อมูล

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

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name = "John",id = 1}, 
   P1 = P#person{name = "Dan"}, 
   
   io:fwrite("~p~n",[P1#person.id]), 
   io:fwrite("~p~n",[P1#person.name]).

เอาต์พุต

ผลลัพธ์ของโปรแกรมข้างต้นมีดังนี้ -

1
“Dan”

ระเบียนที่ซ้อนกัน

Erlang ยังมีสิ่งอำนวยความสะดวกในการจัดทำระเบียนซ้อน ตัวอย่างต่อไปนี้แสดงวิธีสร้างเรกคอร์ดที่ซ้อนกันเหล่านี้

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

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", address}). 
-record(employee, {person, id}). 

start() -> 
   P = #employee{person = #person{name = "John",address = "A"},id = 1}, 
   io:fwrite("~p~n",[P#employee.id]).

ในตัวอย่างข้างต้นต้องสังเกตสิ่งต่อไปนี้ -

  • ก่อนอื่นเราจะสร้างบันทึกของบุคคลซึ่งมีค่าฟิลด์ของชื่อและที่อยู่

  • จากนั้นเรากำหนดระเบียนพนักงานซึ่งมีบุคคลเป็นฟิลด์และฟิลด์เพิ่มเติมที่เรียกว่า id

เอาต์พุต

ผลลัพธ์ของโปรแกรมข้างต้นมีดังนี้

1

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

โดยปกติเมื่อมีข้อยกเว้นหรือข้อผิดพลาดเกิดขึ้นใน Erlang ข้อความต่อไปนี้จะแสดงขึ้น

{"init terminating in do_boot", {undef,[{helloworld,start,[],[]}, 
{init,start_it,1,[]},{init,start_em,1,[]}]}}

Crash Dump จะเขียนถึง -

erl_crash.dump
init terminating in do_boot ()

ใน Erlang มีข้อยกเว้น 3 ประเภท -

  • Error - โทร erlang:error(Reason)จะสิ้นสุดการดำเนินการในกระบวนการปัจจุบันและรวมการติดตามสแต็กของฟังก์ชันสุดท้ายที่เรียกด้วยอาร์กิวเมนต์เมื่อคุณจับได้ นี่คือประเภทของข้อยกเว้นที่กระตุ้นให้เกิดข้อผิดพลาดรันไทม์ด้านบน

  • Exists- ทางออกมีสองประเภท: ทางออก "ภายใน" และทางออก "ภายนอก" ทางออกภายในจะถูกเรียกใช้โดยการเรียกใช้ฟังก์ชันexit/1และทำให้กระบวนการปัจจุบันหยุดการดำเนินการ ทางออกภายนอกเรียกว่าด้วยexit/2 และต้องเกี่ยวข้องกับกระบวนการหลายอย่างในแง่มุมของ Erlang พร้อมกัน

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

ก try ... catch เป็นวิธีการประเมินนิพจน์ในขณะที่ให้คุณจัดการกับกรณีที่ประสบความสำเร็จและข้อผิดพลาดที่พบ

ไวยากรณ์ทั่วไปของนิพจน์ try catch มีดังนี้

ไวยากรณ์

try Expression of 
SuccessfulPattern1 [Guards] -> 
Expression1; 
SuccessfulPattern2 [Guards] -> 
Expression2 

catch 
TypeOfError:ExceptionPattern1 -> 
Expression3; 
TypeOfError:ExceptionPattern2 -> 
Expression4 
end

นิพจน์ระหว่าง try and ofกล่าวกันว่าได้รับการคุ้มครอง ซึ่งหมายความว่าข้อยกเว้นใด ๆ ที่เกิดขึ้นภายในการโทรนั้นจะถูกจับได้ รูปแบบและนิพจน์ระหว่างtry ... of and catch ปฏิบัติตนในลักษณะเดียวกับก case ... of.

ในที่สุดส่วนที่จับได้ - ที่นี่คุณสามารถแทนที่ได้ TypeOfErrorตามข้อผิดพลาดโยนหรือออกสำหรับแต่ละประเภทที่เราเห็นในบทนี้ หากไม่มีการระบุประเภทจะถือว่าเป็นการโยน

ต่อไปนี้เป็นข้อผิดพลาดและสาเหตุของข้อผิดพลาดใน Erlang -

ข้อผิดพลาด ประเภทข้อผิดพลาด
Badarg โต้แย้งไม่ดี อาร์กิวเมนต์เป็นประเภทข้อมูลที่ไม่ถูกต้องหรือมีรูปแบบที่ไม่เหมาะสม
บาดาริ ธ อาร์กิวเมนต์ไม่ถูกต้องในนิพจน์เลขคณิต
{badmatch, V} การประเมินนิพจน์การจับคู่ล้มเหลว ค่า V ไม่ตรงกัน
function_clause ไม่พบประโยคฟังก์ชันที่ตรงกันเมื่อประเมินการเรียกใช้ฟังก์ชัน
{case_clause, V} ไม่พบสาขาที่ตรงกันเมื่อประเมินนิพจน์เคส ค่า V ไม่ตรงกัน
if_clause ไม่พบสาขาที่แท้จริงเมื่อประเมินนิพจน์ if
{try_clause, V} ไม่พบสาขาที่ตรงกันเมื่อประเมินส่วนของนิพจน์ลอง ค่า V ไม่ตรงกัน
undef ไม่พบฟังก์ชันเมื่อประเมินการเรียกใช้ฟังก์ชัน ..
{badfun, F} มีบางอย่างผิดปกติกับ F สนุก ๆ
{badarity, F} ความสนุกถูกนำไปใช้กับจำนวนอาร์กิวเมนต์ที่ไม่ถูกต้อง F อธิบายถึงความสนุกสนานและข้อโต้แย้ง
timeout_value ค่าการหมดเวลาในการรับ .. หลังจากนิพจน์ถูกประเมินเป็นอย่างอื่นที่ไม่ใช่จำนวนเต็มหรืออินฟินิตี้
noproc พยายามเชื่อมโยงไปยังกระบวนการที่ไม่มีอยู่

ต่อไปนี้เป็นตัวอย่างวิธีใช้ข้อยกเว้นเหล่านี้และวิธีดำเนินการต่างๆ

  • ฟังก์ชันแรกสร้างข้อยกเว้นที่เป็นไปได้ทั้งหมด

  • จากนั้นเราเขียนฟังก์ชัน wrapper เพื่อเรียกใช้ generate_exception ในการลอง ... จับการแสดงออก

ตัวอย่าง

-module(helloworld). 
-compile(export_all). 

generate_exception(1) -> a; 
generate_exception(2) -> throw(a); 
generate_exception(3) -> exit(a); 
generate_exception(4) -> {'EXIT', a}; 
generate_exception(5) -> erlang:error(a). 

demo1() -> 
   [catcher(I) || I <- [1,2,3,4,5]]. 
catcher(N) -> 
   try generate_exception(N) of 
      Val -> {N, normal, Val} 
   catch 
      throw:X -> {N, caught, thrown, X}; 
      exit:X -> {N, caught, exited, X}; 
      error:X -> {N, caught, error, X} 
   end. 
      
demo2() -> 
   [{I, (catch generate_exception(I))} || I <- [1,2,3,4,5]]. 
demo3() -> 
   try generate_exception(5) 
   catch 
      error:X -> 
         {X, erlang:get_stacktrace()} 
   end. 
   
lookup(N) -> 
   case(N) of 
      1 -> {'EXIT', a}; 
      2 -> exit(a) 
   end.

ถ้าเรารันโปรแกรมเป็น helloworld: demo () เราจะได้ผลลัพธ์ต่อไปนี้ -

เอาต์พุต

[{1,normal,a},
{2,caught,thrown,a},
{3,caught,exited,a},
{4,normal,{'EXIT',a}},
{5,caught,error,a}]

โดยทั่วไปมักใช้มาโครสำหรับการเปลี่ยนโค้ดแบบอินไลน์ ใน Erlang มาโครถูกกำหนดผ่านข้อความต่อไปนี้

  • -define (คงที่เปลี่ยน)
  • - กำหนด (Func (Var1, Var2, .. , Var), การเปลี่ยน)

ต่อไปนี้เป็นตัวอย่างของมาโครที่ใช้ไวยากรณ์แรก -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
-define(a,1). 

start() -> 
   io:fwrite("~w",[?a]).

จากโปรแกรมด้านบนคุณจะเห็นว่ามาโครได้รับการขยายโดยใช้ "?" สัญลักษณ์. ค่าคงที่จะถูกแทนที่ด้วยค่าที่กำหนดไว้ในมาโคร

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

1

ตัวอย่างของมาโครที่ใช้คลาสฟังก์ชันมีดังนี้ -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
-define(macro1(X,Y),{X+Y}). 

start() ->
   io:fwrite("~w",[?macro1(1,2)]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

เอาต์พุต

{3}

คำสั่งเพิ่มเติมต่อไปนี้มีให้สำหรับมาโคร -

  • undef(Macro)- ไม่กำหนดมาโคร หลังจากนี้คุณจะไม่สามารถเรียกมาโครได้

  • ifdef(Macro) - ประเมินบรรทัดต่อไปนี้เฉพาะในกรณีที่มีการกำหนดมาโคร

  • ifndef(Macro) - ประเมินบรรทัดต่อไปนี้เฉพาะในกรณีที่ไม่ได้กำหนดมาโคร

  • else- อนุญาตหลังจากคำสั่ง ifdef หรือ ifndef หากเงื่อนไขเป็นเท็จจะมีการประเมินข้อความที่ตามมา

  • endif - ทำเครื่องหมายจุดสิ้นสุดของคำสั่ง ifdef หรือ ifndef

เมื่อใช้ข้อความข้างต้นควรใช้อย่างถูกต้องตามที่แสดงในโปรแกรมต่อไปนี้

-ifdef(<FlagName>).

-define(...).
-else.
-define(...).
-endif.

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

ก่อนอื่นมาสร้างไฟล์ชื่อ user.hrl และเพิ่มรหัสต่อไปนี้ -

-record(person, {name = "", id}).

ตอนนี้ในไฟล์โปรแกรมหลักของเราให้เพิ่มรหัสต่อไปนี้ -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   P = #person{name = "John",id = 1}, 
   io:fwrite("~p~n",[P#person.id]), 
   io:fwrite("~p~n",[P#person.name]).

ดังที่คุณเห็นจากโปรแกรมด้านบนจริงๆแล้วเราเพิ่งรวมไฟล์ user.hrl ที่แทรกไฟล์ –record รหัสอยู่ในนั้น

หากคุณรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้

เอาต์พุต

1
“John”

คุณยังสามารถทำสิ่งเดียวกันกับมาโครได้คุณสามารถกำหนดมาโครภายในไฟล์ส่วนหัวและอ้างอิงในไฟล์หลักได้ ลองดูตัวอย่างนี้ -

ก่อนอื่นมาสร้างไฟล์ชื่อ user.hrl และเพิ่มรหัสต่อไปนี้ -

-define(macro1(X,Y),{X+Y}).

ตอนนี้ในไฟล์โปรแกรมหลักของเราให้เพิ่มรหัสต่อไปนี้ -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   io:fwrite("~w",[?macro1(1,2)]).

หากคุณรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

{3}

ก่อนที่จะคอมไพล์โมดูล Erlang โมดูลนี้จะถูกประมวลผลโดยอัตโนมัติโดย Erlang Preprocessor ตัวประมวลผลก่อนขยายมาโครใด ๆ ที่อาจอยู่ในไฟล์ต้นฉบับและแทรกไฟล์ที่จำเป็น

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

erlc -P some_module.erl

ตัวอย่างเช่นสมมติว่าเรามีไฟล์รหัสต่อไปนี้ -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   io:fwrite("~w",[?macro1(1,2)]).

และถ้าเราดำเนินการคำสั่งต่อไปนี้จากบรรทัดคำสั่ง -

erlc –P helloworld.erl

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

-file("helloworld.erl", 1). -module(helloworld).

-export([start/0]).
-file("user.hrl", 1).
-file("helloworld.erl", 3).

start() ->
   io:fwrite("~w", [{1 + 2}]).

รูปแบบมีลักษณะเหมือนกับคำศัพท์ - อาจเป็นตัวอักษรธรรมดา ๆ เช่นอะตอมและตัวเลขสารประกอบเช่นสิ่งทอและรายการหรือทั้งสองอย่างผสมกัน นอกจากนี้ยังสามารถมีตัวแปรซึ่งเป็นสตริงตัวเลขและตัวอักษรที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่หรือขีดล่าง "ตัวแปรที่ไม่ระบุตัวตน" พิเศษ _ (ขีดล่าง) ถูกใช้เมื่อคุณไม่สนใจเกี่ยวกับค่าที่จะจับคู่และจะไม่ใช้มัน

รูปแบบจะจับคู่ว่ามี "รูปร่าง" เหมือนกันกับคำที่จับคู่และอะตอมที่พบจะเหมือนกัน ตัวอย่างเช่นการแข่งขันต่อไปนี้ประสบความสำเร็จ -

  • B = 1.
  • 2 = 2.
  • {ok, C} = {ok, 40}
  • [H | T] = [1, 2, 3,4]

โปรดทราบว่าในตัวอย่างที่สี่ไปป์ (|) ซึ่งมีความหมายที่ส่วนหัวและส่วนท้ายของรายการตามที่อธิบายไว้ในข้อกำหนด โปรดทราบว่าด้านซ้ายมือควรตรงกับด้านขวามือซึ่งเป็นกรณีปกติสำหรับรูปแบบ

ตัวอย่างการจับคู่รูปแบบต่อไปนี้จะล้มเหลว

  • 1 = 2.
  • {ok, A} = {failure, "Don't know the question"}
  • [H | T] = []

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

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

ไวยากรณ์ทั่วไปของคำสั่ง guard มีดังนี้ -

function(parameter) when condition ->

ที่ไหน

  • Function(parameter) - นี่คือการประกาศฟังก์ชันที่ใช้ในสภาวะยาม

  • Parameter - โดยทั่วไปเงื่อนไขการป้องกันจะขึ้นอยู่กับพารามิเตอร์

  • Condition - เงื่อนไขที่ควรได้รับการประเมินเพื่อดูว่าควรเรียกใช้ฟังก์ชันหรือไม่

  • ต้องใช้คำสั่ง when เมื่อระบุเงื่อนไขการป้องกัน

มาดูตัวอย่างสั้น ๆ ว่าสามารถใช้ยามได้อย่างไร -

ตัวอย่าง

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

display(N) when N > 10 ->   
   io:fwrite("greater then 10"); 
display(N) when N < 10 -> io:fwrite("Less 
   than 10"). 

start() -> 
   display(11).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับตัวอย่างข้างต้น -

  • ฟังก์ชั่นการแสดงผลถูกกำหนดพร้อมกับยาม การประกาศการแสดงผลครั้งแรกจะมีการป้องกันเมื่อพารามิเตอร์ N มีค่ามากกว่า 10 ดังนั้นหากพารามิเตอร์มีค่ามากกว่า 10 ฟังก์ชันนั้นจะถูกเรียกใช้

  • ฟังก์ชันการแสดงผลถูกกำหนดอีกครั้ง แต่คราวนี้มียามน้อยกว่า 10 ด้วยวิธีนี้คุณสามารถกำหนดฟังก์ชันเดียวกันได้หลายครั้งโดยแต่ละฟังก์ชันจะมีเงื่อนไขการป้องกันแยกกัน

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

greater than 10

นอกจากนี้ยังสามารถใช้เงื่อนไขการป้องกันได้ if else และ caseงบ มาดูกันว่าเราจะดำเนินการเฝ้าระวังตามข้อความเหล่านี้ได้อย่างไร

ยามสำหรับคำสั่ง 'if'

นอกจากนี้ยังสามารถใช้ Guards สำหรับ if statement เพื่อให้ชุดของคำสั่งที่ดำเนินการนั้นเป็นไปตามเงื่อนไขการป้องกัน มาดูกันว่าเราจะบรรลุเป้าหมายนี้ได้อย่างไร

ตัวอย่าง

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

start() -> 
   N = 9, 
   if 
      N > 10 -> 
         io:fwrite("N is greater than 10"); 
      true -> 
         io:fwrite("N is less than 10") 
   end.

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับตัวอย่างข้างต้น -

  • ฟังก์ชั่นยามถูกใช้ร่วมกับคำสั่ง if หากฟังก์ชันการป้องกันประเมินว่าเป็นจริงคำสั่ง“ N มากกว่า 10” จะปรากฏขึ้น

  • หากฟังก์ชันการป้องกันประเมินว่าเป็นเท็จคำสั่ง“ N น้อยกว่า 10” จะปรากฏขึ้น

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

N is less than 10

ยามสำหรับคำสั่ง 'case'

นอกจากนี้ยังสามารถใช้ Guards สำหรับคำสั่ง case เพื่อให้ชุดของคำสั่งที่เรียกใช้เป็นไปตามเงื่อนไข guard มาดูกันว่าเราจะบรรลุเป้าหมายนี้ได้อย่างไร

ตัวอย่าง

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

start() -> 
   A = 9, 
   case A of {A} when A>10 -> 
      io:fwrite("The value of A is greater than 10"); _ -> 
      io:fwrite("The value of A is less than 10") 
   end.

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับตัวอย่างข้างต้น -

  • ฟังก์ชั่นยามถูกใช้ร่วมกับคำสั่งกรณี หากฟังก์ชั่นการป้องกันประเมินว่าเป็นจริงคำสั่ง“ ค่าของ A มากกว่า 10” จะปรากฏขึ้น

  • หากฟังก์ชันป้องกันประเมินเป็นอย่างอื่นข้อความ“ ค่าของ A น้อยกว่า 10” จะปรากฏขึ้น

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

The value of A is less than 10

เงื่อนไขการป้องกันหลายอย่าง

นอกจากนี้ยังสามารถระบุเงื่อนไขการป้องกันหลายรายการสำหรับฟังก์ชันได้ ไวยากรณ์ทั่วไปของคำสั่งยามที่มีเงื่อนไขการป้องกันหลายรายการแสดงไว้ด้านล่าง -

function(parameter) when condition1 , condition1 , .. conditionN ->

ที่ไหน

  • Function(parameter) - นี่คือการประกาศฟังก์ชันที่ใช้เงื่อนไขการป้องกัน

  • Parameter - โดยทั่วไปเงื่อนไขการป้องกันจะขึ้นอยู่กับพารามิเตอร์

  • condition1, condition1, .. conditionN - นี่คือเงื่อนไขการป้องกันหลายอย่างที่ใช้กับฟังก์ชัน

  • ต้องใช้คำสั่ง when เมื่อระบุเงื่อนไขการป้องกัน

มาดูตัวอย่างสั้น ๆ ว่าสามารถใช้ยามหลายคนได้อย่างไร -

ตัวอย่าง

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

display(N) when N > 10 , is_integer(N) -> 
   io:fwrite("greater then 10"); 
display(N) when N < 10 -> 
   io:fwrite("Less than 10"). 
   
start() -> 
   display(11).

ประเด็นต่อไปนี้ต้องสังเกตเกี่ยวกับตัวอย่างข้างต้น -

  • คุณจะสังเกตเห็นว่าสำหรับการประกาศฟังก์ชันการแสดงครั้งแรกนอกเหนือจากเงื่อนไขสำหรับ N> 10 แล้วเงื่อนไขสำหรับ is_integerระบุไว้ด้วย ดังนั้นเฉพาะในกรณีที่ค่าของ N เป็นจำนวนเต็มและมากกว่า 10 ฟังก์ชันนี้จะถูกเรียกใช้งาน

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

Greater than 10

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

มาดูตัวอย่างการใช้งาน BIF -

ตัวอย่าง

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

start() ->   
   io:fwrite("~p~n",[tuple_to_list({1,2,3})]), 
   io:fwrite("~p~n",[time()]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับตัวอย่างข้างต้น -

  • ในตัวอย่างแรกเราใช้ BIF ที่เรียกว่า tuple_to_list เพื่อแปลงทูเพิลเป็นรายการ

  • ในฟังก์ชัน BIF ที่สองเรากำลังใช้ไฟล์ time function เพื่อส่งออกเวลาของระบบ

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

เอาต์พุต

[1,2,3]
{10,54,56}

ลองดูฟังก์ชั่น BIF เพิ่มเติมที่มีใน Erlang

ซีเนียร์ ฟังก์ชัน BIF และคำอธิบาย
1

วันที่

วิธีนี้ส่งคืนวันที่ของระบบปัจจุบัน
2

byte_size

วิธีนี้จะส่งคืนจำนวนไบต์ที่มีอยู่ใน Bitstring
3

ธาตุ

เมธอดส่งคืนองค์ประกอบ N ในทูเปิล
4

ลอย

วิธีนี้จะคืนค่าลอยตัวของจำนวนเฉพาะ
5

ได้รับ

วิธีนี้จะส่งคืนพจนานุกรมกระบวนการเป็นรายการ
6

ใส่

วิธีนี้ใช้ในการใส่ไฟล์ key,value จับคู่ในพจนานุกรมกระบวนการ
7

เวลาท้องถิ่น

วิธีนี้ใช้เพื่อระบุวันที่และเวลาท้องถิ่นในระบบ
8

หน่วยความจำ

ส่งคืนรายการที่มีข้อมูลเกี่ยวกับหน่วยความจำที่จัดสรรแบบไดนามิกโดยโปรแกรมจำลอง Erlang
9

ตอนนี้

วิธีนี้จะส่งคืนทูเพิล {MegaSecs, Secs, MicroSecs} ซึ่งเป็นเวลาที่ผ่านไปนับตั้งแต่ 00:00 GMT วันที่ 1 มกราคม 1970
10

พอร์ต

ส่งคืนรายการพอร์ตทั้งหมดบนโลคัลโหนด
11

กระบวนการ

ส่งคืนรายการตัวระบุกระบวนการที่สอดคล้องกับกระบวนการทั้งหมดที่มีอยู่ในโลคัลโหนด
12

universaltime

ส่งคืนวันที่และเวลาปัจจุบันตาม Universal Time Coordinated (UTC)

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

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

ต่อไปนี้เป็นตัวอย่างของไบนารีใน Erlang -

ตัวอย่าง

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

start() -> 
   io:fwrite("~p~n",[<<5,10,20>>]), 
   io:fwrite("~p~n",[<<"hello">>]).

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

เอาต์พุต

<<5,10,20>>
<<"hello">>

มาดูฟังก์ชั่น Erlang ที่ใช้งานได้กับ Binaries -

ซีเนียร์ วิธีการและคำอธิบาย
1

list_to_binary

วิธีนี้ใช้เพื่อแปลงรายการที่มีอยู่เป็นรายการไบนารี
2

Split_binary

วิธีนี้ใช้เพื่อแยกรายการไบนารีตามตำแหน่งดัชนีที่ระบุ
3

term_to_binary

วิธีนี้ใช้ในการแปลงเทอมเป็นไบนารี
4

is_binary

วิธีนี้ใช้เพื่อตรวจสอบว่า bitstring เป็นค่าไบนารีหรือไม่
5

binary_part

วิธีนี้ใช้เพื่อแยกส่วนของสตริงไบนารี
6

binary_to_float

วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นค่าลอย
7

binary_to_integer

วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นค่าจำนวนเต็ม
8

binary_to_list

วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นรายการ
9

binary_to_atom

วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นอะตอม

Funs ใช้เพื่อกำหนดฟังก์ชันที่ไม่ระบุชื่อใน Erlang ไวยากรณ์ทั่วไปของฟังก์ชันนิรนามแสดงไว้ด้านล่าง -

ไวยากรณ์

F = fun (Arg1, Arg2, ... ArgN) ->
   ...
End

ที่ไหน

  • F - นี่คือชื่อตัวแปรที่กำหนดให้กับฟังก์ชันนิรนาม

  • Arg1, Arg2, ... ArgN - นี่คืออาร์กิวเมนต์ที่ส่งผ่านไปยังฟังก์ชันนิรนาม

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถใช้ฟังก์ชันนิรนามได้อย่างไร

ตัวอย่าง

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

start() -> 
   A = fun() -> io:fwrite("Hello") end, 
   A().

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • ฟังก์ชันนิรนามถูกกำหนดให้กับตัวแปร A

  • ฟังก์ชันนิรนามผ่านตัวแปร A ()

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

“Hello”

อีกตัวอย่างหนึ่งของฟังก์ชันที่ไม่ระบุตัวตนมีดังต่อไปนี้ แต่เป็นการใช้พารามิเตอร์

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

start() -> 
   A = fun(X) -> 
      io:fwrite("~p~n",[X]) 
      end, 
   A(5).

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

เอาต์พุต

5

การใช้ตัวแปร

ฟังก์ชัน Anonymous มีความสามารถในการเข้าถึงตัวแปรที่อยู่นอกขอบเขตของฟังก์ชันนิรนาม ลองดูตัวอย่างนี้ -

ตัวอย่าง

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

start() -> 
   B = 6, 
   A = fun(X) -> 
      io:fwrite("~p~n",[X]), 
      io:fwrite("~p~n",[B]) 
      end, 
   A(5).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • ตัวแปร B อยู่นอกขอบเขตของฟังก์ชันนิรนาม

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

เอาต์พุต

5

6

ฟังก์ชั่นภายใน Functions

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

ตัวอย่าง

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

start() -> 
   Adder = fun(X) -> fun(Y) -> io:fwrite("~p~n",[X + Y]) end end, 
   A = Adder(6), 
   A(10).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • Adder เป็นฟังก์ชันลำดับที่สูงกว่าซึ่งกำหนดให้เป็น fun (X)

  • ฟังก์ชัน Adder fun (X) มีการอ้างอิงถึงฟังก์ชันอื่น (Y)

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

เอาต์พุต

16

ความละเอียดของภาวะพร้อมกันใน Erlang เป็นกระบวนการ กระบวนการคือกิจกรรม / งานที่ทำงานพร้อมกันและเป็นอิสระจากกระบวนการอื่น ๆ กระบวนการเหล่านี้ใน Erlang แตกต่างจากกระบวนการและเธรดที่คนส่วนใหญ่คุ้นเคย กระบวนการ Erlang มีน้ำหนักเบาดำเนินการใน (หน่วยความจำ) แยกจากกระบวนการอื่น ๆ และกำหนดโดย Virtual Machine (VM) ของ Erlang เวลาในการสร้างกระบวนการต่ำมากรอยเท้าหน่วยความจำของกระบวนการที่เพิ่งเกิดมีขนาดเล็กมากและ Erlang VM เดียวสามารถมีกระบวนการทำงานได้หลายล้านกระบวนการ

กระบวนการถูกสร้างขึ้นด้วยความช่วยเหลือของวิธีการวางไข่ ไวยากรณ์ทั่วไปของวิธีการได้รับด้านล่าง

ไวยากรณ์

spawn(Module, Name, Args)

พารามิเตอร์

  • Module - นี่คือค่าอะตอมที่กำหนดไว้ล่วงหน้าซึ่งต้องเป็น? MODULE

  • Name - นี่คือชื่อของฟังก์ชันที่จะเรียกใช้เมื่อกำหนดกระบวนการ

  • Args - นี่คืออาร์กิวเมนต์ที่จำเป็นต้องส่งไปยังฟังก์ชัน

ส่งคืนค่า

ส่งคืนรหัสกระบวนการของกระบวนการใหม่ที่สร้างขึ้น

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

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

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

call(Arg1, Arg2) -> 
   io:format("~p ~p~n", [Arg1, Arg2]). 
start() -> 
   Pid = spawn(?MODULE, call, ["hello", "process"]), 
   io:fwrite("~p",[Pid]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • มีการกำหนดฟังก์ชันที่เรียกว่าการโทรและจะใช้ในการสร้างกระบวนการ

  • วิธีการวางไข่เรียกใช้ฟังก์ชันการโทรด้วยพารามิเตอร์ hello และ process

เอาต์พุต

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

<0.29.0>"hello" "process"

ตอนนี้เรามาดูฟังก์ชั่นอื่น ๆ ที่มีให้ในกระบวนการ

ซีเนียร์ วิธีการและคำอธิบาย
1

is_pid

วิธีนี้ใช้เพื่อตรวจสอบว่ามีรหัสกระบวนการหรือไม่
2

is_process_alive

สิ่งนี้เรียกว่า is_process_alive (Pid) Pid ต้องอ้างถึงกระบวนการที่โลคัลโหนด
3

pid_to_list

จะแปลงรหัสกระบวนการเป็นรายการ
4

จดทะเบียน

ส่งคืนรายการที่มีชื่อของกระบวนการที่ลงทะเบียนทั้งหมด
5

ตนเอง

หนึ่งใน BIF ที่ใช้บ่อยที่สุดจะคืนค่า pid ของกระบวนการโทร
6

ลงทะเบียน

ใช้เพื่อลงทะเบียนกระบวนการในระบบ
7

อยู่ไหน

เรียกว่า whereis (ชื่อ) ส่งคืน pid ของกระบวนการที่ลงทะเบียนด้วยชื่อ
8

ยกเลิกการลงทะเบียน

ใช้เพื่อยกเลิกการลงทะเบียนกระบวนการในระบบ

ในการส่งอีเมลโดยใช้ Erlang คุณต้องใช้แพ็คเกจจาก githubสำหรับสิ่งเดียวกัน ลิงค์ github คือ -https://github.com/Vagabond/gen_smtp

ลิงค์นี้มีไฟล์ smtp utilityซึ่งสามารถใช้ในการส่งอีเมลจากแอปพลิเคชัน Erlang ทำตามขั้นตอนเพื่อให้สามารถส่งอีเมลจาก Erlang ได้

Step 1 - ดาวน์โหลดไฟล์ erl files จาก github site. ไฟล์ควรถูกดาวน์โหลดไปยังไดเร็กทอรีที่ไฟล์helloworld.erl แอปพลิเคชันอยู่

Step 2 - รวบรวมไฟล์ smtp related files แสดงในรายการต่อไปนี้โดยใช้ไฟล์ erlc command. ต้องรวบรวมไฟล์ต่อไปนี้

  • smtp_util
  • gen_smtp_client
  • gen_smtp_server
  • gen_smtp_server_session
  • binstr
  • gen_smtp_application
  • socket

Step 3 - สามารถเขียนโค้ดต่อไปนี้เพื่อส่งอีเมลโดยใช้ smtp

ตัวอย่าง

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

start() -> 
   gen_smtp_client:send({"[email protected]", ["[email protected]"], "Subject: testing"},
   
   [{relay, "smtp.gmail.com"}, {ssl, true}, {username, "[email protected]"}, 
      {password, "senderpassword"}]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • ฟังก์ชัน smtp ข้างต้นถูกใช้ร่วมกับเซิร์ฟเวอร์ smtp ที่มีให้จาก google

  • เนื่องจากเราต้องการส่งโดยใช้ smtp ที่ปลอดภัยเราจึงระบุพารามิเตอร์ ssl เป็น true

  • คุณต้องระบุรีเลย์เป็น smtp.gmail.com.

  • คุณต้องระบุชื่อผู้ใช้และรหัสผ่านที่สามารถเข้าถึงเพื่อส่งอีเมลได้

เมื่อคุณกำหนดการตั้งค่าทั้งหมดข้างต้นและดำเนินการโปรแกรมผู้รับจะได้รับอีเมลสำเร็จ

Erlang มีความสามารถในการเชื่อมต่อกับฐานข้อมูลดั้งเดิมเช่น SQL Server และ Oracle Erlang มีinbuilt odbc library ที่สามารถใช้เพื่อทำงานกับฐานข้อมูล

การเชื่อมต่อฐานข้อมูล

ในตัวอย่างของเราเราจะใช้ประโยชน์จาก Microsoft SQL Server ก่อนเชื่อมต่อกับฐานข้อมูล Microsoft SQL Server ตรวจสอบให้แน่ใจว่าได้เลือกตัวชี้ต่อไปนี้แล้ว

  • คุณได้สร้างฐานข้อมูล TESTDB

  • คุณได้สร้างตาราง EMPLOYEE ใน TESTDB

  • ตารางนี้มีฟิลด์ FIRST_NAME, LAST_NAME, AGE, SEX และ INCOME

  • ID ผู้ใช้ "testuser" และรหัสผ่าน "test123" ถูกตั้งค่าให้เข้าถึง TESTDB

  • ตรวจสอบให้แน่ใจว่าคุณได้สร้าง ODBC DSN ที่เรียกว่า usersqlserver ซึ่งสร้างการเชื่อมต่อ ODBC กับฐานข้อมูล

การสร้างการเชื่อมต่อ

ในการสร้างการเชื่อมต่อกับฐานข้อมูลสามารถใช้ตัวอย่างโค้ดต่อไปนี้

Example

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

start() ->
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver;UID = testuser;PWD = test123", []), 
   io:fwrite("~p",[Ref]).

ผลลัพธ์ของโปรแกรมข้างต้นมีดังนี้ -

Output

<0.33.0>

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • วิธีการเริ่มต้นของไลบรารี odbc ใช้เพื่อระบุจุดเริ่มต้นของการดำเนินการฐานข้อมูล

  • วิธีการเชื่อมต่อต้องใช้ DSN ชื่อผู้ใช้และรหัสผ่านเพื่อเชื่อมต่อ

การสร้างตารางฐานข้อมูล

ขั้นตอนต่อไปหลังจากเชื่อมต่อกับฐานข้อมูลคือการสร้างตารางในฐานข้อมูลของเรา ตัวอย่างต่อไปนี้แสดงวิธีสร้างตารางในฐานข้อมูลโดยใช้ Erlang

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123, []), 
   odbc:sql_query(Ref, "CREATE TABLE EMPLOYEE (FIRSTNAME char varying(20), 
   LASTNAME char varying(20), AGE integer, SEX char(1), INCOME integer)")

หากคุณตรวจสอบฐานข้อมูลตอนนี้คุณจะเห็นว่ามีตารางที่เรียกว่า EMPLOYEE จะถูกสร้างขึ้น

การแทรกบันทึกลงในฐานข้อมูล

จำเป็นเมื่อคุณต้องการสร้างระเบียนของคุณลงในตารางฐานข้อมูล

ตัวอย่างต่อไปนี้จะแทรกบันทึกในตารางพนักงาน หากอัปเดตตารางสำเร็จระเบียนและคำสั่งจะส่งคืนค่าของระเบียนที่อัปเดตและจำนวนระเบียนที่อัปเดต

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123", []), 
   io:fwrite("~p",[odbc:sql_query(Ref, 
   "INSERT INTO EMPLOYEE VALUES('Mac', 'Mohan', 20, 'M', 2000)")]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

{updated,1}

การดึงข้อมูลจากฐานข้อมูล

Erlang ยังมีความสามารถในการดึงข้อมูลจากฐานข้อมูล สิ่งนี้ทำได้ผ่านไฟล์sql_query method.

ตัวอย่างจะแสดงในโปรแกรมต่อไปนี้ -

Example

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

start() ->
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123", []), 
   io:fwrite("~p",[odbc:sql_query(Ref, "SELECT * FROM EMPLOYEE") ]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

Output

{selected,["FIRSTNAME","LASTNAME","AGE","SEX","INCOME"],
[{"Mac","Mohan",20,"M",2000}]}

ดังนั้นคุณจะเห็นว่าคำสั่งแทรกในส่วนสุดท้ายใช้งานได้และคำสั่ง select ส่งคืนข้อมูลที่ถูกต้อง

การดึงข้อมูลจากฐานข้อมูลตามพารามิเตอร์

Erlang ยังมีความสามารถในการดึงข้อมูลจากฐานข้อมูลตามเกณฑ์การกรองบางอย่าง

ตัวอย่างมีดังนี้ -

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN=usersqlserver; UID=testuser;PWD=test123", []), 
   io:fwrite("~p",[ odbc:param_query(Ref, "SELECT * FROM EMPLOYEE WHERE SEX=?", 
   [{{sql_char, 1}, ["M"]}])]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

{selected,["FIRSTNAME","LASTNAME","AGE","SEX","INCOME"],
         [{"Mac","Mohan",20,"M",2000}]}

การอัปเดตบันทึกจากฐานข้อมูล

Erlang ยังมีความสามารถในการอัปเดตบันทึกจากฐานข้อมูล

ตัวอย่างเช่นเดียวกันมีดังนี้ -

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123", []), 
   
   io:fwrite("~p",[ odbc:sql_query(Ref, "
      UPDATE EMPLOYEE SET AGE = 5 WHERE INCOME= 2000")]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

Output

{updated,1}

การลบบันทึกจากฐานข้อมูล

Erlang ยังมีความสามารถในการลบบันทึกจากฐานข้อมูล

ตัวอย่างเช่นเดียวกันมีดังนี้ -

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123", []), 
   io:fwrite("~p",[ odbc:sql_query(Ref, "DELETE EMPLOYEE WHERE INCOME= 2000")]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

Output

{updated,1}

โครงสร้างตาราง

Erlang ยังมีความสามารถในการอธิบายโครงสร้างตาราง

ตัวอย่างมีดังนี้ -

Example

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

start() -> 
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = testuser;PWD = test123", []), 
   io:fwrite("~p",[odbc:describe_table(Ref, "EMPLOYEE")]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้ -

Output

{ok,[{"FIRSTNAME",{sql_varchar,20}},
   {"LASTNAME",{sql_varchar,20}},
   {"AGE",sql_integer},
   {"SEX",{sql_char,1}},
   {"INCOME",sql_integer}]}

จำนวนบันทึก

Erlang ยังมีความสามารถในการดึงจำนวนระเบียนทั้งหมดในตาราง

ตัวอย่างเช่นเดียวกันจะแสดงในโปรแกรมต่อไปนี้

Example

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

start() ->
   odbc:start(), 
   {ok, Ref} = odbc:connect("DSN = usersqlserver; UID = sa;PWD = demo123", []), 
   io:fwrite("~p",[odbc:select_count(Ref, "SELECT * FROM EMPLOYEE")]).

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น -

{ok,1}

ใน Erlang พอร์ตใช้สำหรับการสื่อสารระหว่างโปรแกรมต่างๆ ซ็อกเก็ตเป็นจุดสิ้นสุดการสื่อสารที่อนุญาตให้เครื่องสื่อสารผ่านอินเทอร์เน็ตโดยใช้ Internet Protocol (IP)

ประเภทของโปรโตคอลที่ใช้ในพอร์ต

มีโปรโตคอล 2 ประเภทสำหรับการสื่อสาร หนึ่งคือ UDP และอีกอันคือ TCP UDP ช่วยให้แอปพลิเคชันสามารถส่งข้อความสั้น ๆ (เรียกว่าดาตาแกรม) ถึงกันได้ แต่ไม่มีการรับประกันว่าจะส่งข้อความเหล่านี้ได้ นอกจากนี้ยังสามารถมาถึงนอกสถานที่ได้ ในทางกลับกัน TCP ให้สตรีมไบต์ที่เชื่อถือได้ซึ่งส่งตามลำดับตราบเท่าที่มีการสร้างการเชื่อมต่อ

มาดูตัวอย่างง่ายๆของการเปิดพอร์ตโดยใช้ UDP

ตัวอย่าง

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

start() -> 
   {ok, Socket} = gen_udp:open(8789), 
   io:fwrite("~p",[Socket]).

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • gen_udp มีโมดูลใน Erlang ที่ใช้สำหรับการสื่อสาร UDP

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

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

#Port<0.376>

การส่งข้อความบนพอร์ต

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

ไวยากรณ์

send(Socket, Address, Port, Packet)

พารามิเตอร์

  • Socket - นี่คือซ็อกเก็ตที่สร้างด้วยคำสั่ง gen_udp: open

  • Address - นี่คือที่อยู่เครื่องที่จะต้องส่งข้อความถึง

  • port - นี่คือพอร์ตที่ไม่จำเป็นต้องส่งข้อความ

  • Packet - นี่คือรายละเอียดแพ็คเก็ตหรือข้อความที่ต้องส่ง

ส่งคืนค่า

ข้อความตกลงจะถูกส่งกลับหากข้อความถูกส่งอย่างถูกต้อง

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

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

start() ->
   {ok, Socket} = gen_udp:open(8789), 
   io:fwrite("~p",[Socket]), 
   io:fwrite("~p",[gen_udp:send 
   (Socket,"localhost",8789,"Hello")]).

เอาต์พุต

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็นดังนี้

#Port<0.376>ok

การรับข้อความบนพอร์ต

เมื่อเปิดพอร์ตแล้วจะสามารถรับข้อความบนพอร์ตได้ สิ่งนี้ทำได้ผ่านไฟล์recv method. ลองดูไวยากรณ์และตัวอย่างต่อไปนี้

ไวยากรณ์

recv(Socket, length)

พารามิเตอร์

  • Socket - นี่คือซ็อกเก็ตที่สร้างด้วยคำสั่ง gen_udp: open

  • Length - นี่คือความยาวของข้อความที่ต้องได้รับ

ส่งคืนค่า

ข้อความตกลงจะถูกส่งกลับหากข้อความถูกส่งอย่างถูกต้อง

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

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

start() ->
   {ok, Socket} = gen_udp:open(8789), 
   io:fwrite("~p",[Socket]), 
   io:fwrite("~p",[gen_udp:send(Socket,"localhost",8789,"Hello")]),
   io:fwrite("~p",[gen_udp:recv(Socket, 20)]).

โปรแกรมที่สมบูรณ์

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

ตัวอย่าง

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

start() -> 
   spawn(fun() -> server(4000) end).

server(Port) ->
   {ok, Socket} = gen_udp:open(Port, [binary, {active, false}]), 
   io:format("server opened socket:~p~n",[Socket]), 
   loop(Socket). 

loop(Socket) ->
   inet:setopts(Socket, [{active, once}]), 
   receive 
      {udp, Socket, Host, Port, Bin} -> 
      io:format("server received:~p~n",[Bin]), 
      gen_udp:send(Socket, Host, Port, Bin), 
      loop(Socket) 
   end. 

client(N) -> 
   {ok, Socket} = gen_udp:open(0, [binary]), 
   io:format("client opened socket=~p~n",[Socket]), 
   ok = gen_udp:send(Socket, "localhost", 4000, N), Value = receive 
      {udp, Socket, _, _, Bin} ->
         io:format("client received:~p~n",[Bin]) after 2000 ->
      0 
   end, 
   
gen_udp:close(Socket), 
Value.

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • เรากำหนด 2 ฟังก์ชันอย่างแรกคือเซิร์ฟเวอร์ สิ่งนี้จะใช้เพื่อฟังบนพอร์ต 4000 ตัวที่สองคือไคลเอนต์ที่จะใช้ในการส่งข้อความ“ สวัสดี” ไปยังส่วนประกอบเซิร์ฟเวอร์

  • ลูปรับใช้เพื่ออ่านข้อความที่ส่งภายในกำหนดลูป

เอาต์พุต

ตอนนี้คุณต้องเรียกใช้โปรแกรมจาก 2 หน้าต่าง หน้าต่างแรกจะใช้เพื่อเรียกใช้ส่วนประกอบเซิร์ฟเวอร์โดยเรียกใช้รหัสต่อไปนี้ในไฟล์erl command line window.

helloworld:start().

สิ่งนี้จะแสดงผลลัพธ์ต่อไปนี้ในหน้าต่างบรรทัดคำสั่ง

server opened socket:#Port<0.2314>

ตอนนี้ในหน้าต่างบรรทัดคำสั่ง erl ที่สองให้เรียกใช้คำสั่งต่อไปนี้

Helloworld:client(“<<Hello>>”).

เมื่อคุณออกคำสั่งนี้ผลลัพธ์ต่อไปนี้จะแสดงในหน้าต่างบรรทัดคำสั่งแรก

server received:<<"Hello">>

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

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

  • Performance - เราสามารถทำให้โปรแกรมของเราทำงานได้เร็วขึ้นโดยจัดให้ส่วนต่างๆของโปรแกรมทำงานคู่ขนานกันบนเครื่องต่างๆ

  • Reliability- เราสามารถสร้างระบบที่ทนต่อความผิดพลาดได้โดยการจัดโครงสร้างระบบให้ทำงานบนเครื่องจักรหลายเครื่อง หากเครื่องใดเครื่องหนึ่งล้มเหลวเราสามารถดำเนินการต่อในเครื่องอื่นได้

  • Scalability- ในขณะที่เราขยายขนาดแอปพลิเคชันไม่ช้าก็เร็วเราจะหมดความสามารถของเครื่องจักรที่ทรงพลังที่สุด ในขั้นตอนนี้เราต้องเพิ่มเครื่องจักรมากขึ้นเพื่อเพิ่มกำลังการผลิต การเพิ่มเครื่องใหม่ควรเป็นการดำเนินการง่ายๆที่ไม่ต้องมีการเปลี่ยนแปลงสถาปัตยกรรมแอปพลิเคชันขนาดใหญ่

แนวคิดหลักใน Erlang แบบกระจายคือโหนด โหนดคือสิ่งที่มีอยู่ในตัว

ระบบ Erlang ประกอบด้วยเครื่องเสมือนที่สมบูรณ์พร้อมพื้นที่แอดเดรสของตัวเองและชุดกระบวนการของตัวเอง

ลองดูที่แตกต่างกัน methods ซึ่งใช้สำหรับ Distributed Programming.

ซีเนียร์ วิธีการและคำอธิบาย
1

วางไข่

ใช้เพื่อสร้างกระบวนการใหม่และเริ่มต้น
2

โหนด

สิ่งนี้ใช้เพื่อกำหนดค่าของโหนดที่กระบวนการต้องรัน
3

วางไข่บน Node

ใช้เพื่อสร้างกระบวนการใหม่บนโหนด
4

is_alive

สิ่งนี้จะคืนค่าจริงหากโหนดโลคัลยังมีชีวิตอยู่และสามารถเป็นส่วนหนึ่งของระบบกระจาย
5

spawnlink

ใช้เพื่อสร้างลิงก์กระบวนการใหม่บนโหนด

OTP ย่อมาจาก Open Telecom Platform เป็นระบบปฏิบัติการแอปพลิเคชันชุดของไลบรารีและขั้นตอนที่ใช้สำหรับการสร้างแอปพลิเคชันขนาดใหญ่ที่ทนทานต่อข้อผิดพลาดและกระจาย หากคุณต้องการตั้งโปรแกรมแอปพลิเคชันของคุณเองโดยใช้ OTP แนวคิดหลักที่คุณจะพบว่ามีประโยชน์มากคือพฤติกรรมของ OTP พฤติกรรมห่อหุ้มรูปแบบพฤติกรรมทั่วไป - คิดว่ามันเป็นกรอบงานแอปพลิเคชันที่กำหนดพารามิเตอร์โดยโมดูลการเรียกกลับ

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

ตัวอย่าง

-module(server). 
-export([start/2, rpc/2]). 

start(Name, Mod) -> 
   register(Name, spawn(fun() -> loop(Name, Mod, Mod:init()) end)). 
rpc(Name, Request) -> 
   Name ! {self(), Request}, 
   receive 
      {Name, Response} -> Response 
   end. 
   
loop(Name, Mod, State) ->
   receive 
      {From, Request} ->
         {Response, State1} = Mod:handle(Request, State), 
         From ! {Name, Response}, 
         loop(Name, Mod, State1) 
   end.

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • กระบวนการหากลงทะเบียนกับระบบโดยใช้ฟังก์ชัน register

  • กระบวนการสร้างฟังก์ชันลูปซึ่งจัดการกับการประมวลผล

ตอนนี้เรามาเขียนโปรแกรมไคลเอนต์ที่จะใช้โปรแกรมเซิร์ฟเวอร์

ตัวอย่าง

-module(name_server). 
-export([init/0, add/2, whereis/1, handle/2]). 
-import(server1, [rpc/2]). 

add(Name, Place) -> rpc(name_server, {add, Name, Place}). 
whereis(Name) -> rpc(name_server, {whereis, Name}). 

init() -> dict:new().
handle({add, Name, Place}, Dict) -> {ok, dict:store(Name, Place, Dict)}; 
handle({whereis, Name}, Dict) -> {dict:find(Name, Dict), Dict}.

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

ดังนั้นนี่คือวิธีการเรียกใช้โปรแกรมข้างต้น -

ใน erlขั้นแรกให้รันโปรแกรมเซิร์ฟเวอร์โดยรันคำสั่งต่อไปนี้

server(name_server,name_server)

คุณจะได้รับผลลัพธ์ต่อไปนี้ -

เอาต์พุต

true

จากนั้นรันคำสั่งต่อไปนี้

name_server.add(erlang,”Tutorialspoint”).

คุณจะได้รับผลลัพธ์ต่อไปนี้ -

เอาต์พุต

Ok

จากนั้นเรียกใช้คำสั่งต่อไปนี้ -

name_server.whereis(erlang).

คุณจะได้รับผลลัพธ์ต่อไปนี้ -

เอาต์พุต

{ok,"Tutorialspoint"}

การเขียนโปรแกรมพร้อมกันใน Erlang จำเป็นต้องมีหลักการหรือกระบวนการพื้นฐานดังต่อไปนี้

รายการประกอบด้วยหลักการดังต่อไปนี้ -

piD = วางไข่ (สนุก)

สร้างกระบวนการใหม่พร้อมกันที่ประเมินความสนุก กระบวนการใหม่ทำงานควบคู่ไปกับผู้โทร ตัวอย่างมีดังนี้ -

ตัวอย่าง

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

start() ->
   spawn(fun() -> server("Hello") end). 

server(Message) ->
   io:fwrite("~p",[Message]).

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

“Hello”

ปิ๊ด! ข้อความ

ส่งข้อความไปยังกระบวนการที่มีตัวระบุ Pid การส่งข้อความเป็นแบบอะซิงโครนัส ผู้ส่งไม่รอ แต่ทำต่อไป‘!’ เรียกว่าตัวดำเนินการส่ง

ตัวอย่างมีดังนี้ -

ตัวอย่าง

-module(helloworld). 
-export([start/0]). 
start() -> 
   Pid = spawn(fun() -> server("Hello") end), 
   Pid ! {hello}. 

server(Message) ->
   io:fwrite("~p",[Message]).

รับ…จบ

รับข้อความที่ถูกส่งไปยังกระบวนการ มีไวยากรณ์ต่อไปนี้ -

ไวยากรณ์

receive

Pattern1 [when Guard1] ->

Expressions1;

Pattern2 [when Guard2] ->

Expressions2;
...
End

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

ตัวอย่างของกระบวนการทั้งหมดที่มีทั้ง 3 คำสั่งแสดงอยู่ในโปรแกรมต่อไปนี้

ตัวอย่าง

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

loop() ->
   receive 
      {rectangle, Width, Ht} -> 
         io:fwrite("Area of rectangle is ~p~n" ,[Width * Ht]), 
         loop(); 
      {circle, R} ->
      io:fwrite("Area of circle is ~p~n" , [3.14159 * R * R]), 
      loop(); 
   Other ->
      io:fwrite("Unknown"), 
      loop() 
   end. 

start() ->
   Pid = spawn(fun() -> loop() end), 
   Pid ! {rectangle, 6, 10}.

สิ่งต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น -

  • ฟังก์ชันลูปมีลูปปลายรับ ดังนั้นเมื่อข้อความถูกส่งข้อความจะถูกประมวลผลโดยลูปสิ้นสุดการรับ

  • กระบวนการใหม่เกิดขึ้นซึ่งไปที่ฟังก์ชันลูป

  • ข้อความถูกส่งไปยังกระบวนการสร้างทาง Pid! คำสั่งข้อความ

ผลลัพธ์ของโปรแกรมข้างต้นคือ -

เอาต์พุต

Area of the Rectangle is 60

จำนวนกระบวนการสูงสุด

ในการทำงานพร้อมกันเป็นสิ่งสำคัญในการกำหนดจำนวนสูงสุดของกระบวนการที่ได้รับอนุญาตบนระบบ จากนั้นคุณควรจะเข้าใจว่ามีกระบวนการใดที่สามารถดำเนินการพร้อมกันบนระบบได้

มาดูตัวอย่างวิธีที่เราสามารถกำหนดจำนวนโปรเซสสูงสุดที่สามารถดำเนินการในระบบได้

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

max(N) -> 
   Max = erlang:system_info(process_limit), 
   io:format("Maximum allowed processes:~p~n" ,[Max]), 
   
   statistics(runtime), 
   statistics(wall_clock), 
   
   L = for(1, N, fun() -> spawn(fun() -> wait() end) end), 
   {_, Time1} = statistics(runtime), 
   {_, Time2} = statistics(wall_clock), lists:foreach(fun(Pid) -> Pid ! die end, L), 
   
   U1 = Time1 * 1000 / N, 
   U2 = Time2 * 1000 / N, 
   io:format("Process spawn time=~p (~p) microseconds~n" , [U1, U2]).
   wait() -> 
   
   receive 
      die -> void 
   end. 
 
for(N, N, F) -> [F()]; 
for(I, N, F) -> [F()|for(I+1, N, F)]. 

start()->
   max(1000), 
   max(100000).

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

Maximum allowed processes:262144

Process spawn time=47.0 (16.0) microseconds

Maximum allowed processes:262144

Process spawn time=12.81 (10.15) microseconds

รับด้วยการหมดเวลา

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

ต่อไปนี้เป็นไวยากรณ์ของข้อความรับที่ระบุการหมดเวลา

ไวยากรณ์

receive 
Pattern1 [when Guard1] -> 
Expressions1; 

Pattern2 [when Guard2] ->
Expressions2; 
... 
after Time -> 
Expressions 
end

ตัวอย่างที่ง่ายที่สุดคือการสร้างฟังก์ชัน Sleeper ดังที่แสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

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

sleep(T) ->
   receive 
   after T -> 
      true 
   end. 
   
start()->
   sleep(1000).

โค้ดด้านบนจะเข้าสู่โหมดสลีป 1,000 Ms ก่อนที่จะออกจริง

เลือกรับ

แต่ละกระบวนการใน Erlang มีกล่องจดหมายที่เกี่ยวข้อง เมื่อคุณส่งข้อความไปยังกระบวนการข้อความจะถูกใส่ลงในกล่องเมล เวลาเดียวที่จะตรวจสอบกล่องจดหมายนี้คือเมื่อโปรแกรมของคุณประเมินคำสั่งรับ

ต่อไปนี้เป็นไวยากรณ์ทั่วไปของคำสั่ง Selective Receive

ไวยากรณ์

receive 
Pattern1 [when Guard1] ->
Expressions1; 

Pattern2 [when Guard1] ->
Expressions1; 
... 
after 
Time ->
ExpressionTimeout 
end

นี่คือวิธีการทำงานของคำสั่งรับข้างต้น -

  • เมื่อเราป้อนคำสั่งรับเราจะเริ่มจับเวลา (แต่เฉพาะในกรณีที่มีส่วน after อยู่ในนิพจน์เท่านั้น)

  • รับข้อความแรกในกล่องเมลและพยายามจับคู่กับ Pattern1, Pattern2 และอื่น ๆ หากการจับคู่สำเร็จข้อความจะถูกลบออกจากกล่องจดหมายและระบบจะประเมินนิพจน์ตามรูปแบบ

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

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

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

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

เมื่อพูดถึงประสิทธิภาพควรสังเกตประเด็นต่อไปนี้เกี่ยวกับ Erlang

  • Funs are very fast - Funs ได้รับประเภทข้อมูลของตัวเองใน R6B และได้รับการปรับให้เหมาะสมเพิ่มเติมใน R7B

  • Using the ++ operator- จำเป็นต้องใช้ตัวดำเนินการนี้อย่างถูกวิธี ตัวอย่างต่อไปนี้เป็นวิธีการดำเนินการ ++ ที่ไม่ถูกต้อง

ตัวอย่าง

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

start()->
   fun_reverse([H|T]) ->
   fun_reverse(T)++[H]; 
   fun_reverse([]) ->
   [].

เมื่อตัวดำเนินการ ++ คัดลอกตัวถูกดำเนินการทางซ้ายผลลัพธ์จะถูกคัดลอกซ้ำ ๆ ซึ่งนำไปสู่ความซับซ้อนของกำลังสอง

  • Using Strings- การจัดการสตริงอาจช้าหากทำไม่ถูกต้อง ใน Erlang คุณต้องคิดเพิ่มเติมเล็กน้อยเกี่ยวกับวิธีการใช้สตริงและเลือกการแสดงที่เหมาะสม หากคุณใช้นิพจน์ทั่วไปให้ใช้ re-module ใน STDLIB แทนไฟล์obsolete regexp module.

  • BEAM is a Stack-Based Byte-Code Virtual Machine- BEAM เป็นเครื่องเสมือนที่ใช้การลงทะเบียน มีการลงทะเบียนเสมือน 1024 ตัวที่ใช้สำหรับเก็บค่าชั่วคราวและสำหรับส่งผ่านอาร์กิวเมนต์เมื่อเรียกใช้ฟังก์ชัน ตัวแปรที่ต้องการเพื่อให้มีการเรียกใช้ฟังก์ชันจะถูกบันทึกลงในสแต็ก BEAM เป็นตัวแปลรหัสเธรด แต่ละคำสั่งเป็นคำที่ชี้ไปยัง C-code ที่เรียกใช้งานได้โดยตรงทำให้การส่งคำสั่งทำได้รวดเร็วมาก

บางครั้งเราต้องการเรียกใช้โปรแกรมภาษาต่างประเทศภายใน Erlang Runtime System ในกรณีนี้โปรแกรมจะถูกเขียนเป็นไลบรารีแบบแบ่งใช้ที่เชื่อมโยงแบบไดนามิกเข้ากับระบบรันไทม์ Erlang ไดรเวอร์ที่เชื่อมโยงกับโปรแกรมเมอร์จะปรากฏเป็นโปรแกรมพอร์ตและเป็นไปตามโปรโตคอลเดียวกันกับโปรแกรมพอร์ต

การสร้างไดรเวอร์

การสร้างไดรเวอร์ที่เชื่อมโยงกันเป็นวิธีที่มีประสิทธิภาพที่สุดในการเชื่อมต่อรหัสภาษาต่างประเทศกับ Erlang แต่ก็เป็นอันตรายที่สุดเช่นกัน ข้อผิดพลาดร้ายแรงใด ๆ ในไดรเวอร์ที่เชื่อมโยงกันจะทำให้ระบบ Erlang ผิดพลาด

ต่อไปนี้เป็นตัวอย่างการใช้งานไดรเวอร์ใน Erlang -

ตัวอย่าง

-module(helloworld). 
-export([start/0, stop/0]). 
-export([twice/1, sum/2]). 

start() ->
   start("example1_drv" ). 
start(SharedLib) ->
   case erl_ddll:load_driver("." , SharedLib) of 
   ok -> ok; 
      {error, already_loaded} -> ok; 
      _ -> exit({error, could_not_load_driver}) 
   end, 
   
   spawn(fun() -> init(SharedLib) end). 

init(SharedLib) -> 
   register(example1_lid, self()), 
   Port = open_port({spawn, SharedLib}, []), 
   loop(Port). 

stop() -> 
   example1_lid ! stop. 

twice(X) -> call_port({twice, X}). 
sum(X,Y) -> call_port({sum, X, Y}). call_port(Msg) -> 
   example1_lid ! {call, self(), Msg}, receive 
      {example1_lid, Result} -> 
      Result 
   end. 

LINKED-IN DRIVERS 223 
loop(Port) -> 
receive 
   {call, Caller, Msg} -> 
   Port ! {self(), {command, encode(Msg)}}, receive 
   {Port, {data, Data}} ->
   Caller ! {example1_lid, decode(Data)} 
   end, 

loop(Port); 
stop -> Port ! 
   {self(), close}, 
   receive 
      {Port, closed} -> 
      exit(normal) 
   end; 
   
      {'EXIT', Port, Reason} -> 
      io:format("~p ~n" , [Reason]), 
      exit(port_terminated) 
   end. 

encode({twice, X}) -> [1, X]; 
encode({sum, X, Y}) -> [2, X, Y]. decode([Int]) -> Int.

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

ใน Erlang, the inets libraryสามารถสร้างเว็บเซิร์ฟเวอร์ใน Erlang มาดูฟังก์ชั่นบางอย่างที่มีใน Erlang สำหรับการเขียนโปรแกรมบนเว็บ เราสามารถใช้เซิร์ฟเวอร์ HTTP หรือที่เรียกว่า httpd เพื่อจัดการคำขอ HTTP

เซิร์ฟเวอร์ใช้คุณสมบัติมากมายเช่น -

  • Secure Sockets Layer (SSL)
  • อินเตอร์เฟสการเขียนสคริปต์ Erlang (ESI)
  • อินเทอร์เฟซเกตเวย์ทั่วไป (CGI)
  • การตรวจสอบผู้ใช้ (โดยใช้ Mnesia, Dets หรือฐานข้อมูลข้อความธรรมดา)
  • รูปแบบไฟล์บันทึกทั่วไป (มีหรือไม่มีการสนับสนุน disk_log (3))
  • นามแฝง URL
  • การแมปการดำเนินการ
  • รายชื่อไดเรกทอรี

งานแรกคือการเริ่มต้นเว็บไลบรารีผ่านคำสั่ง

inets:start()

ขั้นตอนต่อไปคือการใช้ฟังก์ชัน start ของไลบรารี inets เพื่อให้สามารถใช้งานเว็บเซิร์ฟเวอร์ได้

ต่อไปนี้เป็นตัวอย่างของการสร้างกระบวนการเว็บเซิร์ฟเวอร์ใน Erlang

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

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

start() ->
   inets:start(), 
   Pid = inets:start(httpd, [{port, 8081}, {server_name,"httpd_test"}, 
   {server_root,"D://tmp"},{document_root,"D://tmp/htdocs"},
   {bind_address, "localhost"}]), io:fwrite("~p",[Pid]).

ประเด็นต่อไปนี้ต้องสังเกตเกี่ยวกับโปรแกรมข้างต้น

  • หมายเลขพอร์ตต้องไม่ซ้ำกันและไม่ใช้โดยโปรแกรมอื่น httpd service จะเริ่มต้นที่หมายเลขพอร์ตนี้

  • server_root และ document_root เป็นพารามิเตอร์บังคับ

เอาต์พุต

ต่อไปนี้เป็นผลลัพธ์ของโปรแกรมข้างต้น

{ok,<0.42.0>}

เพื่อใช้งาน a Hello world web server ใน Erlang ให้ทำตามขั้นตอนต่อไปนี้ -

Step 1 - ใช้รหัสต่อไปนี้ -

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

start() ->
   inets:start(httpd, [ 
      {modules, [ 
         mod_alias, 
         mod_auth, 
         mod_esi, 
         mod_actions, 
         mod_cgi, 
         mod_dir,
         mod_get, 
         mod_head, 
         mod_log, 
         mod_disk_log 
      ]}, 
      
      {port,8081}, 
      {server_name,"helloworld"}, 
      {server_root,"D://tmp"}, 
      {document_root,"D://tmp/htdocs"}, 
      {erl_script_alias, {"/erl", [helloworld]}}, 
      {error_log, "error.log"}, 
      {security_log, "security.log"}, 
      {transfer_log, "transfer.log"}, 
      
      {mime_types,[ 
         {"html","text/html"}, {"css","text/css"}, {"js","application/x-javascript"} ]} 
   ]). 
         
service(SessionID, _Env, _Input) -> mod_esi:deliver(SessionID, [ 
   "Content-Type: text/html\r\n\r\n", "<html><body>Hello, World!</body></html>" ]).

Step 2- รันโค้ดดังนี้ คอมไพล์ไฟล์ด้านบนแล้วรันคำสั่งต่อไปนี้ในerl.

c(helloworld).

คุณจะได้รับผลลัพธ์ต่อไปนี้

{ok,helloworld}

คำสั่งต่อไปคือ -

inets:start().

คุณจะได้รับผลลัพธ์ต่อไปนี้

ok

คำสั่งต่อไปคือ -

helloworld:start().

คุณจะได้รับผลลัพธ์ต่อไปนี้

{ok,<0.50.0>}

Step 3 - คุณสามารถเข้าถึง url ได้แล้ว - http://localhost:8081/erl/hello_world:service.

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 - 2025 | All Rights Reserved