ทำไมตัวแปรจึงต้องมีประเภท

10

ดังนั้นเราจึงเขียน:

Customer c = new Customer();

ทำไมการออกแบบไม่ใช่แบบที่เราเขียน:

c = new Customer();
c.CreditLimit = 1000;

คอมไพเลอร์สามารถคำนวณคะแนน c ให้กับลูกค้าและอนุญาตให้สมาชิกของลูกค้าเรียกใช้บน c?

ฉันรู้ว่าเราอาจต้องการเขียน:

IPerson c = new Customer();
IPerson e = new Employee();

เพื่อที่จะสามารถเขียน:

public string GetName(IPerson object)
{
    return object.Name
}

string name = GetName(c); // or GetName(e);

แต่ถ้าเราเขียนว่า:

c = new Customer();
e = new Employee();

เรายังสามารถเขียน:

public string GetName(object)
{
    return object.Name
}    

string name = GetName(c); // or GetName(e);

คอมไพเลอร์อาจบ่นเกี่ยวกับโค้ดด้านบนทันทีหากการอ้างอิงวัตถุชนิด c ไม่สนับสนุนคุณสมบัติชื่อ (เนื่องจากสามารถตรวจสอบสมาชิกที่ใช้ในอาร์กิวเมนต์ / พารามิเตอร์ภายในเมธอด) หรือรันไทม์อาจบ่น

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

c# languages variables

— sturdytree
แหล่งที่มา

12

นี่คือเหตุผลที่มีภาษาแบบไดนามิกเช่น Python และ Ruby (และอื่น ๆ ) ไม่มีคำตอบสำหรับคำถามนี้ มันเป็นความจริงที่บางภาษาใช้การประกาศประเภทและบางภาษาไม่ได้

— S.Lott

2

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

— S.Lott

1

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

— Mason Wheeler

2

var x = 1; - คุณหมายถึง 32 บิต, 64 บิต, 16 บิตหรือเปล่า ไบต์? ลอย? สอง? ทศนิยม? นี่เป็นเพียงการจัดการกับดั้งเดิม

— งาน

4

คุณสามารถใช้varใน C # และเป็น exlicit เกี่ยวกับตำแหน่งที่คุณต้องการประกาศตัวแปรที่ดีเสมอ

— Daniel Little

22

แต่ทำไมตัวแปรถึงต้องการประเภทเลย

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

— เฟรดฟู
แหล่งที่มา

1

กรุณาอธิบาย downvote

— Fred Foo

4

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

— Charles Salvia

@CharlesSalvia: จุดดีเพิ่มที่คำตอบ

— Fred Foo

2

@sturdytree: สำหรับ "ถ้ามันไม่มีประเภทก็ไม่สามารถพิมพ์ผิด" - เท่าที่กฎภาษาไปนั่นเป็นความจริง แต่ตัวแปรอาจยังคงได้รับการกำหนดประเภทที่ไม่ถูกต้องจากมุมมองเชิงความหมายเช่นคุณพิมพ์ชื่อตัวสร้างผิดและโปรแกรมยังคงทำงาน แต่ไม่ได้ทำสิ่งที่คุณต้องการ

— Fred Foo

5

@sturdytree ในขณะที่มันเป็นความจริงที่ไม่มีภาษาที่มีอย่างแท้จริงtypelessตัวแปรที่มีการตรวจสอบชนิดมีภาษาที่มีการอนุมานชนิด กล่าวคือภาษาจะพิจารณาการใช้งานตัวแปรและอนุมานประเภทจากการใช้งานของคุณ หากมีข้อขัดแย้ง (เช่นคุณดำเนินการa = new Bar()แล้วเรียกเมธอดจากคลาสBaz) ในภายหลังคอมไพเลอร์ทำให้เกิดข้อผิดพลาด ภาษาเช่น Haskell และ OCaml เป็นผู้บุกเบิกการอนุมานประเภท แต่มันมีอยู่ใน C # ด้วยvarคำหลัก

— จำนวน

9

คุณมีจุดที่ถูกต้องสมบูรณ์ภาษาที่ไม่ได้ติดตามชนิดของตัวแปรที่มีอยู่และถูกเรียกว่า "พิมพ์แบบไดนามิก" หมวดหมู่รวมถึงภาษาเช่น JavaScript, Perl, Lisp และ Python

ข้อได้เปรียบที่เราได้รับจากภาษาที่พิมพ์แบบคงที่คือการตรวจสอบข้อผิดพลาดเวลาคอมไพล์เพิ่มเติม

ตัวอย่างเช่นสมมติว่าคุณมีวิธีการดังต่อไปนี้:

