ඔබේ කාර්යය සරලයි. බැලූ බැල්මට දෝෂයක් සම්පාදනය කරන විට හෝ ක්‍රියාත්මක වන විට පැහැදිලිවම දෝෂයක් ඇති කළ හැකි නමුත් වෙනත් සම්බන්ධයක් නැති දෝෂයක් ඇති නොකරයි. මෙය ජනප්‍රිය තරගයක් බැවින් නිර්මාණශීලී වන්න.

සී ++

පහත දැක්වෙන කේතය සම්මත අනුකූලතා ආකාරයෙන් සම්පාදනය කරන බවට වග බලා ගන්න (නිදසුනක් ලෙස, g ++ සඳහා -ansi ධජය භාවිතා කරන්න):

int main()
{
  // why doesn't the following line give a type mismatch error??/
  return "success!";
}

එය ක්‍රියාත්මක වන ආකාරය:

?? / යනු ත්‍රිමාණ අනුක්‍රමයක් වන අතර එය බැක්ස්ලෑෂ් බවට පරිවර්තනය කර ඇති අතර එය පහත දැක්වෙන නව රේඛාවෙන් ගැලවී යයි, එබැවින් ඊළඟ පේළිය තවමත් විවරණයේ කොටසක් වන අතර එම නිසා සින්ටැක්ස් දෝෂයක් ජනනය නොවේ. C ++ හි, නැවත පැමිණීම මඟ හැරීම mainමනාව අර්ථ දක්වා ඇති අතර එය 0 නැවත පැමිණීමට සමාන වේ.

රූබි

සෑම විටම මෙම රසිකයෙක්.

x = x

නැත NameError. x දැන් nil.

මෙය රූබිගේ "අංගයක්" පමණි :-)

මෙන්න මීට පෙර මා ලබාගත් තවත් ලෞකික එකක්:

x = 42

if x < 0
  raise Exception, "no negatives please"
elseif x == 42
  raise Exception, "ah! the meaning of life"
else  
  p 'nothing to see here...'
end 

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

ඒක elsif නැහැ, elseif . (සහ එය නිසැකව නෑ elif ! - විපතක මහත හිතුවක්කාර පිඹුරා ක්රමලේඛකයෙක් (මට) වෙත) ඒ නිසා පරිවර්ථකයා elseif සාමාන්ය ක්රමය තිබෙන්නේ ඒ වගේ පෙනුම, අපි x ඇතුල් වෙන්න එපා <0 වාරණ සිට, අප වෙත කෙළින්ම යන්න වෙන හා ව්යතිරේකයක් මතු නොකරන්න. ඕනෑම සින්ටැක්ස් ඉස්මතු කරන පරිසරයක මෙම දෝෂය ඇදහිය නොහැකි තරම් පැහැදිලිව පෙනේ, ස්තූතිවන්ත වන (?) කේත ගොල්ෆ් එවැනි පරිසරයක් නොවේ.

සී?

මෙහි සාමාන්‍ය කේතය ...

void main() = main--;

එය හස්කල් මිස සී නොවේ. එය තර්ක දෙකක් ගන්නා "අවලංගු" නම් ශ්‍රිතයක් අර්ථ දක්වයි. පළමුවැන්න "ප්‍රධාන" ලෙස නම් කර ඇති අතර දෙවැන්න (නම් නොකල) හිස් ගෙඩියක් නම්, එය "ප්‍රධාන" විචල්‍යය ලබා දෙයි. "-" හස්කල් හි අදහස් දැක්වීමක් ආරම්භ කරයි, එබැවින් ";" අදහස් දක්වා ඇත.

ජාවාස්ක්‍රිප්ට්

var а = 100;
if (typeof a !== 'undefined') throw 'This should always throw, right?';
console.log('How am I still alive?');

එය ක්‍රියාත්මක වන ආකාරය මෙන්න:

