Javascript เป็นภาษาเขียนโปรแกรมเชิงฟังก์ชันหรือไม่

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

ทำซ้ำคำตอบของตัวเองสำหรับคำถามที่คล้ายกัน

ไม่มีคำจำกัดความที่ยอมรับของภาษาการเขียนโปรแกรมเชิงฟังก์ชัน

หากคุณกำหนดภาษาที่ใช้งานได้เป็นภาษาที่รองรับฟังก์ชันชั้นหนึ่งและแลมบ์ดาใช่แล้ว JavaScript * คือ * ภาษาที่ใช้งานได้

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

---

ฉันขอแนะนำให้คุณอ่านบล็อกโพสต์ที่เกี่ยวข้องต่อไปนี้ (และความคิดเห็นด้านล่าง):

• Scala ไม่ใช่ภาษาที่ใช้งานได้

• Erlang ใช้งานไม่ได้

• Reddit สนทนาเรื่อง "Erlang ไม่ทำงาน"

ฉันจะบอกว่ามันเป็นภาษาหลายกระบวนทัศน์

แก้ไข: เป็นหลายกระบวนทัศน์และรวมถึงโครงสร้างที่ใช้งานได้

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

คำตอบสำหรับคำถามของคุณในระดับชีวิตประจำวันมากขึ้นคือ"ไม่"

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

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

คำว่าภาษา "การเขียนโปรแกรมเชิงฟังก์ชัน" มีงานล้นมือมากจนทุกวันนี้แทบไม่มีประโยชน์ มีสองความหมายที่โดดเด่น:

1. มีฟังก์ชั่นชั้นหนึ่ง
   • Javascript นี่แหละ!
2. ขึ้นอยู่กับฟังก์ชันที่ใช้ในแคลคูลัสแลมบ์ดาโดยเน้นที่การหลีกเลี่ยงสถานะที่เปลี่ยนแปลงไม่ได้ถาวร (มักแทนที่ด้วยพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชัน)
   • ตามที่เขียนกันทั่วไป Javascript ไม่ใช่สิ่งนี้จากระยะไกล

เลือกความหมายของคุณจากนั้นคำถามก็ตอบได้

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

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

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

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

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

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

@petraszd ฉันเขียนโค้ดของคุณใหม่เล็กน้อยเพื่อรับ "ใหม่" สำหรับโอเปอเรเตอร์:

   
   function ffor(a, b, f){
     function it(i){
       if(i > b)return
       f(i)
       it(i+1)
     }
     it(a)
   }

   print("----" + new Date()+"----")

   var funcs = []
   ffor(0, 9, function(i){
     funcs.push(function(){return i})
   })

   ffor(0, 9, function(i){
     print(funcs[i]())
   })

แต่ฉันรู้ว่าวิธีนี้มีข้อเสียสำหรับลูปใหญ่ ...

คำถามที่เกี่ยวข้องเกี่ยวกับการเพิ่มประสิทธิภาพการเรียกซ้ำหางใน JS

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

ใน Javascript คุณสามารถทำสิ่งนี้ได้ !!

// Data
var fruits = [
    { name: 'apple',  price: 5 }, 
    { name: 'orange', price: 10 }, 
    { name: 'lemon',  price: 15 }
]

// Request Data from magicURL
request('magicURL')
    .then(selectKeyOf('price'))
    .then(priceMethod('sum'))
    .then((result)=>{
        console.log(result) // 30
    })

ฉันได้สร้างหน้า githubเพื่อสาธิตแนวคิดนี้และคุณสามารถโคลน / ดูการใช้งานของฉันได้

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

สิ่งที่ฉันเกลียดมากในจาวาสคริปต์ (ถ้าคุณพยายามมองว่ามันเป็นภาษา FP) คือ:

function getTenFunctionsBad() {
  var result = [];
  for (var i = 0; i < 10; ++i) {
    result.push(function () {
      return i;
    });
  }
  return result;
}

function getTenFunctions() {
  var result = [];
  for (var i = 0; i < 10; ++i) {
    result.push((function (i) {
      return function () {
        return i;
      }
    })(i));
  }
  return result;
}

var functionsBad = getTenFunctionsBad();
var functions = getTenFunctions()
for (var i = 0; i < 10; ++i) {
  // using rhino print
  print(functionsBad[i]() + ', ' + functions[i]());
}

// Output:
//   10, 0
//   10, 1
//   10, 2
//   10, 3
//   10, 4
//   10, 5
//   10, 6
//   10, 7
//   10, 8
//   10, 9

คุณต้องเข้าใจสภาพแวดล้อม JS stack (ฉันไม่รู้ว่ามันเป็นคำที่เหมาะสมหรือไม่) เพื่อทำความเข้าใจพฤติกรรมดังกล่าว

ในรูปแบบเช่นคุณไม่สามารถสร้างสิ่งนั้นได้ (โอเคตกลง - ด้วยความช่วยเหลือของการอ้างอิงภาษาพื้นฐานคุณสามารถสร้างได้):

(define (make-ten-functions)
  (define (iter i)
    (cond ((> i 9) '())
          (else (cons (lambda () i) (iter (+ i 1))))))
  (iter 0))

(for-each (lambda (f)
            (display (f))
            (newline)) (make-ten-functions))