අමුතුම භාෂා ලක්ෂණය

ඔබේ මතය අනුව, ඔබ මුහුණ දී ඇති වඩාත්ම පුදුම සහගත, අමුතු, අමුතු හෝ සැබවින්ම “WTF” භාෂා අංගය කුමක්ද?

කරුණාකර පිළිතුරකට එක් අංගයක් පමණි.

C හි, අරා එසේ සුචිගත කළ හැකිය:

a[10]

එය ඉතා සුලභ ය.

කෙසේ වෙතත්, එතරම් නොදන්නා ස්වරූපය (එය සැබවින්ම ක්‍රියාත්මක වේ!):

10[a]

එහි තේරුම ඉහත ආකාරයටම ය.

JavaScript හි:

 '5' + 3 gives '53'

ෙකෙසේෙවතත්

 '5' - 3 gives 2

ජාවාස්ක්‍රිප්ට් හි, පහත දැක්වෙන ඉදිකිරීම්

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

ප්‍රතිලාභundefined යනු නව රේඛාවට පසුව සනීපාරක්ෂක අර්ධ සළකුණ ඇතුළු කිරීම නිසා වාක්‍ය ඛණ්ඩයකි return. ඔබ අපේක්ෂා කළ පරිදි පහත සඳහන් දෑ ක්‍රියාත්මක වේ:

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

ඊටත් වඩා භයානක දෙය නම් මෙයද ක්‍රියාත්මක වේ (ක්‍රෝම් හි අවම වශයෙන්):

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

සින්ටැක්ස් දෝෂයක් නොදක්වන එකම නිකුතුවේ ප්‍රභේදයක් මෙන්න, නිහ ly ව අසමත් වේ:

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

මුලාශ්‍රය: ඩග් ක්‍රොක්ෆර්ඩ්

සී සහ සී ++ හි ත්‍රිකෝණ.

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

LOL|ත්‍රිකෝණය ??!පරිවර්තනය කර ඇති නිසා මෙය මුද්‍රණය වේ |.

ස්වයංක්‍රීය බොක්සිං සහ ජාවා හි පූර්ණ සංඛ්‍යා හැඹිලිය සමඟ විනෝද වන්න:

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

පැහැදිලි කිරීම

ජාවා ප්‍රභව කේතය ඉක්මණින් බැලීමෙන් පහත සඳහන් දෑ ලැබෙනු ඇත:

/**
 * 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සකසා නොමැති නම් පෙරනිමිය .

ස්වයංක්‍රීය බොක්සිං සමඟ සිදුවන්නේ, පැහැදිලිවම නිර්මාණය කර නොමැති නම්, හැඹිලියෙන් ලබාගත් එකම පූර්ණ වස්තුවක් foo සහ bar කිරීම ය: උදා: foo = new Integer(42)මේ අනුව යොමු සමානාත්මතාවය සංසන්දනය කිරීමේදී ඒවා අසත්‍යයට වඩා සත්‍ය වනු ඇත. පූර්ණ අගය සංසන්දනය කිරීමේ නිසි ක්‍රමය භාවිතා කිරීමයි.equals;

නීල් ෆ්‍රේසර් උපුටා දැක්වීම (එම පිටුවේ අවසානය දෙස බලන්න),

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

(ජාවා හි, නමුත් හැසිරීම ජාවාස්ක්‍රිප්ට් සහ පයිතන් වල සමාන වේ). ප්‍රති result ලය පා er කයාට අභ්‍යාසයක් ලෙස ඉතිරි වේ.

සංස්කරණය කරන ලදි: අප මෙම විෂය පිළිබඳව සිටින තාක් කල් මෙයද සලකා බලන්න:

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

ඒපීඑල් (ඒ සියල්ල හැර), ඕනෑම වැඩසටහනක් එක් පේළියකින් ලිවීමේ හැකියාව.

උදා: කොන්වේ ගේ ගේම් ඔෆ් ලයිෆ් ඒපීඑල් හි එක් පේළියක :

alt පෙළ http://catpad.net/michael/APLLife.gif

එම රේඛාව WTF නොවේ නම්, කිසිවක් නැත!

මෙන්න වීඩියෝවක්

C ++ සැකිලි සඳහා අමුතු දේවල් භාවිතා කළ හැකි අතර, එය වඩාත් හොඳින් නිරූපණය කර ඇත්තේ “බහු-මාන මාන ඇනලොග් සාහිත්‍යකරුවන්” විසිනි, එය “ඇදගත්” හැඩතලවල ප්‍රදේශය ගණනය කිරීම සඳහා සැකිලි භාවිතා කරයි. 3x3 සෘජුකෝණාස්රයක් සඳහා පහත කේතය වලංගු C ++ වේ

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

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

නැතහොත් ත්‍රිමාණ ube නකයක් සහිත තවත් උදාහරණයක්:

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

පර්ල් හි බොහෝ බිල්ට් විචල්‍යයන්:

• $#- අදහස් දැක්වීමක් නොවේ !
• $0,, $$සහ $?- එකම නමින් ෂෙල් විචල්‍යයන් මෙන්
• $ˋ,, $&සහ $'- අමුතු ගැලපෙන විචල්‍යයන්
• $"සහ $,- ලැයිස්තු- සහ ප්‍රතිදාන-ක්ෂේත්‍ර-බෙදුම්කරුවන් සඳහා අමුතු විචල්‍යයන්
• $!- errnoඅංකයක් strerror(errno)මෙන් නමුත් නූලක් ලෙස
• $_- මෙම රහසිගත විචල්ය, හැම විටම භාවිතා කවදාවත් දැකලා
• $#_ - අන්තිම සබ්මැරීන් තර්කයේ දර්ශක අංකය ... සමහර විට
• @_ - වත්මන් ශ්‍රිතයේ (නොවන) නම් ... සමහර විට
• $@ - අවසන් වරට මතු කරන ලද ව්‍යතිරේකය
• %:: - සංකේත වගුව
• $:, $^, $~, $-, සහ $=- හැඩතල යමක්
• $.සහ $%- ආදාන රේඛා අංකය, ප්‍රතිදාන පිටු අංකය
• $/සහ $\- ආදාන සහ ප්‍රතිදාන වාර්තා බෙදුම්කරුවන්
• $| - ප්‍රතිදාන බෆරින් පාලකය
• $[- ඔබේ අරාව පදනම 0-පදනම් 1 සිට 42-පදනම් දක්වා වෙනස් කරන්න: WHEEE!
• $}- කිසිවක් නැත, අමුතු තරම්!
• $<, $>, $(, $)- සැබෑ හා ඵලදායී UIDs හා GIDs
• @ISA - වත්මන් පැකේජයේ සෘජු සුපිරි පන්තිවල නම්
• $^T - ස්ක්‍රිප්ට් ආරම්භක වේලාව යුග තත්පර වලින්
• $^O - වත්මන් මෙහෙයුම් පද්ධතියේ නම
• $^V - පර්ල්ගේ අනුවාදය මෙයයි

ඒවා පැමිණියේ කොහෙන්ද? සම්පූර්ණ ලැයිස්තුව මෙතැනින් කියවන්න .

PHP විසින් සංඛ්‍යාත්මක අගයන් නූල් වලින් හැසිරවීම . සම්පූර්ණ විස්තර සඳහා වෙනත් ප්‍රශ්නයකට මෙම පෙර පිළිතුර බලන්න , නමුත් කෙටියෙන්:

"01a4" != "001a4"

ඔබට වෙනස් අක්ෂර සංඛ්‍යාවක් අඩංගු නූල් දෙකක් තිබේ නම්, ඒවා සමාන යැයි සැලකිය නොහැකිය. ප්‍රමුඛ ශුන්‍යයන් වැදගත් වන්නේ මේවා නූල් සංඛ්‍යා නොවන බැවිනි.

"01e4" == "001e4"

PHP නූල් වලට කැමති නැත. එය ඔබගේ අගයන් සංඛ්‍යා ලෙස සැලකීමට සොයා ගත හැකි ඕනෑම නිදහසට කරුණක් සොයමින් සිටී. එම නූල්වල ඇති ෂඩාස්රාකාර අක්ෂර තරමක් වෙනස් කරන්න, හදිසියේම PHP තීරණය කරන්නේ මේවා තවදුරටත් නූල් නොවන බවයි, ඒවා විද්‍යාත්මක අංකනයෙහි සංඛ්‍යා වේ (ඔබ උපුටා දැක්වීම් භාවිතා කළ බව PHP ගණන් ගන්නේ නැත) සහ ඒවා සමාන වන්නේ ප්‍රමුඛ ශුන්‍යයන් සංඛ්‍යා සඳහා නොසලකා හරින බැවිනි. මෙම කරුණ ශක්තිමත් කිරීම සඳහා PHP ද "01e4" == "10000"සත්‍ය යැයි තක්සේරු කරන බව පෙනේ, මන්ද මේවා සමාන අගයන් සහිත සංඛ්‍යා වේ. මෙය ලේඛනගත හැසිරීමකි, එය ඉතා සංවේදී නොවේ.

වෙන් කළ වචන ඉවත් කිරීමට උත්සාහ කළ සියලුම භාෂා (පීඑල් / අයි වැනි) සඳහා ඡන්දය ප්‍රකාශ කරමු.

එවැනි විනෝදජනක ප්‍රකාශ ඔබට නීත්‍යානුකූලව ලිවිය හැක්කේ කොතැනින්ද:

IF IF THEN THEN = ELSE ELSE ELSE = THEN

( IF, THEN, ELSEවිචල්ය නම් වේ)

හෝ

IF IF THEN THEN ELSE ELSE

( IFවිචල්‍යයක් වන THENඅතර ELSEඒවා සබ්මැරීන වේ)

ජාවාස්ක්‍රිප්ට් අෂ්ටක පරිවර්තනය 'විශේෂාංගය' ගැන දැන ගැනීමට හොඳ එකකි:

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

වැඩි විස්තර මෙතැනින් .

සී හි ඩෆ්ගේ උපාංගය!

C හි කෙනෙකුට ස්විච් ප්‍රකාශයක් සමඟ කළ යුතු / අතරමැදි කළ හැකිය. මෙම ක්‍රමය භාවිතා කරන මතක සටහනක උදාහරණයක් මෙන්න:

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);
    }
}

ඇල්ගෝල් නම අනුව ගමන් කිරීම (සී සින්ටැක්ස් භාවිතයෙන් නිදර්ශනය කර ඇත):

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]);
}

පයිතන්හි:

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

WTF නොව ප්‍රයෝජනවත් අංගයකි.

ජාවා හි:

int[] numbers() {
  return null;
}

මෙසේ ලිවිය හැකිය:

int numbers() [] {
  return null;
}

INTERCAL යනු අමුතුම භාෂා අංගයන්ගේ හොඳම එකතුවයි. මගේ පුද්ගලික ප්‍රියතමය වන්නේ ගොටෝට ප්‍රතිවිරුද්ධ (පාහේ) COMEFROM ප්‍රකාශයයි.

COMEFROM යනු දළ වශයෙන් GOTO ට ප්‍රතිවිරුද්ධ දෙයකි, එමඟින් ක්‍රියාත්මක වන තත්වය කේතයේ ඕනෑම අත්තනෝමතික ස්ථානයක සිට COMEFROM ප්‍රකාශයක් දක්වා ගෙන යා හැකිය. රාජ්‍ය මාරුව සිදුවන කේතයේ ලක්ෂ්‍යය සාමාන්‍යයෙන් COMEFROM හි පරාමිතියක් ලෙස දෙනු ලැබේ. නිශ්චිත හුවමාරු ස්ථානයේ උපදෙස් වලට පෙර හෝ පසුව මාරුව සිදුවන්නේද යන්න රඳා පවතින්නේ භාවිතා කරන භාෂාව මතය. භාවිතා කරන භාෂාව මත පදනම්ව, එකම පිටවීමේ ස්ථානය සඳහන් කරන බහු COMEFROMs අවලංගු විය හැකිය, නිර්ණය කළ නොහැකි විය හැකිය, යම් ආකාරයක නිර්වචනය කළ ප්‍රමුඛතාවයකින් ක්‍රියාත්මක කළ හැකිය, නැතහොත් නූල් ඉන්ටර්කල් හි දැක්වෙන පරිදි සමාන්තර හෝ වෙනත් සමගාමී ක්‍රියාත්මක කිරීමක් ඇති කළ හැකිය. “COMEFROM x” ප්‍රකාශයක සරල උදාහරණයක් වන්නේ “උගුල් දොරක්” ලෙස ක්‍රියා කරන x (එහි අනුරූප COMEFROM අසල භෞතිකව ස්ථානගත වීමට අවශ්‍ය නොවන) ලේබලයයි. කේත ක්‍රියාත්මක කිරීම ලේබලය වෙත ළඟා වූ විට, COMEFROM වලින් පසුව ප්‍රකාශය වෙත පාලනය ලබා දෙනු ලැබේ. මෙහි ප්‍රති effect ලය මූලික වශයෙන් නිදොස් කිරීම (සහ වැඩසටහනේ පාලන ප්‍රවාහය අවබෝධ කර ගැනීම) අතිශයින් දුෂ්කර කිරීමකි, මන්ද ලේබලය අසල කිසිදු පාලනයක් අභිරහස් ලෙස වැඩසටහනේ වෙනත් ස්ථානයකට පනින බවට කිසිදු සාක්ෂියක් නොමැති බැවිනි.

ඇත්ත වශයෙන්ම භාෂා අංගයක් නොව ක්‍රියාත්මක කිරීමේ දෝෂයකි: සමහර මුල් ෆෝට්රාන් සම්පාදකයින් නියත සංචිතයක් භාවිතා කරමින් නියතයන් ක්‍රියාත්මක කළහ. සියලුම පරාමිතීන් යොමු කර ඇත. ඔබ ශ්‍රිතයක් හැඳින්වූයේ නම්, උදා

f(1)

සම්පාදකයා නියත තටාකයේ නියත 1 හි ලිපිනය ශ්‍රිතයට ලබා දෙනු ඇත. ශ්‍රිතයේ පරාමිතියට ඔබ අගයක් ලබා දුන්නේ නම්, ඔබ වැඩසටහනේ ගෝලීය වශයෙන් අගය (මේ අවස්ථාවේ දී 1 හි අගය) වෙනස් කරනු ඇත. හිස සීරීමට හේතු විය.

එය භාෂා අංගයක් ලෙස සැලකිය හැකිදැයි නොදනී, නමුත්, C ++ හි සැකිලි හා සම්බන්ධ ඕනෑම සම්පාදක දෝෂයක් පාහේ ලොව පුරා බොහෝ C ++ ක්‍රමලේඛකයින්ට WTF සාධාරණ ප්‍රමාණයක් ලබා දෙයි :)

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);
}

පයිතන්හි මුළු සුදු අවකාශයම මගේ විශාලතම WTF ලක්ෂණය යැයි මම කියමි. ටික කලකට පසු ඔබ වැඩි වැඩියෙන් හෝ අඩුවෙන් පුරුදු වී සිටින අතර නවීන කතුවරුන් සමඟ ගනුදෙනු කිරීම පහසු කරයි, නමුත් පසුගිය වසර පුරා බොහෝ විට පූර්ණ කාලීන පයිතන් සංවර්ධනයෙන් පසුව පවා එය නරක අදහසක් බව මට තවමත් ඒත්තු ගොස් තිබේ. මම එහි පිටුපස ඇති සියලු තර්ක කියවා ඇත්තෙමි, නමුත් අවංකවම, එය මගේ tivity ලදායිතාවයට මග පාදයි. වැඩි වශයෙන් නොවේ, නමුත් එය තවමත් සෑදලය යට බර් ය.

සංස්කරණය කරන්න: අදහස් දැක්වීමෙන් විනිශ්චය කිරීම, සමහර අය සිතන්නේ මගේ කේතය ඇතුල් කිරීමට මා අකමැති බවයි. එය වැරදි තක්සේරුවකි. කුමන භාෂාව සහ මට බල කළත් නැතත් මම සෑම විටම මගේ කේතය ඇතුල් කළෙමි. මා අකමැති දෙය නම් කේත රේඛාවක් තිබෙන්නේ කුමන අවහිරයක්ද යන්න නිර්වචනය කරන්නේ ඉන්ඩෙන්ටේෂන් වීමයි. ඒ සඳහා මම පැහැදිලි පරිසීමකයන්ට කැමැත්තෙමි. වෙනත් හේතු අතර, පැහැදිලි පරිසීමක මඟින් කේතය කැපීම හා ඇලවීම පහසු කරයි.

නිදසුනක් ලෙස, මා සතුව අවකාශ 4 ක් ඇතුල් කර ඇති අතර එය අවකාශ 8 ක් ඇතුලත් කර ඇති බ්ලොක් එකක් අවසානයේ අලවන්න, මගේ සංස්කාරකවරයාට (සියලුම සංස්කාරකවරුන්ට) පේස්ට් කේතය අවකාශ 8 ක කොටසකට හෝ පිටතට අයත් දැයි අදහසක් නැත. වාරණය. OTOH, මා සතුව පැහැදිලි පරිසීමක තිබේ නම්, කුමන කේතය අයත් වන්නේද යන්න සහ එය නැවත ඇතුල් කළ යුත්තේ කෙසේද යන්න පැහැදිලිය - එය එසේ කරන්නේ බුද්ධිමත්ව බ්ලොක් පරිසීමක සොයමින් ය.

2 වන සංස්කරණය: අදහස් දක්වන සමහර අය මෙය මා පිළිකුල් කරන අංගයක් යැයි සිතන බවක් හෝ පයිතන් දුර්වල භාෂාවක් බවට පත් කරන බව මම සිතමි. නැවතත්, සත්‍ය නොවේ. මම ඒ සියල්ලට එතරම් අකමැති වුවත්, එය කාරණය පසෙකින් තිබේ. ප්‍රශ්නය වන්නේ අමුතුම භාෂා ලක්ෂණය ගැන වන අතර , මෙය අමුතු දෙයක් යැයි මම සිතමි, එය ඉතා සුළු (නමුත්> 0) භාෂා භාවිතා කරන දෙයක් වීම නිසා.

මම මේ ගැන ටිකක් වෙහෙසුණා:

1;

පර්ල් වලදී, මොඩියුලයන් සත්‍ය දෙයක් ආපසු ලබා දිය යුතුය .

විෂුවල් බේසික් හි 7 ලූප ඉදිකිරීම් ගැන කිසිවෙකු සඳහන් නොකිරීම ගැන මම පුදුම වෙමි .

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) ඉවත්වීම" bc අවසන් වීමට හේතු වේ.

halt : halt statement (දිගුවක්) යනු ක්‍රියාත්මක කරන ලද ප්‍රකාශයක් වන අතර එමඟින් bc ප්‍රොසෙසරය ක්‍රියාත්මක වන්නේ එය ක්‍රියාත්මක වූ විට පමණි. උදාහරණයක් ලෙස, "if (0 == 1) නැවතුම" නතර කිරීම ක්‍රියාත්මක නොවන නිසා bc අවසන් වීමට හේතු නොවේ.

සරලම වැඩසටහන කුමක්දැයි මම නිතරම කල්පනා කළෙමි:

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

එය විය හැකි නමුත්:

print "Hello World!"

සමහර විට මෙය පරිගණක විද්‍යා සිසුන් මුලින් බිය ගැන්වීමට විය හැකිය ...

ජාවාස්ක්‍රිප්ට් වස්තු නැඹුරු, නේද? එබැවින් වචනාර්ථයෙන් නූල් සහ සංඛ්‍යා මත ධාවනය වන ක්‍රම ක්‍රියාත්මක විය යුතුය. වගේ "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] ඇයි?

මගේ ලොකුම වෛරයට ලක්වූ ලක්ෂණය වන්නේ කොන්දේසිගත තර්කනය ඇතුළත් ඕනෑම වින්‍යාස ගොනු සින්ටැක්ස් ය. ජාවා ලෝකයේ මේ ආකාරයේ දේවල් බහුලව දක්නට ලැබේ (කුහුඹුවා, මේවන්, ආදිය. ඔබ කවුදැයි ඔබ දන්නවා!).

සීමිත නිදොස්කරණය සහ සීමිත සංස්කාරක සහාය ඇතිව ඔබ ac ** p භාෂාවෙන් ක්‍රමලේඛනය අවසන් කරයි.

ඔබේ වින්‍යාසය තුළ ඔබට තර්කනයක් අවශ්‍ය නම්, නියම භාෂාවකින් වින්‍යාසය කේතනය කිරීමේ “පයිතොනික්” ප්‍රවේශය වඩා හොඳය.

powerbasic (www.powerbasic.com) ට සම්පාදක නියෝගය ඇතුළත් වේ:

# BLOAT {bloatsize}

මෙය <bloatsize>බයිට් මගින් සම්පාදනය කළ හැකි ප්‍රමාණය වැඩි කරයි . ක්‍රියාත්මක කළ හැකි නිර්මාණය කරන පුද්ගලයින් උත්පාදනය කළ හැකි ක්‍රියාත්මක කළ හැකි කුඩා ප්‍රමාණයට අකමැති නම් මෙය සම්පාදකයා තුළට දමා ඇත. එය ඉදිමුණු ක්‍රමලේඛන භාෂාවන් සමඟ තරඟ කිරීමට EXE විශාල බව පෙනේ :)