Javascript เป็นภาษาโปรแกรมใช้งานหรือไม่

• Javascript เป็นภาษาที่ใช้งานได้หรือไม่? ฉันรู้ว่ามันมีวัตถุ & คุณสามารถทำ OOP ได้ด้วย แต่มันก็เป็นภาษาที่ใช้งานได้ด้วยวิธีนั้นหรือไม่?
• คุณรู้ว่า OOP กลายเป็น / ดูเหมือนวิวัฒนาการต่อไปในการเขียนโปรแกรมหมายความว่า 'Functional Programming' เป็นวิวัฒนาการต่อไปอย่างไร (หมายเหตุ: นี่ไม่ใช่พรอมต์สำหรับความเห็น แต่พร้อมรับคำสำหรับหลักฐานตามข้อเท็จจริงและบันทึกนี้คือ มากกว่าสำหรับผู้กลั่นกรองมากกว่าผู้สนับสนุน;)
• ฉันเรียนรู้ผ่านตัวอย่างที่ดีที่สุดบางทีบางคนอาจแสดงการทำงานเดียวกันในแบบ OOP และในรูปแบบการเขียนโปรแกรมเชิงฟังก์ชั่นเพื่อให้ฉันเข้าใจและเปรียบเทียบการเขียนโปรแกรมการทำงาน

ฉันไม่เข้าใจจริงๆว่า 'ฟังก์ชั่นการเขียนโปรแกรม' จริง ๆ แล้ว: P ดังนั้นการเปรียบเทียบ Javascript กับการเขียนโปรแกรมฟังก์ชั่นอาจไม่ถูกต้องทั้งหมด

เพื่อนำการเขียนโปรแกรมฟังก์ชั่นในแง่ laymans: มันเป็นเพียงประโยชน์ของ abstration ผ่านการใช้ฟังก์ชั่นที่ไม่ระบุชื่อ?

หรือว่าเป็นวิธีที่ง่ายเกินไป? ในวิธีที่เรียบง่าย OOP คือประโยชน์ของนามธรรมผ่านวัตถุ แต่ฉันเชื่อว่ามันง่ายเกินไปที่จะอธิบาย OOP

นี่เป็นตัวอย่างที่ดีของการตั้งโปรแกรมการทำงานหรือไม่ ...

ตัวอย่าง Javascript OOP:

// sum some numbers
function Number( v )
{ 
  this.val = v;
}

Number.prototype.add( /*Number*/ n2 )
{
    this.val += n2.val;
}

ตัวอย่างการเขียนโปรแกรมการทำงาน:

function forEach(array, action) 
{
   for (var i = 0; i < array.length; i++)
       action(array[i]);
}  

function add(array)
{
    var i=0;
    forEach(array, function(n)
    {
        i += n;
    });
    return i;
}

var res = add([1,9]);

Javascript เป็นภาษาที่ใช้งานได้หรือไม่? ฉันรู้ว่ามันมีวัตถุ & คุณสามารถทำ OOP ได้ด้วย แต่มันก็เป็นภาษาที่ใช้งานได้ด้วยวิธีนั้นหรือไม่?

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

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

แม้ว่า Javascript จะไม่เป็นที่รู้จักกันอย่างแพร่หลายหรือใช้เป็นภาษาที่ใช้งานได้ แต่ก็มีองค์ประกอบที่ใช้งานได้บางอย่าง:

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

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

การเขียนโปรแกรมแบบอิงต้นแบบเป็นรูปแบบของการเขียนโปรแกรมเชิงวัตถุซึ่งไม่มีคลาสและการนำพฤติกรรมมาใช้ใหม่ (หรือที่เรียกว่าการสืบทอดในภาษาที่อิงกับคลาส) ดำเนินการผ่านกระบวนการโคลนวัตถุที่มีอยู่ซึ่งทำหน้าที่เป็นต้นแบบ รุ่นนี้ยังสามารถเป็นที่รู้จักกันในนาม classless, oriented-oriented หรือ instance-based programming การมอบหมายคือคุณสมบัติภาษาที่รองรับการเขียนโปรแกรมต้นแบบ

ดังนั้นถึงแม้ว่า Javascript จะเป็นเชิงวัตถุ แต่ก็ไม่ได้เป็นไปตามโมเดลพื้นฐานที่ใช้กันทั่วไปเช่นภาษา C ++, C #, Java และ PHP (และอื่น ๆ อีกมากมาย) และแน่นอนว่ามันยังเป็นภาษาที่จำเป็นซึ่งนำไปสู่ความสับสนกับการเขียนโปรแกรมฟังก์ชั่นที่ฉันอธิบายไว้ข้างต้น

คุณรู้ว่า OOP กลายเป็น / ดูเหมือนวิวัฒนาการต่อไปในการเขียนโปรแกรมหมายความว่า 'ฟังก์ชั่นการเขียนโปรแกรม' เป็นวิวัฒนาการต่อไป

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

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

