คำถามติดแท็ก functions

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

22 java  class  functions 

บทช่วยสอน (สำหรับ Javascript) ฉันขอแนะนำให้เราเขียนฟังก์ชั่นแบบนี้: function sayHello() { //Some comments explaining the next line window.alert("Hello"); } นอกเหนือจากความงุนงงจะมีประโยชน์ในการเขียนสิ่งนี้ในชีวิตจริง? ถ้าเป็นเช่นนั้นประโยชน์คืออะไร?

21 language-agnostic  functions 

ฉันกำลังอ่าน 'ห้องสมุดมาตรฐาน C' โดย PJ Plauger ซึ่งน่าสนใจจริงๆ หนังสือเล่มนี้ไม่เพียง แต่อธิบายวิธีการใช้ห้องสมุด แต่ยังอธิบายถึงวิธีการนำไปใช้งาน ฉันอ่านctype.hส่วนเสร็จแล้วและในส่วนหัวฟังก์ชั่นจะประกาศเป็นทั้งมาโครและฟังก์ชั่น ตัวอย่างเช่น int isdigit(int); แต่ยัง #define isdigit(c) (_Ctype[(int)(c)] & _DI) ฉันไม่เข้าใจว่าทำไมใช้ทั้งคู่ นอกจากนี้ถ้าฉันพยายามสร้างctypeส่วนหัวที่กำหนดเองและการนำไปใช้ใหม่ฉันสามารถรวบรวมได้สำเร็จถ้าฉันลบแมโครออก (ใส่เครื่องหมายความคิดเห็นในการกำหนด) แง่มุมนี้ไม่ได้อธิบายในหนังสือ ใครช่วยอธิบายหน่อยได้ไหม?

20 c  naming  functions  macros 

โค้ด Scala ต่อไปนี้ใช้งานได้และสามารถส่งผ่านไปยังเมธอด Java ที่ต้องการฟังก์ชัน มีวิธีที่สะอาดกว่านี้หรือไม่? นี่คือการผ่านครั้งแรกของฉัน: val plusOne = new java.util.function.Function[Int,Int] { override def apply(t:Int):Int = t + 1 override def andThen[V](after:function.Function[_ >: Int, _ <: V]): function.Function[Int, V] = ??? override def compose[V](before:function.Function[_ >: V, _ <: Int]): function.Function[V, Int] = ??? } นี่คือรอบที่สองของฉัน - มันใช้ wrapper ทั่วไปสำหรับส่วนต่อประสานฟังก์ชั่น …

18 functional-programming  scala  functions  higher-order-functions  java8 

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

18 functions 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันกำลังใช้งานฟังก์ชั่น PHP อยู่และฉันไม่สามารถสังเกตเห็นสิ่งต่อไปนี้ได้: <?php function foo(&$var) { } foo($a); // $a is "created" and assigned to null $b = array(); foo($b['b']); var_dump(array_key_exists('b', $b)); // bool(true) $c = new StdClass; foo($c->d); var_dump(property_exists($c, 'd')); // bool(true) ?> สังเกตarray_key_exists()และproperty_exists()ฟังก์ชั่น ในอันแรกชื่อคุณสมบัติ (คีย์สำหรับอาร์เรย์) เป็นพารามิเตอร์แรกในขณะที่ในครั้งที่สองมันเป็นพารามิเตอร์ที่สอง โดยสัญชาตญาณเราคาดว่าพวกเขาจะมีลายเซ็นที่คล้ายกัน สิ่งนี้สามารถนำไปสู่ความสับสนและเวลาในการพัฒนาอาจสูญเปล่าโดยการแก้ไขประเภทนี้ PHP หรือภาษาใด …

17 php  naming  functions 

ฉันใช้ C ++ กับ ESP-32 เมื่อลงทะเบียนตัวจับเวลาฉันต้องทำสิ่งนี้: timer_args.callback = reinterpret_cast<esp_timer_cb_t>(&SoundMixer::soundCallback); timer_args.arg = this; soundCallbackนี่โทรจับเวลา และสิ่งเดียวกันเมื่อลงทะเบียนงาน: xTaskCreate(reinterpret_cast<TaskFunction_t>(&SoundProviderTask::taskProviderCode), "SProvTask", stackSize, this, 10, &taskHandle); ดังนั้นวิธีการเริ่มต้นในงานที่แยกจากกัน GCC เตือนฉันเสมอเกี่ยวกับการแปลงเหล่านี้ แต่ทำงานได้ตามแผนที่วางไว้ เป็นที่ยอมรับในรหัสการผลิตหรือไม่ มีวิธีที่ดีกว่าในการทำเช่นนี้?

16 c++  c  functions 

ฉันกำลังพยายามที่จะเข้าใจเบื้องหลังม่าน Javascript และชนิดของการติดอยู่ในการทำความเข้าใจการสร้างสร้างขึ้นในวัตถุโดยเฉพาะวัตถุและฟังก์ชั่นและความสัมพันธ์ระหว่างพวกเขา เมื่อฉันอ่านว่าวัตถุในตัวทั้งหมดเช่น Array, String ฯลฯ เป็นส่วนขยาย (สืบทอด) จาก Object ฉันคิดว่า Object เป็นวัตถุแรกที่สร้างขึ้นในวัตถุที่สร้างขึ้นและส่วนที่เหลือของวัตถุสืบทอดมาจากมัน แต่มันก็ไม่สมเหตุสมผลเมื่อคุณรู้ว่า Object สามารถสร้างได้โดยฟังก์ชั่นเท่านั้น แต่ฟังก์ชั่นนั้นก็ไม่ได้มี แต่วัตถุของ Function มันเริ่มที่จะฟังดูลำบากเช่นไก่และไก่ สิ่งที่สับสนอย่างยิ่งคือถ้าฉันconsole.log(Function.prototype)พิมพ์ฟังก์ชั่น แต่เมื่อฉันพิมพ์console.log(Object.prototype)มันจะพิมพ์วัตถุ ทำไมFunction.prototypeฟังก์ชั่นเมื่อมันถูกหมายถึงเป็นวัตถุ? นอกจากนี้ตามเอกสาร Mozilla ทุก javascript functionเป็นส่วนขยายของFunctionวัตถุ แต่เมื่อคุณconsole.log(Function.prototype.constructor)เป็นอีกฟังก์ชั่น ตอนนี้คุณจะใช้บางสิ่งเพื่อสร้างมันเองได้อย่างไร (Mind = blown) สิ่งสุดท้ายFunction.prototypeคือฟังก์ชั่น แต่ฉันสามารถเข้าถึงconstructorฟังก์ชั่นที่ใช้Function.prototype.constructorหมายความว่าFunction.prototypeเป็นฟังก์ชั่นที่ส่งกลับprototypeวัตถุ

16 javascript  object-oriented-design  functions  object 

แนวคิดนี้ได้รับแรงบันดาลใจจากตัวดำเนินการข้อเท็จจริงเช่น +, -,%, เป็นต้นซึ่งสามารถมองเห็นได้ว่าเป็นฟังก์ชั่นที่ผ่านการโต้แย้งหนึ่งหรือสองครั้งและไม่มีผลข้างเคียง สมมติว่าฉันหรือคนอื่นเขียนภาษาที่หยุดไม่ให้มีการโต้แย้งมากกว่าสองข้อและยังใช้งานได้ผ่านการส่งคืนเท่านั้น: ก) ภาษานั้นจะทำให้เข้าใจรหัสได้ง่ายขึ้นหรือไม่ b) การไหลของรหัสจะชัดเจนขึ้นหรือไม่ (บังคับให้ทำตามขั้นตอนมากขึ้นโดยที่การโต้ตอบ 'ซ่อน' อาจมีน้อยลง c) ข้อ จำกัด จะทำให้ภาษามีขนาดใหญ่เกินไปสำหรับโปรแกรมที่ซับซ้อนมากขึ้น d) (โบนัส) ความคิดเห็นอื่น ๆ เกี่ยวกับข้อดี / ข้อเสีย บันทึก: การตัดสินใจสองครั้งจะยังคงต้องทำก่อนคืออนุญาตให้ผู้ใช้ป้อนข้อมูลนอกหลัก () หรือเทียบเท่าและสิ่งที่กฎจะเกี่ยวกับสิ่งที่เกิดขึ้นเมื่อผ่านอาร์เรย์ / โครงสร้าง ตัวอย่างเช่นหากมีคนต้องการฟังก์ชั่นเดียวที่จะเพิ่มค่าหลายค่าเขาสามารถหลีกเลี่ยงข้อ จำกัด โดยรวมมันเข้าไปในอาร์เรย์ สิ่งนี้สามารถหยุดได้โดยไม่อนุญาตให้อาร์เรย์หรือโครงสร้างจากการโต้ตอบกับตัวเองซึ่งจะช่วยให้คุณตัวอย่างเช่นหารจำนวนแต่ละจำนวนด้วยจำนวนที่แตกต่างกันขึ้นอยู่กับตำแหน่งของมัน