public addCustomerContact(Customer client, Employee contact) {
   ...
}

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

ทีนี้คุณอาจสงสัยว่าทำไมผู้แปลไม่สามารถอนุมานประเภทของjamesและbobและยังเตือนเราได้ บางครั้งอาจเป็นไปได้ แต่ถ้าตัวแปรไม่มีประเภทจริงเราสามารถทำสิ่งต่อไปนี้:

var james;
var bob;
if (getRandomNumber() > 0.5) {
   james = new Customer();
   bob = new Employee();
} else {
   james = new Employee();
   bob = new Customer();
}

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

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

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

— ทีโอดอร์ Murdock
แหล่งที่มา

ขอบคุณทีโอดอร์ "แต่ถ้าคอมไพเลอร์ไม่ทราบประเภทของตัวแปรมันก็ไม่สามารถเตือนคุณได้ว่าคุณโทรออกไม่ถูกต้อง" เมื่อคุณพูดถึงคอมไพเลอร์สามารถรู้ประเภทของวัตถุที่ตัวแปรชี้ไป

— Durableytree

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

— Durableytree

2

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

— Theodore Murdock

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

— Durableytree

1

-1; การพิมพ์แบบ strong / weak เป็นแบบ orthogonal ไปเป็นแบบ static / dynamic C ถูกพิมพ์แบบคงที่อย่างอ่อน Lisp และ Python ถูกพิมพ์ทั้งสองอย่างมากแบบไดนามิก

— Fred Foo

5

ดังนั้นโปรแกรมเมอร์มืออาชีพไม่จำเป็นต้องทราบว่า

10 + "10"

is "1010" or 20....

สิ่งที่เป็นข้อผิดพลาดในเวลารวบรวมด้วยภาษาที่พิมพ์แบบคงที่หรือเวลาทำงานโดยพิมพ์หนึ่งแบบไดนามิก คนที่มีสติดีอยู่แล้ว

— โทนี่ฮอปกินสัน
แหล่งที่มา

2

เช่น Perl ไม่ได้เป็นภาษาที่มีสติ? :)

— Fred Foo

5

@larsmans: ตามความเป็นจริงไม่ใช่มันไม่ใช่ แต่นั่นเป็นความเห็นล้วนๆ

— NotMe

2

@ChrisLively: ฉันดีใจที่มันเป็นเรื่องจริงตอนนี้ ได้โปรดมาที่ทำงานของฉันได้ตลอดเวลาเพื่อโน้มน้าวให้เพื่อนร่วมงานที่รัก Perl ของฉัน;)

— Fred Foo

2

10 + "10" กำลังใช้โอเปอเรเตอร์ '+' บนวัตถุจำนวนเต็มชนิดและวัตถุชนิดสตริง คอมไพเลอร์จะออกข้อผิดพลาด คำถามของฉันเกี่ยวกับประเภทของตัวแปรไม่ใช่วัตถุ

— Durableytree

2

มันเป็นที่ถูกต้อง C: มันเป็นตัวชี้เลขคณิต

— dan04

4

สมมติว่าคุณมีตัวแปรone(ชุดที่ 1) one + oneและพยายามที่จะประเมิน หากคุณไม่มีความคิดประเภทดังนั้น 1 + 1 จะไม่ชัดเจน คุณสามารถยืนยันว่า 2 หรือ 11 อาจเป็นคำตอบที่ถูกต้อง มันจะคลุมเครือหากไม่ได้รับบริบท

ฉันเคยเห็นสิ่งนี้เกิดขึ้นใน SQLite ซึ่งฐานข้อมูลถูกตั้งค่าโดยไม่ตั้งใจVARCHARแทนที่จะเป็นINTและเมื่อการดำเนินการเสร็จสิ้นผู้คนจะได้รับผลลัพธ์ที่ไม่คาดคิด

ใน c # if context infers ประเภทคุณสามารถใช้varคำหลัก

var c = new Customer();
var e = new Employer();

จะรวบรวม c และ e กับชนิดที่อนุมาน ณ เวลารวบรวม

— Stephen Quan
แหล่งที่มา

1

ใน Python 1 + 1มีประเภทเสมอintแต่ไม่จำเป็นต้องประกาศสิ่งนั้น คำถามคือว่าทำไมถึงตัวแปรที่มีประเภทที่ไม่เห็นคุณค่า

— Fred Foo

ขออภัยที่คุณvariablesไม่ได้เห็นvaluesเมื่อฉันใช้1 + 1ในตัวอย่างของฉัน ฉันคิดว่ามันไม่ชัดเจน

— Stephen Quan

