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

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

REXX ได้รับการออกแบบและดำเนินการครั้งแรกในภาษาประกอบเป็น 'ตัวเองเวลาโครงการระหว่างวันที่ 20 ^THมีนาคม 1979 และกลางปี 1982 โดยไมค์ Cowlishaw ของ IBM แต่เดิมเป็นภาษาโปรแกรมสคริปต์เพื่อเปลี่ยนภาษาEXEC and EXEC 2. มันถูกออกแบบมาให้เป็นไฟล์macro or scripting languageสำหรับระบบใด ๆ ดังนั้น Rexx จึงถือเป็นสารตั้งต้นของ Tcl และ Python Rexx ยังได้รับการออกแบบโดยผู้สร้างให้เป็นเวอร์ชันที่เรียบง่ายและง่ายต่อการเรียนรู้ของภาษาโปรแกรม PL / I

คุณสมบัติของ Rexx

Rexx เป็นภาษาโปรแกรมมีคุณสมบัติที่สำคัญดังต่อไปนี้ -

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

เว็บไซต์อย่างเป็นทางการของ Rexx คือwww.oorexx.org

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

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

ความต้องการของระบบ

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

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

ในการดาวน์โหลด Rexx คุณควรใช้ URL ต่อไปนี้ - https://www.oorexx.org/download.html

หน้านี้มีการดาวน์โหลดที่หลากหลายสำหรับ Rexx เวอร์ชันต่างๆดังที่แสดงในภาพหน้าจอต่อไปนี้

คลิกที่ 'ooRexx install files' ในตารางที่มีส่วนหัวของ Release 4.2.0

หลังจากนี้คุณจะถูกนำไปยังหน้าต่อไปนี้อีกครั้ง

คลิกที่ ooRexx-4.2.0.windows.x86_64.exe เพื่อดาวน์โหลดไฟล์ 64-bitเวอร์ชันของซอฟต์แวร์ เราจะหารือเกี่ยวกับการติดตั้งซอฟต์แวร์ในบทต่อไปนี้

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

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

Step 2 - คลิกปุ่มถัดไปบนหน้าจอต่อไปนี้เพื่อดำเนินการติดตั้ง

Step 3 - คลิกที่ไฟล์ I Agree เพื่อดำเนินการต่อ

Step 4 - ยอมรับไฟล์ default components จากนั้นคลิกที่ปุ่มถัดไป

Step 5 - เลือกตำแหน่งการติดตั้งและคลิกที่ปุ่มถัดไป

Step 6 - ยอมรับกระบวนการเริ่มต้นที่จะติดตั้งและคลิกที่ปุ่มถัดไป

Step 7 - เลือกการเชื่อมโยงไฟล์เริ่มต้นและคลิกที่ปุ่มถัดไป

Step 8 - คลิกที่ช่องทำเครื่องหมายของรายการส่ง Rexx ไปยังไฟล์เรียกใช้งานจากนั้นคลิกที่ปุ่มถัดไปดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 9- ในหน้าจอถัดไปให้เลือกตัวแก้ไขสำหรับทำงานกับไฟล์ Rexx ให้ notepad เป็นตัวเลือกเริ่มต้น ยอมรับนามสกุลเริ่มต้นสำหรับไฟล์ Rexx แต่ละไฟล์ด้วย

Step 10 - ยอมรับการตั้งค่าเริ่มต้นบนหน้าจอต่อไปนี้ที่ปรากฏขึ้นและคลิกที่ปุ่มถัดไปเพื่อดำเนินการติดตั้งต่อไป

Step 11 - สุดท้ายคลิกที่ปุ่มติดตั้งเพื่อดำเนินการติดตั้งต่อไป

Step 12 - เมื่อการติดตั้งเสร็จสมบูรณ์คุณต้องคลิกที่ปุ่มถัดไปเพื่อดำเนินการต่อ

Step 13 - คลิกที่ปุ่ม Finish เพื่อทำการติดตั้ง

ในบทนี้เราจะพูดถึงวิธีการติดตั้งปลั๊กอิน popular IDE’s (Integrated Development Environment). Rexx เป็นภาษาโปรแกรมยังมีอยู่ใน IDE ยอดนิยมเช่นEclipse. มาดูกันว่าเราจะรับปลั๊กอินที่จำเป็นใน IDE เหล่านี้ได้อย่างไรเพื่อให้คุณมีทางเลือกมากขึ้นในการทำงานกับ Rexx

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

เพื่อให้การติดตั้ง Rexx ใน Eclipse ปราศจากปัญหาคุณจะต้องปฏิบัติตามขั้นตอนต่อไปนี้

Step 1 - เปิด Eclipse และคลิกที่รายการเมนู Help → Eclipse Marketplace ดังที่แสดงในภาพหน้าจอต่อไปนี้

Step 2 - ในกล่องโต้ตอบถัดไปให้ป้อน Rexx ในเกณฑ์การค้นหาและคลิกที่ปุ่มค้นหา

เมื่อเสร็จแล้วคลิกปุ่มติดตั้ง

Step 3 - คลิกที่ปุ่มยืนยันเพื่อดำเนินการติดตั้งคุณสมบัติต่อไป

Step 4- จากนั้น Eclipse จะดาวน์โหลดไฟล์ที่จำเป็นเพื่อเริ่มการติดตั้ง เมื่อเสร็จแล้ว Eclipse จะขอให้ยอมรับข้อตกลงใบอนุญาต คลิกที่ยอมรับข้อตกลงใบอนุญาตจากนั้นคลิกที่ปุ่มเสร็จสิ้นตามที่แสดงในภาพหน้าจอต่อไปนี้

จากนั้น Eclipse จะเริ่มติดตั้งซอฟต์แวร์ในพื้นหลัง

Step 5- คุณอาจได้รับคำเตือนด้านความปลอดภัย (ดังที่แสดงในภาพหน้าจอต่อไปนี้) คลิกที่ปุ่ม OK เพื่อดำเนินการต่อ

Step 6- คุณจะได้รับแจ้งให้รีสตาร์ท Eclipse เมื่อติดตั้งการอัปเดตแล้ว คลิกใช่เพื่อรีสตาร์ท Eclipse

เพื่อให้เข้าใจไวยากรณ์พื้นฐานของ Rexx ก่อนอื่นเรามาดูโปรแกรม Hello World แบบง่ายๆ

ตัวอย่าง

/* Main program */ 
say "Hello World"

เราจะเห็นว่าโปรแกรม hello world นั้นเรียบง่ายเพียงใด มันเป็นบรรทัดสคริปต์ง่ายๆที่ใช้ในการดำเนินการโปรแกรม Hello World

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

say command ใช้เพื่อส่งออกค่าไปยังคอนโซล
/* */ ใช้สำหรับความคิดเห็นใน Rexx

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

Hello World

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

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

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

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

มาดูสิ่งที่เราเข้าใจจากโปรแกรมด้านบนกัน -

เพิ่มเป็นฟังก์ชันที่กำหนดให้เพิ่มตัวเลข 2 ตัว
ในโปรแกรมหลักค่า 5 และ 6 ถูกใช้เป็นพารามิเตอร์ของฟังก์ชันเพิ่ม
คีย์เวิร์ด exit ใช้เพื่อออกจากโปรแกรมหลัก ใช้เพื่อแยกความแตกต่างของโปรแกรมหลักจากฟังก์ชันเพิ่ม
ฟังก์ชันเพิ่มแตกต่างจากสัญลักษณ์ ':'
คำสั่งแยกวิเคราะห์ใช้เพื่อแยกวิเคราะห์อาร์กิวเมนต์ที่เข้ามา
สุดท้ายคำสั่ง return ใช้เพื่อส่งกลับผลรวมของค่าตัวเลข

รูทีนย่อยและฟังก์ชั่น

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

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

การใช้งานฟังก์ชัน

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

การใช้งาน Subroutine

/* Main program */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

ผลลัพธ์ของทั้งสองโปรแกรมจะเป็นค่า 11

การดำเนินการคำสั่ง

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

ตัวอย่างมีดังนี้ -

ตัวอย่าง

/* Main program */ 
parse arg command 
command "file1" 
command "file2" 
command "file3" 
exit

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

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

sh: file1: command not found
     3 *-* command "file1" 
       >>>   " file1"
       +++   "RC(127)"
sh: file2: command not found
     4 *-* command "file2" 
       >>>   " file2"
       +++   "RC(127)"
sh: file3: command not found
     5 *-* command "file3" 
       >>>   " file3"
       +++   "RC(127)"

คำหลักใน Rexx

ไวยากรณ์ฟรีของ REXX หมายความว่าสัญลักษณ์บางตัวสงวนไว้สำหรับการใช้งานของตัวประมวลผลภาษาในบางบริบท

ภายในคำแนะนำเฉพาะสัญลักษณ์บางอย่างอาจถูกสงวนไว้เพื่อแยกส่วนต่างๆของคำสั่ง สัญลักษณ์เหล่านี้เรียกว่าคำหลัก ตัวอย่างของคำหลัก REXX คือWHILE in a DO instruction, และ THEN (ซึ่งทำหน้าที่เป็นตัวยุติประโยคในกรณีนี้) ตามหลังไฟล์ IF or WHEN clause.

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

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

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

ตัวอย่างมีดังนี้ -

/* Main program */
/* Call the add function */
add(5,6)

/* Exit the main program */
exit add:

/* Parse the arguments passed to the add function */ parse arg a,b
/* Display the added numeric values */
say a + b

ความคิดเห็นสามารถเขียนระหว่างบรรทัดรหัสดังที่แสดงในโปรแกรมต่อไปนี้ -

/* Main program */ 
/* Call the add function */ 
add(5,6) 

/* Exit the main program */ 
exit 
add: 
parse    /* Parse the arguments passed to the add function */ 
arg a,b 

/* Display the added numeric values */ 
say a + b

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

คุณสามารถมีหลายบรรทัดในความคิดเห็นดังที่แสดงในโปรแกรมต่อไปนี้ -

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

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

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

คุณอาจต้องการจัดเก็บข้อมูลประเภทข้อมูลต่างๆเช่น String, Character, Wide Character, Integer, Floating Point, Boolean เป็นต้นระบบปฏิบัติการจะจัดสรรหน่วยความจำและตัดสินใจว่าจะจัดเก็บข้อมูลใดในพื้นที่สงวน หน่วยความจำ.

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

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

Integer- สตริงตัวเลขที่ไม่มีจุดทศนิยมหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นได้a plus (+) or minus (-) sign. ตัวเลขที่แสดงต้องอยู่ระหว่าง -2147483648 ถึง 2147483647
Big Integer- สตริงของตัวเลขที่ไม่มีจุดทศนิยมหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-) ตัวเลขที่แสดงต้องอยู่ระหว่าง -9223372036854775808 ถึง 2147483648 รวมหรือระหว่าง 2147483648 ถึง 9223372036854775807
Decimal - จะมาจากรูปแบบใดรูปแบบหนึ่งต่อไปนี้ -
- สตริงตัวเลขที่มีจุดทศนิยม แต่ไม่มีตัวระบุเลขชี้กำลัง p แสดงถึงความแม่นยำและ sแสดงถึงมาตราส่วนของเลขฐานสิบที่สตริงแสดง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-)
- สตริงของตัวเลขที่ does not contain a decimal pointหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-) ตัวเลขที่แสดงน้อยกว่า -9223372036854775808 หรือมากกว่า 9223372036854775807
Float- สตริงที่แสดงถึงตัวเลขในสัญกรณ์ทางวิทยาศาสตร์ สตริงประกอบด้วยชุดของตัวเลขตามด้วยตัวระบุเลขชี้กำลัง (E หรือ e ตามด้วยเครื่องหมายบวก (+) หรือลบ (-) และชุดตัวเลข) สตริงสามารถเริ่มต้นด้วยเครื่องหมายบวก (+) หรือลบ (-)
String - สตริงอักขระปกติ

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

จำนวนเต็ม

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

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6)  

exit 
add:  

parse arg a,b 
say a + b

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

จำนวนเต็มใหญ่

โปรแกรมต่อไปนี้แสดงความสามารถของ Rexx ในการจัดการกับจำนวนเต็มขนาดใหญ่ โปรแกรมนี้แสดงวิธีการบวกเลขจำนวนเต็ม 2 ตัว

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(500000000000,6000000000000000000000)  

exit 
add:  

parse arg a,b 
say a + b

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

6.00000000E+21

ทศนิยม

โปรแกรมต่อไปนี้แสดงความสามารถของ Rexx ในการจัดการตัวเลขทศนิยม โปรแกรมนี้แสดงวิธีการเพิ่มทศนิยม 2 ตัว

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5.5,6.6)  

exit 
add:  

parse arg a,b 
say a + b

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

12.1

ลอย

ตัวอย่างต่อไปนี้แสดงกรณีที่ตัวเลขสามารถทำงานเป็นทศนิยมได้

Example

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(12E2,14E4)  

exit 
add:  

parse arg a,b 
say a + b

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

สตริง

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

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

Example

/* Main program */ 
display("hello")  

exit 
display:  

parse arg a 
say a

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

hello

ใน Rexx ตัวแปรทั้งหมดถูกผูกไว้กับคำสั่ง '=' ชื่อตัวแปรบางครั้งเรียกว่าสัญลักษณ์ อาจประกอบด้วยตัวอักษรตัวเลขและอักขระเช่น '. ! ? _'. ชื่อตัวแปรที่คุณสร้างต้องไม่ขึ้นต้นด้วยตัวเลขหรือจุด ชื่อตัวแปรง่ายๆไม่รวมจุด ชื่อตัวแปรที่มีจุดเรียกว่าตัวแปรผสมและแสดงถึงอาร์เรย์หรือตาราง

