การกำหนดค่าเริ่มต้นสำคัญอย่างไร

การเริ่มต้นที่เหมาะสมหลีกเลี่ยงการรั่วไหลของหน่วยความจำหรือมีข้อได้เปรียบด้านประสิทธิภาพหรือไม่?

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

เนื่องจากการทำสำเนาของข้อบกพร่องอาจเป็นไปไม่ได้ในสภาพแวดล้อมการทดสอบจึงเป็นไปไม่ได้ที่จะค้นหาและแก้ไข

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

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

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

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

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

การเริ่มต้นตัวแปรตามที่ Telastyn ชี้ให้เห็นสามารถป้องกันข้อบกพร่องได้ หากตัวแปรนั้นเป็นประเภทการอ้างอิงการเริ่มต้นมันสามารถป้องกันข้อผิดพลาดในการอ้างอิง Null ได้

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

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

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

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

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

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

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

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

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

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

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

ค่าคงที่และตัวแปรคลาส

ตัวแปรคลาส - ทำเครื่องหมายด้วยstaticใน Java - เป็นเหมือนค่าคงที่ ตัวแปรเหล่านี้ปกติควรเป็นที่สิ้นสุดและเริ่มต้นความหมายโดยตรงหลังจากใช้=หรือจากภายในชั้น initializer static { // initialize here }บล็อก

ทุ่ง

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

ลองและต่อต้านความอยากที่จะใช้nullเป็นค่าสถานะหรือค่าพิเศษบางอย่าง มันจะดีกว่าที่จะรวมถึงเขตข้อมูลที่เฉพาะเจาะจงเพื่อเก็บสถานะ ฟิลด์ที่มีชื่อstateซึ่งใช้ค่าของการStateแจงนับจะเป็นตัวเลือกที่ดี

พารามิเตอร์วิธีการ

เนื่องจากการเปลี่ยนแปลงไปเป็นค่าของพารามิเตอร์ (ไม่ว่าจะอ้างอิงกับวัตถุหรือชนิดพื้นฐานเช่นจำนวนเต็ม ฯลฯ ) finalจะไม่สามารถมองเห็นได้โดยโทรพารามิเตอร์ควรจะทำเครื่องหมายว่าเป็น ซึ่งหมายความว่าค่าของตัวแปรนั้นไม่สามารถเปลี่ยนแปลงได้ โปรดทราบว่าค่าของอินสแตนซ์ของวัตถุที่ไม่แน่นอนสามารถเปลี่ยนแปลงได้การอ้างอิงไม่สามารถเปลี่ยนให้ชี้ไปที่วัตถุอื่นหรือnullแม้ว่า

ตัวแปรท้องถิ่น

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

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

public static doMethod(final int x) {
    final int y; // no assignment yet, it's final so it *must* be assigned
    if (x < 0) {
        y = 0;
    } else if (x > 0) {
        y = x;
    } else {
        // do nothing <- error, y not assigned if x = 0
        // throwing an exception here is acceptable though
    }
}

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

ไม่มีปัญหากับตัวแปรเริ่มต้น

ปัญหาเกิดขึ้นเมื่อคุณอ่านตัวแปรที่ยังไม่ได้เขียนเท่านั้น

ขึ้นอยู่กับคอมไพเลอร์และ / หรือชนิดของตัวแปรการเริ่มต้นจะดำเนินการเมื่อเริ่มต้นแอปพลิเคชัน หรือไม่.

เป็นการใช้งานทั่วไปที่จะไม่พึ่งพาการเริ่มต้นอัตโนมัติ

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

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