วิศวกรรมซอฟต์แวร์

ใน Java โดย getter การประชุมและตั้งค่าสำหรับเขตข้อมูลแบบบูลจะเป็นและisField() setField()นี้ทำงานได้อย่างสมบูรณ์ดีกับชื่อเขตที่มีคำคุณศัพท์ชอบactive, visible, closedฯลฯ แต่ฉันจะตั้งชื่อฟิลด์ที่มีความหมายของคำกริยาได้haveChildrenอย่างไร เพิ่ม“ _ing” ในคำกริยา ( ) หรืออาจ?havingChildren เพื่อชี้แจงฉันไม่สามารถควบคุมชื่อเมธอด (getter และ setter) เนื่องจากสร้างโดยอัตโนมัติโดย IDE ดังนั้นสิ่งที่ฉันต้องการคือชื่อเขตข้อมูลที่เหมาะสมเพื่อที่ว่าเมื่อ IDE สร้างผู้ทะเยอทะยานมันจะทำให้เกิดความรู้สึก ยกตัวอย่างเช่นhasChildrenเป็นชื่อเขตข้อมูลที่สมบูรณ์แบบ แต่เมื่อ IDE สร้าง getter isHasChildrenสำหรับฟิลด์มันจะ ฉันจะแก้ปัญหานี้ได้อย่างไร

14 java  naming 

ฉันกำลังทำงานในโครงการที่การโทรภายในคลาสเป็นปกติ แต่ผลลัพธ์จะมีค่าง่าย ๆ หลายครั้ง ตัวอย่าง ( ไม่ใช่รหัสจริง ): public boolean findError(Set<Thing1> set1, Set<Thing2> set2) { if (!checkFirstCondition(set1, set2)) { return false; } if (!checkSecondCondition(set1, set2)) { return false; } return true; } การเขียนการทดสอบหน่วยสำหรับรหัสประเภทนี้นั้นยากมากเพราะฉันแค่ต้องการทดสอบระบบเงื่อนไขและไม่ได้ใช้สภาพจริง (ฉันทำอย่างนั้นในการทดสอบแยก) ในความเป็นจริงมันจะดีกว่าถ้าฉันผ่านฟังก์ชั่นที่ใช้เงื่อนไขและในการทดสอบฉันเพียงแค่ให้ล้อเลียน ปัญหาด้วยวิธีนี้คือความฮือฮาไปนี้เราจะใช้ยาชื่อสามัญมาก วิธีการทำงาน; อย่างไรก็ตามคือการทำให้วัตถุที่ทดสอบเป็นสายลับและเยาะเย้ยการเรียกไปยังฟังก์ชันภายใน systemUnderTest = Mockito.spy(systemUnderTest); doReturn(true).when(systemUnderTest).checkFirstCondition(....); ข้อกังวลที่นี่คือการใช้งาน SUT นั้นมีการเปลี่ยนแปลงอย่างมีประสิทธิภาพและอาจเป็นปัญหาในการทดสอบให้สอดคล้องกับการใช้งาน มันเป็นเรื่องจริงเหรอ? มีวิธีปฏิบัติที่ดีที่สุดในการหลีกเลี่ยงความหายนะของการเรียกใช้เมธอดภายในหรือไม่? โปรดทราบว่าเรากำลังพูดถึงบางส่วนของอัลกอริทึมดังนั้นการแบ่งออกเป็นหลายคลาสอาจไม่ใช่การตัดสินใจที่ต้องการ

