Je suis surpris que cela n'ait pas encore posé de problème.

Sortez l'adresse IP de la machine que vous utilisez. Vous devez sortir les adresses IP locales et externes.

Adresse IP locale, c'est-à-dire selon le format par défaut 192.168.xx

L'adresse IP publique peut être vérifiée en utilisant google https://www.google.co.uk/search?source=hp&q=whats+my+ip

La sortie peut être dans n'importe quel format. IPv4 ou IPv6 ou tout mélange de chacun est autorisé, mais ils doivent être la seule sortie. Le code peut être un programme complet ou une fonction.

les règles de code-golf s'appliquent donc le code le plus court l'emporte.

Les échappatoires standard sont interdites.

EDIT: Selon le commentaire de @Peter Taylor, dans le cas où plusieurs de l'un ou l'autre type d'adresse sont présents, vous pouvez choisir de sortir la première ou autant que vous pouvez accéder. Tant qu’au moins un local et un public sont présents.

Bash + curl + iproute2 , 54 50 49 48 33 octets

ip r g 1|awk '$0=$7'
curl eth0.me

Merci @DomHastings d'avoir joué au golf sur 1 octet!

Merci @Sisyphus d'avoir trouvé une URL plus courte!

Merci @zeppelin d'avoir joué au golf sur 9 octets!

Bash 37 31 27 octets

Ceci est inspiré par la réponse de Bruce Forte . Cette réponse ne fonctionne qu'avec IPv4, ce qui signifie que cela ne fonctionne pas pour moi. Je l'ai réécrit dans une version qui (uniquement) fonctionne avec IPv6:

ip r g b::|awk '$0=$9" "$9'

Ceci est testé sur Ubuntu 14.04.5 connecté via PPPoE et puisque IPv6 est conçu pour être utilisé sans aucun NAT, il affichera deux fois la même adresse IP.

-6 octets grâce à zeppelin , -2 octets grâce à Ferrybig , -2 octets grâce à Markasoftware .

Mathematica, 17 octets

^{Mathematica a une fonction intégrée pour tout}

$MachineAddresses

Comme décrit dans la documentation , cette commande intégrée répertorie toutes les adresses IP (locales et externes) associées à votre appareil.

AutoIt, 56 53 octets

#include<Inet.au3>
ConsoleWrite(@IPAddress1&_GetIP())

@IPAddress1 est une macro qui revient

Adresse IP de la première carte réseau

_GetIP() résultats

l'adresse IP publique.

C #, 196 194 188 163 163 octets

namespace System.Net.Sockets{using Linq;_=>Dns.GetHostEntry("").AddressList.First(i=>(int)i.AddressFamily==2)+" "+new WebClient().DownloadString("http://eth0.me")}

Enregistré 2 octets grâce à @Xynos.
25 octets enregistrés grâce à @Nick.

Version complète / formatée:

namespace System.Net.Sockets
{
    using Linq;

    class P
    {
        static void Main()
        {
            Func<object, string> f = _ =>
                Dns.GetHostEntry(Dns.GetHostName())
                    .AddressList
                    .First(i => (int)i.AddressFamily == 2) + " " + new WebClient().DownloadString("http://eth0.me");

            Console.WriteLine(f(null));

            Console.ReadLine();
        }
    }
}

PowerShell v4 +, 40 36 octets

NetIPAddress|% IPA*
iwr eth0.me|% C*

(Fonctionne uniquement sur Server 2012 R2 ou supérieur, ou Windows 8.1 ou supérieur. Ne fonctionne pas sur TIO.)

Est-ce exactement ce qu'il dit sur l'étain. Obtient les adresses IP du réseau local et sélectionne uniquement la IPApartie de celle-ci (par exemple, filtre le masque de sous-réseau, la passerelle, etc.).

Le second est un Invoke-WebRequestàhttp://eth0.me qui obtient simplement son Ccontenu; c'est-à-dire, juste l'adresse IP publique.

Version non golfée:

(Get-NetIPAddress).IPAddress
(Invoke-WebRequest eth0.me).content

Unix Shell + stunclient , 40 octets

stunclient stun.vo.lu|cut -d: -f2|sed 1d

Utilise un protocole STUN :

Session Traversal Utilities for NAT (STUN) est un protocole qui sert d'outil à d'autres protocoles pour gérer la traversée du Network Address Translator (NAT). Il peut être utilisé par un point de terminaison pour déterminer l'adresse IP et le port qui lui sont attribués par un NAT

Le nom du serveur STUN provient de la liste des serveurs STUN publics .

Le format de sortie est:

 LOCAL IPV4 ADDRESS
 PUBLIC IPV4 ADDRESS

Notez que les deux lignes seront en retrait avec un seul espace, mais je pense que cela ne casse pas les règles de sortie telles qu'elles sont écrites.

Exemple de sortie:

  192.168.1.100    
  209.85.233.147

curl (bash one-liner): 27 octets

curl -w%{local_ip} eth0.me

Le résultat est imprimé stdoutet ressemble à ceci:

1.2.3.4
192.168.0.10
# no trailing newline, use "curl -w%{local_ip}\\n eth0.me" for it

