Escreva um programa que, conforme o script tenha acesso à Internet, produza uma saída que seja "Truthy / Falsey" . Você pode tentar se conectar a qualquer site existente, a seu critério (não use um site obscuro que tenha apenas 10% de tempo de atividade - tente manter acima de 80% de tempo de atividade anual). Se o site estiver inativo, seu programa não precisa funcionar.

Deve ser um programa independente ou uma função . Você pode usar bibliotecas fora da biblioteca padrão para conseguir isso. As brechas padrão são proibidas. Esse é o código golf, portanto o código com a menor contagem de bytes vence.

Exemplo de pseudocódigo:

function a:
    try:
        connect to internet 
        return 1
    catch error:
        return 0

Este é o meu primeiro post sobre código de golfe, por isso, se isso violar alguma regra ou for um tolo, por favor me avise.

EDIT: Devido a inúmeras sugestões, removi a restrição de contagem de bytes UTF-8

Bash (com dnsutils ), 3 bytes

Envia uma solicitação de DNS para "." (Raiz do DNS), o código de saída é 0 para obter sucesso e> 0 em caso contrário.

Golfe

dig

Teste

% dig >/dev/null; echo $?;        
0

% nmcli nm wifi off
% dig >/dev/null; echo $?;
9

aviso Legal

Obviamente, isso só funcionará se o servidor DNS estiver na rede do provedor, ou seja, na "Internet" (como a rede do provedor normalmente faz parte dela) ou se o sistema estiver usando um servidor DNS público (como 8.8.8.8 do Google, que os sistemas baseados no Android usam), caso contrário, você pode obter uma cópia em cache de um servidor LAN local (ou host local).

Mas suponho que isso não seja contrário às regras do código-golfe , pois obviamente há mais de um sistema em que isso funciona como pretendido.

Os métodos de HTTP puro também podem fornecer falsos positivos, devido a um proxy de armazenamento em cache intermediário, e não é garantido que funcionem em todos os lugares, portanto, isso não é algo exclusivo desse método.

Uma versão um pouco mais confiável, 8 bytes

dig +tra

(uma pequena homenagem a @ Dig ital Tra uma!)