ต่อไปนี้เป็นประเภทพื้นฐานของตัวแปรใน Rexx ซึ่งได้อธิบายไว้ในบทที่แล้ว -

Integers- ใช้แทนจำนวนเต็มหรือจำนวนทศนิยม ตัวอย่างคือ 10
Big integers - หมายถึงค่าจำนวนเต็มขนาดใหญ่
Decimal - ค่าทศนิยมคือสตริงของตัวเลขที่มีจุดทศนิยม แต่ไม่มีตัวระบุเลขชี้กำลัง
Float - ค่าลอยเป็นสตริงที่แสดงถึงตัวเลขในสัญกรณ์ทางวิทยาศาสตร์
String - ชุดอักขระกำหนดสตริงใน Rexx

ฟังก์ชันตัวแปรประเภทต่างๆ

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

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

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

var-name = var-value

ที่ไหน

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

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

Example

/* Main program */ 
X = 40 
Y = 50 
Result = X + Y 
say Result

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

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

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

ชื่อตัวแปรบางครั้งเรียกว่าสัญลักษณ์ อาจประกอบด้วยตัวอักษรตัวเลขและอักขระเช่น " ! เหรอ? _ '. ชื่อตัวแปรที่คุณสร้างต้องไม่ขึ้นต้นด้วยตัวเลขหรือจุด

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

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

Example

/* Main program */ 
unassignedvalue 
say unassignedvalue

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

UNASSIGNEDVALUE
sh: UNASSIGNEDVALUE: command not found
     2 *-* unassignedvalue 
       >>>   "UNASSIGNEDVALUE"
       +++   "RC(127)"

ตัวแปรสามารถกำหนดค่าได้มากกว่าหนึ่งครั้ง โปรแกรมด้านล่างนี้แสดงให้เห็นว่าค่าของ X สามารถกำหนดค่าหลาย ๆ ครั้งได้อย่างไร

Example

/* Main program */ 
X = 40 
X = 50 
say X

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

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

ค่าของตัวแปรถูกพิมพ์โดยใช้ sayคำสั่ง ต่อไปนี้เป็นตัวอย่างของการพิมพ์ตัวแปรต่างๆ

Example

/* Main program */ 
X = 40 

/* Display an Integer */ 
say X 
Y = 50.5 

/* Display a Float */ 
say Y 
Z = "hello" 

/* Display a string */ 
say Z

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

40 
50.5 
hello

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

Rexx มีตัวดำเนินการหลายประเภทซึ่งอธิบายโดยละเอียดดังนี้ -

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

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

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

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

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

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

ตัวดำเนินการเชิงสัมพันธ์อนุญาตให้มีการเปรียบเทียบวัตถุ ต่อไปนี้เป็นตัวดำเนินการเชิงสัมพันธ์ที่มีอยู่ใน Rexx ใน Rexx ค่าจริงจะแสดงด้วย 1 และค่าเท็จแสดงด้วย 0

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

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

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

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

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

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

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

Groovy มีตัวดำเนินการสี่บิต ด้านล่างนี้คือตัวดำเนินการระดับบิตที่มีอยู่ใน Groovy

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

ซีเนียร์	ตัวดำเนินการและคำอธิบาย
1	bitand นี่คือโอเปอเรเตอร์“ และ” แบบบิต
2	bitor นี่คือโอเปอเรเตอร์“ หรือ” แบบบิต
3	bitxor นี่คือ "xor" แบบบิตหรือเฉพาะตัวหรือโอเปอเรเตอร์

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

ตารางต่อไปนี้แสดงลำดับความสำคัญของตัวดำเนินการสำหรับตัวดำเนินการ Rexx ตามลำดับความสำคัญจากมากไปหาน้อยของลำดับความสำคัญ

ตัวดำเนินการ	ลำดับความสำคัญ
ตัวดำเนินการคำนำหน้า	+ - \
การบวกและการลบ	+ -
ตัวดำเนินการเปรียบเทียบ	= ==> <> = <=
ตรรกะ AND	&
ตรรกะหรือ	\|
EXCLUSIVE หรือ	&&

อาร์เรย์ในภาษาโปรแกรมใด ๆ ช่วยให้คุณสามารถจัดกลุ่มรายการค่าประเภทเดียวกันได้ การใช้อาร์เรย์คือการช่วยให้คุณสร้างรายการประเภทของค่าที่คล้ายกันซึ่ง ได้แก่sortable, searchable และสามารถ easily manipulated. Rexx ยังช่วยให้สามารถกำหนดอาร์เรย์ได้ อาร์เรย์เหล่านี้อาจเป็นมิติเดียวหรือหลายมิติ

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

ในหลายภาษาโปรแกรมคุณต้องกังวลว่าตัวห้อยของรายการแรกในตารางคืออะไร ตัวห้อยตัวเลขตัวแรกเป็น 0 หรือ 1? ใน Rexx ตัวห้อยแรกคืออะไรก็ได้ที่คุณใช้! ดังนั้นป้อนองค์ประกอบอาร์เรย์แรกในตำแหน่ง 0 หรือ 1 ตามที่คุณต้องการ

array_name.0 = ‘first element’

หรือ

array_name.1 = ‘first element’

มาดูการดำเนินการต่างๆสำหรับอาร์เรย์

การสร้างอาร์เรย์

อาร์เรย์ถูกสร้างขึ้นด้วยหลักการตั้งชื่อเดียวกันซึ่งใช้สำหรับตัวแปรใน Rexx

ไวยากรณ์ทั่วไปสำหรับการสร้างอาร์เรย์มีดังนี้ -

Arrayname.index = value

ที่ไหน

Arrayname - นี่คือชื่อที่ระบุให้กับอาร์เรย์
Index - นี่คือตำแหน่งดัชนีในอาร์เรย์เพื่ออ้างถึงองค์ประกอบเฉพาะ
Value - นี่คือค่าที่กำหนดให้กับองค์ประกอบดัชนีในอาร์เรย์

ตัวอย่างการประกาศอาร์เรย์มีดังนี้ -

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0

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

ชื่อของอาร์เรย์ถูกกำหนดเป็นรายการ
มี 3 องค์ประกอบของอาร์เรย์ซึ่งเริ่มต้นด้วยค่า 0

การกำหนดค่าให้กับองค์ประกอบอาร์เรย์

สามารถกำหนดค่าใหม่ให้กับองค์ประกอบอาร์เรย์ได้ในลักษณะเดียวกับที่องค์ประกอบอาร์เรย์เริ่มต้น

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

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30

การแสดงค่าของอาร์เรย์

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

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
say list.1 
say list.2 
say list.3

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

10
0
30

คัดลอกอาร์เรย์

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

Newarray. = sourcearray.

ที่ไหน

Newarray - นี่คืออาร์เรย์ใหม่ที่ต้องคัดลอกองค์ประกอบไปยัง
Sourcearray - นี่คืออาร์เรย์ต้นทางที่จำเป็นต้องคัดลอกองค์ประกอบ

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

Example

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
listnew. = list. 

say listnew.1 
say listnew.2 
say listnew.3

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

10
0
30

การวนซ้ำผ่านองค์ประกอบอาร์เรย์

องค์ประกอบของอาร์เรย์สามารถทำซ้ำได้โดยใช้คำสั่งซ้ำที่มีอยู่ใน Rexx ตัวอย่างวิธีการทำได้มีดังนี้ -

Example

/* Main program */ 
list.1 = 10 
list.2 = 20 
list.3 = 30 

number_of_elements = 3 
do j = 1 to number_of_elements 
say list.j 
end

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

do loop ใช้เพื่อวนซ้ำผ่านองค์ประกอบอาร์เรย์
ตัวแปร number_of_elements ใช้ในการจัดเก็บจำนวนองค์ประกอบในอาร์เรย์
variable j ใช้เพื่อวนซ้ำผ่านแต่ละองค์ประกอบของอาร์เรย์

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

10
20
30

อาร์เรย์สองมิติ

มีการกล่าวถึงด้วยว่าเราสามารถสร้างอาร์เรย์หลายมิติใน Rexx ได้ ลองดูตัวอย่างวิธีการใช้อาร์เรย์ 2 มิติ

Example

/* Main program */ 
list.1 = 10 
list.1.1 = 11 
list.1.2 = 12 

say list.1 
say list.1.1 
say list.1.2

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

10
11
12

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

ในการสร้างอาร์เรย์หลายมิติเราสามารถใช้การสร้างดัชนีอีกชั้นหนึ่งได้ ดังนั้นในตัวอย่างของเราเราใช้list.1.1 เพื่อสร้างอาร์เรย์ภายในอื่นสำหรับค่าดัชนี 1 ของอาร์เรย์รายการ

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

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

ให้เราพูดคุยเกี่ยวกับลูปต่างๆที่ Rexx สนับสนุน

ซีเนียร์	ประเภทห่วงและคำอธิบาย
1	ทำวน do loopใช้เพื่อเรียกใช้งานคำสั่งจำนวนหนึ่งในหลาย ๆ ครั้ง จำนวนครั้งที่ต้องดำเนินการคำสั่งจะพิจารณาจากค่าที่ส่งไปยังลูป do
2	ทำในขณะที่วนซ้ำ คำสั่ง do-while ใช้เพื่อจำลองลูป while แบบง่ายซึ่งมีอยู่ในภาษาโปรแกรมอื่น ๆ
3	ทำจนวน ลูป do-until เป็นการเปลี่ยนแปลงเล็กน้อยของ do while loop การวนซ้ำนี้แตกต่างกันไปตามข้อเท็จจริงที่ออกเมื่อเงื่อนไขที่ประเมินเป็นเท็จ

การควบคุมซ้ำ

do loops สามารถรองรับเพื่อดำเนินการควบคุมคำสั่งซ้ำ ๆ

ไวยากรณ์

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

do index = start [to limit] [by increment] [for count] 
statement #1 
statement #2 
end

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

แผนภาพการไหล

ลองดูแผนภาพการไหลของลูปนี้ -

จากแผนภาพด้านบนคุณจะเห็นได้อย่างชัดเจนว่าการวนซ้ำถูกดำเนินการตามค่าดัชนีและวิธีการเพิ่มค่าดัชนี

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

ตัวอย่าง

/* Main program */ 
do i = 0 to 5 by 2 
   say "hello" 
end

ในโปรแกรมข้างต้นค่าของ count iถูกตั้งค่าเป็น 0 ก่อน จากนั้นจะเพิ่มขึ้นเป็นจำนวน 2 จนกว่าค่าจะไม่เกิน 5

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

hello 
hello 
hello

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

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

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

ลองดูงบตัดสินใจต่างๆที่มีอยู่ใน Rexx

ซีเนียร์	คำชี้แจงและคำอธิบาย
1	ถ้าคำสั่ง คำแถลงการตัดสินใจแรกคือ ifคำให้การ. อันif คำสั่งประกอบด้วยนิพจน์บูลีนตามด้วยหนึ่งคำสั่งหรือมากกว่า
2	คำสั่ง if-else คำสั่งในการตัดสินใจต่อไปคือคำสั่ง if-else อันif สามารถตามด้วยคำสั่งอื่นที่เป็นทางเลือกซึ่งจะดำเนินการเมื่อนิพจน์บูลีนเป็นเท็จ

ซ้อนถ้าคำสั่ง

บางครั้งมีข้อกำหนดที่จะต้องมี multiple if statementsฝังอยู่ภายในซึ่งกันและกันดังที่เป็นไปได้ในภาษาโปรแกรมอื่น ๆ ใน Rexx ยังเป็นไปได้

ไวยากรณ์

if (condition1) then 
   do 
      #statement1 
   end 
else 
   if (condition2) then 
      do 
      #statement2 
   end

แผนภาพการไหล

แผนภาพการไหลของซ้อน if งบมีดังนี้ -

ลองมาดูตัวอย่างของการซ้อนกัน if คำสั่ง -

ตัวอย่าง

/* Main program */ 
i = 50 
if (i < 10) then 
   do 
      say "i is less than 10" 
   end 
else 
if (i < 7) then 
   do 
      say "i is less than 7" 
   end 
else 
   do 
      say "i is greater than 10" 
   end

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

i is greater than 10

เลือกคำสั่ง

Rexx เสนอคำสั่ง select ซึ่งสามารถใช้ในการดำเนินการนิพจน์ตามเอาต์พุตของคำสั่ง select

ไวยากรณ์

รูปแบบทั่วไปของคำสั่งนี้คือ -