curl devrait être au moins de la version 7.29.0 (à partir du 6 février 2013).

La réponse est basée sur /codegolf//a/139538/66016 .

Go, MacOS uniquement, 10 octets

Dans macOS, ce killswitch pourrait être utilisé, il peut imprimer l'IP active privée actuelle et l'IP publique:

$ killswitch 
Interface  MAC address         IP
en1        bc:34:36:d2:81:ba   192.168.2.10

Public IP address: 179.43.176.99

No VPN interface found, verify VPN is connected

Ce n'est pas un outil intégré mais essaie de simplifier le processus de recherche des IP appropriées.

La sortie pourrait être obtenue en utilisant des commandes comme:

$ route get 0.0.0.0

$ ifconfig | pcregrep -M -o '^[^\t:]+:([^\n]|\n\t)*status: active'

$ networksetup -listnetworkserviceorder

$ scutil --dns

IP publique:

$ dig o-o.myaddr.l.google.com @ns.google.com txt +short

PowerShell v3 + (réponse alternative pour Windows 7+)

((ipconfig) -match "v4").split(":")[1]
Invoke-RestMethod eth0.me

Bash + Awk + Curl, 43 octets

utilisant uniquement des outils intégrés pour Mac et Linux

ifconfig|awk '/bro/{print $2}';curl eth0.me

Python 3, 124 133 octets

from urllib2 import urlopen
import socket
a=urlopen('http://eth0.me').read()
b=socket.gethostbyname(socket.gethostname())
print a,b

Node.js (JavaScript) 224 223 194 175 173 130 130 octets

r=require,l=console.log,r('dns').lookup(r('os').hostname(),(a,b)=>l(b));r('http').get('http://eth0.me',a=>a.on('data',c=>l(c+"")))

Version non golfée:

require('dns').lookup(require('os').hostname(), (err, loc, fam) => console.log(loc));
require('http').get('http://eth0.me', res => {
    res.on('data', chunk => console.log(chunk + ""));
});

• 1 octet enregistré (en raison d'un point-virgule inutile).
• 29 octets enregistrés grâce à @AndrewLi (fonctions de flèche utilisées pour le code plus court).
• 19 octets enregistrés grâce à @MiniGod (utilisé .get()au lieu de .request()- .end();supprimé).
• Sauvegardé 2 octets grâce à @ Zacharý (les parenthèses ne sont pas nécessaires autour d'un seul paramètre d'une fonction flèche).
• Sauvegardé 43 octets grâce à @Birjolaxew (stocké requireet console.logdans des variables à lettre unique, transmis directement l'URL à require('http').get, sortie enregistrée directement à partir de l' dataévénement).

Fichier batch de Windows , 116 octets

@for /f "tokens=1-2 delims=:" %%a in ('ipconfig^|find "v4"')do @echo%%b
@powershell -Command "(iwr eth0.me).content"

La première ligne parcourt les résultats de l'exécution ipconfig et obtient votre adresse IPv4 locale.

Pour la partie IP publique, j'ai dû voler un peu de la merveilleuse réponse Powershell car, à ma connaissance, il n'y a aucun moyen d'obtenir l'IP publique de la machine en utilisant uniquement des scripts batch.

Nous commençons par un @signe, pour supprimer l'écho de l'invite ( C:\...\path>), puis exécutons la commande Powershell Invoke-WebRequest(avec son alias,iwr ) et extrayons la contentpartie de cela.

J'ai expérimenté non utiliser(...).content et, au lieu de cela, d'exécuter uniquement la commande et d'extraire les informations réelles de la sortie complète, en utilisant un lot. Mais cela s'est avéré bien plus long que cette solution, alors je l'ai gardée.

Testé sur Windows 10.0.15063.

R, 142 , 140 , 137 octets

library(magrittr);system("ipconfig",int=T)%>%regmatches(.,regexpr("v4.+",.))%>%{a=nchar(.);substr(.,a-14,a)};readLines("http://eth0.me")

Testé sur win10 et R (3.4.1).
Merci pour @ Bruce-Forte pour l'URL courte.

Version non golfée:

library(magrittr)
system("ipconfig",int=T) %>% 
     regmatches(.,regexpr("v4.+",.)) %>% 
      {a <- nchar(.)
       substr(., a - 14, a)}
readLines("http://eth0.me")

Python 2.7.13 128 octets

print __import__("urllib").urlopen("http://eth0.me").read(),__import__("socket").gethostbyname(__import__("socket").getfqdn())

Bash + Curl, 24 octets

hostname -i;curl eth0.me

MS-SQL, 59 octets

SELECT TOP 1 local_net_address
FROM sys.dm_exec_connections

Renvoie l'adresse IP côté client de l'instance SQL exécutant la requête.

VBA, 58 octets

Oups, ne gère pas l'adresse locale - correction en cours

Remarque: utilise une référence à

Microsoft Internet Controls

Fonction de fenêtre immédiate VBE anonyme qui ne prend aucune entrée et génère l'adresse IP de l'utilisateur via une fenêtre Internet Explorer

Set i=New InternetExplorer:i.Visible=1:i.Navigate"eth0.me"