Il tuo compito è semplice. Scrivi un programma che ovviamente dovrebbe produrre un errore a prima vista o quando compilato o eseguito, ma non lo fa o produce qualche altro errore non correlato. Questo è un concorso di popolarità, quindi sii creativo.

C ++

Assicurati di compilare il seguente codice in modalità conforme standard (ad esempio, per g ++ usa il flag -ansi):

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

Come funziona:

?? / è una sequenza trigraph che viene tradotta in una barra rovesciata che sfugge alla nuova riga successiva, quindi la riga successiva fa ancora parte del commento e quindi non genererà un errore di sintassi. Si noti che in C ++, omettere il ritorno in mainè ben definito ed equivale a restituire 0, indicando una corretta esecuzione.

Rubino

Sempre un fan di questo.

x = x

No NameError. x è ora nil.

Questa è solo una "caratteristica" di Ruby :-)

Eccone uno più banale che mi ha ottenuto prima:

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 

Stampa "niente da vedere qui".

E ' ELSIF , non elseif . (e certamente non è elif - guai al programmatore python ribelle (me)!) Quindi per l'interprete elseif sembra una normale chiamata di metodo, e poiché non entriamo nel blocco x <0, andiamo direttamente su else e non sollevare un'eccezione. Questo bug è incredibilmente evidente in qualsiasi ambiente che evidenzi la sintassi, per fortuna (?) Il codice golf non è un tale ambiente.

C?

Codice abbastanza normale qui ...

void main() = main--;

È Haskell, non C. Definisce una funzione chiamata "void" che accetta due argomenti. Il primo si chiama "principale" e se il secondo (senza nome) è una tupla vuota, restituisce la variabile "principale". "-" inizia un commento in Haskell, quindi il ";" è commentato.

JavaScript

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

Ecco come funziona:

Il primo aè in realtà un а(cioè Cryllic Unicode "a").

JavaScript

Quando stavo fornendo il seguente codice mi è stato detto molte volte "Deve essere un refuso! Come può funzionare?" .

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

La descrizione che segue è stata copiata esattamente da uno dei casi recenti .

Come probabilmente saprai, in JavaScript tutto tranne i letterali è un oggetto. Anche i numeri sono oggetti. Quindi teoricamente (e praticamente) puoi ottenere proprietà o chiamare metodi di qualsiasi non letterale tramite notazione punto, come fai tu 'string'.lengtho [1,2,3].pop(). In caso di numeri puoi fare lo stesso ma dovresti tenere presente che dopo un singolo punto il parser cercherà una parte frazionaria del numero aspettandosi un valore float (come in 123.45). Se si utilizza un numero intero si dovrebbe "raccontare" il parser che una parte frazionaria è vuoto, l'impostazione di un punto in più prima di affrontare una proprietà: 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

risultati

• Potresti aspettarti che lo script non produca alcun errore, poiché esce dopo il primo comando. Non

• Potresti aspettarti i tipici messaggi di errore causati da una bomba a forcella in corso a causa del forloop. Non c'è bomba a forcella.

• Potresti aspettarti che bash si lamenti del maybecomando mancante o dell'intero gruppo di errori di sintassi all'interno del ifblocco. Non lo farà.

• L'unico messaggio di errore che lo script potrebbe generare termina 2: No such file or directory.

Spiegazione

• [non è speciale per bash, quindi < 2esegue, come al solito, il reindirizzamento. A meno che non ci sia un file con nome 2nella directory corrente, ciò causerà un errore.

• A causa dell'errore sopra riportato, il comando precedente &&avrà uno stato di uscita diverso da zero e exitnon verrà eseguito.

• Il forciclo non è infinito. In effetti, non esiste alcun loop. Poiché bash non può calcolare la 64a potenza di 2, il risultato dell'espressione aritmetica è 0.

• [[ false ]]verifica se falseè una stringa nulla. Non lo è, quindi questo whileciclo è infinito.

• A causa di quanto sopra, l' ifistruzione non viene mai eseguita, quindi non vengono rilevati errori.

Perl

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

Fonte e spiegazione: https://stackoverflow.com/questions/11695110

Giava

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

Nessuno stack trabocca qui; andare avanti.

A prima vista, questo dovrebbe produrre un StackOverflowError, ma non lo fa! In realtà funziona solo per sempre (almeno per tutti gli scopi pratici; tecnicamente terminerebbe dopo un tempo molti ordini di grandezza più lunghi dell'età dell'universo). Se vuoi sapere come / perché funziona, vedi questo . Inoltre, se ti capita di chiederti perché possiamo chiamare main()senza argomenti quando il metodo principale in genere avrebbe bisogno di un String[]argomento: è perché qui l'abbiamo dichiarato argomento variabile, il che è perfettamente valido.

CoffeeScript

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

?seguito da uno spazio è un operatore che chiama una funzione, ma solo se esiste. JavaScript non ha una funzione chiamata What, quindi la funzione non viene chiamata e i suoi argomenti vengono semplicemente ignorati. Le altre parole nel codice sono chiamate di funzione che in realtà non sono chiamate, perché la Whatfunzione non esiste. Alla fine, ?è operatore operatore, in quanto non viene utilizzato nella funzione di chiamata. Altri terminatori di frasi, come .o !non funzionano, come .per i metodi, e !non sono operatori (che non possono essere utilizzati dopo un identificatore). Per leggere come CoffeeScript ha convertito questo in JavaScript, visitare http://coffeescript.org/#try:What%3F%20No%20error%3F%20Yep%2C%20this%20code%20does%20not%20have%20any%20bugs%2C % 20why% 20it% 20would% 3F .

VBScript

L' &operatore in VBScript è la concatenazione di stringhe ma cosa diavolo sono gli operatori &&e &&&? (Ricorda che l'operatore "e" in VBScript Andnon lo è &&.)

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