select 
when (condition#1) then 
statement#1 

when (condition#2) then 
statement#2 
otherwise 

defaultstatement 
end

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

คำสั่ง select มีช่วงของคำสั่งเพื่อประเมินเงื่อนไขที่แตกต่างกัน
แต่ละ when clause มีเงื่อนไขที่แตกต่างกันซึ่งจำเป็นต้องได้รับการประเมินและคำสั่งที่ตามมาจะถูกดำเนินการ
คำสั่งอื่นจะใช้เพื่อเรียกใช้คำสั่งเริ่มต้นใด ๆ หากก่อนหน้านี้เมื่อเงื่อนไขไม่ evaluate to true.

แผนภาพการไหล

แผนภาพการไหลของ select คำสั่งมีดังนี้

โปรแกรมต่อไปนี้เป็นตัวอย่างของคำสั่ง case ใน Rexx

ตัวอย่าง

/* Main program */ 
i = 50 
select 
when(i <= 5) then 
say "i is less than 5" 

when(i <= 10) then 
say "i is less than 10" 

otherwise 
say "i is greater than 10" 
end

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

i is greater than 10

Rexx มีประเภทข้อมูลต่อไปนี้สำหรับตัวเลข

Integer- สตริงตัวเลขที่ไม่มีจุดทศนิยมหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-) ตัวเลขที่แสดงต้องอยู่ระหว่าง -2147483648 ถึง 2147483647
Big Integer- สตริงของตัวเลขที่ไม่มีจุดทศนิยมหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-) ตัวเลขที่แสดงต้องอยู่ระหว่าง -9223372036854775808 ถึง 2147483648 รวมหรือระหว่าง 2147483648 ถึง 9223372036854775807
Decimal - หนึ่งในรูปแบบต่อไปนี้ -
- สตริงตัวเลขที่มีจุดทศนิยม แต่ไม่มีตัวระบุเลขชี้กำลังโดยที่ p แสดงถึงความแม่นยำและ sแสดงถึงมาตราส่วนของเลขฐานสิบที่สตริงแสดง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-)
- สตริงตัวเลขที่ไม่มีจุดทศนิยมหรือตัวระบุเลขชี้กำลัง อักขระตัวแรกสามารถเป็นเครื่องหมายบวก (+) หรือลบ (-) ตัวเลขที่แสดงน้อยกว่า -9223372036854775808 หรือมากกว่า 9223372036854775807
Float- สตริงที่แสดงถึงตัวเลขในสัญกรณ์ทางวิทยาศาสตร์ สตริงประกอบด้วยชุดของตัวเลขตามด้วยตัวระบุเลขชี้กำลัง (E หรือ e ตามด้วยเครื่องหมายบวก (+) หรือลบ (-) และชุดตัวเลข) สตริงสามารถเริ่มต้นด้วยเครื่องหมายบวก (+) หรือลบ (-)

ตอนนี้เรามาดูความแตกต่างกัน methods available for numbers.

ซีเนียร์	วิธีการสำหรับ Numbers
1	ABS วิธีนี้ส่งคืนค่าสัมบูรณ์ของหมายเลขอินพุต
2	MAX วิธีนี้ส่งคืนค่าสูงสุดจากรายการตัวเลข
3	นาที วิธีนี้จะคืนค่าต่ำสุดจากรายการตัวเลข
4	สุ่ม วิธีนี้ส่งคืนตัวเลขที่สร้างขึ้นแบบสุ่ม
5	ลงชื่อ ส่งคืน 1 ถ้าตัวเลขมากกว่า 0 หรือ 0 ถ้าตัวเลขเป็น 0 หรือ -1 ถ้าตัวเลขน้อยกว่า 0
6	TRUNC วิธีนี้จะตัดทอนตัวเลข

สตริงใน Rexx แสดงด้วยลำดับของอักขระ โปรแกรมต่อไปนี้เป็นตัวอย่างของสตริง -

/* Main program */ 
a = "This is a string" 
say a

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

This is a string

มาดูวิธีการบางอย่างที่มีอยู่ใน Rexx สำหรับสตริง

ซีเนียร์	วิธีการที่มีอยู่ใน Rexx for Strings
1	ซ้าย วิธีนี้ส่งคืนอักขระจำนวนหนึ่งจากด้านซ้ายของสตริง
2	ขวา วิธีนี้จะส่งคืนอักขระจำนวนหนึ่งจากทางขวาของสตริง
3	ความยาว วิธีนี้จะส่งคืนจำนวนอักขระในสตริง
4	ย้อนกลับ วิธีนี้ส่งคืนอักขระในรูปแบบย้อนกลับ
5	เปรียบเทียบ วิธีนี้จะเปรียบเทียบ 2 สตริง ส่งคืน "0" ถ้า "string1" และ "string2" เหมือนกัน มิฉะนั้นจะส่งคืนตำแหน่งของอักขระตัวแรกที่ไม่ตรงกัน
6	สำเนา วิธีนี้คัดลอกไฟล์ string n จำนวนครั้ง.
7	สถานีย่อย วิธีนี้ได้รับสตริงย่อยจากสตริงเฉพาะ
8	ตำแหน่ง วิธีนี้จะคืนตำแหน่งของสตริงหนึ่งภายในอีกสตริง
9	delstr วิธีนี้จะลบสตริงย่อยจากภายในสตริง

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

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

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

FunctionName: 
PARSE ARG arguement1, arguement2… arguementN 
Return value

ที่ไหน

FunctionName - นี่คือชื่อที่กำหนดให้กับฟังก์ชัน
PARSE ARG - นี่คือคีย์เวิร์ดใน Rexx ซึ่งใช้เพื่อระบุว่าพารามิเตอร์ถูกส่งไปยังฟังก์ชัน
arguement1, arguement2… arguementN - นี่คืออาร์กิวเมนต์ที่ส่งผ่านไปยังฟังก์ชัน
Return value - นี่คือค่าที่ส่งคืนโดยฟังก์ชัน

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

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 
return a + b

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

เรากำลังกำหนดฟังก์ชันที่เรียกว่า add ซึ่งยอมรับ 2 พารามิเตอร์ a และ b
ฟังก์ชันใช้คำสั่ง return เพื่อส่งกลับผลรวมของ a และ b
ต้องใช้คำสั่ง exit เพื่อแสดงถึงการสิ้นสุดของโปรแกรมหลัก

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

การทำงานกับอาร์กิวเมนต์

ใน Rexx มีฟังก์ชันเฉพาะที่สามารถใช้กับอาร์กิวเมนต์ได้ ลองดูข้อโต้แย้งสองสามข้อดังกล่าว

อาร์กิวเมนต์

วิธีนี้ใช้เพื่อส่งกลับจำนวนอาร์กิวเมนต์ที่กำหนดไว้สำหรับฟังก์ชัน

Syntax -

arg()

Parameters - ไม่มี

Return Value - วิธีนี้จะส่งคืนจำนวนอาร์กิวเมนต์ที่กำหนดไว้สำหรับฟังก์ชัน

Example -

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg() 
return a + b

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

2 
11

arg (ดัชนี)

วิธีนี้ใช้เพื่อส่งกลับค่าของอาร์กิวเมนต์ที่ตำแหน่งเฉพาะ

Syntax -

arg(index)

Parameter -

Index - ตำแหน่งดัชนีของอาร์กิวเมนต์ที่จะส่งคืน

Return Value - วิธีนี้จะคืนค่าของอาร์กิวเมนต์ที่ตำแหน่งเฉพาะ

Example -

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
return a + b

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

5 
11

ฟังก์ชันแบบเรียกซ้ำ

ฟังก์ชันวนซ้ำหรือรูทีนคือสิ่งที่เรียกตัวเอง ฟังก์ชันการเรียกซ้ำใด ๆ อาจถูกเข้ารหัสในรูปแบบที่ไม่เรียกซ้ำแบบเดิม (หรือวนซ้ำ) แต่บางครั้งการเรียกซ้ำจะช่วยแก้ปัญหาได้ดีกว่า ภาษาโปรแกรมบางภาษาไม่รองรับการเรียกซ้ำ Rexx ทำ

มาดูตัวอย่างโปรแกรมแฟกทอเรียลที่มีชื่อเสียงซึ่งใช้ฟังก์ชันเรียกซ้ำใน Rexx

/* Main program */ 
do n = 1 to 5 
say 'The factorial of' n 'is:' factorial( n ) 
end 
return  

/* Function to get factorial */ 
factorial : procedure 
n = arg(1) 
if n = 1 then 
return 1 
return n * factorial( n - 1 )

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

The factorial of 1 is: 1
The factorial of 2 is: 2 
The factorial of 3 is: 6 
The factorial of 3 is: 24 
The factorial of 3 is: 120

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

ลองมาดูตัวอย่างของกอง

/* STACK: */
/* */ 
/* This program shows how to use the Rexx Stack as either a */ 

/* stack or a queue. */ 
do j = 1 to 3 
push ‘Stack: line #’ || j 

/* push 3 lines onto the stack */ 
end 
do j = 1 to queued() 

/* retrieve and display LIFO */ 
pull line 
say line 
end 
do j = 1 to 3 queue ‘Queue: line #’ || j 

/* queue 3 lines onto the stack */ 
end 
do queued() 

/* retrieve and display FIFO */ 
pull line 
say line 
end 
exit 0

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

รายการที่วางไว้ในสแต็กโดยคำสั่งผลักจะถูกดึงมาตามลำดับ LIFO -

do j = 1 to 3 
push ‘Stack: line #’ || j     /* push 3 lines onto the stack */ 
end

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

do j = 1 to queued()    /* retrieve and display LIFO */ 
pull line 
say line 
end

เนื่องจากไอเท็มทั้งสามชิ้นถูกวางลงบนสแต็กผ่านการพุชจึงถูกดึงข้อมูลตามลำดับ LIFO

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

STACK: LINE #3 
STACK: LINE #2 
STACK: LINE #1

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

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

ฟังก์ชั่นที่มีอยู่ใน Rexx สำหรับ File I / O นั้นขึ้นอยู่กับทั้งอินพุตบรรทัดและอินพุตอักขระและเราจะดูฟังก์ชั่นที่มีให้สำหรับทั้งสองอย่างโดยละเอียด

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

Example1

Example2

Example3

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

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

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

ลองดูฟังก์ชั่นที่ใช้ในการทำสิ่งนี้

เข้าแถว

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

Syntax -

linein(filename)

Parameter -

filename - นี่คือชื่อของไฟล์ที่ต้องอ่านบรรทัด

Return Value - วิธีนี้ส่งกลับไฟล์ทีละบรรทัด

Example -

/* Main program */ 
line_str = linein(Example.txt) 
say line_str

รหัสข้างต้นค่อนข้างง่ายในความจริงที่ว่า Example.txtชื่อไฟล์ถูกระบุให้กับฟังก์ชัน linein จากนั้นฟังก์ชันนี้จะอ่านบรรทัดของข้อความและให้ผลลัพธ์แก่ตัวแปรline_str.

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

Example1

การอ่านเนื้อหาของไฟล์ในครั้งเดียว

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

ตัวอย่างวิธีการนี้สามารถทำได้แสดงอยู่ด้านล่าง

/* Main program */ 
do while lines(Example.txt) > 0  
line_str = linein(Example.txt) 
say line_str 
end

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

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

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

Example1 
Example2 
Example3

การเขียนเนื้อหาลงในไฟล์

เช่นเดียวกับการอ่านไฟล์ Rexx ยังมีความสามารถในการเขียนลงไฟล์ ลองดูฟังก์ชั่นที่ใช้ในการทำสิ่งนี้

ผู้เล่นตัวจริง

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

Syntax -

lineout(filename)

Parameter -

filename - นี่คือชื่อของไฟล์ที่ต้องเขียนบรรทัดถึง

Return Value- วิธีนี้จะคืนสถานะของฟังก์ชัน lineout ค่าที่ส่งคืนคือ 0 หากเขียนบรรทัดสำเร็จมิฉะนั้นจะส่งคืนค่า 1

Example -

/* Main program */ 
out = lineout(Example.txt,"Example4")

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

ในบทนี้เราจะพูดถึงฟังก์ชันอื่น ๆ ที่พร้อมใช้งานสำหรับไฟล์

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

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

ใน Rexx โมดูลสามารถเขียนได้โดยใช้รูทีนย่อยและฟังก์ชัน มาดูรูทีนย่อยโดยละเอียด

การกำหนด Subroutine

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

FunctionName: 
   Statement#1 
   Statement#2 
   …. 
   Statement#N

ที่ไหน

FunctionName - นี่คือชื่อที่กำหนดให้กับรูทีนย่อย
Statement#1 .. Statement#N - นี่คือรายการของคำสั่งที่ประกอบเป็นรูทีนย่อย

โปรแกรมต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้รูทีนย่อย

/* Main program */ 
call add 
exit 
add: 
a = 5 
b = 10 
c = a + b 
say c

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

เรากำลังกำหนดรูทีนย่อยที่เรียกว่า add.
รูทีนย่อยทำหน้าที่เพิ่มอย่างง่าย
ต้องใช้คำสั่ง exit เพื่อแสดงถึงการสิ้นสุดของโปรแกรมหลัก

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

การทำงานกับอาร์กิวเมนต์

นอกจากนี้ยังสามารถทำงานกับอาร์กิวเมนต์ใน Rexx ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 
c = a + b 
say c

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

เรากำลังกำหนดรูทีนย่อยที่เรียกว่า add ซึ่งรับ 2 พารามิเตอร์
ในรูทีนย่อยพารามิเตอร์ 2 ตัวจะถูกแยกวิเคราะห์โดยใช้คีย์เวิร์ด PARSE และ ARG

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

วิธีการต่างๆสำหรับการโต้แย้ง

มาดูวิธีการอื่น ๆ สำหรับการโต้แย้งกัน

อาร์กิวเมนต์

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

Syntax -

arg()

Parameters - ไม่มี

Return Value - วิธีนี้ส่งคืนจำนวนอาร์กิวเมนต์ที่กำหนดไว้สำหรับรูทีนย่อย

Example -

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg() 
c = a + b 
say c

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

2 
3

arg (ดัชนี)

วิธีนี้ใช้เพื่อส่งกลับค่าของอาร์กิวเมนต์ที่ตำแหน่งเฉพาะ

Syntax -

arg(index)

Parameters

Index - ตำแหน่งดัชนีของอาร์กิวเมนต์ที่จะส่งคืน

Return Value - วิธีนี้จะคืนค่าของอาร์กิวเมนต์ที่ตำแหน่งเฉพาะ

Example -

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
c = a + b 
say c

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

1 
3

