Écrivez un programme ou une fonction avec les fonctionnalités suivantes:

• Le programme / fonction tente d'abord d'écrire la chaîne Hello, world!dans le flux de sortie standard. (Aucune autre forme de sortie n'est acceptable pour ce défi, car l'accent est mis sur les E / S plutôt que sur le comportement trivial du programme lui-même.) Selon qu'il a réussi:
  • S'il a réussi à sortir Hello, world!, le programme / fonction se ferme sans autre comportement.
  • S'il n'a pas produit la sortie correcte en raison d'une erreur, le programme / la fonction tente d'écrire la chaîne Error writing "Hello, world!"dans le flux d'erreur standard. (Aux fins de ce défi, vous n'avez pas besoin de la gestion des erreurs pour la gestion des erreurs elle-même.)

Clarifications

• Votre programme / fonction sera exécuté sans entrée (sauf s'il est écrit dans un langage qui nécessite absolument une entrée pour fonctionner, auquel cas il sera exécuté avec l'entrée la plus simple possible).

• Lorsque vous produisez une sortie, vous pouvez également produire une seule nouvelle ligne de fin si vous le souhaitez, mais cela n'est pas obligatoire.

• La définition de «l'écriture d'erreur sur la sortie standard» que votre programme implémente doit traiter au moins les cas suivants comme des erreurs:

  • La sortie standard étant inexistante (c'est-à stdout- dire un descripteur de fichier fermé, aucun descripteur de fichier 1 n'existe, ou cependant ces cas se traduisent dans la langue et le système d'exploitation que vous utilisez);
  • Sortie standard faisant référence à un fichier sur un disque qui n'a plus d'espace libre;
  • Sortie standard se connectant à un autre programme, qui a déjà fermé son extrémité de la connexion.

  et doit traiter au moins les cas suivants comme un succès (c'est-à-dire pas une erreur):

  • La sortie standard se connecte à un terminal et Hello, world!s'affiche à l'écran.
  • La sortie standard se connecte à un fichier et Hello, world!est écrite dans le fichier.

  Vous pouvez choisir les détails de ce qui compte comme une erreur de sortie, tant qu'il est conforme aux règles ci-dessus.

• Votre programme / fonction ne doit pas se bloquer lors de la rencontre de l'une des situations d'erreur répertoriées ci-dessus. C'est à vous de choisir le code de sortie que vous utilisez.

• Votre programme / fonction ne doit pas décrire la nature de l'erreur rencontrée sur le flux d'erreur standard; il devrait simplement imprimer la chaîne spécifiée ci-dessus. La sortie étrangère sur erreur standard (par exemple les avertissements du compilateur) n'est légale que si elle est produite sans condition, indépendamment du fait qu'une erreur soit rencontrée ou non.

• Votre programme ne doit fonctionner que sur un seul système d'exploitation (bien qu'il doit s'agir d'un système sur lequel les erreurs répertoriées ci-dessus ont un sens; j'ai essayé de les garder suffisamment générales pour fonctionner sur la plupart des systèmes d'exploitation grand public multitâche, mais des systèmes d'exploitation plus étranges peuvent bien être exclus de ce défi). Si votre programme n'est pas portable, indiquez les hypothèses qu'il doit exécuter dans le titre de votre soumission.

• Cette tâche peut ne pas être possible dans toutes les langues (toutes les langues ne permettent pas à un programme de gérer les erreurs de sortie de manière personnalisée). Vous devrez choisir une langue où cela est possible.

• Assurez-vous que votre programme / fonction fonctionne! Ne vous fiez pas seulement à la documentation des fonctions de la bibliothèque pour faire ce qu'ils disent faire. La gestion des erreurs des fonctions de sortie simples s'avère souvent être rompue dans la pratique, même si les fonctions prétendent gérer les erreurs en théorie.

Cas de test

Voici un moyen de simuler chacune des conditions d'erreur ci-dessus en utilisant bashsous Linux (vous n'avez pas besoin d'utiliser Linux, mais c'est probablement le système le plus simple pour tester cela):

your_program_here >&-           # nonexistent stdout
your_program_here > /dev/full   # out of disk space
mkfifo test  # note: change "test" to a filename that isn't in use
true < test &
your_program_here > test        # connecting to a program that doesn't want input
rm test      # clean up the FIFO we used earlier

Les deux premiers cas de test sont déterministes. Le dernier n'est pas (il repose sur une condition de course); à des fins de test, je recommande d'ajouter un délai entre le début de votre programme et la sortie réelle à la sortie standard, afin de garantir que la condition de concurrence critique est résolue de la manière qui expose l'erreur.

Condition de victoire

C'est un défi de code-golf , donc plus court est mieux. Comme (presque) toujours, nous mesurons la longueur du programme en octets.

Bash , 71 60 octets

h=Hello,\ world!
(echo $h)2>&-||echo Error writing \"$h\">&2

Essayez-le en ligne!

Comment ça fonctionne

Après avoir enregistré Hello, world!dans la variable h , nous procédons comme suit.

Tout d'abord, (echo $h)2>&-tente d'imprimer Hello, world!sur STDOUT. 2>&-est requis pour empêcher l'affichage du message d'erreur echo: erreur d'écriture: descripteur de fichier incorrect en cas d'échec de l'écriture. Étant donné que l'écriture dans un canal nommé qui n'accepte pas d'entrée tuerait le programme Bash avec le signal 13 (SIGPIPE), nous exécutons la commande dans un sous-shell ( (...)), donc seul le sous-shell sera tué.

Enfin, si l'impression vers STDOUT a échoué, le sous-shell se terminera avec un code d'état non nul (141 pour SIGPIPE, 1 pour une erreur générique), echo Error writing \"$h\">&2imprime donc le message souhaité à STDERR.

Python 2 , 65 octets

h='Hello, world!'
try:print h
except:exit('Error writing "%s"'%h)

Deux octets pourraient être enregistrés en imprimant des guillemets simples.

Essayez-le en ligne!

Zsh , 55 octets

h=Hello,\ world!
2>&-<<<$h||<<<'Error writing "'$h\">&2

Contrairement à son cousin Bash, Zsh refuse de mourir à cause d'une pipe cassée.

Essayez-le en ligne!

C (gcc) , 87 86 octets

f(){signal(13,1);write(1-puts("Hello, world!"),"Error writing \"Hello, world!\"",29);}

Essayez-le en ligne!

Non golfé

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

void f(void)
{
    signal(SIGPIPE, SIG_IGN); // Works (and is required) on TIO. YMMV
    int fd = (puts("Hello, world!")) < 0 ? 2 : -13;
    write(fd, "Error writing \"Hello, world!\"", 29);
}

PowerShell, 80 octets

try{echo($h="Hello, World!") -ea 4}catch{$host.ui|% *rL* "Error writing ""$h"""}

expliqué:

try{
    #Attempt to 'echo' (write output) the string, and assign it to $h
    #Make sure the 'error action' is set to '4' to make it a terminating error.
    echo($h="Hello, World!") -ea 4
} catch { 
    #Use the "WriteErrorLine" function in $host.ui to stderr
    $host.ui|% *rL* "Error writing ""$h"""
}

n'ont pas réussi à réellement essayer cela quand il fait une erreur, mais cela devrait certainement ~ fonctionner ~.

Javascript, 79 76 octets

try{(l=console).log(a="Hello, world!")}catch(e){l.error('Error writing '+a)}

Perl 5, 51 octets

nécessite -M5.01, qui est gratuit

say$h="Hello, world!"or die"Error writing \"$h\"$/"

Testé dans Strawberry Perl 5.24.0 en exécutant le programme tel quel (imprimé sur la sortie standard) et en exécutant

print f $h="Hello, world!"or die"Error writing \"$h\"$/"

(imprimé à l'erreur standard). Je ne sais pas comment tester d'autres erreurs avec Strawberry, mais elles doivent être traitées de la même manière….

REXX, 1111106 octets

signal on notready
a='Hello, world!'
_=lineout(,a)
exit
notready:_=lineout('stderr','Error writing "'a'"')

Le programme repose sur l'existence d'un flux appelé «stderr». Ce ne sera probablement pas le cas sur les systèmes IBM.

C, 77 octets

f(a){a="Error writing \"Hello, world!\"";write(1,a+15,13)-13&&write(2,a,29);}

pour appeler

main(){f(1); return 0;}

R , 91 octets

s="Hello, world!"
tryCatch(cat(s),error=function(e)cat('Error writing "','"',file=2,sep=s))

Essayez-le en ligne!

J'ai essayé de l'erreur en l'exécutant avec cat(s,file=12)au lieu de cat(s), et il imprime le texte correct sur stderr. C'est une invalid connectionerreur sinon.