Quel frammento di programma è VBScript legale. Perché? E qual è il valore di x?

Il lexer lo scompone come x = 10 & 987 & &654& & &321. Un letterale intero che inizia con &è, stranamente, un letterale ottale. Un letterale ottale che termina con &è, ancora più stranamente, un numero intero lungo. Quindi il valore di x è la concatenazione dei valori decimali di quei quattro numeri interi: 10987428209.

Objective-C

Non è un grosso problema, ma mi ha sorpreso mentre cercavo di inserire un link all'interno di un commento:

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

http è un'etichetta di codice qui, tali etichette vengono utilizzate nelle istruzioni goto

C #

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

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

Poiché il Barmetodo esegue un yield, il metodo non viene effettivamente eseguito quando viene chiamato, restituisce un enumeratore che, quando ripetuto, esegue il metodo.

C

main=195;

Funziona su piattaforme x86, dove 195 è il codice operativo per ret. Non fa nulla,

Giava

Probabilmente troppo ovvio.

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

Che cosa?

Genera un errore di sintassi dopo \u000d. \u000dè l'unicode per una nuova linea. Anche se è commentato, il compilatore Java tratta ciò che è dopo come codice poiché non è più commentato.

C ++

#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';
}

Perché?

NULLè una costante intergal, quindi corrisponde al intsovraccarico strettamente migliore di int*quello. Tuttavia, la maggior parte dei programmatori si è NULLassociata ai puntatori, quindi ci si può aspettare una dereferenza del puntatore nulla.

Pitone

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

Perfettamente valido, ma l'output è difficile da indovinare. I primi 3 "caratteri iniziano una stringa multilinea e i successivi due fanno parte della stringa. Alla fine, i primi tre" terminano la stringa e gli ultimi due sono una stringa vuota letterale che viene concatenata dal parser alla stringa multilinea .

JavaScript

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

Come funziona:

C'è infinito positivo e negativo in JS e nessun errore per la divisione per zero.

C ++

Mescolare trigrafi e lambda senza spazio può essere abbastanza confuso e sicuramente apparire errato per le persone che non sono a conoscenza delle trigrafi:

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

Come funziona:

Alcune sequenze composte da 3 simboli, che iniziano con ??, sono chiamate trigrafi e saranno sostituite da un preprocessore completamente conforme. Preelaborata, la riga in questione appare come segue: return ~ [] () {return "\ x00FF"; } () [0]; Come si può vedere, questo non è altro che una funzione lambda superflua che restituisce una stringa composta dal carattere 0xFFth. Il [0] solo estrae quel personaggio e ~ NOTs, quindi viene restituito 0.

VBA / VB6

Private Sub DivByZero()

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

    Debug.Print 1 / UBound(x)

End Sub

La divisione di una stringa delimitata da virgole vuote dovrebbe fornire una matrice vuota. Dovrebbe esserci un'ovvia divisione per zero errori, giusto?

No. Sorprendentemente, quando una stringa di lunghezza zero viene divisa, il runtime fornisce un array con un limite inferiore di 0 e un limite superiore di -1. Il codice sopra mostrerà -1.

Javascript

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

Dà: 5

Mentre:

5.toString();

Fornisce SyntaxError

Come funziona:

JavaScript tenta di analizzare il punto su un numero come letterale in virgola mobile

HTML

Primo post qui, non sono sicuro di avere questo o no, ma qui va.

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

È un .htmlfile ...

PHP (40 byte)

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

Questa è stata la risposta che ho dato a questa domanda: Insanity Check Program

L'idea era di creare un codice che producesse errori.

Il primo errore a cui penseremo è un errore di sintassi.

Non ci sono errori di sintassi ...

Altro sarebbe che la classe / funzione non esiste.

Non va così lontano ...

Altro sarebbe un timeout o un overflow della memoria, ma, di nuovo, non raggiunge così lontano ...

Prova qui il codice: http://writecodeonline.com/php/ (rimuovi <?all'inizio per testare).

VBScript

Gli utenti di Visual Basic 6 lo sapranno

If Blah Then Foo Bar