පළමුවැන්න aසැබවින්ම а(එනම්, ක්‍රිලික් යුනිකෝඩ් "අ") ය.

ජාවාස්ක්‍රිප්ට්

මම පහත කේතය ලබා දෙන විට මට බොහෝ විට පවසා ඇත්තේ "එය අක්ෂර වින්‍යාසයක් විය යුතුයි! එය ක්‍රියා කරන්නේ කෙසේද?" .

console.log( 42..toString(2) );

පහත විස්තරය හරියටම මෑත සිදුවීම් වලින් පිටපත් කරන ලදි .

ඔබ බොහෝ විට දන්නා පරිදි, ජාවාස්ක්‍රිප්ට් හි වචනාර්ථයන් හැර අන් සියල්ලම වස්තුවකි. ඉලක්කම් යනු වස්තූන් ද වේ. ඒ නිසා, න්යායිකව (සහ ප්රායෝගිකව) ඔබ මෙන්, තිතක් අංකනය හරහා ඕනෑම ප්රායෝගික අසම්පූර්ණ ගුණ හෝ ඇමතුමක් ක්රම ලබා ගැනීමට හැකි වනු ඇත 'string'.lengthහෝ [1,2,3].pop(). සංඛ්‍යා සම්බන්ධයෙන් ඔබට එයම කළ හැකි නමුත් ඔබ මතක තබා ගත යුතු කරුණක් නම් එක් තිතකට පසුව විග්‍රහ කරන්නා පාවෙන අගයක් අපේක්ෂා කරන සංඛ්‍යාවෙන් භාගයක් සොයනු ඇත (මෙන් 123.45). ඔබ පූර්ණ සංඛ්‍යාවක් භාවිතා කරන්නේ නම්, භාගික කොටසක් හිස් බව ඔබ පාර්සර්ට "පැවසිය යුතුය", දේපලක් ඇමතීමට පෙර අමතර තිතක් සකසන්න : 123..method().

bash

#!/bin/bash

[ 1 < 2 ] && exit

for i in `seq 1 $[2 ** 64]`
    do "$0" | "$0"
done

while [[ false ]]
    do :
done

if maybe
    do [: [: [: [: [; [; [; [; ;] ;] ;] ;] :] :] :] :]
fi

ප්රතිපල

• පළමු විධානයෙන් පසුව පිටවන බැවින් ස්ක්‍රිප්ට් කිසිදු දෝෂයක් ඇති නොවනු ඇතැයි ඔබ අපේක්ෂා කළ හැකිය. එය එසේ නොවේ.

• forලූපය හේතුවෙන් අඛණ්ඩ දෙබලක බෝම්බයක් නිසා සිදුවන සාමාන්‍ය දෝෂ පණිවිඩ ඔබ අපේක්ෂා කළ හැකිය . ෆෝක් බෝම්බයක් නැත.

• අතුරුදහන් වූ maybeවිධානය ගැන හෝ ifබ්ලොක් තුළ ඇති සින්ටැක්ස් දෝෂය ගැන බාෂ් පැමිණිලි කරනු ඇතැයි ඔබ අපේක්ෂා කළ හැකිය . එය එසේ නොවේ.

• ස්ක්‍රිප්ට් නිපදවිය හැකි එකම දෝෂ පණිවිඩය අවසන් වේ 2: No such file or directory.

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

