คุณสมบัติภาษาการเขียนโปรแกรมกึ่งพิเศษของนักฆ่า [ปิด]

เมื่อเรียนรู้ภาษาการเขียนโปรแกรมใหม่บางครั้งคุณจะพบคุณสมบัติภาษาที่ทำให้คุณต้องการในภาษาโปรแกรมอื่น ๆ ที่คุณรู้

มีคุณลักษณะภาษาอะไรบ้างในขณะที่เรียนรู้สิ่งใหม่ ๆ สำหรับคุณและคุณต้องการให้ภาษาโปรแกรมอื่นของคุณมี

ตัวอย่างนี้เป็นเครื่องกำเนิดไฟฟ้าใน Python หรือ C # ตัวอย่างอื่น ๆ อาจรวมถึงรายการ comprehensions ใน Python, เท็มเพลตใน C ++ หรือ LINQ ใน. NET หรือการประเมินสันหลังยาวใน Haskell

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

แทบทุกอย่างใน Haskell

• monads ใช่ - คำที่น่ากลัวมากที่ทำให้การแยกวิเคราะห์ง่ายขึ้นเรื่อย ๆ , IO, การดำเนินการในรายการและสิ่งอื่น ๆ นั้นง่ายมาก (เมื่อคุณสังเกตเห็นรูปแบบทั่วไป)
• ลูกศร เช่นเดียวกันสำหรับผู้ใช้ขั้นสูง;)
• สิ่งมาตรฐานเช่น lambdas เป็นต้น
• ฟังก์ชั่นการแกง
• ชนิดข้อมูลเชิงพีชคณิต
• การจับคู่รูปแบบ

และอื่น ๆ อีกมากมาย.

PS ใช่. ฉันเป็นแฟนบอย Haskell ถ้าใครถาม

มาโครเสียงกระเพื่อม

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

เทมเพลตการเขียนโปรแกรม C ++ เทมเพลตมีความสามารถในสิ่งที่คล้ายกัน แต่ในภาษาที่แตกต่างจาก C ++ ปกติมาก

มัณฑนากร Python

มันง่ายมากที่จะใช้การบันทึกหรือเวลาของฟังก์ชั่นการใช้มัณฑนากร

ตัวอย่างของฟังก์ชั่นจับเวลา

class FuncTimer(object):
    """ Time how much time a function takes """
    def __init__(self, fn):
        self.fn = fn
        self.memo = {}
        self.start_time = time.time()
    def __call__(self, *args):
        self.memo['return'] = self.fn(*args)
        print("Function '%s' took %u seconds" % (self.fn.__name__, time.time() - self.start_time))
        return self.memo['return']

ตอนนี้ถ้าคุณมีฟังก์ชั่น foo ที่คุณต้องการเวลาคุณก็สามารถทำได้

@FuncTimer
def foo():
    # foo's implememtation goes here

คุณจะเห็นสิ่งที่ชอบ

ฟังก์ชั่น 'foo' ใช้เวลา 3 วินาที

การส่งไปที่void*C คุณสามารถส่งทุกอย่างเป็นไบต์ดิบและทำทุกอย่างที่คุณต้องการด้วยข้อมูลเหล่านี้

(ใช่ทุกวันนี้มันไม่เหมือนใคร ... )

ผลตอบแทนใน Python

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

การแสดงออกของแลมบ์ดา (การปิดฟังก์ชันที่ซ้อนกันวิธีการไม่ระบุชื่อสิ่งที่คุณเรียกว่า)

ฉันมาเจอพวกเขาครั้งแรกใน Perl รักพวกเขาทันทีและสงสัยว่าทำไมภาษาอื่นไม่มีพวกเขา ทุกวันนี้ฉันคิดว่ามันคงไม่เหมือนเดิมอีกแล้ว แม้แต่ PHP ก็สามารถแฮ็คมันได้ แต่พวกเขาก็ไม่เหมือนใครในเวลานั้น