ยังพิมพ์ภาษาแบบไดนามิกสามารถจัดการกับสิ่งนี้ ในหลาม, พิมพ์one=1; print(one+one) พิมพ์ ตัวอย่าง SQLite มีความน่าเชื่อถือมากกว่า แต่ปัญหาที่เกิดขึ้นคือการพิมพ์ที่อ่อนแออย่างหนึ่งดังนั้นจึงไม่เกี่ยวข้องกับ C # 2one="1"; print(one+one)11

— Fred Foo

ในแบบแผนที่แนะนำของฉันหนึ่ง = 1 หมายถึงตัวแปรที่ชี้ไปยังประเภทจำนวนเต็ม (ฉันไม่ได้แนะนำประเภทใดเลย - วัตถุจะมีประเภท) หนึ่ง + หนึ่งจะไม่คลุมเครือ (เรากำลังเพิ่มวัตถุ / ค่าจำนวนเต็มสองรายการ)

— ทนทานแข็งแรง

1

สวัสดี @ dan04 ฉันเห็นมันORDER BYโดยไม่ได้ตั้งใจทำในVARCHARทุ่ง ดูstackoverflow.com/questions/9103313/...

— Stephen Quan

4

ตัวแปรไม่จำเป็นต้องมีประเภทที่เกี่ยวข้อง ภาษาที่เป็นจริง ได้แก่ Lisp, Scheme, Erlang, Prolog, Smalltalk, Perl, Python, Ruby และอื่น ๆ

อาจเป็นไปได้ที่ตัวแปรจะมีชนิด แต่คุณอาจไม่ต้องเขียนชนิดในโปรแกรม ซึ่งมักเรียกว่าการอนุมานประเภท ML, Haskell และลูกหลานของพวกเขามีการอนุมานแบบทรงพลัง ภาษาอื่นบางภาษามีในรูปแบบที่น้อยกว่าเช่นautoการประกาศของ C ++

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

— Ryan Culpepper
แหล่งที่มา

1

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

หากคุณประกาศตัวแปรต่อไปนี้:

myVar      = 5;
myOtherVar = "C";

คุณสามารถอนุมานตัวแปรเหล่านี้ได้อย่างไร มีการmyVarลงนามประทับแล้วหรือยัง มันคือ 8-bit, 64-bit หรืออะไรทำนองนั้น? คือmyOtherVarสตริง (อย่างมีประสิทธิภาพอาร์เรย์) หรือ Char? มันเป็น ANSI หรือ Unicode

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

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

— S.Robins
แหล่งที่มา

จุดดีถึงแม้ว่าคอมไพเลอร์สามารถใช้ชนิดที่มีประสิทธิภาพมากที่สุด (เช่น int ขนาดเล็ก) ตามค่าได้ แต่ฉันเห็นว่าเราอาจต้องการให้ "C" เป็นวัตถุสตริงแทนที่จะเป็นอักขระเพื่อให้สามารถดำเนินการบางอย่างได้ . ในกรณีเช่นนี้เราสามารถระบุ = (สตริง) "C" สิ่งนี้จะสร้างวัตถุสตริงและ 'a' (ตัวแปรที่ไม่พิมพ์) เพียงชี้ไปที่มัน ฉันไม่เห็นสิ่งนี้น่ากลัวกว่าสตริง a = "C";

— Durableytree

0

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

ทำไมฉันถึงพูดแบบนี้? เพราะสิ่งนี้นำไปสู่คำตอบสำหรับคำถามของคุณ

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

บางภาษาให้กล่องที่เหมือนกันซึ่งมี แต่ฉลากเท่านั้นที่มีความสำคัญ แต่คุณสามารถใส่อะไรก็ได้ลงไปคุณสามารถใช้ตัวแปรชื่อ "เป้าหมาย" เพื่อจัดเก็บ "คน" ที่จุดเริ่มต้นและ "รถยนต์" ที่ส่วนท้ายของ อัลกอริทึมเดียวกัน คนอื่นต้องการให้คุณสร้างกล่อง "รูปร่าง" ดังนั้นจึงแตกต่างกันไปสำหรับบุคคลหรือรถยนต์ - แม้ว่าพวกเขาจะยังให้คุณสร้าง "กล่องทั่วไป" (วัตถุ Java, C / C ++ โมฆะ *, วัตถุประสงค์ C "id" ... ) และโยนมันตามที่คุณต้องการ ภาษาที่พิมพ์ช่วยให้คุณสามารถแสดงโครงสร้างของคุณในรายละเอียดปลีกย่อยการสร้าง "สัญญาประเภท" สำหรับตัวแปรของคุณ (แม้ว่าคุณสามารถแฮ็ครอบข้อ จำกัด นี้) ในขณะที่ภาษาที่ไม่พิมพ์รองรับการสนับสนุนนี้ "ฉันจะรู้ว่า เป็นค่าเริ่มต้นและพฤติกรรมเท่านั้น

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