è legale così com'è

If Blah Then 
    Foo Bar
End If

Ma per quanto riguarda

If Blah Then Foo Bar End If

? Si scopre che è legale in VBScript ma non in VB6. Perché?

È un bug nel parser; l'intenzione era di respingerlo. Il codice che rileva il End Ifdoveva anche verificare se si trattava di Ifun'istruzione multilinea , e non lo fece. Quando ho provato a risolverlo e ho inviato una versione beta con la correzione, una certa influente organizzazione di notizie del settore ha scoperto che avevano questa linea di codice in uno dei loro programmi VBScript e ha detto che avrebbero dato alla nuova versione un punteggio basso a meno che non avessimo annullato- corretto il bug, perché non volevano cambiare il loro codice sorgente.

C

Questo mi ha ricordato un errore che ho riscontrato quando ho appreso C. Purtroppo la variante originale non sembra funzionare con un GCC corrente, ma questo continua a:

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

Questo ovviamente segfault perché dereferenziamo un puntatore nullo, giusto?

Sbagliato - in realtà, è un loop infinito poiché la nostra condizione di loop è disattivata da uno. A causa del decremento del prefisso, iva da 1023 a -1. Ciò significa che l'assegnazione sovrascrive non solo tutti gli elementi arr, ma anche la posizione della memoria direttamente prima di esso, che risulta essere il luogo in cui iè memorizzato. Al raggiungimento -1, si isovrascrive 0e quindi la condizione del loop viene nuovamente soddisfatta ...

Questa era la variante originale I che non riesco più a riprodurre:

La stessa cosa ha funzionato iandando verso l'alto da 0 e rimanendo fuori di uno. L'ultimo GCC viene sempre archiviato iprimaarr in memoria; questo deve essere stato diverso nelle versioni precedenti (forse a seconda dell'ordine di dichiarazione). È stato un vero errore che ho prodotto in uno dei miei primi programmi di giocattoli relativi alle matrici.

Inoltre, questo è ovvio se sai come funzionano i puntatori in C, ma può essere sorprendente se non lo fai:

Potresti pensare che l'assegnazione a (--i)[arr]genera un errore, ma è valida ed equivalente a arr[--i]. Un'espressione a[x]è solo zucchero sintattico per il *(a + x)quale calcola e dereferenzia il puntatore all'elemento indicizzato; l'aggiunta è ovviamente commutativa e quindi equivalente a *(x + a).

Giava

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

Perché questo funziona:

I campi unitizzati hanno valori predefiniti. In questo caso d è solo 0 . 0/0 = NaN in doppia divisione e NaN non è mai uguale a se stesso, quindi if restituisce false. Nota che questo non funzionerebbe se tu avessi 0/0 == 0/0 , poiché at sarebbe una divisione 0/0 intera che DOVREBBE lanciare un'eccezione aritmetica .

C ++ 11

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

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

Compilare ed eseguire senza alcun avviso con g++ -pedantic-errors -std=c++11.

complè un'ortografia alternativa standard per ~, proprio come notè un'alternativa per !. complviene utilizzato qui per sovrascrivere operator~e quindi definire un distruttore. Un altro trucco è che operator compè una funzione di conversione dal tipo compa se stesso. Sorprendentemente lo standard non proibisce una tale funzione di conversione, ma afferma che tale funzione non viene mai utilizzata.

VBScript

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

'Output: :)

Cosa fa:

I nomi di funzioni, sottotitoli e variabili in VBScript possono essere qualsiasi cosa se si usano parentesi quadre. Questo script crea una funzione chiamata :(e un argomento "):"ma poiché non seguono la normale convenzione di denominazione sono racchiusi tra parentesi quadre. Il valore restituito è impostato sul valore del parametro. Un altro punto viene utilizzato per ottenere tutto su una riga. L'istruzione Msgbox ottiene un riferimento alla funzione (ma non ha bisogno delle parentesi quadre) e la chiama con uno smiley :)come parametro.

C #

In realtà mi sono preso per sbaglio facendo proprio questo :)

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

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

lanciare , non tornare .

Giava

enum derp
{

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

E come funziona:

Innanzitutto pensi che l'Enum non sia valido ma valido; allora pensi che stamperà gli attributi standard di un oggetto Point ma Gotcha! a causa della serializzazione di Snakeyaml viene visualizzato un errore StackOverFLow regolare

E un altro:

enum derp
{

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

    static
    {
        System.exit(x);
    }
}

pensi che uno StackOverflow accadrà a causa dell'ovvia ricorsione, ma il programma abusa del fatto che quando lo esegui static{} blockverrà eseguito per primo e quindi uscirà prima che il main () venga caricato

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

questo si basa su quel /*Error*/codice commentato come punto di chiusura per il commento aperto prima di ab = 0; la spiegazione dell'intero ab a 0x000d nasconde la nuova riga per attivare il commento della riga successiva

C

Stringhe e array in c possono essere piuttosto confusi

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