คุณควรต่อต้านความอยากที่จะปฏิบัติต่อภาษาและกระบวนทัศน์ในฐานะงบแฟชั่น มีความไม่เข้าใจในเรื่องอื้อฉาวส่วนใหญ่เขียนโดย fanboys / fangirls หรือนักการตลาดโดยมีความรู้และความเข้าใจในการเขียนโปรแกรมน้อยมาก (ถ้ามี) คำเช่น "ดีกว่า", "มีการพัฒนามากขึ้น" ฯลฯ ไม่สามารถใช้ได้

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

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

_{¹แต่เมื่อเร็ว ๆ นี้พยายามที่จะขยายขอบเขตไปสู่การเขียนโปรแกรมทั่วไปลองมาดูกันว่ามันจะเป็นอย่างไร}

สรุปแล้ว:

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

Javascript สามารถใช้เป็นภาษาที่ใช้งานได้จริง ๆ แล้วมันทำได้ค่อนข้างดี มันเป็นไปได้ที่จะนำmonadsมาใช้เพื่อสนับสนุนแลมบ์ดาสร้าง ฯลฯ มันไม่ได้เป็นเพียงภาษาที่ใช้ในการทำงานเท่านั้น แต่ยังมีคุณสมบัติเชิงวัตถุจำนวนมาก แต่สามารถใช้งานได้ จริงๆแล้วฉันพบว่าการใช้ Javascript เป็นภาษาที่ใช้งานได้เป็นวิธีที่ยอดเยี่ยมในการใช้งาน (ตัวอย่าง jQuery และ underscore.js)

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

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

เลขที่

JavaScript เป็นภาษาที่เน้นวัตถุเป็นอันดับแรก

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

IMO วิธีจำแนกภาษาเป็นกระบวนทัศน์ที่เหมาะสมคือการพิจารณา:

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

โดยส่วนตัวฉันคิดว่ามันค่อนข้างน่าขบขันที่ผู้คนจำนวนมากชอบที่จะอ้างว่าภาษาเป็น "การทำงาน" เพียงเพราะมันเป็นคำที่ทันสมัยในขณะนี้ :-)

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

Javascript นั้นเป็นต้นแบบแรกที่มีความสามารถในการใช้งานซึ่งได้รับจากการใช้ฟังก์ชั่นเป็นวัตถุชั้นหนึ่ง

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

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

// oops, this is producing a side effect
function sideEffecter(){//theres no input...        
    window.thingy = 'foo';
    // hey, this isn't returning anything!!!
} 

ภาษาที่ใช้งานได้นั้นไม่ทำลายซึ่งหมายความว่าพวกมันจะไม่ทำให้เกิดการเปลี่ยนแปลงอินพุต แต่จะส่งคืนข้อมูลใหม่ทั้งหมดโดยอิงจากอินพุตนั้น ดูหัวข้อนี้: https://stackoverflow.com/questions/749084/jquery-map-vs-each

ภาษาที่ใช้งานได้ยังมีวิธีการทั่วไปจำนวนมากเช่นชื่อ "แผนที่", "พับ", "ลด" ที่กระบวนการแสดง / รวบรวม ใน JS ซึ่งแตกต่างจากภาษาอื่น ๆ เราจะต้องจัดการสิ่งเหล่านี้ให้มีอยู่ - ดูตัวอย่างเช่นunderscore.jsสำหรับห้องสมุดแม้ว่าการใช้งานล่าสุดของ JS จะมีสิ่งเหล่านี้ออกมาตรงๆ

สิ่งสำคัญที่ต้องคำนึงถึง (IMO) คือในขณะที่ JS สามารถใช้รูปแบบการทำงานบางอย่างก็ไม่ได้พร้อมที่จะดำเนินการ

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

var test = ['foo', 'bar', 'baz'], removeFunc, removeLoop;

//(semi)functional style...
// to be really functional each condition in the ternary would be another function
removeFunc = function(src, trg) {
    return src.length === 0 ? 
        src : 
            src[0] === trg ? 
                src.slice(1) : 
                    [src[0]].concat(removeFunc(src.slice(1), trg));
};

//but this is faster
removeLoop = function(src, trg){
    var len = src.length, // using variables to represent state...
        i=0, 
        result = [];        
    while(i < n){
       if(src[i] !== trg){
          result.push(src[i]);
       }
       i = i+1;
    }
}

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

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

นี่คือลิงค์บางส่วนที่คุณอาจสนใจ:

บทที่ดีเกี่ยวกับฟังก์ชั่นการเขียนโปรแกรมใน Javascript จาก "Eloquent Javascript" ที่ยอดเยี่ยม

The Little Schemer

เพื่อนของฉันคนหนึ่งเขียนไลบรารี JS จาก Little Schemer

บทแนะนำที่ดีเกี่ยวกับ Scheme ที่อาจช่วยให้คุณเข้าใจ FP ได้ดีขึ้น