ความแตกต่างระหว่างภาษาการทำงานและการเขียนโปรแกรมที่จำเป็นคืออะไร?

ภาษากระแสหลักส่วนใหญ่รวมถึงภาษาการเขียนโปรแกรมเชิงวัตถุ (OOP) เช่น C #, Visual Basic, C ++ และ Java ได้รับการออกแบบมาเพื่อสนับสนุนการเขียนโปรแกรมที่จำเป็น (ขั้นตอน) ส่วนใหญ่ในขณะที่ Haskell / gofer เหมือนภาษาล้วนๆ ใครสามารถอธิบายเพิ่มเติมเกี่ยวกับความแตกต่างระหว่างสองวิธีในการเขียนโปรแกรมได้อย่างไร

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

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

ตัวอย่าง: Java เป็นภาษาที่จำเป็น ตัวอย่างเช่นโปรแกรมสามารถสร้างขึ้นเพื่อเพิ่มชุดของตัวเลข:

 int total = 0;
 int number1 = 5;
 int number2 = 10;
 int number3 = 15;
 total = number1 + number2 + number3; 

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

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

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

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

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

สำหรับคน OOP หรือภาษาที่จำเป็น:

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

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

จุดด้อย:

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

เมื่อวิวัฒนาการไปในทางที่ผิดคุณมีปัญหา:

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

นี่คือความแตกต่าง:

ความจำเป็น:

• เริ่มต้น
• เปิดขนาดรองเท้าของคุณ 9 1/2
• หาที่ว่างในกระเป๋าของคุณเพื่อเก็บอาร์เรย์ [7] ของกุญแจ
• วางกุญแจไว้ในห้องเพื่อหากุญแจในกระเป๋า
• เข้าอู่
• เปิดอู่ซ่อมรถ
• เข้าสู่รถยนต์

... และต่อ ๆ ไป ...

• ใส่นมในตู้เย็น
• หยุด.

ประกาศฟังก์ชั่นดังกล่าวเป็นประเภทย่อย:

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

... และต่อ ๆ ไป ...

• ตรวจสอบให้แน่ใจว่าเรามีนมในตู้เย็น (เมื่อต้องการ - สำหรับภาษาที่ใช้งานได้ดี)

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

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

ฟังก์ชั่นการเขียนโปรแกรม: คำนวณแฟคทอเรียลของ n ie n! ie nx (n-1) x (n-2) x ... x 2 X 1

-- | Haskell comment goes like
-- | below 2 lines is code to calculate factorial and 3rd is it's execution  

factorial 0 = 1
factorial n = n * factorial (n - 1)
factorial 3