ทุกภาษาการเขียนโปรแกรมมีฟังก์ชันในตัวที่ช่วยให้โปรแกรมเมอร์ทำงานประจำบางอย่างได้ Rexx ยังมีฟังก์ชั่นในตัวมากมาย

ลองดูฟังก์ชั่นทั้งหมดที่มีอยู่ใน Rexx

ซีเนียร์	ฟังก์ชั่นที่มีอยู่ใน Rexx
1	ที่อยู่ วิธีนี้จะส่งคืนชื่อของสภาพแวดล้อมที่คำสั่ง Rexx กำลังทำงานอยู่
2	เสียงบี๊บ วิธีนี้ทำให้เกิดเสียงในระบบที่ความถี่และระยะเวลาเฉพาะ
3	ประเภทข้อมูล วิธีนี้จะคืนค่าเป็น "NUM" หากอินพุตเป็นตัวเลขที่ถูกต้องมิฉะนั้นจะคืนค่าเป็น "CHAR" คุณยังสามารถระบุได้ว่าคุณต้องการเปรียบเทียบค่าอินพุตกับค่า NUM หรือ CHAR ในแต่ละกรณีค่าที่ส่งกลับจะเป็น 1 หรือ 0 ขึ้นอยู่กับผลลัพธ์
4	วันที่ วิธีนี้จะส่งคืนวันที่ในเครื่องในรูปแบบต่อไปนี้
5	หลัก วิธีนี้ส่งคืนการตั้งค่าปัจจุบันของ NUMERIC DIGITS ตามที่กำหนดไว้ในระบบปัจจุบัน
6	ERRORTEXT วิธีนี้ส่งคืนข้อความแสดงข้อผิดพลาด Rexx ที่เกี่ยวข้องกับหมายเลขข้อผิดพลาด 'errorno' โปรดทราบว่าหมายเลขข้อผิดพลาดต้องมีค่าตั้งแต่ 0 ถึง 99 สิ่งนี้มีประโยชน์ในกรณีที่โปรแกรมของคุณส่งคืนรหัสข้อผิดพลาดและคุณต้องการทราบว่ารหัสข้อผิดพลาดหมายถึงอะไร
7	แบบฟอร์ม วิธีนี้จะคืนค่าการตั้งค่าปัจจุบันของ 'NUMERIC FORM' ซึ่งใช้ในการคำนวณทางคณิตศาสตร์ในระบบ
8	เวลา วิธีนี้จะส่งคืนเวลาท้องถิ่นในรูปแบบนาฬิกา 24 ชั่วโมงดังที่แสดงในโปรแกรมต่อไปนี้
9	USERID วิธีนี้จะส่งคืน ID ผู้ใช้ปัจจุบันที่ล็อกอินเข้าสู่ระบบ
10	XRANGE วิธีนี้จะส่งคืนอักขระในช่วงที่ระบุโดยอักขระเริ่มต้นและสิ้นสุด
11	X2D วิธีนี้จะคืนค่าการแปลงทศนิยมของไฟล์ hexstring value.
12	X2C วิธีนี้ส่งกลับการแปลงอักขระของค่า hexstring

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

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

Rexx มีคำสั่งระบบจำนวนมากที่สามารถใช้เพื่อทำงานซ้ำ ๆ เช่นนี้ได้ มาดูคำสั่งระบบบางคำสั่งที่มีอยู่ใน Rexx

ผบ

นี่คือคำสั่งแสดงรายการไดเร็กทอรีปกติที่ใช้ใน Windows

ไวยากรณ์

dir

พารามิเตอร์

ไม่มี

ส่งคืนค่า

วิธีนี้ส่งคืนรายการไดเร็กทอรีปัจจุบันบนระบบ

ตัวอย่าง

/* Main program */ 
dir

เอาต์พุตขึ้นอยู่กับไดเร็กทอรีในระบบ

โปรแกรมต่อไปนี้เป็นเพียงตัวอย่าง

เอาต์พุต

Volume in drive D is LENOVO 
Volume Serial Number is BAC9-9E3F  
Directory of D:\ 
04/06/2016  12:52 AM           268,205 100008676689.pdf 
10/20/2015  08:51 PM    <DIR>          data 
06/01/2016  10:23 AM                31 Example.txt 
10/28/2014  06:55 PM    <DIR>          Intel 
06/02/2016  11:15 AM                23 main.rexx 
12/22/2014  08:49 AM    <DIR>          PerfLogs  
12/13/2015  11:45 PM    <DIR>          Program Files 
12/24/2015  10:26 AM    <DIR>          Program Files (x86) 
07/17/2015  01:21 AM    <DIR>          Users 
12/23/2015  10:01 AM    <DIR>          Windows 
               3 File(s)        268,259 bytes 
               7 Dir(s)     202,567,680 bytes free

อีกตัวอย่างหนึ่งของไฟล์ dir commandจะแสดงในโปรแกรมต่อไปนี้ เฉพาะเวลานี้เราใช้ประโยชน์จากไฟล์special rc variable. ตัวแปรนี้มีความพิเศษใน Rexx และให้สถานะของการดำเนินการคำสั่งของระบบ หากค่าที่ส่งคืนเป็น 0 แสดงว่าคำสั่งดำเนินการสำเร็จ นอกจากนี้หมายเลขข้อผิดพลาดจะได้รับในชื่อตัวแปร rc

ตัวอย่าง

/* Main program */ 
dir 
if rc = 0 then 
   say 'The command executed successfully' 
else 
   say 'The command failed, The error code is =' rc

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

เอาต์พุต

The command failed, The error code is = 127

คำสั่งการเปลี่ยนเส้นทาง

Rexx ยังมีสิ่งอำนวยความสะดวกในการใช้คำสั่งการเปลี่ยนเส้นทาง คำสั่งการเปลี่ยนเส้นทางต่อไปนี้มีอยู่ใน Rexx

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

ลองดูตัวอย่างการใช้คำสั่งเปลี่ยนเส้นทาง ในตัวอย่างต่อไปนี้เรากำลังใช้คำสั่ง sort เพื่อจัดเรียงไฟล์ที่เรียกว่าsortin.txt. ข้อมูลจากไฟล์จะถูกส่งไปยังคำสั่ง sort จากนั้นเอาต์พุตของคำสั่ง sort จะถูกส่งไปยังไฟล์ sortout.txt

ตัวอย่าง

/* Main program */ 
'sort <sortin.txt> sortout.txt'

สมมติว่าไฟล์ sortin.txt มีข้อมูลต่อไปนี้

เอาต์พุต

b 
c 
a

ไฟล์ sortout.txt จากนั้นจะมีข้อมูลต่อไปนี้

a 
b 
c

ฟังก์ชัน ADDRESS

วิธีนี้ใช้เพื่อค้นหาว่าสภาพแวดล้อมเริ่มต้นที่ใช้สำหรับสตรีมอินพุตข้อผิดพลาดและเอาต์พุตคืออะไร

ไวยากรณ์

ADDRESS(options)

พารามิเตอร์

ตัวเลือกสำหรับที่อยู่ของระบบใดระบบหนึ่ง

ส่งคืนค่า

วิธีนี้ส่งคืนชื่อของสภาพแวดล้อมสำหรับสตรีมอินพุตข้อผิดพลาดและเอาต์พุต

ตัวอย่าง

/* Main program */ 
say ADDRESS('I') 
say ADDRESS('O') 
say ADDRESS('E')

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

เอาต์พุต

INPUT NORMAL 
REPLACE NORMAL 
REPLACE NORMAL

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

XML คืออะไร?

Extensible Markup Language XML เป็นภาษามาร์กอัปเหมือนกับ HTML หรือ SGML สิ่งนี้แนะนำโดย World Wide Web Consortium และพร้อมใช้งานในรูปแบบมาตรฐานเปิด XML มีประโยชน์อย่างยิ่งสำหรับการติดตามข้อมูลจำนวนน้อยถึงปานกลางโดยไม่ต้องใช้แบ็คโบนที่ใช้ SQL

สำหรับตัวอย่างโค้ด XML ทั้งหมดของเราลองใช้ไฟล์ XML ง่ายๆต่อไปนี้ movies.xml สำหรับการสร้างไฟล์ XML และอ่านไฟล์ในภายหลัง

<collection shelf = "New Arrivals"> 
   <movie title = "Enemy Behind"> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
   
   <movie title = "Transformers"> 
      <type>Anime, Science Fiction</type> 
      <format>DVD</format> 
      <year>1989</year> 
      <rating>R</rating> 
      <stars>8</stars> 
      <description>A schientific fiction</description> 
   </movie> 
   
   <movie title = "Trigun"> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Vash the Stam pede!</description> 
   </movie> 
   
   <movie title = "Ishtar"> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>2</stars> 
      <description>Viewable boredom </description> 
   </movie> 
</collection>

เริ่มต้นใช้งาน

โดยค่าเริ่มต้นฟังก์ชัน xml จะไม่รวมอยู่ในตัวแปล Rexx ในการทำงานกับ XML ใน Rexx จำเป็นต้องปฏิบัติตามขั้นตอนต่อไปนี้

ดาวน์โหลดไฟล์ต่อไปนี้ -
- Rexxxml - www.interlog.com/~ptjm/
- Libxml2 - www.ctindustries.net/libxml/
- iconv-1.9.2.win32 - www.xmlsoft.org/sources/win32/oldreleases/
- libxslt-1.1.26.win32 - www.xmlsoft.org/sources/win32/oldreleases/
แตกไฟล์ทั้งหมดและตรวจสอบให้แน่ใจว่ารวมอยู่ในเส้นทางระบบ

กำลังโหลดฟังก์ชัน XML

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

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

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

ฟังก์ชั่น rxfuncaddใช้เพื่อโหลดไลบรารีภายนอก xmlloadfuncs ฟังก์ชันใช้เพื่อโหลดไลบรารีทั้งหมดในไฟล์ rexxxml ไฟล์ลงในหน่วยความจำ
ถ้าค่า rcc <> 0 ก็จะทำให้เกิดข้อผิดพลาด สำหรับสิ่งนี้เราสามารถเรียกไฟล์rxfuncerrmsg เพื่อให้รายละเอียดเพิ่มเติมเกี่ยวกับข้อความแสดงข้อผิดพลาด
ในที่สุดเราก็โทรไปที่ xmlloadfuncsเพื่อให้สามารถเปิดใช้งานฟังก์ชันที่เกี่ยวข้องกับ xml ในโปรแกรม Rexx ได้แล้ว

ลองดูที่ต่างๆ methods available for XML in Rexx.

xmlVersion

วิธีนี้จะส่งคืนเวอร์ชันของไลบรารี XML และ XSLT ที่ใช้บนระบบ

ไวยากรณ์

xmlVersion()

พารามิเตอร์

ไม่มี

ส่งคืนค่า

วิธีนี้จะส่งคืนเวอร์ชันของไลบรารี XML และ XSLT ที่ใช้บนระบบ

ตัวอย่าง

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 
say xmlVersion()

เมื่อเรารันโปรแกรมด้านบนเราจะได้ผลลัพธ์ดังต่อไปนี้ ขึ้นอยู่กับเวอร์ชันของไลบรารี XML ที่ใช้บนระบบอีกครั้ง

เอาต์พุต

1.0.0 20631 10126

xmlParseXML

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

ไวยากรณ์

xmlParseXML(filename)

พารามิเตอร์

Filename - นี่คือชื่อของไฟล์ XML ที่ต้องแยกวิเคราะห์

ส่งคืนค่า

โครงสร้างเอกสารถูกส่งกลับโดยฟังก์ชัน อื่นจะคืนค่า 0 หากมีข้อผิดพลาด

ตัวอย่าง

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

say xmlVersion() 
sw = xmlParseXML('test.xml')

เอาต์พุต

ไม่มีเอาต์พุตทั่วไป

xmlFindNode

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

ไวยากรณ์

xmlParseXML(XPath,document)

พารามิเตอร์

XPath - นี่คือเส้นทางของโหนดในไฟล์ xml
document - นี่คือเอกสาร XML

ส่งคืนค่า

ประเมินนิพจน์ XPath และส่งคืนผลลัพธ์เป็นชุดโหนดซึ่งสามารถใช้ได้ในภายหลัง

ตัวอย่าง

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

say xmlVersion() 
document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
say xmlNodesetCount(nodeset)

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

เอาต์พุต

ผลลัพธ์จะแสดงจำนวนโหนดภาพยนตร์ในรายการ xml ของเรา

xmlEvalExpression

วิธีการด้านล่างนี้ใช้เพื่อประเมินนิพจน์ XPath และส่งคืนสตริงเป็นผลลัพธ์

ไวยากรณ์

xmlParseXML(XPath,Node)

พารามิเตอร์

XPath - นี่คือเส้นทางของโหนดในไฟล์ xml
document - องค์ประกอบโหนดเฉพาะ

ส่งคืนค่า

สตริงจะถูกส่งคืนตามนิพจน์ XPath ที่ส่งไป

ตัวอย่าง

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
do j = 1 to xmlNodesetCount(nodeset) 
value = xmlEvalExpression('type', xmlNodesetItem(nodeset, j)) 
say value 
end

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

เอาต์พุต

War, Thriller 
Anime, Science Fiction 
Anime, Action 
Comedy

Regina เป็นล่าม Rexx อีกตัวที่สามารถคอมไพล์และรันโปรแกรม Rexx ได้ เว็บไซต์อย่างเป็นทางการของ Regina คือ - www.regina-rexx.sourceforge.net/

ข้อดีบางประการของการใช้ Regina มีดังนี้ -