16 design  programming-languages  functional-programming  functions 

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

16 design  terminology  requirements  functions  features 

ฉันมีคลาสที่ตั้งค่าอาร์เรย์ของโหนดและเชื่อมต่อกับแต่ละอื่น ๆ ในโครงสร้างคล้ายกราฟ เป็นการดีที่สุดที่จะ: คงฟังก์ชันการทำงานเพื่อเริ่มต้นและเชื่อมต่อโหนดในฟังก์ชันเดียว มีฟังก์ชั่นการเริ่มต้นและการเชื่อมต่อในฟังก์ชั่นที่แตกต่างกันสองฟังก์ชั่น (และมีลำดับที่ต้องพึ่งพาซึ่งต้องเรียกใช้ฟังก์ชั่น - แม้ว่าโปรดทราบว่าฟังก์ชั่นเหล่านี้เป็นแบบส่วนตัว) วิธีที่ 1: (แย่ในฟังก์ชั่นหนึ่งที่ทำสองสิ่ง แต่มันเก็บหน้าที่การทำงานที่พึ่งพากันไว้ด้วยกัน - โหนดไม่ควรเชื่อมต่อโดยไม่ต้องเริ่มต้นก่อน) init() { setupNodes() } private func setupNodes() { // 1. Create array of nodes // 2. Go through array, connecting each node to its neighbors // according to some predefined constants } วิธีที่ 2: (ในแง่ที่ดีกว่าว่าเป็นการจัดทำเอกสารด้วยตนเอง …

15 functions  code-organization  file-structure 

พิจารณารหัส "C" ต่อไปนี้: #include<stdio.h> main() { printf("func:%d",Func_i()); } Func_i() { int i=3; return i; } Func_i()ถูกกำหนดในตอนท้ายของซอร์สโค้ดและไม่มีการประกาศให้ก่อนที่จะใช้main()มัน ในเวลามากเมื่อคอมไพเลอร์เห็นFunc_i()ในmain()มันออกมาของและพบว่าออกmain() Func_i()คอมไพเลอร์อย่างใดพบว่าค่าส่งกลับโดยและให้มันไปFunc_i() printf()ผมยังไม่ทราบว่าคอมไพเลอร์ไม่สามารถหาประเภทผลตอบแทนFunc_i()ของ มันโดยปกติจะใช้เวลา (คาดเดา?) ประเภทผลตอบแทนของการที่จะเป็นFunc_i() intนั่นคือถ้ารหัสfloat Func_i()นั้นคอมไพเลอร์จะให้ข้อผิดพลาด: ประเภทที่ขัดแย้งFunc_i()กัน จากการสนทนาข้างต้นเราจะเห็นว่า: Func_i()คอมไพเลอร์สามารถหาค่าที่ส่งกลับโดย หากคอมไพเลอร์สามารถค้นหาค่าที่ส่งคืนโดยFunc_i()ออกมาmain()และค้นหาซอร์สโค้ดเหตุใดจึงไม่พบประเภทของ Func_i () ซึ่งกล่าวถึง อย่างชัดเจน คอมไพเลอร์ต้องรู้ว่าFunc_i()เป็นประเภทลอย - นั่นเป็นสาเหตุที่ทำให้เกิดข้อผิดพลาดของประเภทที่ขัดแย้งกัน หากคอมไพเลอร์รู้ว่าFunc_iเป็นประเภทลอยตัวแล้วทำไมมันยังถือว่าFunc_i()เป็นประเภท int และให้ข้อผิดพลาดของประเภทที่ขัดแย้งกัน? ทำไมมันไม่ได้ทำให้มันกลายFunc_i()เป็นประเภทลอย ผมมีข้อสงสัยเช่นเดียวกันกับการประกาศตัวแปร พิจารณารหัส "C" ต่อไปนี้: #include<stdio.h> main() { /* [extern int Data_i;]--omitted …

15 c  language-design  functions  variables  declarations 

ฉันเพิ่งพบฟังก์ชันนี้ในโครงการที่ฉันทำงานอยู่: -- Just returns the text unchanged. -- Note: <text> may be nil, function must return nil in that case! function Widget:wtr(text) return text end น่าเศร้าที่ผู้ทำรหัสไม่ทำงานใน บริษัท อีกต่อไป ทำไมหนึ่งจะสร้างฟังก์ชั่นที่ไม่ทำอะไรเลย แต่ส่งกลับพารามิเตอร์ที่เรียกว่าด้วย? มีการใช้ฟังก์ชันดังกล่าวไม่ได้ระบุตัวอย่างนี้ แต่โดยรวมในกรณีใด ๆ ? เนื่องจาก function aFunction(parameter) return parameter end จบลงแล้ว aFunction(parameter) == parameter ทำไมฉันต้องเขียนอะไรบางอย่าง aFunction(parameter) == whatIWantToCheck แทน parameter …

15 functions  parameters  lua  method-chaining 

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

15 design-patterns  object-oriented  functions 

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

15 programming-languages  language-agnostic  functional-programming  functions  continuation