Ativa o "modo de rastreamento", que forçará a escavação a fazer a pesquisa recursiva por si só (consulte https://serverfault.com/a/778830 ), evitando problemas de cache.

Utilitários Bash + GNU, 8

• 5 bytes salvos graças ao @Muzer.

wget to.

As outras respostas do shell verificam o código de retorno e ecoam alguma saída de status de acordo. Isso é desnecessário. O código de retorno do shell já é um código Truthy / Falsey utilizável e acessível no $?parâmetro que é idiomático para o bash. O código de retorno 0 significa True. Código de retorno> 0 significa Falso.

Em uso:

ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:10:51--  http://to./
Resolving to. (to.)... 216.74.32.107, 216.74.32.107
Connecting to to. (to.)|216.74.32.107|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 11510 (11K) [text/html]
Saving to: ‘index.html.6’

index.html.6        100%[===================>]  11.24K  --.-KB/s    in 0.04s   

2017-01-13 09:10:51 (285 KB/s) - ‘index.html.6’ saved [11510/11510]

ubuntu@ubuntu:~$ echo $?
0
ubuntu@ubuntu:~$ sudo ifconfig ens33 down
ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:11:00--  http://to./
Resolving to. (to.)... failed: Temporary failure in name resolution.
wget: unable to resolve host address ‘to.’
ubuntu@ubuntu:~$ echo $?
4
ubuntu@ubuntu:~$ sudo ifconfig ens33 up
ubuntu@ubuntu:~$ # Local network up, upstream link down
ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:11:34--  http://to./
Resolving to. (to.)... failed: Name or service not known.
wget: unable to resolve host address ‘to.’
ubuntu@ubuntu:~$ echo $?
4
ubuntu@ubuntu:~$ 

Lote, 8 bytes

ping to.

pingserá definido ERRORLEVELcomo 1se o endereço não puder ser resolvido ou alcançado.

05AB1E , 11 9 bytes

2 bytes salvos em "para". cortesia de ev3commander

…to..wgX›

Verifica se o tamanho do conteúdo em http: // to . é maior que 1.
.wretorna 0 em erro.

MATL , 15 14 bytes

Um byte salvo graças a Kevin Cruijssen sugestão de

'http://to.'Xi

A saída é feita por STDOUT. Isso exibe uma seqüência de caracteres não vazia contendo caracteres diferentes de zero (que é verdade) se houver uma conexão com a Internet; e não exibe nada (o que é falso) se não houver conexão.

Isso não pode ser testado on-line porque Xinão é permitido nos intérpretes on-line.

Explicação

'http://to.'  % Push this string
Xi            % Return contents of that URL as a string. If there is no Internet
              % connection this gives an error, with no output on STDOUT

Bash 66 62 21 bytes

ping -c1 g.gl echo $?

Obrigado @Alex L. pela dica de redução de URL.

Versão não destruída:

r=$(ping -c1 g.gl)
if [ $? -ne 0 ];
 then echo "0"
else echo "1"
fi

Esta é a minha primeira resposta no Bash, não tenho certeza se reduzi o script o suficiente.

R, 20 bytes

curl::has_internet()

Há uma função para exatamente essa tarefa no curlpacote.

Java, 72 bytes

a->new java.net.InetSocketAddress("to.",80).getAddress().isReachable(9);

Perl, 15 bytes

print`curl to.`

Correr com:

perl -e 'print`curl to.`' 2> /dev/null

curlproduz coisas STDERR, não se importe com elas. Se o computador tiver acesso à Internet, ele imprimirá algumas linhas de html (verdade), caso contrário, ele não imprimirá nada (falso).

Salvei 1 bytes usando to.(em vez do meu anterior b.io) graças a @Kevin Cruijssen.

C #, 87 bytes

_=>{try{new System.Net.WebClient().OpenRead("http://g.gl");return 1;}catch{return 0;}};

Se uma exceção é considerada falsey, o que eu não acho que seja, então são 65 bytes:

_=>new System.Net.WebClient().OpenRead("http://g.gl").ReadByte();

Também tentei usar o link, http://to.conforme indicado por @KevinCruijssen, mas ele não parecia funcionar.

8 , 23 21 bytes

Dois bytes salvos graças à sugestão de Kevin Cruijssen e à minha descoberta:http: // parece funcionar tão bem quantohttp: // para . (salvando outro byte)

"http://to" net:get .

Se o site http: // to puder ser acessado, ele será impresso true. Caso contrário, ele imprime false. Ele deixa os dados recuperados na pilha.

MATLAB, 32 22 bytes

urlread('http://g.gl')

Explicação:

Se a conexão à Internet estiver ativa, isso resultará em ans(a variável padrão) uma string com todo o código html em texto sem formatação (o que é verdadeiro no MATLAB).

Se a conexão à Internet estiver inativa, isso gravará uma mensagem de erro no STDERR e deixará a área de trabalho vazia (o que é falso no MATLAB).

Infelizmente, urlreadrequer um endereço de URL completo , portanto g.glnão é suficiente. 11 dos 22 bytes são, portanto, apenas o endereço da URL.

Abordagem alternativa:

Uma solução que captura o erro e deixa um 0 (também falso ) no espaço de trabalho se a conexão estiver inoperante:

0;try urlread('http://g.gl'),end

0;inicializa a variável padrão anspara 0, que está falseem MATLAB. Então vamos tryler o URL. Isso causará um erro se a conexão à Internet estiver inativa ou uma matriz de caracteres, se não (que está trueno MATLAB).

Não precisamos pegar nada, então acabamos. Se a chamada urlread foi bem-sucedida, anshaverá uma longa sequência com o conteúdo do site, caso contrário ans=0.

Bash, 39 bytes

exec 4<>/dev/tcp/to./80&&echo 1||echo 0

JavaScript ES6, 71 43 bytes

fetch``.then(a=>alert(1)).catch(a=>alert``)

Alertas 1 se online, alerta uma string vazia se estiver offline. Agradeço a Patrick Roberts por me ajudar a eliminar alguns bytes

Versão antiga

_=>fetch('http://enable-cors.org').then(a=>alert(a)).catch(a=>alert(0))

Alertas [object Reponse]se online, alertas 0se offline

Removido o trecho de código, ele não funciona porque é carregado de um domínio diferente sem o CORS, mas funciona no console do navegador

JavaScript ES6, 90 81 bytes

f=a=>{i=new Image();i.src="//placehold.it/1x1";i.onload=b=>a(1);i.onerror=c=>a()}

JavaScript ES6, 22 21 bytes (inválido)

Alguns navegadores não oferecem suporte total ou produzem o resultado esperado ao usar o navigator.onLine.

f=a=>navigator.onLine

Scala, 54 bytes

x=>(Runtime.getRuntime exec "ping -c 1 ai."waitFor)<1

Bem simples; executa um comando ping em http://ai./e retorna true se sair com 0 ou false caso contrário.

Brainfuck (não concorrente) 21 bytes

++++++[>++++++++<-]>.

O Brainfuck não pode se conectar à Internet (pelo que sei); portanto, como o programa não consegue se conectar, a resposta é sempre 0

Não concorrente porque parece estar dentro da brecha padrão de saída codificada , mesmo que este programa tecnicamente esteja correto para o desafio.

Powershell, 64 26 23 bytes

Economizou 38 bytes, graças a Shawn Esterman

Economizou 3 bytes e script reparado, graças ao briantist

Test-Connection -q g.gl

PHP, 23 PHP + Ondulação, 14

Usando o operador backtick do PHP:

<?=`curl to.`;

Resposta original:

Vou tentar começar:

<?=file('http://x.gl');

Isso não produz nada se x.gl não puder ser alcançado e Arrayse for.

Outra versão em que não tenho certeza se eles se encaixam:

<?=getmxrr('x.gl',$a);  // 22 chars

Solicitações Python 3 +, 59 55 53 bytes

Tem que haver uma resposta de pedidos, certo?

from requests import*
try:get("http://to.")
except:Z

O status de saída é 0 para internet, 1 para não internet. Exemplo:

$ python inet.py 
$ echo $?
0
$ # Remove ethernet cable
$ python inet.py 
$ echo $?
1

Changelog:

• -4 bytes (obrigado Mego)

Elixir, 33 bytes

{:ok,_}=:inet.getaddr('to',:inet)

0 se conectado, 1 caso contrário.

PowerShell , 12 bytes

!!(irm g.gl)

Mathematica 10 Bytes

Supondo que você tenha uma cópia válida do Mathematica e credenciais de login em user.wolfram.com

CloudPut@1

gravará o valor 1 na nuvem. Verdade: CloudObject [""] Falsey: $ Falha

CloudGet@%

Retornará o valor 1 que foi carregado na nuvem.

Python 2.7, 70 77 bytes

from urllib import*
a=1
try:urlopen('http://to.')
except:a=0
print a

import urllib as l
try: 
 l.urlopen('http://a.uk')
 print 1
except:
 print 0

Usa 1 para verdade, 0 para falsidade. O a.uk redireciona para uma empresa de roupas para motocicletas. Economizou 3 bytes atribuindo a uma variável e imprimindo isso. E outro para o "to". truque (confirmado para trabalhar com urllib), dois para se livrar dos recuos traquinas.

Julia + Bash (com dnsutils), 10 bytes

run(`dig`)

`command`em julia cria um cmdobjeto que pode ser executado run.

Clojure, 49 bytes

#(try(slurp"http://to.")1(catch Exception _ nil))

Retorna 1se ele pode se conectar e, nilcaso contrário.

Apenas tentativas para slurpa página; lançando uma NoRouteToHostExceptionexceção em caso de falha, que é capturada.

Infelizmente, o protocolo e o ponto parecem ser obrigatórios.

Javascript (Nashorn), 61 bytes

print(new java.net.InetSocketAddress("to.",80).getAddress())

Baseado na resposta Java do Huntro.