Regina สามารถทำงานบนแพลตฟอร์มใดก็ได้ไม่ว่าจะเป็น Windows, Linux หรือ Mac OS
Regina ทำงานตามมาตรฐานที่มีอยู่ทั้งหมด
Regina มีชุมชนใหญ่ติดตามดังนั้นจึงมีฟอรัมและสื่อการเรียนรู้มากมายสำหรับ Regina
Regina มีเครื่องมือมากมายสำหรับเขียนและทดสอบโปรแกรม Rexx
ใน Regina คุณสามารถเรียกใช้คำสั่งที่ไม่สามารถทำได้ใน Rexx Interpreter เริ่มต้น ตัวอย่างเช่นหากคุณรวมการตั้งค่าคอนฟิกบางอย่างคุณสามารถรันคำสั่งระดับระบบพื้นฐานได้จริงซึ่งไม่สามารถทำได้ใน Rexx

เมื่อคุณติดตั้ง Rexx ผ่านการติดตั้งที่ระบุไว้ใน Chapter 2 – Rexx Environmentล่าม Regina ได้รับการติดตั้งพร้อมกับมัน

ตอนนี้เรามาดูวิธีการทั่วไปที่มีให้เมื่อใช้ Regina ฟังก์ชั่นเหล่านี้เป็นฟังก์ชันเพิ่มเติมซึ่งไม่สามารถใช้ได้ผ่านการใช้งานปกติ

ในการใช้ฟังก์ชันเพิ่มเติมคุณต้องใส่โค้ดบรรทัดต่อไปนี้ สิ่งนี้ทำให้สามารถใช้ฟังก์ชันเพิ่มเติมของ Regina ได้

options arexx_bifs

ประการที่สองในขณะที่รันโปรแกรม Rexx ทั้งหมดให้ใช้คำสั่งต่อไปนี้

regina main.rexx

Where,

regina - นี่คือล่ามที่ใช้สำหรับโปรแกรม Rexx
main.rexx - โปรแกรม Rexx ของคุณ

ตอนนี้เราจะพูดคุยในรายละเอียดต่างๆ functions of Regina Rexx Interpreter.

ซีเนียร์	หน้าที่ของ Regina Rexx Interpreter
1	b2c วิธีนี้ใช้ในการแปลงค่าไบนารีเป็นค่าสตริง
2	bitcomp วิธีนี้ใช้ในการเปรียบเทียบสตริง 2 บิตทีละบิต
3	bittst วิธีนี้ใช้เพื่อระบุสถานะของบิตที่ระบุในสตริงบิต
4	หา วิธีนี้ใช้เพื่อค้นหาสตริงที่เกิดขึ้นครั้งแรกในสตริงอื่น
5	getenv วิธีนี้ส่งคืนค่าของตัวแปรสภาพแวดล้อมบนระบบ
6	getpid วิธีนี้ใช้เพื่อรับค่าของ id กระบวนการที่รันอยู่ในปัจจุบัน
7	กัญชา วิธีนี้ส่งคืนแอตทริบิวต์แฮชของสตริงเป็นตัวเลขทศนิยม นอกจากนี้ยังอัปเดตค่าแฮชภายในของสตริง
8	ปรับ วิธีนี้ใช้เพื่อเพิ่มเหตุผลหรือตัดทอนค่าของสตริงตามค่าความยาว
9	putenv วิธีนี้ใช้เพื่อกำหนดค่าของตัวแปรสภาพแวดล้อม
10	ไดเรกทอรี วิธีนี้ได้รับค่าของไดเร็กทอรีปัจจุบันบนระบบ
11	chdir วิธีนี้เปลี่ยนค่าของไดเร็กทอรีการทำงานปัจจุบันบนระบบ
12	แรนดู วิธีนี้จะส่งคืนตัวเลขสุ่มหลอกระหว่าง 0 ถึง 1

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

รูปแบบทั่วไปของคำสั่งแยกวิเคราะห์มีดังนี้ -

ไวยากรณ์

PARSE {UPPER|LOWER|CASELESS} source {template}

Where,

UPPER - แหล่งที่มาจะถูกแปลงเป็นตัวพิมพ์ใหญ่ก่อนที่จะแยกวิเคราะห์
LOWER - แหล่งที่มาจะถูกแปลงเป็นตัวพิมพ์เล็กก่อนที่จะแยกวิเคราะห์
CASELESS - เมื่อส่งผ่านพารามิเตอร์นี้ปลอกจะถูกละเว้น
source- นี่คือแหล่งที่มาที่ต้องแยกวิเคราะห์ มีตัวเลือกมากมายสำหรับสิ่งนี้และอาจเป็นอย่างใดอย่างหนึ่งต่อไปนี้ -
- ARG - อาร์กิวเมนต์สำหรับโปรแกรมหรือโพรซีเดอร์สามารถใช้เป็นแหล่งที่มาได้
- LINEIN - สามารถใช้อินพุตบรรทัดถัดไปเป็นแหล่งสัญญาณได้
- SOURCE - ข้อมูลแหล่งที่มาของโปรแกรมสามารถใช้เป็นแหล่งที่มาได้
- VAR name - ค่าของชื่อตัวแปรสามารถใช้เป็นแหล่งที่มาได้
template- พารามิเตอร์นี้ระบุวิธีการแยกวิเคราะห์แหล่งที่มา มีตัวเลือกมากมายสำหรับสิ่งนี้ บางส่วนมีการกล่าวถึงด้านล่าง
- variable name - นี่คือค่าที่กำหนดให้กับตัวแปร
- literal string - สตริงตามตัวอักษรซึ่งสามารถใช้รูปแบบเพื่อแยกสาย
- #- ตำแหน่งอักขระสัมบูรณ์ภายในแหล่งที่มา ดังนั้นถ้าคุณระบุค่าของ 5, 5 ^{วันที่}ตัวละครจะถูกนำมาใช้
- +#- ตำแหน่งอักขระสัมพัทธ์ภายในแหล่งที่มาเอง ดังนั้นถ้าคุณระบุค่าของ 5, 5 ^{วันที่}ตัวละครจะถูกนำมาใช้ค่อนข้าง

ลองดูตัวอย่างง่ายๆว่าการแยกวิเคราะห์สามารถทำได้ใน Rexx อย่างไร

ตัวอย่าง

/* Main program */ 
parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'"

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

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

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

'This' 
'is' 
'a' 
'Tutorial'

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

ตัวอย่าง

/* Main program */ 
phrase = 'This is a Tutorial' 

do while phrase <> '' 
   parse var phrase word phrase 
   say "'"word"'" 
   end

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

'This' 
'is' 
'a' 
'Tutorial'

การแยกตำแหน่ง

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

ตัวอย่าง

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 11 name2 21 birthday 31 town 51 country 
say name1 
say name2 
say birthday 
say town 
say country

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

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

Doe 
John M. 
03/03/78 
Mumbai 
India

คุณยังสามารถใช้ relative positional parsing ในกรณีนี้.

ตัวอย่าง

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 +10 name2 +10 birthday +10 town +20 country 
say name1 
say name2 
say birthday 
say town 
say country

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

Doe 
John M. 
03/03/78 
Mumbai 
India

ใน Rexx คำสั่งสัญญาณโดยทั่วไปจะใช้เพื่อวัตถุประสงค์สองประการคือ -

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

หากคำสั่งสัญญาณถูกใช้ในคำสั่งคำสั่งใด ๆ ต่อไปนี้โครงสร้างการควบคุมที่รอดำเนินการจะถูกปิดใช้งานโดยอัตโนมัติ

ถ้า ... แล้ว ... อื่น ...
ทำ ... จบ
ทำ i = 1 ถึง n ... end [และทำลูปที่คล้ายกัน]
เลือกเมื่อ ... แล้ว ... ... ฯลฯ ไม่งั้น ... จบ

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

ไวยากรณ์

signal labelName  
   
signal [ VALUE ] labelExpression

ลองดูตัวอย่างวิธีการใช้คำสั่งสัญญาณ

ตัวอย่าง

/* Main program */ 
n = 100.45 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say 'This is a whole number' 
   return 0 
msg : 
   say 'This is an incorrect number'

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

เอาต์พุต

This is an incorrect number.

หากคุณเปลี่ยนค่าของตัวแปร n เป็นจำนวนเต็มดังที่แสดงในโปรแกรมต่อไปนี้ -

/* Main program */ 
n = 100 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say ' This is a whole number ' 
   return 0 
msg : 
   say ' This is an incorrect number '

คุณจะได้รับผลลัพธ์ต่อไปนี้ -

This is a whole number

นอกจากนี้ยังสามารถถ่ายโอนไปยังค่าของฉลากตามที่แสดงในโปรแกรมต่อไปนี้ -

/* Main program */ 
n = 1 

if \ datatype( n, wholenumber ) then 
   signal msg 

if n < 1 | n > 3 then 
   signal msg  
   signal value n 
   3 : say 'This is the number 3' 
   2 : say ' This is the number 2' 
   1 : say ' This is the number 1' 
   return n 
msg : 
   say ' This is an incorrect number ' 
   exit 99

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

This is the number 1

Trap Label Transfer การเปิดใช้งาน / การปิดใช้งาน

ดังที่เราได้กล่าวไว้ก่อนหน้านี้คำสั่งสัญญาณยังสามารถใช้เพื่อถ่ายโอนการควบคุมไปยังป้ายกำกับกับดัก

ไวยากรณ์ทั่วไปของการถ่ายโอนเลเบลกับดักมีให้ดังนี้ -

ไวยากรณ์

signal ON conditionName [ NAME Label ] 
  
signal OFF conditionName

ที่ไหน

conditionName - นี่คือเงื่อนไขที่ควรเปิดหรือปิดสัญญาณ
Label - ป้ายกำกับที่เป็นทางเลือกซึ่งโปรแกรมควรเปลี่ยนไป

มาดูตัวอย่างการใช้การถ่ายโอนฉลากกับดัก

ตัวอย่าง

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue 
beep(1) 
signal off error 
signal off failure 
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured'

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

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

An error has occurred.

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

ติดตามในโหมดแบทช์

คำสั่ง trace ใช้เพื่อให้ระดับรายละเอียดของคำสั่ง Rexx แต่ละคำสั่งที่เรียกใช้งาน

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

ไวยากรณ์

trace [setting]

โดยที่การตั้งค่าสามารถเป็นตัวเลือกใดก็ได้ดังต่อไปนี้ -

A - ติดตามคำสั่งทั้งหมด
C - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการ
E - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการซึ่งทำให้เกิดข้อผิดพลาด
F - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการซึ่งส่งผลให้เกิดความล้มเหลว
I - สิ่งนี้ให้การติดตามระดับกลางของคำสั่ง Rexx
L - ตัวเลือกนี้คือหากคุณต้องการติดป้ายกำกับการติดตามที่เกิดขึ้น
N - นี่คือตัวเลือกเริ่มต้นที่ไม่มีการติดตามเกิดขึ้น

มาดูตัวอย่างของคำสั่ง trace

ตัวอย่าง

/* Main program */ 
trace A 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 

msg : 
   say ' This is an incorrect number '

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

5 *-* n = 100.45 if datatype( n, wholenumber ) then signal msg
   7 *-* say 'This is a whole number
This is a whole number                                                   
   8 *-* return 0

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

หมายเลขบรรทัดพร้อมกับคำสั่งที่ดำเนินการจะถูกเพิ่มลงในเอาต์พุตการติดตาม
แต่ละบรรทัดที่ดำเนินการจะแสดงในเอาต์พุตการติดตาม

ฟังก์ชัน Trace

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

ไวยากรณ์

trace()

ฟังก์ชันข้างต้นส่งคืนระดับการติดตามปัจจุบัน

พารามิเตอร์

ไม่มี

ส่งคืนค่า

ฟังก์ชันด้านบนให้ระดับการติดตามปัจจุบัน

ตัวอย่าง

/* Main program */ 
say trace() 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 
msg : 

say 'This is an incorrect number '

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

N 
This is an incorrect number

บรรทัดแรกของ N แสดงว่าการติดตามถูกตั้งค่าเป็น Normal

การตั้งค่า Trace

ระดับการติดตามสามารถตั้งค่าได้ด้วยฟังก์ชันการติดตาม ไวยากรณ์และตัวอย่างทั่วไปแสดงอยู่ด้านล่าง

ไวยากรณ์

trace(travel_level)

พารามิเตอร์

trace_level - สิ่งนี้คล้ายกับตัวเลือกที่มีให้สำหรับการตั้งค่าระดับการติดตาม

ส่งคืนค่า

ฟังก์ชันด้านบนให้ระดับการติดตามปัจจุบัน

ตัวอย่าง

/* Main program */ 
say trace() 
current_trace = trace('A') 
say current_trace 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg say 'This is a whole number' 
return 0 
msg : 
say ' This is an incorrect number '

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

N 
   4 *-* say current_trace 
N 
   6 *-* n = 100.45 
   7 *-* if \ datatype( n, wholenumber ) then 
   8 *-* signal msg 
   12 *-* say 'This is an incorrect number' 
'This is an incorrect number'

การติดตามแบบโต้ตอบ

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

ไวยากรณ์ทั่วไปมีดังนี้ -

ไวยากรณ์

trace ?options

โดยที่อ็อพชันเหมือนกันสำหรับคำสั่ง trace ดังที่แสดงด้านล่าง

A - ติดตามคำสั่งทั้งหมด
C - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการ
E - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการซึ่งทำให้เกิดข้อผิดพลาด
F - ติดตามเฉพาะคำสั่งโฮสต์ที่ส่งไปยังระบบปฏิบัติการซึ่งส่งผลให้เกิดความล้มเหลว
I - สิ่งนี้ให้การติดตามระดับกลางของคำสั่ง Rexx
L - ตัวเลือกนี้คือหากคุณต้องการติดป้ายกำกับการติดตามที่เกิดขึ้น
N - นี่คือตัวเลือกเริ่มต้นที่ไม่มีการติดตามเกิดขึ้น