• [පහර දීමට විශේෂ නොවේ, එබැවින් < 2සුපුරුදු පරිදි යළි හරවා යැවීම සිදු කරයි. 2වත්මන් නාමාවලියෙහි නම සහිත ගොනුවක් නොමැති නම් , මෙය දෝෂයක් ඇති කරයි.

• ඉහත දෝෂය හේතුවෙන්, පෙර විධානයට &&ශුන්‍ය නොවන පිටවීමේ තත්වයක් ඇති අතර exitඑය ක්‍රියාත්මක නොවේ.

• මෙම forලූපය අනන්ත නොවේ. ඇත්ත වශයෙන්ම, කිසිදු ලූපයක් නොමැත. 2 හි 64 වන බලය ගණනය කිරීමට බැෂ් හට නොහැකි බැවින්, අංක ගණිත ප්‍රකාශනයේ ප්‍රති result ලය වේ 0.

• [[ false ]]පරීක්ෂණ falseශුන්‍ය නූලක් නම්. එය එසේ නොවේ, එබැවින් මෙම whileලූපය අනන්තය.

• ඉහත නිසා, ifප්‍රකාශය කිසි විටෙකත් ක්‍රියාත්මක නොවන බැවින් කිසිදු දෝෂයක් අනාවරණය නොවේ.

පර්ල්

use strict;
use warnings;
Syntax error!
exit 0;

මූලාශ්‍රය සහ පැහැදිලි කිරීම: /programming/11695110

ජාවා

class Gotcha {
    public static void main(String... args) {
        try  {
            main();
        } finally {
            main();
        }
    }
}

මෙහි තොග පිටාර ගැලීමක් නොමැත; ඉදිරියට යන්න.

බැලූ බැල්මට, මෙය නිපදවිය යුතුය StackOverflowError, නමුත් එය එසේ නොවේ! එය සැබවින්ම සදහටම ක්‍රියාත්මක වේ (සියලු ප්‍රායෝගික අරමුණු සඳහා අවම වශයෙන්; තාක්‍ෂණිකව එය විශ්වයේ වයසට වඩා විශාල ප්‍රමාණයේ ඇණවුම් කාලයකට පසු අවසන් වේ). ඔබ / ඇයි මේ ක්රියා ආකාරය දැන ගැනීමට අවශ්ය නම්, බලන්න මේ . එසේම, main()ප්‍රධාන ක්‍රමයට සාමාන්‍යයෙන් String[]තර්කයක් අවශ්‍ය වූ විට අපට තර්ක නොමැතිව ඇමතිය හැක්කේ මන්දැයි ඔබ කල්පනා කරන්නේ නම් : එයට හේතුව අප එය මෙහි විචල්‍ය-තර්කයක් ලෙස ප්‍රකාශයට පත් කර ඇති නිසාය.

කෝපි ස්ක්‍රිප්ට්

What? No error? Yep, this code does not have any bugs, why would it?

?අවකාශයක් අනුගමනය කිරීමෙන් ශ්‍රිතයක් කැඳවන ක්‍රියාකරු වේ, නමුත් එය පවතින්නේ නම් පමණි. ජාවාස්ක්‍රිප්ටයට Whatශ්‍රිතයක් නැත, එබැවින් ශ්‍රිතය කැඳවනු නොලැබේ, සහ එහි තර්ක සරලව නොසලකා හරිනු ලැබේ. කේතයේ ඇති අනෙක් වචන වන්නේ ක්‍රියාකාරී ඇමතුම් Whatනොවේ. ?ඇමතුම් ශ්‍රිතයේ භාවිතා නොවන බැවින් අවසානයේ, පැවැත්ම ක්‍රියාකරු වේ. ක්‍රම සඳහා වන පරිදි ක්‍රියා කරන .හෝ ක්‍රියා !නොකරන වෙනත් වාක්‍ය අවසන් කරන්නන් ක්‍රියාකරු නොවේ (හඳුනාගැනීමෙන් පසුව භාවිතා කළ නොහැක). කෝපි ස්ක්‍රිප්ට් මෙය ජාවාස්ක්‍රිප්ට් බවට පරිවර්තනය කළේ කෙසේදැයි කියවීමට, http://coffeescript.org/#try:What%3F%20No%20error%3F%20Yep%2C%20this%20code%20does%20not%20have%20any%20bugs%2C වෙත පිවිසෙන්න. % 20why% 20it% 20would% 3F ..!

VBScript

&VBScript හි ක්‍රියාකරු නූල් සම්මුතියකි, නමුත් පෘථිවියේ &&සහ &&&ක්‍රියාකරුවන් යනු කුමක්ද? (ඔබට මතක ඇති VBScript දී "සහ" ක්රියාකරු බව ය Andනොව, &&.)

x = 10&987&&654&&&321

එම වැඩසටහන් කොටස නීත්‍යානුකූල VBScript වේ. මන්ද? එහි වටිනාකම xකුමක්ද?

ලෙක්සර් මෙය බිඳ දමයි x = 10 & 987 & &654& & &321. ආරම්භ වන පූර්ණ සංඛ්‍යා වචනාර්ථයෙන් &, අශෝභන ලෙස, අෂ්ටක වචනාර්ථයකි. අවසන් වන අෂ්ටාංශික &වචනය ඊටත් වඩා විකාර සහගත ලෙස දිගු නිඛිලයකි. එබැවින් x හි අගය යනු එම නිඛිල හතරේ දශම අගයන්හි සංක්ෂිප්තකරණයයි : 10987428209.

පරමාර්ථය-සී

ලොකු දෙයක් නොවේ, නමුත් අදහස් දැක්වීමක් තුළ සබැඳියක් තැබීමට උත්සාහ කරන අතරතුර එය මා පුදුමයට පත් කර ඇත:

http://www.google.com
        return 42;

http යනු මෙහි කේත ලේබලයකි, එවැනි ලේබල් ගොටෝ උපදෙස් වල භාවිතා වේ

සී #

class Foo
{
    static void Main(string[] args)
    {
        Bar();
    }

    static IEnumerable<object> Bar()
    {
        throw new Exception("I am invincible!");
        yield break;
    }
}

Barක්‍රමවේදය a කරන නිසා, ක්‍රමය yieldකැඳවූ විට සැබවින්ම ක්‍රියාත්මක නොවන අතර, එය ගණනය කරන විට එය ගණනය කරන විට එය ක්‍රියාත්මක වේ.

සී

main=195;

X86 වේදිකා මත ක්‍රියා කරයි, එහිදී 195 යනු නැවත ලබා ගැනීම සඳහා වන ඔප්කෝඩයයි. කිසිවක් නොකරයි,

ජාවා

බොහෝ දුරට පැහැදිලිය.

public static void main(String[] varargs) throws Exception{
    char a, b = (char)Integer.parseInt("000d",16);
    // Chars have \u000d as value, so they're equal
    if(a == b){
        throw new Exception("This should be thrown");
    }
}

කුමක්ද?

සින්ටැක්ස් දෝෂයක් පසුව විසි කරයි \u000d. \u000dයනු නව රේඛාවක් සඳහා යුනිකෝඩයයි. එය අදහස් දැක්වුවද, ජාවා සම්පාදකයා මෙයින් පසුව ඇති දේ කේතයක් ලෙස සලකන්නේ එය තවදුරටත් අදහස් නොදක්වන බැවිනි.

සී ++

#include <iostream>

int succ(int x)
{
  return x + 1;
}

int succ(double x)
{
  return int(x + 1.0);
}

int succ(int *p)
{
  return *p + 1;
}

int main()
{
  std::cout << succ(NULL) << '\n';
}

මන්ද?

NULLඅන්තර්ගෝලීය නියතයක් වන බැවින් එය intඅධික බරට වඩා හොඳින් ගැලපේ int*. තවමත්, බොහෝ ක්‍රමලේඛකයින් NULLදර්ශකයන් සමඟ සම්බන්ධ වී ඇති බැවින් ශුන්‍ය දර්ශක විරූපණයක් අපේක්ෂා කළ හැකිය.

පයිතන්

print """""quintuple-quoted strings!"""""

පරිපූර්ණ ලෙස වලංගු වේ, නමුත් ප්‍රතිදානය අනුමාන කිරීම අපහසුය. පළමු 3 "අක්ෂර බහු රේඛාවක් ආරම්භ කරන අතර ඊළඟ දෙක නූලෙහි කොටසකි. අවසානයේ පළමු තිදෙනාගේ නූල අවසන් වන අතර අවසාන දෙක හිස් නූලකි. .

ජාවාස්ක්‍රිප්ට්

if (1/0 === -1/0) {
  throw "Surely there's an error in here somewhere...";
}

එය ක්‍රියාත්මක වන ආකාරය:

JS හි ධනාත්මක හා සෘණ අනන්තය ඇති අතර ශුන්‍යයෙන් බෙදීමේ කිසිදු දෝෂයක් නොමැත.

සී ++

ත්‍රිකෝණ සහ අවකාශය අඩු ලැම්බඩා මිශ්‍ර කිරීම තරමක් ව්‍යාකූල විය හැකි අතර ත්‍රිකෝණ ගැන නොදන්නා අයට අනිවාර්යයෙන්ම වැරදිසහගත ලෙස පෙනේ:

int main()
{
    return??-??(??)()??<return"??/x00FF";??>()??(0??);
}

එය ක්‍රියාත්මක වන ආකාරය:

?? වලින් ආරම්භ වන සංකේත 3 කින් සමන්විත සමහර අනුක්‍රමයන් ත්‍රිකෝණ ලෙස හැඳින්වෙන අතර ඒවා සම්පුර්ණයෙන්ම අනුකූල වන පෙර සැකසුම්කරුවෙකු විසින් ආදේශ කරනු ඇත. පෙර සැකසූ, ප්‍රශ්නාර්ථ රේඛාව පහත පරිදි පෙනේ: ආපසු ~ [] () {ආපසු "\ x00FF"; } () [0]; කෙනෙකුට පෙනෙන පරිදි, මෙය 0xFFth අක්ෂරයෙන් සමන්විත නූලක් ආපසු ලබා දෙන අතිරික්ත ලැම්බඩා ශ්‍රිතයක් මිස වෙන කිසිවක් නොවේ. මෙම [0] දැන් සාරය ස්වභාවය හා ඒ ~ එය, ඒ නිසා 0 ආපසු NOTs.

VBA / VB6

Private Sub DivByZero()

    Dim x() As String
    x = Split(vbNullString, ",")

    Debug.Print 1 / UBound(x)

End Sub

හිස් කොමාවකින් වෙන් කරන ලද නූලක් බෙදීමෙන් හිස් අරාවක් ලබා දිය යුතුය. ශුන්‍ය දෝෂයකින් පැහැදිලි බෙදීමක් විය යුතුයි නේද?

නෑ. පුදුමයට කරුණක් නම්, ඕනෑම ශුන්‍ය දිග නූලක් බෙදී ගිය විට ධාවන කාලය ඔබට 0 හි පහළ මායිමක් සහ -1 ඉහළ මායිමක් සහිත අරාවක් ලබා දෙයි. ඉහත කේතය ප්‍රතිදානය -1 වේ.

ජාවාස්ක්‍රිප්ට්

5..toString();
5 .toString();

ලබා දෙයි: 5

ෙකෙසේෙවතත්:

5.toString();

සින්ටැක්ස් දෝෂය ලබා දෙයි

එය ක්‍රියාත්මක වන ආකාරය:

ජාවාස්ක්‍රිප්ට් පාවෙන ලක්ෂ්‍යයක් ලෙස අංකයක් මත තිතක් විග්‍රහ කිරීමට උත්සාහ කරයි

HTML

මෙහි පළමු පෝස්ට් එක, මට මෙය ලැබුනද නැද්ද යන්න මට විශ්වාස නැත, නමුත් මෙහි යයි.

<html>
    <head></head>
    <body>
        <?php $_POST['non-existant'] = $idontexisteither ?>
    </body>
</html>

එය .htmlගොනුවක් ...

VBScript

දෘශ්‍ය මූලික 6 පරිශීලකයින් එය දැන ගනු ඇත

If Blah Then Foo Bar

නීත්‍යානුකූලයි

If Blah Then 
    Foo Bar
End If

නමුත් කුමක් ද?

If Blah Then Foo Bar End If

? එය VBScript හි නීත්‍යානුකූල නමුත් VB6 හි නොවේ. මන්ද?

එය විග්‍රහයේ දෝෂයකි; අභිප්‍රාය වූයේ මෙය ප්‍රතික්ෂේප කිරීමයි. එය හඳුනාගන්නා කේතය End Ifඑය බහු රේඛා Ifප්‍රකාශයක් දැයි පරීක්ෂා කළ යුතු අතර එය එසේ නොවීය. මම එය නිවැරදි කිරීමට උත්සාහ කර නිවැරදි කිරීම සමඟ බීටා යවන විට, එක්තරා බලගතු කර්මාන්ත ප්‍රවෘත්ති සංවිධානයක් ඔවුන්ගේ VBScript වැඩසටහනක මෙම කේත රේඛාව ඇති බව සොයා ගත් අතර, අප නොකියන්නේ නම් ඔවුන් නව අනුවාදයට අඩු ශ්‍රේණියක් ලබා දෙන බව පැවසීය. ඔවුන්ගේ ප්‍රභව කේතය වෙනස් කිරීමට ඔවුන්ට අවශ්‍ය නැති නිසා දෝෂය නිවැරදි කරන ලදි.

සී

මෙය මට සී.

#define ARR_SIZE 1234
int main() {
    int i = ARR_SIZE;
    int arr[ARR_SIZE];
    while(i >= 0) {
        (--i)[arr] = 0;
    }
    i = *(int*)0;
}

මෙය පැහැදිලිවම සෙග්ෆෝල්ට් වන්නේ අප ශුන්‍ය දර්ශකයක් අවලංගු කරන නිසා නේද?

වැරදියි - ඇත්ත වශයෙන්ම, එය අපගේ අසීමිත පුඩුවක් වන බැවින් එය අසීමිත පුඩුවක් වේ. උපසර්ගය අඩුවීම හේතුවෙන් i1023 සිට -1 දක්වා දිව යයි. මෙයින් අදහස් කරන්නේ පැවරුම තුළ ඇති සියලුම අංග arrපමණක් නොව මතක ස්ථානයට කෙලින්ම පෙර ලියන බවයි - එය iගබඩා කර ඇති ස්ථානය වේ. ළඟා වූ විට -1, iනැවත නැවත ලියන 0අතර එමඟින් ලූප් තත්ත්වය නැවත ඉටු වේ ...

මට තවදුරටත් ප්‍රතිනිෂ්පාදනය කළ නොහැකි මුල් ප්‍රභේදය මෙයයි:

i0 සිට ඉහළට ගොස් එකකින් off ත් වීමත් සමඟම එකම දේ ක්‍රියාත්මක විය. නවතම සහ ගල්ෆ් සෑම විටම ගබඩා iපෙර arrමතකයේ; මෙය පැරණි අනුවාදවල වෙනස් විය යුතුය (සමහර විට ප්‍රකාශන අනුපිළිවෙල අනුව). එය අරා සමඟ කටයුතු කරන මගේ පළමු සෙල්ලම් වැඩසටහනක නිපදවූ සත්‍ය දෝෂයකි.

එසේම, සී හි දර්ශකයන් ක්‍රියා කරන්නේ කෙසේදැයි ඔබ දන්නේ නම් මෙය පැහැදිලිව පෙනේ, නමුත් ඔබ එසේ නොකරන්නේ නම් පුදුම විය හැකිය:

පැවරුම (--i)[arr]දෝෂයක් ඇති කරයි යැයි ඔබ සිතනු ඇත , නමුත් එය වලංගු හා සමාන වේ arr[--i]. ප්‍රකාශනයක් a[x]යනු හුදෙක් සින්ටැක්ටික් සීනි වන *(a + x)අතර ඒ සඳහා දර්ශකය සුචිගත කරන ලද මූලද්‍රව්‍යයට ගණනය කරයි. එකතු කිරීම ඇත්ත වශයෙන්ම සංක්‍රමණික වන අතර ඒ හා සමාන වේ *(x + a).

ජාවා

public class WhatTheHeckException extends RuntimeException {
    private static double d;        // Uninitialized variable
    public static void main(String... args) {
        if (d/d==d/d) throw new WhatTheHeckException();
        // Well that should always be true right? == is reflexive!

        System.out.println("Nothing to see here...");
    }
}

මෙය ක්‍රියාත්මක වන්නේ ඇයි:

ඒකීයකරණය කළ ක්ෂේත්‍රවල පෙරනිමි අගයන් ඇත. මෙම අවස්ථාවේ දී d යනු 0 ක් පමණි . 0/0 = නන් ද්විත්ව අංශය, සහ නන් නිසා, තමන් සමාන නැහැ නම් ප්රතිලාභ බොරු. ඔබට 0/0 == 0/0 තිබුනේ නම් මෙය ක්‍රියා නොකරනු ඇති බව සලකන්න, පූර්ණ සංඛ්‍යා 0/0 බෙදීම මගින් අංක ගණිතමය ව්‍යතිරේකයක් විසි කරනු ඇත .

PHP (බයිට් 40)

<?for(;;$e.=$e++)foreach($e::$e()as&$e);

මෙම ප්‍රශ්නයේදී මා දුන් පිළිතුර මෙයයි: උමතුතා පරීක්‍ෂා කිරීමේ වැඩසටහන

අදහස වූයේ දෝෂ ඇති කරන කේතයක් සෑදීමයි.

අප සිතන පළමු දෝෂය සින්ටැක්ස් දෝෂයකි.

සින්ටැක්ස් දෝෂ නොමැත ...

අනෙක් කාරණය නම් පන්තිය / ශ්‍රිතය නොපවතින බවයි.

එය එතරම් දුර දිව යන්නේ නැත ...

අනෙක් ඒවා කල් ඉකුත් වීමක් හෝ මතක පිටාර ගැලීමක් වනු ඇත, නමුත් නැවතත්, එය එතරම් දුරට ළඟා නොවේ ...

මෙහි කේතය පරීක්ෂා කරන්න: http://writecodeonline.com/php/ ( <?පරීක්ෂා කිරීමට ආරම්භයේදීම ඉවත් කරන්න ).

සී ++ 11

struct comp {
    comp operator compl () { return comp { }; }
    operator comp () { return comp { }; }
    compl comp () { return; comp { }; }
};

int main() {
    comp com;
    compl com;
}

කිසිදු අනතුරු ඇඟවීමකින් තොරව සම්පාදනය කර ධාවනය කරයි g++ -pedantic-errors -std=c++11.

complසඳහා ප්රමිතියක් විකල්ප අක්ෂර වින්යාසය යනු ~වගේ, notසඳහා විකල්ප වේ !. complපළමුවෙන්ම අභිබවා operator~ගොස් විනාශකාරකයක් අර්ථ දැක්වීමට මෙහි භාවිතා වේ. තවත් උපක්‍රමයක් නම් operator compඑය වර්ගයේ compසිට තමාටම පරිවර්තනය කිරීමේ ශ්‍රිතයකි . පුදුමයට කරුණක් නම් ප්‍රමිතිය එවැනි පරිවර්තන ශ්‍රිතයක් තහනම් නොකරයි - නමුත් එය පවසන්නේ එවැනි ශ්‍රිතයක් කිසි විටෙකත් භාවිතා නොකරන බවයි.

VBScript

function[:(](["):"]):[:(]=["):"]:
end function
msgbox getref(":(")(":)")

'Output: :)

එය කරන්නේ කුමක්:

VBScript හි ක්‍රියාකාරිත්වය, උප සහ විචල්‍ය නම් ඔබ වර්ග වරහන් භාවිතා කරන්නේ නම් ඕනෑම දෙයක් විය හැකිය. මෙම ස්ක්‍රිප්ට් එක ශ්‍රිතයක් :(සහ එක් තර්කයක් සාදයි, "):"නමුත් ඒවා සාමාන්‍ය නම් කිරීමේ සම්මුතියක් අනුගමනය නොකරන නිසා ඒවා වර්ග වරහන් වලින් වටවී ඇත. ප්‍රතිලාභ අගය පරාමිති අගයට සකසා ඇත. සෑම දෙයක්ම එක පේළියකින් ලබා ගැනීම සඳහා අතිරේක බඩවැලක් භාවිතා කරයි. Msgbox ප්‍රකාශය ශ්‍රිතය පිළිබඳ සඳහනක් ලබා ගනී (නමුත් වරහන් අවශ්‍ය නොවේ) එය :)පරාමිති ලෙස සිනහවකින් අමතයි .

සී #

ඇත්තටම මම වැරදියට ඒක කරනවා කියලා මට තේරුණා :)

public static object Crash(int i)
{
    if (i > 0)
        return i + 1;
    else
        return new ArgumentOutOfRangeException("i");
}

public static void Main()
{
    Crash(-1);
}

විසි කරන්න , ආපසු නොඑන්න .

ජාවා

enum derp
{

    public static void main(String[] a)
    {
        System.out.println(new org.yaml.snakeyaml.Yaml().dump(new java.awt.Point()));
    }
}

එය ක්‍රියාත්මක වන ආකාරය:

එනූම් වලංගු නොවන නමුත් එය වලංගු යැයි ඔබ සිතන ආයතන; එවිට ඔබ සිතන්නේ එය සම්මත ලක්ෂ්‍ය වස්තු ගුණාංග මුද්‍රණය කරනු ඇති නමුත් ගොචා! Snakeyaml අනුක්‍රමිකව ක්‍රියා කරන නිසා ඔබට සුමට StackOverFLow දෝෂයක් ලැබෙනු ඇත

තවත් එකක්:

enum derp
{

    ;public static void main(String[] a)
    {
        main(a);
    }
    static int x = 1;

    static
    {
        System.exit(x);
    }
}

පැහැදිලි පුනරාවර්තනය හේතුවෙන් ස්ටැක් ඕවර් ප්‍රවාහයක් සිදුවනු ඇතැයි ඔබ සිතන නමුත් ඔබ එය ක්‍රියාත්මක කරන විට එය static{} blockමුලින්ම ක්‍රියාත්මක වන අතර ප්‍රධාන () පැටවීමට පෙර එය පිටවන නිසා වැඩසටහන අනිසි ලෙස භාවිතා කරයි.

enum derp
{

    ;
        public static void main(
            String[] a)
    {
        int aa=1;
        int ab=0x000d;
        //setting integer ab to \u000d  /*)
        ab=0;

        /*Error!*/
        aa/=ab;
    }
    static int x = 1;
}

/*Error*/ab = 0 ට පෙර විවෘත කළ අදහස් දැක්වීමේ අවසාන ලක්ෂ්‍යය ලෙස මෙය සංයුක්ත කළ කේතය මත රඳා පවතී ; 0x000d දක්වා වූ පූර්ණ සංඛ්‍යා පිළිබඳ පැහැදිලි කිරීම ඊළඟ පේළියේ විවරණය සක්‍රීය කිරීම සඳහා නව රේඛාව සඟවයි

සී

C හි ඇති නූල් සහ අරා සෑහෙන්න ව්‍යාකූල විය හැකිය

main(){
  int i=0;
  char string[64]="Hello world;H%s";
  while(strlen(&i++[string])){
    i[' '+string]=string[i]-' ';
  }
  5[string]=44;
  return printf(string,'!'+string);
}