ฉันคิดว่ามันไม่จำเป็นที่จะบอกว่าฉันชอบกฎกติกาโดยเฉพาะอย่างยิ่งสำหรับโครงการระยะยาวทีมใหญ่ (aka: "ร้ายแรง") เหตุผล: เท่าที่ฉันทราบสาเหตุที่เป็นไปได้มากที่สุดของความล้มเหลว / การลื่นล้มของโครงการ SW คือ: ข้อกำหนดที่ไม่ชัดเจนและการออกแบบไม่ดี (80%! จากการศึกษาที่ฉันรู้) และมีเพียงไม่กี่เปอร์เซ็นต์ กฎและสัญญาทั้งหมดบังคับใช้การออกแบบที่สะอาดกว่าคิดล่วงหน้าและต้องการการตัดสินใจที่จะทำก่อนหน้านี้และโดยคนที่เหมาะสม ประเภทหมายถึงกฎ: "อิสระ" และ "ความเย็น" น้อยลง - การเตรียมการคิดมาตรฐานการเข้ารหัสการทำงานเป็นทีมที่ควบคุมได้มากขึ้น สำหรับฉันมันฟังดูเป็นปัจจัยแห่งความสำเร็จและ "บ้านบ้านอันแสนหวาน"

2 เซนต์ของฉัน

— Lorand Kedves
แหล่งที่มา

-3

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

— Loren Pechtel
แหล่งที่มา

3

คุณรู้ผิด มีคอมไพเลอร์มากมายสำหรับภาษาที่พิมพ์แบบไดนามิกและบางภาษาก็ค่อนข้างเร็ว ตัวอย่าง ได้แก่ Common Lisp, Scheme และ Erlang

— Ryan Culpepper

3

ไม่มีสิ่งเช่น "ภาษาตีความ" ภาษาคือชุดของกฎทางคณิตศาสตร์ที่เป็นนามธรรม ภาษาจะไม่ถูกรวบรวมหรือตีความ ภาษาก็คือ การรวบรวมและการตีความเป็นลักษณะของการนำไปปฏิบัติไม่ใช่ภาษา ทุกภาษาสามารถนำไปใช้กับล่ามและทุกภาษาสามารถนำไปใช้กับคอมไพเลอร์ และแทบทุกภาษามีทั้งการตีความและการคอมไพล์การใช้งานเช่นมีล่ามสำหรับ C และคอมไพเลอร์สำหรับ ECMAScript, Ruby และ Python

— Jörg W Mittag

-4

ภาษาที่พิมพ์แบบไดนามิกมักถูกขนานนามว่า "เชิงวัตถุ" พวกเขาจะไม่. พวกเขาอาจจะมุ่งเน้นไปที่ encapsulation แต่ไม่เคยมุ่งเน้นวัตถุ การวางแนววัตถุนั้นเกี่ยวกับประเภท

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

ในภาษาที่พิมพ์แบบไดนามิกสถานการณ์สามารถแสดงได้อย่างเดียวดังนั้น:

"วัตถุขี่วัตถุสิ่งของของเขาไปยังวัตถุและซื้อวัตถุจากวัตถุ"

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

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

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

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

— มือชาร์ลี
แหล่งที่มา

2

ฉันเกรงว่าฉันจะไม่เห็นด้วยกับคุณในส่วนแรกของการโต้แย้งของคุณ ภาษาที่พิมพ์แบบไดนามิกมักจะเป็น "เชิงวัตถุ" แต่ไม่ใช่ "เชิงแนว" นี่คือความแตกต่างที่สำคัญ ในตัวอย่างของคุณคุณกำลังอยู่ในภาพลวงตา คุณอาจมีBoyชั้นเรียน แต่ฉันสงสัยว่ามันสามารถทำทุกอย่างที่ "เด็กชาย" ในโลกแห่งความจริงทำได้ อย่างไรก็ตามในตัวอย่างแบบไดนามิกของคุณ (วัตถุขี่ ... ) เรารู้สิ่งสำคัญเพียงอย่างเดียวเกี่ยวกับวัตถุ "เด็กชาย" นี้ - มันสามารถขี่ได้ นั่นคือปรัชญาพื้นฐานของภาษาแบบไดนามิก มันมี + ve s และ -ve s สิ่งที่คุณชอบคือความคิดเห็นของคุณ

— ชิป