มาดูตัวอย่างของการใช้งานการติดตามที่ใช้งานอยู่

ตัวอย่าง

/* Main program */ 
trace ?A

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg 

say 'This is a whole number' 
return 0 
msg : say 'This is an incorrect number'

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

This is an incorrect number
       +++ "LINUX COMMAND /home/cg/root/5798511/main.rex"
     5 *-* n = 100.45 if datatype( n, wholenumber ) then 
+++ Interactive trace. "Trace Off" to end debug, ENTER to Continue. +++
     6 *-* signal msg 
    10 *-* msg :
    10 *-* say 'This is an incorrect number'

Rexx มีความสามารถในการจัดการข้อผิดพลาดเช่นเดียวกับภาษาโปรแกรมอื่น ๆ

ต่อไปนี้เป็นเงื่อนไขข้อผิดพลาดต่างๆที่พบใน Rexx

ERROR - สิ่งนี้จะเพิ่มขึ้นเมื่อใดก็ตามที่คำสั่งที่ส่งไปยังระบบปฏิบัติการส่งผลให้เกิดข้อผิดพลาด
FAILURE - สิ่งนี้จะเพิ่มขึ้นเมื่อใดก็ตามที่คำสั่งที่ส่งไปยังระบบปฏิบัติการส่งผลให้เกิดความล้มเหลว
HALT- ปกติจะเพิ่มขึ้นเมื่อใดก็ตามที่การดำเนินการขึ้นอยู่กับการดำเนินการอื่น ตัวอย่างคือหากการดำเนินการ I / O ถูกหยุดไม่ว่าด้วยเหตุผลใดก็ตาม
NOVALUE - เหตุการณ์นี้จะเพิ่มขึ้นเมื่อไม่ได้กำหนดค่าให้กับตัวแปร
NOTREADY - สิ่งนี้ยกขึ้นโดยอุปกรณ์ I / O ใด ๆ ที่ไม่พร้อมที่จะยอมรับการดำเนินการใด ๆ
SYNTAX - เหตุการณ์นี้จะเกิดขึ้นหากมีข้อผิดพลาดทางไวยากรณ์ในโค้ด
LOSTDIGITS - เหตุการณ์นี้เกิดขึ้นเมื่อการดำเนินการทางคณิตศาสตร์ทำให้ตัวเลขสูญหายระหว่างการดำเนินการ

การดักจับข้อผิดพลาด

ข้อผิดพลาดถูกดักด้วยความช่วยเหลือของคำสั่งสัญญาณ ลองดูไวยากรณ์และตัวอย่างนี้

ไวยากรณ์

signal on [Errorcondition]

ที่ไหน

Errorcondition - นี่คือเงื่อนไขข้อผิดพลาดที่ระบุไว้ข้างต้น

ตัวอย่าง

ลองดูตัวอย่างนี้

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
signal off error 
signal off failure
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured'

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

An error has occurred.

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

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
exit 0 
error: failure: syntax: novalue: 

say 'An error has occured' 
say rc 
say sigl

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

An error has occured 
40 
6

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

การประกาศคลาสและวิธีการ

คลาสถูกกำหนดด้วยการประกาศไวยากรณ์ต่อไปนี้

ไวยากรณ์

::class classname

ที่ไหน classname เป็นชื่อที่กำหนดให้กับชั้นเรียน

วิธีการในคลาสถูกกำหนดด้วยการประกาศไวยากรณ์ต่อไปนี้

ไวยากรณ์

::method methodname

ที่ไหน methodname เป็นชื่อที่กำหนดให้กับวิธีการ

คุณสมบัติในคลาสถูกกำหนดด้วยการประกาศไวยากรณ์ด้านล่าง

ไวยากรณ์

::attribute propertyname

ที่ไหน propertyname เป็นชื่อที่ตั้งให้กับคุณสมบัติ

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของคลาสใน Rexx

::class student 
::attribute StudentID 
::attribute StudentName

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

ชื่อชั้นคือนักเรียน
ชั้นเรียนมีคุณสมบัติ 2 อย่างคือ StudentID และ StudentName

วิธี Getter และ Setter

เมธอด Getter และ Setter ใช้เพื่อตั้งค่าและรับค่าคุณสมบัติโดยอัตโนมัติ ใน Rexx เมื่อคุณประกาศคุณสมบัติด้วยคีย์เวิร์ดแอตทริบิวต์เมธอด getter และ setter จะถูกใส่ไว้แล้ว

ตัวอย่าง

::class student 
::attribute StudentID 
::attribute StudentName

ในตัวอย่างข้างต้นจะมีเมธอด Getter และ Setter สำหรับ StudentId และ StudentName

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

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
say value~StudentID 
say value~StudentName 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName

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

1 
Joe

วิธีการอินสแตนซ์

ออบเจ็กต์สามารถสร้างจากคลาสผ่านทางไฟล์ ~new operator. สามารถเรียกวิธีการจากคลาสได้ด้วยวิธีต่อไปนี้

Object~methodname

ที่ไหน methodname เป็นวิธีการที่ต้องเรียกใช้จากคลาส

ตัวอย่าง

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

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
value~Marks1 = 10 
value~Marks2 = 20 
value~Marks3 = 30 
total = value~Total(value~Marks1,value~Marks2,value~Marks3) 
say total 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

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

การสร้างวัตถุหลายชิ้น

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

ที่นี่เรากำลังสร้างวัตถุ 3 ชิ้น (st, st1 และ st2) และเรียกสมาชิกอินสแตนซ์และวิธีการอินสแตนซ์ตามลำดับ

มาดูตัวอย่างวิธีสร้างวัตถุหลายชิ้นได้

ตัวอย่าง

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
total = st~Total(st~Marks1,st~Marks2,st~Marks3) 
say total  

st1  =  .student~new 
st1~StudentID = 2 
st1~StudentName = 'John' 
st1~Marks1 = 10 
st1~Marks2 = 20 
st1~Marks3 = 40 
total = st1~Total(st1~Marks1,st1~Marks2,st1~Marks3) 
say total  

st2  =  .student~new 
st2~StudentID = 3 
st2~StudentName = 'Mark' 
st2~Marks1 = 10 
st2~Marks2 = 20 
st2~Marks3 = 30 
total = st2~Total(st2~Marks1,st2~Marks2,st2~Marks3) 
say total  

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

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

60 
70 
60

มรดก

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

คลาสที่สืบทอดคุณสมบัติของอื่น ๆ เรียกว่า subclass (คลาสที่ได้รับคลาสย่อย) และคลาสที่มีคุณสมบัติสืบทอดเรียกว่า superclass (คลาสพื้นฐานคลาสพาเรนต์)

มาดูตัวอย่างการสืบทอดใน Rexx ในตัวอย่างต่อไปนี้เรากำลังสร้างคลาสที่เรียกว่าPerson. จากนั้นเราใช้คีย์เวิร์ดคลาสย่อยเพื่อสร้างไฟล์Student class เป็น sub-class of Person.

ตัวอย่าง

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
say st~Total(st~Marks1,st~Marks2,st~Marks3)  

exit 0 
::class Person 
::class student subclass Person 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c))

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

ความสามารถในการพกพาเป็นสิ่งสำคัญในภาษาโปรแกรมใด ๆ อย่างที่ทราบกันดีว่า Rexx มีให้บริการในระบบปฏิบัติการที่หลากหลายเช่น Windows และ Linux ดังนั้นจึงจำเป็นต้องมั่นใจว่าเมื่อมีการพัฒนาโปรแกรมบนแพลตฟอร์ม Windows ว่ามีข้อควรระวังที่จำเป็นหากโปรแกรมเดียวกันทำงานบนแพลตฟอร์ม Linux

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

ตัวอย่าง

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

/* Main program */ 
parse version language level date month year. 
parse source system invocation filename. 
language = translate(language) 

if pos('REGINA',language) = 0 then 
   say 'Error , the default interpreter is not Regina' language 
   say 'The Interpreter version/release date is:' date month year 
   say 'The Language level is: ' level say 'The Operating System is'  

   select 
when system = 'WIN32' then 
   'ver'
when system = 'UNIX' | system = 'LINUX' then 
   'uname -a' 
   otherwise 
   say 'Unknown System:' system 
end 
if rc <> 0 then 
   say 'Error :' rc

ผลลัพธ์จะแตกต่างกันไปขึ้นอยู่กับระบบปฏิบัติการ ตัวอย่างผลลัพธ์ได้รับด้านล่าง

The Interpreter version/release date: 5 Apr 2015 
The Language level is:  5.00 
The Operating System is 
Unknown System: WIN64 
Bad return code: RC

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

ซีเนียร์	ฟังก์ชั่นเพิ่มเติม
1	b2c ฟังก์ชันนี้จะแปลงค่าไบนารีเป็นค่าสตริง
2	bitclr ฟังก์ชันนี้ใช้เพื่อสลับบิตที่ระบุในสตริงไบนารีเป็น 0
3	bitcomp ฟังก์ชันนี้ใช้เพื่อเปรียบเทียบ 2 ไบนารีสตริงที่เริ่มต้นด้วยบิต 0
4	buftype ฟังก์ชันนี้ใช้เพื่อแสดงเนื้อหาของสแต็กซึ่งโดยปกติจะใช้ในการดีบัก
5	ห้องใต้ดิน ฟังก์ชันนี้ใช้เพื่อเข้ารหัสสตริง
6	ส้อม ฟังก์ชันนี้ใช้เพื่อสร้างกระบวนการย่อยใหม่บนระบบ
7	getpid ฟังก์ชันนี้ได้รับ id ของกระบวนการที่กำลังทำงานอยู่
8	กัญชา ฟังก์ชันนี้ส่งคืนค่าแฮชของสตริง

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

ซีเนียร์	คำแนะนำ Rexx
1	ที่อยู่ ฟังก์ชันนี้ใช้เพื่อแสดงสภาพแวดล้อมคำสั่งปัจจุบัน
2	หล่น ฟังก์ชันนี้ใช้เพื่อยกเลิกการกำหนดตัวแปร
3	ตีความ ตีความหรือดำเนินการตามคำสั่งที่กำหนดไว้
4	นพ ฟังก์ชันนี้หมายถึงการไม่ดำเนินการใด ๆ โดยปกติคำสั่งนี้จะใช้ในif statements.
5	ดึง ใช้เพื่อดึงอินพุตจากสแต็กหรือจากสตรีมเริ่มต้น
6	ผลักดัน ใช้เพื่อพุชค่าไปยังกอง Rexx

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

OoRexx

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

โปรแกรมต่อไปนี้เป็นตัวอย่างของโปรแกรม Rexx อย่างง่ายซึ่งสามารถรันด้วยตัวดำเนินการ ooRexx

ตัวอย่าง

/* Main program */ 
say ‘hello’

ในการรันโปรแกรมนี้ให้รันคำสั่งต่อไปนี้

rexx main.rexx

เมื่อคุณรันคำสั่งดังกล่าวคุณจะได้รับผลลัพธ์ต่อไปนี้

hello

Netrexx

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

โค้ดต่อไปนี้เป็นตัวอย่างของโปรแกรม NetRexx

สร้างไฟล์ชื่อ main.nrx และวางรหัสต่อไปนี้ในไฟล์

/* Main program */ 
say ‘hello’

ในการคอมไพล์โค้ดให้รันคำสั่งต่อไปนี้ -

NetRexxC main.nrx

จากนั้นคุณจะได้รับผลลัพธ์ต่อไปนี้ NetRexxC เป็นคอมไพเลอร์ที่แปลงโปรแกรม Rexx ให้เทียบเท่ากับ java

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

ตอนนี้คุณสามารถรันโปรแกรม java ของคุณโดยใช้คำสั่ง java ต่อไปนี้

java main

เมื่อคุณรันคำสั่งดังกล่าวคุณจะได้รับผลลัพธ์ต่อไปนี้

Hello

Brexx

นี่เป็นการใช้งาน Rexx ที่มีน้ำหนักเบา นี่เป็นแพ็คเกจที่เบากว่าตัวใช้ Rexx มาตรฐาน แต่มันยังคงมีฟังก์ชั่นการใช้งานของ Rexx อย่างครบถ้วน

โค้ดต่อไปนี้เป็นตัวอย่างของโปรแกรม BRexx

/* Main program */ 
say ‘hello’

ในการรันโปรแกรมให้รันคำสั่งต่อไปนี้

rexx32 main.rexx

เมื่อคุณรันคำสั่งดังกล่าวคุณจะได้รับผลลัพธ์ต่อไปนี้

hello

NetRexx คือการใช้งาน Java ของ Rexx ใน NetRexx ตัวดำเนินการจะใช้เพื่อแปลงโปรแกรม Rexx เป็นโปรแกรม java ซึ่งสามารถรันบนเครื่องเสมือน Java ใดก็ได้

การตั้งค่า NetRexx

ขั้นตอนแรกใน NetRexx คือการตั้งค่าบนเครื่องภายใน ในการดำเนินการนี้เราต้องทำตามขั้นตอนต่อไปนี้ -

Step 1 - ไปที่เว็บไซต์ดาวน์โหลด NetRexx - http://www.netrexx.org/downloads.nsp

ดาวน์โหลดไฟล์ NetRexx.3.04.GA