ตจากโครงการ (ต่อมาเป็นลูกบุญธรรมด้วยภาษาอื่น ๆ ไม่กี่รวมทั้งทับทิม.)

เซตใน Delphi นั้นมีประโยชน์มาก ๆ เพียงแค่อาร์เรย์แบบบูลที่มีชื่อ มีประโยชน์มากสำหรับการบันทึกฟอร์มการตั้งค่าด้วยช่องทำเครื่องหมาย 32 ช่อง แต่พวกเขามีฟังก์ชั่นทฤษฎีเซตเดียวกันทั้งหมด (เช่นความแตกต่างจุดตัดสหภาพ)

ฉันไม่แน่ใจว่าพวกเขาหลุดออกจากแฟชั่น แต่ฉันใช้พวกเขาตลอดเวลา

ส่ง

จาก Erlang ส่งข้อความแบบอะซิงโครนัสไปยังเธรดอื่น

Expr1 ! Expr2

รับ

จาก Erlang รับข้อความจากเธรดอื่น

receive
    Pattern1 [when GuardSeq1] ->
        Body1;
    ...;
    PatternN [when GuardSeqN] ->
        BodyN
end

คุณสมบัติ C #

/// <summary>
/// Get ID
/// </summary>
public int ID
{
    get; set;
}

VS

(Java)

/**
 * Name of user
 */
private String name;

/**
 * Gets name of user
 * @return Name of user
 */
public String getName() {
    return this.name;
}

/**
 * Sets name of user. 
 * @param name
 */
public void setName(final String name) {
    this.name = name;
}

สหภาพแรงงานใน

ฉันไม่สามารถพูดได้อย่างตรงไปตรงมาว่าฉันไม่ได้เขียน C เพียงพอที่จะทำสิ่งเหล่านี้ด้วยตัวเอง แต่ฉันได้ทำงานกับรหัสของผู้อื่นที่ทำ

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

Disclaimer:

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

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

puts "All good" unless input.nil?

คุณไม่ชอบสิ่งนั้นได้อย่างไร : D

ไวยากรณ์อาร์กิวเมนต์หลามแฟนซี

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

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"


parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')

python docs (เลื่อนลงเพื่อดูรายการการโต้แย้งเพิ่มเติม)

ตัวประมวลผลล่วงหน้า C คุณยังสามารถเขียนรหัสทั่วไปไปยังแพลตฟอร์มต่าง ๆ ด้วย - น้อยลงหรือมากขึ้น - ifdefs

หมวดหมู่วัตถุประสงค์ -C

หมวดหมู่นำเสนอวิธีที่ง่ายในการขยายการทำงานของวัตถุในขณะทำงาน ตัวอย่างคลาสสิกคือการเพิ่มเครื่องตรวจคำสะกดลงในคลาส NSString

@interface NSString (SpellChecker)
- (BOOL) checkSpelling;
@end

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

วิธีการฉีดของRubyรวมกับคุณสมบัติSymbol # to_procของ Ruby 1.9 ทำให้เราสามารถเขียนโค้ดที่รัดกุม (แต่ยังคงอ่านได้) ได้อย่างไม่น่าเชื่อ:

เช่น (1..10).inject(:+)

ซึ่งจะรวมจำนวนเต็ม 1 ถึง 10 => 55

การเห็นตัวอย่างเช่นนี้ทำให้ฉันต้องการเรียนรู้ทับทิมซึ่งฉันเพิ่งเริ่มทำ

กลไกการผูกใน JavaFX (RIP) ผูกคำหลักที่ช่วยให้คุณสามารถผูกค่าของตัวแปรที่จะคุ้มค่าของการแสดงออกและการที่คุณกำจัดทุกคนฟังที่น่าเกลียด แต่อย่างใดรหัสสำเร็จรูป

ในขณะที่ JavaFX นั้นค่อนข้างล้มเหลวในหลาย ๆ ด้าน แต่ฉันพบว่าคุณสมบัติต่าง ๆ ของภาษาสคริปต์ค่อนข้างดี

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