14 java  unit-testing 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา มีวิธีปฏิบัติที่ดีที่สุดสำหรับการสั่งซื้อเพื่อกำหนด getters และ setters หรือไม่ ดูเหมือนจะมีสองวิธี: คู่ getter / setter getters แรกจากนั้น setters (หรือวิธีอื่น ๆ ) เพื่อเพิ่มความแตกต่างนี่คือตัวอย่าง Java ของคู่ getter / setter: public class Foo { private int var1, var2, var3; public int getVar1() { return var1; } public void setVar1(int var1) …

14 object-oriented  patterns-and-practices 

ฉันทำงานในการประมวลผลภาพ (ส่วนใหญ่เป็น OCR) และฉันสงสัยว่าฉันควรรวมการทดสอบหน่วยในการพัฒนาของฉันอย่างไร ฉันใช้การทดสอบหน่วยสำหรับรหัสประเภท "ทั่วไป" มากกว่านี้ แต่เมื่อจัดการกับรหัสการประมวลผลภาพฉันไม่แน่ใจว่าจะจัดการกับมันอย่างไร รหัสชนิดนี้ต้องการข้อมูลอินพุต / เอาท์พุตของภาพเสมอและการเยาะเย้ยสิ่งนี้ไม่ชัดเจน สำหรับตอนนี้ฉันส่วนใหญ่ทำการทดสอบการรวม แต่พวกเขาใช้เวลาสักครู่ในการทำงานและฉันต้องการความคิดเกี่ยวกับวิธีการแบ่งรหัสประเภทนี้เป็นการทดสอบหน่วยเพื่อให้ฉันสามารถเรียกใช้พวกเขาได้เร็วขึ้น แก้ไข: การวิเคราะห์ตัวละครสามารถผ่านหลายขั้นตอนที่เกี่ยวข้องกับการหมุนหลายครั้งการปรับขนาดและการทำงานของก้าน ขั้นตอนเหล่านี้เปลี่ยนแปลงบ่อยครั้งเมื่ออัลกอริทึมกำลังพัฒนา ดังนั้นอินพุทและเอาท์พุทที่คาดหวังสามารถพัฒนาได้มากในขณะทดสอบ อักขระแต่ละตัวสามารถมีขนาด 100x100 พิกเซลได้ดังนั้นจึงไม่สามารถเข้ารหัสในรหัสหรือทำงานกับข้อมูลที่สร้างขึ้นได้

14 testing  unit-testing  tdd  integration-tests  mocking 

รูปแบบกลยุทธ์ใช้งานได้ดีเพื่อหลีกเลี่ยงขนาดใหญ่หาก ... สร้างและทำให้ง่ายต่อการเพิ่มหรือแทนที่ฟังก์ชั่น อย่างไรก็ตามมันยังคงมีข้อบกพร่องหนึ่งในความคิดของฉัน ดูเหมือนว่าในการดำเนินการทุกครั้งยังคงต้องมีการสร้างการแยกทาง อาจเป็นไฟล์จากโรงงานหรือไฟล์ข้อมูล เป็นตัวอย่างใช้ระบบการสั่งซื้อ โรงงาน: // All of these classes implement OrderStrategy switch (orderType) { case NEW_ORDER: return new NewOrder(); case CANCELLATION: return new Cancellation(); case RETURN: return new Return(); } รหัสหลังจากนี้ไม่จำเป็นต้องกังวลและมีเพียงที่เดียวที่จะเพิ่มประเภทคำสั่งซื้อใหม่ในขณะนี้ แต่ส่วนของรหัสนี้ยังไม่สามารถขยายได้ การดึงออกมาเป็นไฟล์ข้อมูลช่วยให้อ่านง่ายขึ้น (ฉันรู้ว่าเป็นที่ถกเถียงกัน): <strategies> <order type="NEW_ORDER">com.company.NewOrder</order> <order type="CANCELLATION">com.company.Cancellation</order> <order type="RETURN">com.company.Return</order> </strategies> แต่สิ่งนี้ยังคงเพิ่มรหัสสำเร็จรูปในการประมวลผลไฟล์ข้อมูล - รับได้ง่ายขึ้นหน่วยทดสอบและรหัสที่ค่อนข้างเสถียร แต่ความซับซ้อนเพิ่มเติม …

14 design  design-patterns  unit-testing  strategy 

ฉันเป็นวิศวกรซอฟต์แวร์ในทีมพัฒนาซอฟต์แวร์ 3 ปีที่ผ่านมาเราทำงานให้กับลูกค้าภายในเกี่ยวกับผลิตภัณฑ์ใหม่ ตอนนี้ผลิตภัณฑ์นี้เสร็จแล้วเราจะทำงานกับคุณสมบัติใหม่ที่สำคัญสำหรับผลิตภัณฑ์ที่มีอยู่ สำหรับคุณสมบัติเฉพาะการจัดการผลิตภัณฑ์คาดเดาว่าจะใช้เวลา 150 ชั่วโมงในการพัฒนา ร่วมกับผู้จัดการโครงการของเราเราได้สร้างแผนที่มีรายละเอียดมากและเราพยายาม 300 ชั่วโมง เมื่อวานนี้เราพูดถึงเรื่องนี้และพวกเขาคิดว่าเราประเมินสิ่งที่เกินความจริงอย่างไม่มีการลด ในการวางแผนของเราเราประมาณชั่วโมงสำหรับการเขียนการทดสอบหน่วยความคิดของพวกเขาคือการทิ้งมันไว้เพื่อประหยัดเวลา ยังไม่ได้ทำการตัดสินใจและฉันจะปกป้องการวางแผนนี้และการทดสอบหน่วยหากจำเป็น แต่สิ่งที่ฉันไม่ชอบที่นี่จริง ๆ คือการจัดการรบกวนกระบวนการพัฒนาของเรา ฉันจะป้องกันพวกเขาจากกระบวนการพัฒนาของเราได้อย่างไร และข้อโต้แย้งอะไรที่ฉันสามารถใช้เพื่อให้การทดสอบหน่วยยังคงอยู่ (นอกเหนือจากคุณภาพและการประหยัดเวลานาน) ตามที่ระบุไว้ข้างต้น บริษัท ของเรามีทีมวิศวกร 3 ทีมและทีมงานที่ฉันส่งมอบซอฟต์แวร์ตรงเวลา (ให้หรือรับส่วนต่าง 10%) ในขณะที่ทีมอื่นมักจะส่งมอบล่าช้า แต่ส่วนใหญ่เกิดจากการวางแผนในการประเมินต่ำเกินไป พวกเขาวางแผนการเข้ารหัสเท่านั้นไม่ใช่การจัดการทดสอบและจัดการกับมัน

14 development-process  management 

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

14 object-oriented  functional-programming 

สมมติว่าเราต้องการใช้ระบบย่อยความปลอดภัยขนาดเล็กสำหรับแอปพลิเคชันทางการเงินที่เตือนผู้ใช้ทางอีเมลหากตรวจพบรูปแบบแปลก ๆ สำหรับตัวอย่างนี้รูปแบบจะประกอบด้วยสามธุรกรรมตามที่อธิบายไว้ ระบบย่อยความปลอดภัยสามารถอ่านเหตุการณ์จากระบบหลักจากคิว สิ่งที่ฉันต้องการได้รับคือการแจ้งเตือนที่เป็นผลโดยตรงจากเหตุการณ์ที่เกิดขึ้นในระบบโดยไม่มีการแสดงสื่อกลางที่เป็นแบบจำลองสถานะปัจจุบันของรูปแบบ เปิดใช้งานการตรวจสอบแล้ว ประมวลผลธุรกรรมแล้ว ประมวลผลธุรกรรมแล้ว ประมวลผลธุรกรรมแล้ว ทริกเกอร์แจ้งเตือน (id: 123) ส่งอีเมลเพื่อรับการแจ้งเตือน (สำหรับ id: 123) ประมวลผลธุรกรรมแล้ว เมื่อนึกถึงสิ่งนี้ฉันคิดว่าการจัดหากิจกรรมสามารถทำได้ที่นี่เป็นอย่างดีแม้ว่าฉันจะมีคำถามที่ไม่มีคำตอบที่ชัดเจน การแจ้งเตือนที่ทริกเกอร์ในตัวอย่างมีผลข้างเคียงที่ชัดเจนจำเป็นต้องส่งอีเมลสถานการณ์ที่ควรเกิดขึ้นเพียงครั้งเดียวเท่านั้น ดังนั้นจึงไม่ควรเกิดขึ้นเมื่อเล่นซ้ำเหตุการณ์ทั้งหมดของการรวมซ้ำ ในระดับหนึ่งฉันเห็นอีเมลที่ต้องส่งคล้ายกับการสร้างเนื้อหาที่สร้างขึ้นโดยฝ่ายแบบสอบถามที่ฉันเห็นมาหลายครั้งในวรรณกรรมการจัดหา CQRS / กิจกรรมด้วยความแตกต่างที่ไม่ลึกซึ้งนัก ในวรรณคดีนี้ด้านแบบสอบถามถูกสร้างขึ้นจากตัวจัดการเหตุการณ์ที่สามารถสร้างเป็นตัวเป็นตนของรัฐที่จุดที่กำหนดให้อ่านเหตุการณ์ทั้งหมดอีกครั้ง ในกรณีนี้แม้ว่าจะไม่สามารถบรรลุได้อย่างสมบูรณ์เช่นนั้นด้วยเหตุผลที่อธิบายไว้ก่อนหน้านี้ ความคิดที่ว่าทุกรัฐเป็นชั่วคราวใช้ไม่ได้เป็นอย่างดีที่นี่ เราต้องบันทึกความจริงที่ว่าการแจ้งเตือนถูกส่งไปที่ไหนสักแห่ง ทางออกที่ง่ายสำหรับฉันคือการมีตารางหรือโครงสร้างที่แตกต่างกันซึ่งคุณเก็บบันทึกการแจ้งเตือนที่ถูกเรียกใช้ก่อนหน้านี้ เนื่องจากเรามี ID เราจะสามารถตรวจสอบว่ามีการออกการแจ้งเตือนด้วย ID เดียวกันก่อนหน้านี้หรือไม่ การมีข้อมูลนี้จะทำให้ SendAlertCommand idempotent สามารถออกคำสั่งได้หลายคำสั่ง แต่ผลข้างเคียงจะเกิดขึ้นเพียงครั้งเดียว แม้จะมีวิธีแก้ปัญหานั้นในใจฉันก็ไม่รู้ว่านี่เป็นคำใบ้ว่ามีบางอย่างผิดปกติกับสถาปัตยกรรมนี้สำหรับปัญหานี้หรือไม่ วิธีการของฉันถูกต้องหรือไม่ มีสถานที่ใดบ้างที่ฉันสามารถค้นหาข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้? มันแปลกที่ฉันไม่สามารถหาข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ บางทีฉันอาจใช้ข้อความที่ไม่ถูกต้อง ขอบคุณมาก!

14 event-programming  cqrs  event-sourcing 

ตามไซต์ Kafka : " Kakfa ใช้สำหรับสร้างท่อข้อมูลและแอพสตรีมมิ่งแบบเรียลไทม์ " การค้นหาอินเทอร์เน็ตอย่างกว้างขวางฉันได้พบคำจำกัดความที่เป็นที่ยอมรับโดยทั่วไปของคำว่า " ข้อมูลสตรีม " คืออะไร: ข้อมูลสตรีมเป็นข้อมูลที่ไหลอย่างต่อเนื่องจากต้นทางไปยังปลายทางผ่านเครือข่าย และ ข้อมูลสตรีมไม่ได้เป็นแบบอะตอมมิคหมายถึงส่วนใด ๆ ของสตรีมข้อมูลที่มีความหมายและสามารถประมวลผลได้ซึ่งตรงข้ามกับไฟล์ที่มีไบต์ไม่ได้มีความหมายอะไรนอกจากคุณจะมีทั้งหมด และ ข้อมูลสตรีมสามารถเริ่ม / หยุดได้ตลอดเวลา และ ผู้บริโภคสามารถแนบและแยกออกจากกระแสข้อมูลตามความประสงค์และประมวลผลเฉพาะส่วนที่ต้องการ ตอนนี้ถ้ามีสิ่งใดที่ฉันกล่าวข้างต้นไม่ถูกต้องไม่สมบูรณ์หรือผิดทั้งหมดโปรดเริ่มต้นด้วยการแก้ไขฉัน! สมมติว่าฉันติดตามมากกว่าหรือน้อยกว่านั้น ... ตอนนี้ฉันเข้าใจแล้วว่า "การสตรีมข้อมูล" คืออะไรจากนั้นฉันก็เข้าใจว่าคาฟคาและไคเนซิสหมายถึงอะไรเมื่อพวกเขาเรียกเก็บเงินด้วยตนเองว่าเป็นตัวกลางในการประมวลผล / การเป็นนายหน้าตัวกลางสำหรับแอปพลิเคชัน แต่มันทำให้ฉันสนใจ: สามารถ / ควร "สตรีมมิดเดิลแวร์" เช่น Kafka หรือ Kinesis ใช้สำหรับข้อมูลที่ไม่ได้สตรีมมิงเช่นโบรกเกอร์ข้อความแบบดั้งเดิมหรือไม่ และในทางกลับกัน: สามารถ / ควรใช้ MQ แบบดั้งเดิมเช่น RabbitMQ, ActiveMQ, Apollo …

14 message-queue  stream-processing  apache-kafka 

ขึ้นอยู่กับสิ่งที่ผู้ชายคนนี้พูดว่า: http://toddfredrich.com/ids-in-rest-api.html สมมติว่าเขาถูกต้องเกี่ยวกับการใช้ UUID เพื่อระบุทรัพยากร api จากนั้นฉันก็พบปัญหาในการพยายามใช้มันในลักษณะนี้คือ: class FooEntity { final String id = null; //auto-generated by my backend (mongodb), not shared final UUID uid = UUID.randomUUID(); //the resource id } (ระหว่างไคลเอนต์และเซิร์ฟเวอร์ถูกส่งและรับ DTO ไม่ใช่เอนทิตีฐานข้อมูล) ปัญหาตอนนี้คือidมันไม่มีประโยชน์อย่างที่ฉันไม่ได้ใช้อีกต่อไป ไคลเอนต์ทำการร้องขอด้วยuidเหตุใดฉันจึงรำคาญที่จะจัดการ 2 id ของ จากนั้นเราจะกลับไปสู่จุดเริ่มต้นเดียวกัน หากฉันตั้งค่า UUID เป็นคีย์หลัก ( _id) ฉันจะเปิดเผย ID เบื้องหลังให้กับสาธารณะ นอกจากนั้นยังมีหัวข้อประสิทธิภาพ ฉันอ่านว่าการจัดทำดัชนีโดย …

14 database  api-design  mongodb 

ฉันไม่แน่ใจว่ารูปแบบการออกแบบใดที่สามารถช่วยแก้ไขปัญหานี้ได้ ฉันมีคลาส 'ผู้ประสานงาน' ซึ่งกำหนดว่าควรใช้คลาสใดของผู้ปฏิบัติงานโดยไม่ต้องทราบเกี่ยวกับประเภทของแรงงานที่มีทั้งหมด - เพียงแค่เรียกใช้ WorkerFactory และดำเนินการตามอินเทอร์เฟซ IWorker ทั่วไป จากนั้นตั้งค่าผู้ปฏิบัติงานที่เหมาะสมให้ทำงานและส่งคืนผลลัพธ์ของวิธี 'DoWork' นี่เป็นเรื่องปกติ ... จนถึงตอนนี้; เรามีข้อกำหนดใหม่สำหรับคลาส Worker ใหม่ "WorkerB" ซึ่งต้องการข้อมูลเพิ่มเติมเช่นพารามิเตอร์อินพุตเพิ่มเติมเพื่อให้สามารถใช้งานได้ มันเหมือนกับว่าเราต้องการวิธีการทำงานหนักที่มีพารามิเตอร์อินพุตเพิ่มเติม ... แต่จากนั้นคนงานที่มีอยู่ทั้งหมดจะต้องใช้วิธีการนั้น - ซึ่งดูเหมือนว่าผิดเพราะคนงานเหล่านั้นไม่ต้องการวิธีการนั้นจริงๆ ฉันจะสร้างสิ่งนี้ใหม่ได้อย่างไรเพื่อให้ผู้ประสานงานไม่ทราบว่ามีการใช้งานของคนงานคนใดและยังอนุญาตให้ผู้ใช้งานแต่ละคนได้รับข้อมูลที่ต้องใช้ในการทำงาน แต่ไม่มีคนงานทำสิ่งที่ไม่จำเป็น มีคนงานที่มีอยู่จำนวนมากอยู่แล้ว ฉันไม่ต้องการเปลี่ยนคนงานคอนกรีตที่มีอยู่เพื่อรองรับความต้องการของคลาส WorkerB ใหม่ ฉันคิดว่าบางทีรูปแบบของ Decorator น่าจะดีที่นี่ แต่ฉันไม่เคยเห็น Decorators ตกแต่งวัตถุด้วยวิธีเดียวกัน แต่ใช้พารามิเตอร์ที่แตกต่างกันมาก่อน ... สถานการณ์ในรหัส: public class Coordinator { public string GetWorkerResult(string workerName, int a, …

14 c#  design-patterns 

ฉันพยายามเขียน servlet ซึ่งทำงานตามค่า "การกระทำ" ที่ส่งผ่านไปเป็นอินพุต นี่คือตัวอย่างที่ public class SampleClass extends HttpServlet { public static void action1() throws Exception{ //Do some actions } public static void action2() throws Exception{ //Do some actions } //And goes on till action9 public void doPost(HttpServletRequest req, HttpServletResponse res)throws ServletException, IOException { String action = req.getParameter("action"); …

14 java  design-patterns  object-oriented 

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

14 json  mongodb 

พจนานุกรม C # เป็นวิธีที่ง่ายในการค้นหาว่ามีบางอย่างมีอยู่ ฯลฯ ฉันมีคำถามว่าพวกเขาทำงานอย่างไร สมมุติว่าฉันใช้ ArrayList แทนพจนานุกรม แทนที่จะใช้ContainsKey(หรือวิธีที่เทียบเท่าในภาษาอื่น) ฉันวนลูป ArrayList เพื่อตรวจสอบว่ามีบางสิ่งอยู่ที่นั่น (หรือทำการค้นหาแบบไบนารีถ้าข้อมูลเรียงลำดับหรือคล้ายกัน) ประสิทธิภาพแตกต่างกันอย่างไร เป็นContainsKeyวิธีการที่ใช้บางส่วนวิธีที่มีประสิทธิภาพมากกว่าการวนลูปผ่านปุ่มและตรวจสอบว่าสิ่งที่ฉันค้นหาอยู่? ถ้าสมมติว่าฉันได้สร้างฟังก์ชันแฮชเฉพาะซึ่งสอดคล้องกับประเภทของข้อมูลที่ฉันมีและได้รับการออกแบบมาโดยเฉพาะสำหรับชุดข้อมูลนั้นใช่แล้วฟังก์ชันแฮชนั้นเร็วกว่าการวนลูปผ่านข้อมูล แต่พจนานุกรมทั่วไป เมธอด containKey นั้นไม่เฉพาะเจาะจงกับข้อมูลที่ได้รับ แต่เป็นวิธีการค้นหาทั่วไป โดยทั่วไปสิ่งที่ฉันถามคือ พจนานุกรมมีประโยชน์กับโปรแกรมเมอร์ พวกเขามีวิธีการที่ช่วยในหลายสิ่งและพวกเขารวมสตริงกับจำนวนเต็ม (คีย์และค่า) และอีกมากมาย แต่เกี่ยวกับประสิทธิภาพพวกเขาเสนออะไร สิ่งที่แตกต่างในการมีที่dictionaryVS ArrayListของstructs(string,int)

14 c#  efficiency  dictionary 

คำถามนี้เป็นแรงบันดาลใจคำถามเกี่ยวกับfinalใน java ใน C / C ++ ฉันควรใช้constทุกครั้งที่ทำได้หรือไม่ ฉันรู้ว่ามีคำถามที่เกี่ยวข้องกับการใช้constในพารามิเตอร์อยู่แล้ว น่าเสียดายที่คำถามนั้นและคำตอบนั้นไม่ได้ตอบคำถามของฉันอย่างเต็มที่เพราะมันเป็นเพียงเกี่ยวกับพารามิเตอร์ของฟังก์ชั่น แต่ฉันก็อยากจะรู้เกี่ยวกับกรณีอื่น ๆ (เช่น: ตัวแปรท้องถิ่น) นอกจากนี้คำตอบเกือบทั้งหมดสำหรับคำถามนั้นบอกว่าเราควรใช้constเพราะมันมีข้อมูลที่เป็นประโยชน์เกี่ยวกับการเข้าถึงของตัวแปร แต่สิ่งนี้ดูเหมือนจะขัดแย้งกับคำตอบเกี่ยวกับการใช้ขั้นสุดท้ายใน Javaซึ่งรัฐfinalอาจไม่จำเป็นหากไม่มีข้อมูลเพิ่มเติมและควรละเว้นการรักษารหัสให้สั้นและสะอาด ดังนั้นฉันควรใช้constทุกครั้งที่ทำได้หรือไม่ ถ้าเป็นเช่นนั้นทำไมคำแนะนำสำหรับconstC ++ แตกต่างจากคำแนะนำสำหรับfinalใน Java

14 c++  coding-style  const