Step 2- ตรวจสอบให้แน่ใจว่า java ได้รับการติดตั้งและทำงานบนระบบของคุณ คุณสามารถตรวจสอบได้ว่า java กำลังทำงานอยู่โดยใช้คำสั่ง java – version

ตัวอย่างของผลลัพธ์แสดงอยู่ด้านล่าง

H:\>java -version 
java version "1.7.0_79" 
Java(TM) SE Runtime Environment (build 1.7.0_79-b15) 
Java HotSpot(TM) Client VM (build 24.79-b02, mixed mode, sharing)

Step 3- คลายซิปเนื้อหาของไฟล์ซิป Netrexx คัดลอกไฟล์จากโฟลเดอร์ NetRexx3.04GA \ lib ไปยังโฟลเดอร์การติดตั้ง java / lib / etc ของคุณ

Step 4 - เพิ่มเส้นทาง NetRexx-3.04GA \ bin ให้กับตัวแปรพา ธ บนระบบ

เรียกใช้โปรแกรม NetRexx โปรแกรมแรก

สร้างไฟล์ชื่อ main.nrx และวางรหัสต่อไปนี้ในไฟล์

/* Main program */ 
say ‘hello’

ในการคอมไพล์โค้ดให้รันคำสั่งต่อไปนี้

NetRexxC main.nrx

จากนั้นคุณจะได้รับผลลัพธ์ต่อไปนี้ NetRexxC เป็นคอมไพเลอร์ที่แปลงโปรแกรม rexx ให้เทียบเท่ากับ java

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

ตอนนี้คุณสามารถรันโปรแกรม java ของคุณโดยใช้คำสั่ง java ต่อไปนี้

java main

เมื่อคุณรันคำสั่งดังกล่าวคุณจะได้รับผลลัพธ์ต่อไปนี้

Hello

ตอนนี้ให้เราพูดถึงบางส่วนของไฟล์ special aspects of the Netrexx library.

สตริงที่จัดทำดัชนี

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

ตัวอย่าง

/* Main program */ 
value = 'unknown' 
value['a'] = 'b' 
c = 'a' 
say value[c]

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

เอาต์พุต

ดัชนีหลายรายการ

ใน NetRexx คุณสามารถมีดัชนีหลายรายการสำหรับอาร์เรย์ ตัวอย่างแสดงด้านล่าง

ตัวอย่าง

/* Main program */ 
value = 'null' 
value['a', 'b'] = 1 
say value['a', 'b']

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

เอาต์พุต

ซีเนียร์	คำสั่งและคำอธิบาย
1	ถาม Command คำสั่งนี้ใช้เพื่ออ่านบรรทัดจากสตรีมอินพุตเริ่มต้น
2	หลักคำสั่ง คำสั่งนี้ใช้เพื่อแสดงค่าปัจจุบันของค่าหลัก
3	แบบฟอร์มคำสั่ง คำสั่งนี้ใช้เพื่อแสดงค่าปัจจุบันของค่าฟอร์ม
4	คำสั่งความยาว คำสั่งนี้ใช้เพื่อแสดงความยาวของค่าสตริง
5	คำสั่งเวอร์ชัน คำสั่งนี้ใช้เพื่อส่งคืนเวอร์ชันปัจจุบันของ NetRexx ที่ใช้อยู่
6	ติดตามคำสั่ง คำสั่งนี้ใช้เพื่อส่งคืนการตั้งค่าการติดตามปัจจุบันที่ NetRexx ใช้

BRexx เป็นการนำ Rexx ที่มีน้ำหนักเบากว่า ยังคงมีฟังก์ชันมากมายที่จะนำเสนอเป็นส่วนหนึ่งของการใช้งาน Rexx

การตั้งค่า BRexx

ขั้นตอนแรกใน BRexx คือการตั้งค่าบนเครื่องท้องถิ่น ในการดำเนินการนี้เราต้องทำตามขั้นตอนต่อไปนี้ -

Step 1 - ไปที่เว็บไซต์ดาวน์โหลด BRexx - https://ftp.gwdg.de/pub/languages/rexx/brexx/html/rx.html

ไปที่ส่วนดาวน์โหลดและดาวน์โหลดผลิตภัณฑ์

Step 2 - คลายซิปเนื้อหาของไฟล์บีบอัด Brexx

Step 3 - เพิ่มเส้นทาง BRexx \ bin ให้กับตัวแปรพา ธ บนระบบ

Step 4 - สร้างตัวแปรใหม่ชื่อ RXLIB แล้วชี้ไปที่โฟลเดอร์ lib ในโฟลเดอร์ Brexx

เรียกใช้โปรแกรม BRexx แรก

สร้างไฟล์ชื่อ main.rexx และวางรหัสต่อไปนี้ในไฟล์

/* Main program */ 
say ‘hello’

ในการรันโปรแกรมให้รันคำสั่งต่อไปนี้

rexx32 main.rexx

เมื่อคุณรันคำสั่งดังกล่าวคุณจะได้รับผลลัพธ์ต่อไปนี้

hello

ตอนนี้ให้เราพูดถึงฟังก์ชันที่ใช้บ่อยที่สุดที่มีอยู่ในไลบรารี BRexx

ซีเนียร์	ฟังก์ชั่นที่มีอยู่ในห้องสมุด BRexx
1	คำสั่ง acos คำสั่งนี้ใช้เพื่อรับการแปลงอาร์ก - โคไซน์ของตัวเลข
2	คำสั่ง cos คำสั่งนี้ใช้เพื่อรับการแปลงโคไซน์ของตัวเลข
3	คำสั่งบาป คำสั่งนี้ใช้เพื่อรับการแปลงไซน์ของตัวเลข
4	คำสั่ง asin คำสั่งนี้ใช้เพื่อรับการแปลงอาร์กไซน์ของตัวเลข
5	Tan Command คำสั่งนี้ใช้เพื่อรับการแปลงแทนเจนต์ของตัวเลข
6	คำสั่ง atan คำสั่งนี้ใช้เพื่อรับการแปลงส่วนโค้งแทนเจนต์ของตัวเลข
7	คำสั่ง mkdir คำสั่งนี้ใช้เพื่อสร้างไดเร็กทอรีในไดเร็กทอรีการทำงานปัจจุบัน
8	คำสั่ง rmdir คำสั่งนี้ใช้เพื่อลบไดเร็กทอรีในไดเร็กทอรีการทำงานปัจจุบัน
9	คำสั่งผบ คำสั่งนี้ใช้เพื่อส่งคืนรายการไดเร็กทอรีทั้งหมด

Rexx มีความสามารถในการทำงานกับฐานข้อมูลที่หลากหลายซึ่งแสดงไว้ด้านล่าง

HSQLDB
Oracle
เซิร์ฟเวอร์ SQL
MySQL
MongoDB

ข้อมูลทั้งหมดสำหรับฐานข้อมูล Rexx สามารถพบได้เมื่อคุณคลิกที่ลิงค์ต่อไปนี้ - https://rexxsql.sourceforge.net/

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

Step 1 - ไปที่หน้าดาวน์โหลดไดรเวอร์ต่อไปนี้จากไซต์ Rexx - https://sourceforge.net/projects/rexxsql/files/rexxsql/2.6/

Step 2 - ดาวน์โหลดไดรเวอร์ MYSQL - rxsql26B3_my_w32_ooRexx

Step 3 - คลายซิปเนื้อหาลงในเครื่องท้องถิ่น

Step 4 - เพิ่มเส้นทางของโฟลเดอร์ที่คลายซิปไปยังตัวแปรพา ธ บนเครื่องของคุณ

สำหรับตัวอย่างที่ตามมาทั้งหมดตรวจสอบให้แน่ใจว่ามีตัวชี้ต่อไปนี้ -

คุณได้สร้างฐานข้อมูล TESTDB
คุณได้สร้างตาราง EMPLOYEE ใน TESTDB
ตารางนี้มีฟิลด์ FIRST_NAME, LAST_NAME, AGE, SEX และ INCOME
ID ผู้ใช้ "testuser" และรหัสผ่าน "test123" ถูกตั้งค่าให้เข้าถึง TESTDB
ตรวจสอบให้แน่ใจว่าคุณได้ดาวน์โหลดไฟล์ jar mysql และเพิ่มไฟล์ลงใน classpath ของคุณ
คุณได้ผ่านการสอน MySQL แล้ว

การเชื่อมต่อฐานข้อมูล

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

ไวยากรณ์

SQLConnect(cname,username,password,dbname)

พารามิเตอร์

cname - นี่คือชื่อที่ใช้ในการเชื่อมต่อ
username - ชื่อผู้ใช้ที่จะเชื่อมต่อกับฐานข้อมูล
password - รหัสผ่านสำหรับเชื่อมต่อกับฐานข้อมูล
dbname - สคีมาฐานข้อมูลที่จะเชื่อมต่อ

ส่งคืนค่า

ค่าที่เท่ากับ 0 จะหมายความว่าการเชื่อมต่อฐานข้อมูลสำเร็จ

ตัวอย่าง

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 
say SQLConnect(c1,' testuser ',' test123','testdb')

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

การสร้างตารางฐานข้อมูล

ขั้นตอนต่อไปหลังจากเชื่อมต่อกับฐานข้อมูลคือการสร้างตารางในฐานข้อมูลของเรา ตัวอย่างต่อไปนี้แสดงวิธีสร้างตารางในฐานข้อมูลโดยใช้ Rexx คำสั่งทั้งหมดใน Rexx SQL ดำเนินการโดยใช้ฟังก์ชัน SQLCommand

ไวยากรณ์

SQLConnect(sname,statement)

พารามิเตอร์

sname - นี่คือชื่อที่กำหนดให้กับคำสั่งเพื่อดำเนินการ
statement - นี่คือคำสั่งที่ต้องดำเนินการกับฐานข้อมูล

ส่งคืนค่า

ค่าที่เท่ากับ 0 จะหมายความว่าคำสั่งสำเร็จ

ตัวอย่าง

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = 'create table employee (first_name char(20) not null, last_name 
   char(20),age int, sex   
   char(1), income float)' 

if SQLCommand(c2,sqlstr) == 0 then say 'Employee table created'

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

Connect Succedded 
Changed database to testdb 
Employee table created

การดำเนินการบนตารางฐานข้อมูล

ประเภทของการดำเนินการต่อไปนี้มักจะดำเนินการบนตารางฐานข้อมูล

ซีเนียร์	การทำงานและคำอธิบาย
1	แทรกการทำงาน จำเป็นเมื่อคุณต้องการสร้างระเบียนของคุณลงในตารางฐานข้อมูล
2	อ่านการทำงาน การดำเนินการอ่านบนฐานข้อมูลใด ๆ หมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล
3	อัปเดตการทำงาน การดำเนินการ UPDATE บนฐานข้อมูลใด ๆ หมายถึงการอัปเดตระเบียนตั้งแต่หนึ่งรายการขึ้นไปซึ่งมีอยู่แล้วในฐานข้อมูล
4	ลบการทำงาน จำเป็นต้องดำเนินการ DELETE เมื่อคุณต้องการลบบางระเบียนออกจากฐานข้อมูลของคุณ
5	การปิดการเชื่อมต่อ คำสั่งต่อไปนี้สามารถใช้เพื่อปิดการเชื่อมต่อกับฐานข้อมูล

การทำธุรกรรม

ธุรกรรมเป็นกลไกที่ทำให้ข้อมูลมีความสอดคล้องกัน ธุรกรรมมีคุณสมบัติสี่ประการดังต่อไปนี้ -

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

นี่คือตัวอย่างง่ายๆในการใช้ธุรกรรม

ตัวอย่าง

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 

if SQLCommand(c2,sqlstr) == 0 then 
if sqlcommit() == 0 then say committed

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

Connect Succedded 
Changed database to testdb 
COMMITTED

ดำเนินการ

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

Sqlcommit()

การดำเนินการย้อนกลับ

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

SqlRollback()

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

Rexx บนอุปกรณ์พกพาสามารถทำงานในโหมดต่อไปนี้ -

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

Rexx Interpreters สำหรับอุปกรณ์มือถือประเภทต่างๆแสดงอยู่ด้านล่าง

Windows CE - Brexx
Palm OS - Rexx สำหรับ Palm OS
ระบบปฏิบัติการ Symbian - Regina

สำหรับโปรแกรมจำลอง DOS จำเป็นต้องดำเนินการตามขั้นตอนต่อไปนี้ -

Step 1- อันดับแรกคือการดาวน์โหลด PocketDOS ซึ่งเป็นโปรแกรมจำลอง DOS ยอดนิยม ได้รับการออกแบบให้ทำงานบนระบบปฏิบัติการหลายระบบและรองรับหน้าจอ VGA ทั่วไปและพอร์ตอนุกรมและพอร์ตขนาน

Step 2 - ขั้นตอนต่อไปคือการดาวน์โหลดไฟล์ BRexx สำหรับ DOS 16 บิตไปยัง Windows PC

Step 3 - ขั้นตอนสุดท้ายคือการใช้ ActiveSync เพื่อซิงค์โปรแกรม Rexx กับอุปกรณ์มือถือ

มีผลิตภัณฑ์ที่ใช้ DOS เชิงพาณิชย์อื่น ๆ ที่มีจำหน่าย XTM เป็นผลิตภัณฑ์ที่อยู่ในหมวดหมู่นี้ คุณสมบัติของผลิตภัณฑ์นี้มีดังนี้ -

รองรับซีพียู 80186 และชุดคำสั่ง
มันทำงานจากรหัส BIOS เพื่อประสิทธิภาพที่ดีขึ้น
สามารถจัดเตรียมการจำลองสำหรับตัวประมวลผลคณิตศาสตร์ร่วมเวอร์ชัน 8087 MPU
ให้การเข้าถึงพอร์ตอนุกรม
รองรับภาษาที่หลากหลายเช่นอังกฤษฝรั่งเศสและเยอรมัน

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

