คุณสมบัติภาษาที่แปลกประหลาด

ในความเห็นของคุณฟีเจอร์ภาษาที่แปลกประหลาดแปลกหรือแปลกจริง ๆ ที่คุณพบคืออะไร?

กรุณาเพียงหนึ่งคุณสมบัติต่อคำตอบ

ใน C อาร์เรย์สามารถจัดทำดัชนีดังนี้:

a[10]

ซึ่งเป็นเรื่องธรรมดามาก

อย่างไรก็ตามรูปแบบที่รู้จักน้อยกว่า (ซึ่งใช้งานได้จริง!) คือ:

10[a]

ซึ่งหมายถึงเช่นเดียวกับข้างต้น

ใน JavaScript:

 '5' + 3 gives '53'

แต่ทว่า

 '5' - 3 gives 2

ใน JavaScript โครงสร้างต่อไปนี้

return
{
    id : 1234,
    title : 'Tony the Pony'
};

ผลตอบแทนที่undefinedreturnเป็นข้อผิดพลาดทางไวยากรณ์เนื่องจากการแทรกอัฒภาคนัยส่อเสียดบนบรรทัดใหม่หลังจาก งานต่อไปนี้ตามที่คุณคาดหวัง:

return {
    id : 1234,
    title : 'Tony the Pony'
};

ยิ่งแย่ไปกว่านี้มันใช้งานได้ดี (ใน Chrome อย่างน้อย):

return /*
*/{
    id : 1234,
    title : 'Tony the Pony'
};

นี่คือตัวแปรของปัญหาเดียวกันที่ไม่ได้เกิดข้อผิดพลาดทางไวยากรณ์ แต่ล้มเหลวอย่างเงียบ ๆ :

return
    2 + 2;

ตารางความจริง JavaScript:

''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t\r\n" ==   0             // true

ที่มา: Doug Crockford

Trigraphs ใน C และ C ++

int main() {
   printf("LOL??!");
}

นี้จะพิมพ์LOL|เพราะ trigraph จะถูกแปลงเป็น??!|

สนุกกับ auto Boxing และแคชจำนวนเต็มใน Java:

Integer foo = 1000;
Integer bar = 1000;

foo <= bar; // true
foo >= bar; // true
foo == bar; // false

//However, if the values of foo and bar are between 127 and -128 (inclusive)
//the behaviour changes:

Integer foo = 42;
Integer bar = 42;

foo <= bar; // true
foo >= bar; // true
foo == bar; // true

คำอธิบาย

ดูอย่างรวดเร็วที่ซอร์สโค้ด Java จะปรากฏขึ้นต่อไปนี้:

/**
 * Returns a <tt>Integer</tt> instance representing the specified
 * <tt>int</tt> value.
 * If a new <tt>Integer</tt> instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Integer(int)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  i an <code>int</code> value.
 * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

หมายเหตุ: IntegerCache.highค่าเริ่มต้นเป็น127เว้นแต่จะมีการตั้งค่าโดยคุณสมบัติ

สิ่งที่เกิดขึ้นกับ auto Boxing คือทั้ง foo และ bar วัตถุจำนวนเต็มเดียวกันที่ดึงมาจากแคชเว้นแต่จะสร้างอย่างชัดเจน: เช่นfoo = new Integer(42)เมื่อเปรียบเทียบความเท่าเทียมกันของการอ้างอิงพวกเขาจะเป็นจริงมากกว่าเท็จ วิธีที่เหมาะสมในการเปรียบเทียบค่าจำนวนเต็มคือการใช้.equals;

การอ้างอิงNeil Fraser (ดูที่ส่วนท้ายของหน้านั้น)

try {
    return true;
} finally {
    return false;
}

(ใน Java แต่พฤติกรรมนั้นเหมือนกันใน JavaScript และ Python) ผลที่ได้จะเป็นแบบฝึกหัดให้กับผู้อ่าน

แก้ไข: ตราบใดที่เรายังอยู่ในหัวข้อให้พิจารณาสิ่งนี้ด้วย:

try {
    throw new AssertionError();
} finally {
    return false;
}

APL (นอกเหนือจากทั้งหมด)ความสามารถในการเขียนโปรแกรมใด ๆ ในหนึ่งบรรทัด

เช่นเกมแห่งชีวิตของ Conway ในหนึ่งบรรทัดใน APL :

alt text http://catpad.net/michael/APLLife.gif

ถ้าบรรทัดนั้นไม่ใช่ WTF แสดงว่าไม่มีอะไร!

และนี่คือวิดีโอ

เทมเพลต C ++ ที่แปลกสามารถนำมาใช้เพื่อแสดงให้เห็นได้ดีที่สุดโดย"Multi-Dimensional Analog Literals"ซึ่งใช้เทมเพลตเพื่อคำนวณพื้นที่ของรูปร่าง "วาด" รหัสต่อไปนี้คือ C ++ ที่ถูกต้องสำหรับสี่เหลี่ยมผืนผ้า 3x3

#include"analogliterals.hpp"
using namespace analog_literals::symbols;

          unsigned int c = ( o-----o
                             |     !
                             !     !
                             !     !
                             o-----o ).area;

หรืออีกตัวอย่างหนึ่งที่มีลูกบาศก์ 3 มิติ:

  assert( ( o-------------o
            |L             \
            | L             \
            |  L             \
            |   o-------------o
            |   !             !
            !   !             !
            o   |             !
             L  |             !
              L |             !
               L|             !
                o-------------o ).volume == ( o-------------o
                                              |             !
                                              !             !
                                              !             !
                                              o-------------o ).area * int(I-------------I) );

Perl ตัวแปรในตัวจำนวนมาก:

• $#- ไม่แสดงความคิดเห็น!
• $0, $$และ$?- เช่นเดียวกับตัวแปรเชลล์ด้วยชื่อเดียวกัน
• $ˋ, $&และ$'- ตัวแปรจับคู่แปลก
• $"และ$,- ตัวแปรแปลก ๆ สำหรับ list- และ output-field-separators
• $!- ชอบerrnoเป็นตัวเลข แต่strerror(errno)เป็นสตริง
• $_- ตัวแปรการลักลอบใช้อยู่เสมอและไม่เคยเห็น
• $#_ - หมายเลขดัชนีของอาร์กิวเมนต์รูทีนย่อยสุดท้าย ... อาจจะ
• @_ - ชื่อ (ไม่ใช่) ของฟังก์ชันปัจจุบัน ... อาจจะ
• $@ - ข้อยกเว้นยกล่าสุด
• %:: - ตารางสัญลักษณ์
• $:, $^, $~, $-และ$=- บางสิ่งบางอย่างจะทำอย่างไรกับรูปแบบการออก
• $.และ$%- หมายเลขบรรทัดอินพุตหมายเลขหน้าเอาต์พุต
• $/และ$\- ตัวแยกเร็กคอร์ดอินพุตและเอาต์พุต
• $| - คอนโทรลเลอร์บัฟเฟอร์เอาต์พุต
• $[- เปลี่ยนอาเรย์ฐานของคุณจาก 0 เป็น 1-based เป็น 42-based: WHEEE!
• $}- ไม่มีอะไรแปลกประหลาดพอ!
• $<, $>, $(, $)- UIDs จริงและมีประสิทธิภาพและ GIDs
• @ISA - ชื่อของซูเปอร์คลาสโดยตรงของแพ็คเกจปัจจุบัน
• $^T - เวลาเริ่มต้นสคริปต์ในไม่กี่วินาที
• $^O - ชื่อระบบปฏิบัติการปัจจุบัน
• $^V - Perl รุ่นนี้คืออะไร

ยังมีอีกมากที่มาจาก อ่านรายชื่อทั้งหมดที่นี่

จัดการ PHP ของค่าตัวเลขในสตริง ดูคำตอบก่อนหน้านี้สำหรับคำถามอื่นสำหรับรายละเอียดทั้งหมด แต่โดยย่อ:

"01a4" != "001a4"

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

"01e4" == "001e4"

PHP ไม่ชอบสตริง มันกำลังมองหาข้อแก้ตัวใด ๆ ที่สามารถพบได้ในการรักษาค่าของคุณเป็นตัวเลข เปลี่ยนอักขระเลขฐานสิบหกในสตริงเหล่านั้นเล็กน้อยและทันใดนั้น PHP ตัดสินใจว่าสิ่งเหล่านี้ไม่ใช่สตริงอีกต่อไปพวกเขาเป็นตัวเลขในรูปแบบทางวิทยาศาสตร์ (PHP ไม่สนใจว่าคุณใช้เครื่องหมายคำพูด) และพวกเขาเทียบเท่ากันเพราะศูนย์นำหน้า เพื่อเสริมจุดนี้คุณจะพบว่า PHP ยังประเมิน"01e4" == "10000"ว่าเป็นจริงเพราะตัวเลขเหล่านี้มีค่าเทียบเท่า นี่เป็นพฤติกรรมที่บันทึกไว้มันไม่สมเหตุสมผลนัก

มาโหวตกันทุกภาษา (เช่น PL / I) ที่พยายามกำจัดคำที่สงวนไว้

คุณสามารถเขียนสำนวนที่น่าขบขันเช่นที่อื่นได้ที่ไหน:

IF IF THEN THEN = ELSE ELSE ELSE = THEN

( IF, THEN, ELSEเป็นชื่อตัวแปร)

หรือ

IF IF THEN THEN ELSE ELSE

( IFเป็นตัวแปรTHENและELSEเป็นรูทีนย่อย)

คุณลักษณะ 'การแปลงเลขฐานแปด JavaScript' เป็นสิ่งที่ดีที่ควรทราบ:

parseInt('06') // 6
parseInt('07') // 7
parseInt('08') // 0
parseInt('09') // 0
parseInt('10') // 10

รายละเอียดเพิ่มเติมที่นี่

อุปกรณ์ของ Duff ใน C!

ใน C หนึ่งสามารถทำงานร่วมกันทำ / ขณะที่มีคำสั่งเปลี่ยน นี่คือตัวอย่างของ memcpy โดยใช้วิธีนี้:

void duff_memcpy( char* to, char* from, size_t count ) {
    size_t n = (count+7)/8;
    switch( count%8 ) {
    case 0: do{ *to++ = *from++;
    case 7:     *to++ = *from++;
    case 6:     *to++ = *from++;
    case 5:     *to++ = *from++;
    case 4:     *to++ = *from++;
    case 3:     *to++ = *from++;
    case 2:     *to++ = *from++;
    case 1:     *to++ = *from++;
            }while(--n>0);
    }
}

Algol ผ่านชื่อ (ภาพประกอบโดยใช้ไวยากรณ์ C):

int a[3] = { 1, 2, 3 };
int i = 1;

void f(int j)
{
    int k;
    k = j;  // k = 2
    i = 0;
    k = j;  // k = 1 (!?!)    
}

int main()
{
    f(a[i]);
}

ใน Python:

>>> x=5
>>> 1<x<10
True
>>> 1<x<3
False

ไม่ใช่ WTF แต่เป็นคุณสมบัติที่มีประโยชน์

ใน Java:

int[] numbers() {
  return null;
}

สามารถเขียนเป็น:

int numbers() [] {
  return null;
}

INTERCALน่าจะเป็นบทสรุปที่ดีที่สุดของฟีเจอร์ภาษาที่แปลกประหลาดที่สุด รายการโปรดส่วนตัวของฉันคือคำสั่งCOMEFROMซึ่งเกือบตรงกันข้ามกับ GOTO

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

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

f(1)

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

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

ช่องว่างชื่อจำนวนมากของ C:

typedef int i;

void foo()
{
    struct i {i i;} i;
    i: i.i = 3;
    printf( "%i\n", i.i);
}

หรือกับตัวละคร:

typedef char c;

void foo()
{
    struct c {c c;} c;
    c: c.c = 'c';
    printf( "%c\n", c.c);
}

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

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

ตัวอย่างเช่นถ้าฉันมีบล็อกที่เว้นวรรค 4 ช่องและวางไว้ที่ส่วนท้ายของบล็อกที่มีการเว้นวรรค 8 ตัวแก้ไขของฉัน (บรรณาธิการทั้งหมดหรือไม่) ไม่มีความคิดว่ารหัสที่วางเป็นของบล็อกช่องว่าง 8 หรือด้านนอก บล็อก. OTOH ถ้าฉันมีตัวคั่นชัดเจนมันชัดเจนที่บล็อกรหัสเป็นของและวิธีการที่ควรจะเยื้อง (อีกครั้ง) เยื้อง - มันทำเช่นนั้นโดยการมองหาตัวคั่นบล็อกอย่างชาญฉลาด

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

ฉันพยายามเล็กน้อยเกี่ยวกับเรื่องนี้:

1;

ใน Perl โมดูลต้องกลับสิ่งที่เป็นความจริง

ฉันประหลาดใจที่ไม่มีใครพูดถึง7 loop ของ Visual Basic

For i As Integer = 1 to 10 ... Next
While True ... End While
Do While True ... Loop
Do Until True ... Loop
Do ... Loop While True
Do ... Loop Until True
While True ... Wend

เพราะติด! ในด้านหน้าของเงื่อนไขของคุณเป็นวิธีที่มีความซับซ้อนมากเกินไป!

สำหรับผู้ที่ไม่ทราบว่าbcเป็น "ภาษาเครื่องคิดเลขความแม่นยำโดยพลการ" และฉันใช้บ่อยในการคำนวณอย่างรวดเร็วโดยเฉพาะเมื่อตัวเลขที่เกี่ยวข้องมีขนาดใหญ่ ( $เป็นพรอมต์):

$ bc -lq
12^345
20774466823273785598434446955827049735727869127052322369317059031795\
19704325276892191015329301807037794598378537132233994613616420526484\
93077727371807711237016056649272805971389591721704273857856298577322\
13812114239610682963085721433938547031679267799296826048444696211521\
30457090778409728703018428147734622401526422774317612081074841839507\
864189781700150115308454681772032

bcได้รับคำสั่ง Unix มาตรฐานมาเป็นเวลานาน

ตอนนี้สำหรับ "คุณสมบัติ WTF" นี่คือจากman bc(เหมืองเน้น):

ออกจาก : เมื่ออ่านคำสั่งเลิกหน่วยประมวลผล bc จะถูกยกเลิกโดยไม่คำนึงถึงตำแหน่งที่พบคำสั่งเลิก ตัวอย่างเช่น "if (0 == 1) quit" จะทำให้ bc ยุติ

halt : คำสั่ง halt (ส่วนขยาย) เป็นคำสั่งที่ดำเนินการซึ่งทำให้โปรเซสเซอร์ bc หยุดการทำงานเฉพาะเมื่อมีการดำเนินการ ตัวอย่างเช่น "if (0 == 1) halt" จะไม่ทำให้ bc ยุติเนื่องจาก halt ไม่ถูกดำเนินการ

ฉันมักจะสงสัยว่าทำไมโปรแกรมที่ง่ายที่สุดคือ:

class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

ในขณะที่มันอาจจะเป็น:

print "Hello World!"

บางทีนี่อาจเป็นการทำให้นักศึกษาวิทยาศาสตร์คอมพิวเตอร์หวาดกลัวในตอนแรก ...

JavaScript เป็นเชิงวัตถุใช่ไหม ดังนั้นการเรียกใช้เมธอดบนสตริงและตัวอักษรควรใช้งานได้ กดไลค์"hello".toUpperCase()และ 3.toString()ปรากฎว่าข้อที่สองเป็นข้อผิดพลาดทางไวยากรณ์ทำไม เนื่องจากตัวแยกวิเคราะห์คาดหวังว่าตัวเลขตามด้วยจุดจะเป็นตัวอักษรลอย นั่นไม่ใช่ WTF แต่ WTF ก็คือคุณต้องเพิ่มจุดอื่นเพื่อให้ทำงานได้:

3..toString()

เหตุผลก็คือตัวอักษร3.ถูกตีความว่าเป็น3.0และ3.0.toString()ทำงานได้ดี

ใน JavaScript:

2 == [2]

// Even stranger
2 == [[[2]]]

// And down-right nutty
var a = { "abc" : 1 };
a[[[["abc"]]]] === a["abc"]; // this is also true

โชคดีที่คนใจดีที่ stackoverflow.com อธิบายเรื่องทั้งหมดให้ฉันฟัง: ทำไม 2 == [2] ใน JavaScript?

คุณลักษณะที่น่ารังเกียจที่สุดของฉันที่สุดคือไวยากรณ์ไฟล์การกำหนดค่าใด ๆ ที่มีตรรกะตามเงื่อนไข เรื่องแบบนี้มากมายในโลกของ Java (Ant, Maven ฯลฯ คุณรู้ว่าคุณเป็นใคร!)

คุณเพิ่งจบการเขียนโปรแกรมในภาษา ac ** p พร้อมการดีบักแบบ จำกัด และรองรับการแก้ไขแบบ จำกัด

หากคุณต้องการตรรกะในการกำหนดค่าของคุณ "Pythonic" วิธีการเข้ารหัสการกำหนดค่าในภาษาจริงจะดีกว่ามาก

powerbasic (www.powerbasic.com) รวมถึงคอมไพเลอร์คำสั่ง:

# BLOAT {bloatsize}

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