-- | for brevity let's call factorial as f; And x => y shows order execution left to right
-- | above executes as := f(3) as 3 x f(2) => f(2) as 2 x f(1) => f(1) as 1 x f(0) => f(0) as 1  
-- | 3 x (2 x (1 x (1)) = 6

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

//somewhat functional way
function factorial(n) {
  if(n < 1) {
     return 1;
  }
  return n * factorial(n-1);   
}
factorial(3);

//somewhat more imperative way
function imperativeFactor(n) {
  int f = 1
  for(int i = 1; i <= n; i++) {
     f = f * i
  }
  return f;
}

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

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

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

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

ปัญหา: ฉันต้องการเปลี่ยนสิ่งมีชีวิตนี้จากม้าเป็นยีราฟ

• ยืดคอ
• ยืดขา
• ใช้สปอต
• ให้สิ่งมีชีวิตลิ้นดำ
• ลบหางม้า

แต่ละรายการสามารถเรียกใช้ในลำดับใดก็ได้เพื่อให้ได้ผลลัพธ์ที่เหมือนกัน

การเขียนโปรแกรมเชิงซ้อนเป็นขั้นตอน รัฐและความสงบเรียบร้อยเป็นสิ่งสำคัญ

ปัญหา: ฉันต้องการจอดรถ

1. สังเกตสถานะเริ่มต้นของประตูโรงรถ
2. หยุดรถในทางรถวิ่ง
3. หากประตูโรงรถปิดให้เปิดประตูโรงรถจำสถานะใหม่ อย่างอื่นต่อไป
4. ดึงรถเข้าอู่
5. ปิดประตูโรงรถ

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

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

มันตามมาว่าโปรแกรมการทำงานเป็นเพียงการแสดงออก

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

ในกรอบการทำงานของโปรแกรม - ขณะที่การแสดงออกซึ่งประกอบด้วยฟังก์ชั่นและค่านิยมนั้นถูกสร้างขึ้นด้วยกระบวนทัศน์ทางภาษาทั้งหมดแนวความคิด "รูปแบบการทำงาน", combinators และระบบประเภทต่างๆและอัลกอริทึมการประเมินผล

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

รูปแบบการเขียนโปรแกรมที่จำเป็นได้รับการฝึกฝนในการพัฒนาเว็บตั้งแต่ปี 2005 จนถึง 2013

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

รูปแบบการเขียนโปรแกรมการทำงานสร้างสิ่งที่เป็นนามธรรมผ่านวิธีการที่ชาญฉลาดของการรวมฟังก์ชั่น

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

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

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

ดังนั้นหัวหน้าของเราจะให้รายการเส้นทางสิ่งที่เรารู้ว่าเป็นสูตร

สูตรจะบอกวิธีทำพาย สูตรหนึ่งเขียนในรูปแบบที่จำเป็นเช่น:

1. ผสมแป้ง 1 ถ้วย
2. เพิ่ม 1 ไข่
3. เติมน้ำตาล 1 ถ้วย
4. เทส่วนผสมลงในพิมพ์
5. วางกระทะในเตาอบเป็นเวลา 30 นาทีและ 350 องศาฟาเรนไฮด์

สูตรประกาศจะทำต่อไปนี้:

แป้ง 1 ถ้วยไข่ 1 ฟองน้ำตาล 1 ถ้วย - สถานะเริ่มต้น

กฎระเบียบ

1. หากทุกอย่างผสมอยู่ในกระทะ
2. หากไม่รวมทุกอย่างให้ใส่ชาม
3. หากทุกอย่างในกระทะวางในเตาอบ

ดังนั้นวิธีการที่จำเป็นมีลักษณะโดยวิธีการทีละขั้นตอน คุณเริ่มต้นด้วยขั้นตอนที่หนึ่งและไปที่ขั้นตอนที่ 2 และอื่น ๆ

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

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

เราใช้สถานะเริ่มต้นหรือส่วนผสมเริ่มต้นและใช้กฎบางอย่างกับพวกเขา

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

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

ดังนั้นกฎที่เราอาจต้องการตรวจสอบส่วนผสมหรือสถานะถ้าผสมให้ใส่ในกระทะ

ด้วยสถานะเริ่มต้นของเราที่ไม่ตรงกันเพราะเรายังไม่ได้ผสมส่วนผสมของเรา

ดังนั้นกฎที่ 2 บอกว่าถ้าพวกเขาไม่ผสมให้ผสมพวกเขาในชาม โอเคใช่กฎนี้ใช้

ตอนนี้เรามีชามผสมส่วนผสมตามสถานะของเรา

ตอนนี้เราใช้สถานะใหม่นั้นกับกฎของเราอีกครั้ง

ดังนั้นกฎที่ 1 บอกว่าถ้าส่วนผสมผสมกันในกระทะโอเคใช่แล้วตอนนี้กฎที่ 1 มีผลบังคับใช้แล้วให้ทำ

ตอนนี้เรามีสถานะใหม่นี้ที่ส่วนผสมถูกผสมและในกระทะ กฎ 1 ไม่เกี่ยวข้องอีกต่อไปกฎ 2 ใช้ไม่ได้

กฎข้อที่ 3 บอกว่าหากส่วนผสมอยู่ในกระทะวางไว้ในเตาอบกฎที่ดีคือสิ่งที่ใช้กับสถานะใหม่นี้ให้ทำ

แล้วเราก็จบลงด้วยพายแอปเปิ้ลแสนอร่อยหรืออะไรก็ตาม

ตอนนี้ถ้าคุณเป็นเหมือนฉันคุณอาจจะคิดว่าทำไมเราถึงไม่ทำโปรแกรมที่จำเป็น มันสมเหตุสมผลแล้ว

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

ในวิธีการประกาศเราอาจมีส่วนผสมเริ่มต้นหรือสถานะเริ่มต้นเช่นtextInput=“”ตัวแปรเดียว

บางทีการป้อนข้อความเริ่มจากสตริงว่างเปล่า

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

1. หากผู้ใช้ป้อนข้อความให้อัปเดตการป้อนข้อความ ทีนี้ตอนนี้มันใช้ไม่ได้

2. หากเทมเพลตแสดงผลให้คำนวณวิดเจ็ต

3. หากมีการอัปเดต textInput ให้สร้างเท็มเพลต

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

ดังนั้นในบางครั้งผู้ใช้จะอัปเดตข้อความแล้วเราอาจใช้กฎหมายเลข 1

เราอาจอัปเดตสิ่งนั้นเป็น “abcd”

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

โดยทั่วไปในฐานะโปรแกรมเมอร์เราต้องการที่จะพยายามออกแบบการเขียนโปรแกรมเพิ่มเติม

ความหมายดูเหมือนชัดเจนและชัดเจนมากขึ้น แต่วิธีการประกาศปรับขนาดอย่างมากสำหรับการใช้งานขนาดใหญ่

•ภาษาที่จำเป็น:

• การดำเนินการที่มีประสิทธิภาพ

• ความหมายที่ซับซ้อน

• ไวยากรณ์ที่ซับซ้อน

• การทำงานพร้อมกันได้รับการออกแบบโปรแกรมเมอร์

• การทดสอบที่ซับซ้อนไม่มีความโปร่งใสในการอ้างอิงมีผลข้างเคียง

• มีสถานะ

•ภาษาหน้าที่:

• ความหมายง่าย ๆ

• ไวยากรณ์อย่างง่าย

• การดำเนินการที่มีประสิทธิภาพน้อย

• โปรแกรมสามารถทำพร้อมกันโดยอัตโนมัติ

• การทดสอบอย่างง่ายมีความโปร่งใสในการอ้างอิงไม่มีผลข้างเคียง

• ไม่มีสถานะ

ฉันคิดว่าเป็นไปได้ที่จะแสดงการเขียนโปรแกรมการทำงานในแบบที่จำเป็น:

• ใช้การตรวจสอบสถานะของวัตถุและif... else/ switchคำสั่งจำนวนมาก
• กลไกการหมดเวลา / รอสักครู่เพื่อดูแล asynchornousness

มีปัญหาใหญ่กับวิธีการดังกล่าว:

• กฎ / ขั้นตอนซ้ำแล้วซ้ำอีก
• ความไร้สมรรถภาพทำให้โอกาสในการเกิดผลข้างเคียง / ข้อผิดพลาด

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

ตัวอย่างการใช้งาน: แอพพลิเคชั่นส่วนหน้าเช่น Android, iOS หรือเว็บแอพพลิเคชั่น logics รวม การสื่อสารกับแบ็กเอนด์

ความท้าทายอื่น ๆ เมื่อจำลองการทำงานของโปรแกรมด้วยโค้ดที่จำเป็น / ขั้นตอน:

• สภาพการแข่งขัน
• การรวมกันที่ซับซ้อนและลำดับของเหตุการณ์ ตัวอย่างเช่นผู้ใช้พยายามส่งเงินในแอปธนาคาร ขั้นตอนที่ 1) ทำสิ่งต่อไปนี้แบบขนานทั้งหมดดำเนินการต่อถ้าทั้งหมดดี a) ตรวจสอบว่าผู้ใช้ยังดีอยู่หรือไม่ (ฉ้อโกง, AML) b) ตรวจสอบว่าผู้ใช้มียอดคงเหลือเพียงพอหรือไม่ c) ตรวจสอบว่าผู้รับถูกต้องหรือไม่ AML) ฯลฯ ขั้นตอนที่ 2) ดำเนินการถ่ายโอนขั้นตอนที่ 3) แสดงการอัปเดตเกี่ยวกับยอดคงเหลือของผู้ใช้และ / หรือการติดตามบางประเภท ตัวอย่างเช่นด้วย RxJava โค้ดจะกระชับและสมเหตุสมผล หากไม่มีมันฉันสามารถจินตนาการได้ว่าจะมีโค้ดจำนวนมากยุ่งและมีแนวโน้มที่รหัสผิดพลาด

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

ฉันรู้ว่าคำถามนี้เก่ากว่าและคนอื่น ๆ อธิบายแล้วดีฉันต้องการให้ตัวอย่างปัญหาที่อธิบายเหมือนกันในแง่ง่าย

ปัญหา: การเขียนตารางของ 1

สารละลาย: -

ตามสไตล์ที่จำเป็น: =>

    1*1=1
    1*2=2
    1*3=3
    .
    .
    .
    1*n=n 

ตามสไตล์การใช้งาน: =>

    1
    2
    3
    .
    .
    .
    n

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

ที่ไหนในสไตล์ฟังก์ชั่นสิ่งที่อธิบายตนเองจะถูกละเว้น