Step 1- พยายามลดจำนวนคำสั่ง - ใน Rexx แต่ละคำสั่งจะมีค่าใช้จ่าย ดังนั้นพยายามลดจำนวนคำสั่งในโปรแกรมของคุณ ตัวอย่างคำแนะนำที่สามารถออกแบบใหม่ได้แสดงอยู่ด้านล่าง

แทนที่จะใช้คำสั่ง if else หลายคำสามารถใช้คำสั่งแยกวิเคราะห์ได้ เช่นเดียวกับในโปรแกรมต่อไปนี้แทนที่จะมีเงื่อนไข if สำหรับแต่ละค่าและรับค่าของ word1, word2, word3 และ word4 ให้ใช้คำสั่งแยกวิเคราะห์

/* Main program */  

parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'"

Step 2- พยายามรวมหลาย ๆ คำสั่งให้เป็นคำสั่งเดียว ตัวอย่างแสดงด้านล่าง

สมมติว่าคุณมีรหัสต่อไปนี้ซึ่งทำการมอบหมายให้ - a and b และส่งต่อไปยังวิธีการที่เรียกว่า proc.

do i = 1 to 100 
   a = 0 
   b = 1 
   call proc a,b 
end

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

do i = 1 for 100 
   parse value 0 1 with 
   a, 
   b, 
   call proc a,b 
end

Step 3 - ลองเปลี่ยนไฟล์ do..to loop กับ do..for loopทุกที่ที่เป็นไปได้ โดยปกติจะแนะนำเมื่อตัวแปรควบคุมถูกวนซ้ำผ่านลูป

/* Main program */ 
do i = 1 to 10 
   say i 
end

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

/* Main program */ 
do i = 1 for 10 
   say i 
end

Step 4- ถ้าเป็นไปได้ให้ลบเงื่อนไข for ออกจาก do loop ดังที่แสดงในโปรแกรมต่อไปนี้ หากไม่ต้องการตัวแปรควบคุมให้ใส่ค่าสิ้นสุดในลูป do ดังที่แสดงด้านล่าง

/* Main program */ 
do 10 
   say hello 
end

Step 5 - ใน select clauseสิ่งที่คุณรู้สึกว่าเป็นเงื่อนไขที่ดีที่สุดซึ่งจะได้รับการประเมินจำเป็นต้องให้ความสำคัญเป็นอันดับแรก when clause. ดังนั้นในตัวอย่างต่อไปนี้ถ้าเรารู้ว่า 1 เป็นตัวเลือกที่ใช้บ่อยที่สุดเราจะใส่when 1 clause เป็นประโยคแรกในคำสั่ง select

/* Main program */ 
select 
   when 1 then say'1' 
   when 2 then say'2' 
   otherwise say '3' 
end

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

คำแนะนำ 1

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

ตัวอย่างคำสั่ง address แสดงไว้ด้านล่าง

ตัวอย่าง

/* Main program */ 
address system dir

ผลลัพธ์ของคำสั่งมีดังนี้ แต่อาจแตกต่างกันไปในแต่ละระบบ

Volume in drive H is Apps 
Volume Serial Number is 8E66-AC3D  
Directory of H:\  
06/30/2016  01:28 AM    <DIR>          Apps 
07/05/2016  03:40 AM               463 main.class 
07/07/2016  01:30 AM                46 main.nrx 
07/07/2016  01:42 AM                38 main.rexx 
3 File(s)            547 bytes 
Dir(s)  313,085,173,760 bytes free

คำแนะนำ 2

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

ตัวอย่างเช่นเดียวกันแสดงอยู่ด้านล่าง

ตัวอย่าง

/* Main program */ 
options arexx_bifs 
say chdir('\REXXML100') 
say directory()

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

0 
D:\rexxxml100

คำแนะนำ 3

หลีกเลี่ยงการสร้างบล็อกความคิดเห็นขนาดใหญ่ดังที่แสดงในโปรแกรมต่อไปนี้

ตัวอย่าง

/******/ 
/* */ 
/* */ 
/* */ 
/******/ 
/* Main program */ 
address system dir

คำแนะนำ 4

ใช้คำสั่ง Parse เพื่อกำหนดค่าเริ่มต้น ตัวอย่างเช่นเดียวกันแสดงอยู่ด้านล่าง

ตัวอย่าง

parse value 0 1 with 
a, 
b

คำแนะนำ 5

ใช้คำสั่ง "Left (var1,2)" ทุกที่ที่ทำได้แทนคำสั่ง "substr (var1,1,2)"

คำแนะนำ 6

ใช้คำสั่ง "Right (var1,2)" ทุกที่ที่ทำได้แทนคำสั่ง "substr (var1, length (var1), 2)"

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

การตั้งค่าสภาพแวดล้อม

สิ่งแรกที่ต้องทำคือการตั้งค่าสภาพแวดล้อม มาทำตามขั้นตอนต่อไปนี้เพื่อจัดสภาพแวดล้อม

Step 1 - ดาวน์โหลดแพ็คเกจ Activetcl จากเว็บไซต์ต่อไปนี้ - https://www.activestate.com/activetcl

Step 2- ขั้นตอนต่อไปคือการเริ่มการติดตั้ง ActiveTCl คลิกที่ปุ่มถัดไปบนหน้าจอเพื่อดำเนินการต่อ

Step 3 - ยอมรับข้อตกลงใบอนุญาตและคลิกที่ปุ่มถัดไป

Step 4 - เลือกตำแหน่งสำหรับการติดตั้งและคลิกที่ปุ่มถัดไป

Step 5 - เลือกตำแหน่งสำหรับการติดตั้งการสาธิตและคลิกที่ปุ่มถัดไป

Step 6 - คลิกที่ปุ่มถัดไปเพื่อดำเนินการติดตั้ง

Step 7 - คลิกที่ปุ่ม Finish เพื่อทำการติดตั้ง

Step 8 - ขั้นตอนต่อไปคือการดาวน์โหลดซอฟต์แวร์ Rexxtk จากลิงค์ต่อไปนี้ - https://sourceforge.net/projects/rexxtk/

Step 9- ดับเบิลคลิกไฟล์ตัวติดตั้งจากลิงค์ในขั้นตอนก่อนหน้าเพื่อเริ่มการติดตั้ง คลิกที่ปุ่มถัดไปเพื่อดำเนินการต่อ

Step 10 - ในหน้าจอถัดไปให้คลิกที่ปุ่มใช่เพื่อยอมรับข้อตกลงใบอนุญาต

Step 11 - ในหน้าจอถัดไปเลือกตำแหน่งสำหรับการติดตั้งและคลิกที่ปุ่มถัดไป

Step 12 - เลือกตำแหน่งโฟลเดอร์ Program และคลิกที่ปุ่มถัดไป

เมื่อการติดตั้งเสร็จสมบูรณ์ตอนนี้เราสามารถเริ่มต้นด้วยการเขียนโปรแกรม GUI ใน Rexx

โปรแกรมพื้นฐาน

มาดูกันว่าเราจะออกแบบโปรแกรมพื้นฐานง่ายๆด้วย Rexx ในรูปแบบอินเทอร์เฟซผู้ใช้แบบกราฟิกได้อย่างไร

ตัวอย่าง

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 
do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0

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

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

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

การสร้างเมนู

เมนูถูกสร้างขึ้นด้วยความช่วยเหลือของฟังก์ชัน TkMenu และ TkAdd ไวยากรณ์ของฟังก์ชันเหล่านี้ได้รับด้านล่าง

ไวยากรณ์

TkMenu(widgetname,options,0)

พารามิเตอร์

Widgetname - ชื่อที่จะตั้งให้กับเมนู

ตัวเลือกสามารถเป็นใครก็ได้ดังต่อไปนี้ -

selectcolor - หากใช้ช่องทำเครื่องหมายหรือปุ่มตัวเลือกเป็นตัวเลือกเมนูตัวเลือกนี้จะระบุสีเพื่อเลือกเมื่อเลือกตัวเลือกเมนูใด ๆ
tearoff - ตัวเลือกนี้ใช้สำหรับการเพิ่มเมนูย่อยในเมนูหลัก
title - สตริงที่ต้องใช้เพื่อตั้งชื่อหน้าต่าง

ส่งคืนค่า

ที่จับสำหรับเมนูที่สร้างขึ้น

ตัวอย่าง

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 

menubar = TkMenu('.m1') 
filemenu = TkMenu('.m1.file','-tearoff', 0) 
call TkAdd menubar, 'cascade', '-label', 'File', '-menu', filemenu 
call TkAdd filemenu, 'command', '-label', 'Open...', '-rexx', 'getfile' 
call TkConfig '.', '-menu', menubar 

do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0

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

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

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

Reginald เป็นล่าม Rexx อีกตัวหนึ่งซึ่งพัฒนาโดย Jeff Glantt และมีการปรับแต่งบางอย่างเกี่ยวกับวิธีเรียกใช้โปรแกรม Rexx ในส่วนนี้เราจะดูวิธีการตั้งค่า Reginald และเรียกใช้โปรแกรม Rexx สองสามโปรแกรมในนั้น

การตั้งค่าสภาพแวดล้อม

ขั้นตอนแรกคือการตั้งค่าสภาพแวดล้อมซึ่งคือการดาวน์โหลดไฟล์ Reginald สามารถทำได้จากลิงค์เว็บไซต์ต่อไปนี้ -http://www.manmrk.net/tutorials/rexx/Reginald/win32/rxusrw32.htm

เมื่อการดาวน์โหลดเสร็จสิ้นและคุณเปิดโปรแกรมติดตั้งหน้าจอถัดไปจะอนุญาตให้คุณเลือกตำแหน่งการติดตั้ง

คลิกปุ่มติดตั้งเพื่อดำเนินการต่อ

เมื่อเสร็จสิ้นตอนนี้เราสามารถเริ่มรันโปรแกรมตัวอย่างหนึ่งโปรแกรมในตัวแปล Reginald สร้างโปรแกรมง่ายๆดังภาพด้านล่าง

/* Main program */ 
say 'Hello'

จากนั้นรันคำสั่งต่อไปนี้ -

RxLaunch.exe main.rexx

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

มีฟังก์ชั่นอื่น ๆ

นอกเหนือจากคำสั่ง Rexx ปกติแล้ว Reginald ยังมีคำสั่งเฉพาะบางอย่างที่ออกแบบมาสำหรับระบบปฏิบัติการ Windows DriveMap เป็นหนึ่งในคำสั่งดังกล่าว -

DriveMap

ฟังก์ชันนี้ให้ข้อมูลเกี่ยวกับไดรฟ์

Syntax -

Drivemap(,options)

Parameters -

Options - นี่คือรายการคำสำคัญที่สามารถใช้เพื่อรับข้อมูลต่างๆในไดรฟ์ของคอมพิวเตอร์ในระบบ

Return Value

ค่าสตริงที่มีข้อมูลในไดรฟ์

Example -

/* Main program */ 
say 'Drives on system : ' DriveMap(,'FIXED')

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

List of disk drives :  C:\ D:\

Rexx มีสิ่งอำนวยความสะดวกในการทำงานกับเว็บเซิร์ฟเวอร์เช่นกัน สิ่งที่พบบ่อยที่สุดคือเว็บเซิร์ฟเวอร์ apache ในการใช้ Rexxw กับเว็บเซิร์ฟเวอร์ Apache คุณต้องดาวน์โหลดโมดูล Rexx ก่อนจากลิงค์ต่อไปนี้ -https://sourceforge.net/projects/modrexx/?source=typ_redirect

เมื่อเสร็จแล้วตรวจสอบให้แน่ใจว่าได้เพิ่มโมดูล mod Rexx ในพา ธ คลาสแล้ว

ต้องเพิ่มและแก้ไขบรรทัดต่อไปนี้ในไฟล์คอนฟิกูเรชัน Apache

ต้องเพิ่มบรรทัดต่อไปนี้ต่อท้ายส่วนที่เหมาะสม -

httpd.conf รายการ LoadModule
LoadModule โมดูล rexx_module / mod_rexx.dll

ควรเพิ่มบรรทัดต่อไปนี้ที่ส่วนท้ายของไฟล์ http.conf ไฟล์.

แอปพลิเคชัน AddType / x-httpd-rexx-script .rex .rexx
แอปพลิเคชัน AddType / x-httpd-rexx-rsp .rsp
เพิ่มสิ่งเหล่านี้สำหรับการสนับสนุน REXX Server Page
RexxRspCompiler“ c: / Program Files / Apache Group / Apache2 / bin / rspcomp.rex”

เมื่อทำการเปลี่ยนแปลงข้างต้นแล้วคุณต้องปิดและรีสตาร์ทเว็บเซิร์ฟเวอร์ apache ของคุณ

บรรทัดด้านบนยังช่วยให้คุณมีหน้าเซิร์ฟเวอร์ที่ใช้ Rexx เช่นเดียวกับหน้าเซิร์ฟเวอร์ Java คุณสามารถเพิ่มโค้ด Rexx ลงในเพจ html ได้โดยตรง

ตัวอย่างแสดงด้านล่าง -

<p>The current date and time is 
   <?rexx 
      /* Inserting the rexx statement */ 
      say date() time() 
   ?>
</p>

เมื่อรันเพจเซิร์ฟเวอร์ที่ใช้ Rexx สิ่งต่อไปนี้จะดำเนินการ -

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

สุดท้ายไฟล์ชั่วคราวจะถูกลบออก