Hostname: Difference between revisions
m
→{{header|Wren}}: Minor tidy
No edit summary |
m (→{{header|Wren}}: Minor tidy) |
||
(34 intermediate revisions by 23 users not shown) | |||
Line 8:
=={{header|Ada}}==
Works with GCC/GNAT
<
with GNAT.Sockets;
Line 14:
begin
Put_Line (GNAT.Sockets.Host_Name);
end Demo;</
=={{header|Aikido}}==
<syntaxhighlight lang="aikido">
println (System.hostname)
</syntaxhighlight>
=={{header|ALGOL 68}}==
Line 22 ⟶ 27:
<!-- {{does not works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - No such library function.}} -->
{{works with|POSIX|.1}}
<
get(read OF execve child pipe("/bin/hostname","hostname",""), hostname);
print(("hostname: ", hostname, new line))</
=={{header|AppleScript}}==
<
host name of (system info)
</syntaxhighlight>
=={{header|Arc}}==
<syntaxhighlight lang="arc">(system "hostname -f")</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">print sys\hostname</syntaxhighlight>
{{out}}
<pre>drkameleons-Mac.home</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang
via Windows Management Instrumentation (WMI)
<
MsgBox, % "Hostname:`t" objItem.Name</
=={{header|AWK}}==
{{noticebox||WARNING: the following purported solution makes an assumption about environment variables that may not be applicable in all circumstances.}}
<syntaxhighlight lang="awk">$ awk 'BEGIN{print ENVIRON["HOST"]}'
E51A08ZD</syntaxhighlight>
=={{header|BaCon}}==
<syntaxhighlight lang="freebasic">PRINT "Hostname: ", HOSTNAME$</syntaxhighlight>
=={{header|Batch File}}==
Since Windows 2000 :
<syntaxhighlight lang
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
PROC_initsockets
PRINT "hostname: " FN_gethostname
PROC_exitsockets</
=={{header|C}}/{{header|C++}}==
Line 65 ⟶ 78:
{{works with|POSIX|.1}}
<
#include <stdio.h>
#include <limits.h>
Line 74 ⟶ 87:
char name[_POSIX_HOST_NAME_MAX + 1];
return gethostname(name, sizeof name) == -1 || printf("%s\n", name) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}</
=={{header|C sharp|C#}}==
<syntaxhighlight lang
=={{header|Caché ObjectScript}}==
Line 84 ⟶ 97:
=={{header|Clojure}}==
<
(.. java.net.InetAddress getLocalHost getHostName)
</syntaxhighlight>
<
java -cp clojure.jar clojure.main -e "(.. java.net.InetAddress getLocalHost getHostName)"
</syntaxhighlight>
=={{header|COBOL}}==
<syntaxhighlight lang="cobol"> identification division.
program-id. hostname.
data division.
working-storage section.
01 hostname pic x(256).
01 nullpos pic 999 value 1.
procedure division.
call "gethostname" using hostname by value length of hostname
string hostname delimited by low-value into hostname
with pointer nullpos
display "Host: " hostname(1 : nullpos - 1)
goback.
end program hostname.
</syntaxhighlight>
=={{header|CoffeeScript}}==
<
os = require 'os'
console.log os.hostname()
</syntaxhighlight>
=={{header|Common Lisp}}==
Another operating system feature that is implemented differently across lisp implementations. Here we show how to create a function that obtains the required result portably by working differently for each supported implementation. This technique is heavily used to make portable lisp libraries.
<
#+(or sbcl ccl) (machine-instance)
#+clisp (let ((s (machine-instance))) (subseq s 0 (position #\Space s)))
#-(or sbcl ccl clisp) (error "get-host-name not implemented"))</
{{libheader|CFFI}}
Line 109 ⟶ 140:
Another way is to use the [[FFI]] to access POSIX' <code>gethostname(2)</code>:
<
(buf :pointer) (len :unsigned-long))
Line 116 ⟶ 147:
(unless (zerop (c-gethostname buf 256))
(error "Can't get hostname"))
(values (cffi:foreign-string-to-lisp buf))))</
<syntaxhighlight lang="lisp">BOA> (get-hostname)
"aurora"</syntaxhighlight>
=={{header|Crystal}}==
<syntaxhighlight lang="crystal">hostname = System.hostname</syntaxhighlight>
=={{header|D}}==
<
void main() {
writeln(Socket.hostName());
}</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 144 ⟶ 178:
else
Writeln('error getting host name');
end.</
=={{header|E}}==
<
Not exactly a good way to do it. A better way ought to be introduced along with a proper socket interface. [[Category:E examples needing attention]]
=={{header|Emacs Lisp}}==
<syntaxhighlight lang
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">Host = net_adm:localhost().</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<
=={{header|Factor}}==
<
host-name</
=={{header|Forth}}==
{{works with|GNU Forth|0.7.0}}
<
hostname type</
=={{header|Fortran}}==
Line 182 ⟶ 209:
The function/subroutine <tt>HOSTNM</tt> is a GNU extension.
<
character(len=128) :: name
call hostnm(name)
print *, name
end program HostTest</
Using fortran 2003 C-interoperability we can call posix C function gethostname (unix system call) directly
<
program test_hostname
use, intrinsic :: iso_c_binding
Line 229 ⟶ 256:
end program test_hostname
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' On Windows 10, the command line utility HOSTNAME.EXE prints the 'hostname' to the console.
Line 244 ⟶ 271:
Print
Print "Press any key to quit"
Sleep</
=={{header|friendly interactive shell}}==
{{trans|UNIX Shell}}
<syntaxhighlight lang="fishshell">hostname</syntaxhighlight>
or
<syntaxhighlight lang="fishshell">uname -n</syntaxhighlight>
=={{header|Frink}}==
<syntaxhighlight lang="frink">callJava["java.net.InetAddress", "getLocalHost"].getHostName[]</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
NSLog( @"%@", fn ProcessInfoHostName )
HandleEvents
</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=11d7f489117d7909da509050103b7891 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Print System.Host
End</syntaxhighlight>
Output:
<pre>
charlie
</pre>
=={{header|Go}}==
Use [https://golang.org/pkg/os/#Hostname <code>os.Hostname</code>].
<
import (
Line 257 ⟶ 315:
func main() {
fmt.Println(os.Hostname())
}</
=={{header|Groovy}}==
<syntaxhighlight lang
=={{header|Harbour}}==
<syntaxhighlight lang
=={{header|Haskell}}==
{{libheader|network}}
<
main = do hostName <- getHostName
putStrLn hostName</
Or if you don't want to depend on the network package being installed, you can implement it on your own (this implementation is based on the implementation in the network package).
<
import Foreign.Marshal.Array ( allocaArray0, peekArray0 )
Line 293 ⟶ 351:
main = do hostName <- getHostName
putStrLn hostName</
=={{header|Icon}} and {{header|Unicon}}==
<
write(&host)
end</
=={{header|IDL}}==
<
=={{header|J}}==
<
load 'socket'
Line 316 ⟶ 374:
NB. and the hostname is fetched only once, then use a 'one-liner' to accomplish it:
> {: sdgethostname coinsert 'jsocket' [ load 'socket'</
=={{header|Java}}==
<syntaxhighlight lang
import java.net.InetAddress;
import java.net.UnknownHostException;
</syntaxhighlight>
<syntaxhighlight lang="java">
void printHostname()
InetAddress localhost = InetAddress.getLocalHost();
System.out.println(localhost.getHostName());
}
</syntaxhighlight>
<pre>
penguin
</pre>
=={{header|JavaScript}}==
{{works with|JScript}}
<
var hostname = network.computerName;
WScript.echo(hostname);</
=={{header|jq}}==
Currently jq does not have a "gethostname" or a "system" command, so the best ways for a jq program to have access to the hostname are via an environment variable, or via a command line argument, as illustrated here:
<pre>HOST=$(hostname) jq -n --arg hostname $(hostname) '[env.HOST, $hostname]'</pre>
{{output}}
<pre>[
"mini.local",
"mini.local"
]</pre>
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">var hn = exec("hostname", {retAll:true}).data.trim();</syntaxhighlight>
=={{header|Julia}}==
<syntaxhighlight lang="julia">
println(gethostname())
</syntaxhighlight>
{{out}}
Line 344 ⟶ 418:
harlan
</pre>
=={{header|K}}==
<syntaxhighlight lang="k">
_h
</syntaxhighlight>
{{out}}
<pre>
`"narasimman-pc"
</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.4
import java.net.InetAddress
fun main(args: Array<String>) {
println(InetAddress.getLocalHost().hostName)
}</syntaxhighlight>
=={{header|Lasso}}==
This will ge the hostname as reported by the web server
<syntaxhighlight lang
-> www.myserver.com
This will ge the hostname as reported by the system OS
<
data
Line 385 ⟶ 478:
}
host_name</
-> mymachine.local
=={{header|LFE}}==
<
(net_adm:localhost)
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
struct SIZE,sz As Long
SIZE.sz.struct=Len(lpBuffer$)
Line 402 ⟶ 495:
CurrentComputerName$=Trim$(Left$(lpBuffer$, SIZE.sz.struct))
print CurrentComputerName$</
=={{header|Limbo}}==
As with nearly anything in Inferno, it boils down to reading a file:
<
include "sys.m"; sys: Sys;
Line 438 ⟶ 531:
raise "fail:errors";
}
</syntaxhighlight>
Sys->ATOMICIO is usually 8 kilobytes; this version truncates if you have a ridiculously long hostname.
Line 444 ⟶ 537:
=={{header|Lingo}}==
{{libheader|Shell Xtra}}
<
sx = xtra("Shell").new()
if the platform contains "win" then
Line 450 ⟶ 543:
else
hostname = sx.shell_cmd("hostname", RETURN).line[1]
end if</
=={{header|LiveCode}}==
<syntaxhighlight lang
=={{header|Lua}}==
Requires: LuaSocket
<
print( socket.dns.gethostname() )</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Host {
\\ one way
Print computer$
\\ second way
Declare objNetwork "WScript.Network"
With objNetwork, "ComputerName" as cName$
Print cName$, cName$=Computer$
Declare objNetwork Nothing
}
Host
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang
=={{header|MATLAB}}==
This is a built-in MATLAB function. "failed" is a Boolean which will be false if the command sent to the OS succeeds. "hostname" is a string containing the system's hostname, provided that the external command <tt>hostname</tt> exists.
<
=={{header|mIRC Scripting Language}}==
<syntaxhighlight lang
=={{header|Modula-3}}==
<
IMPORT IO, OSConfig;
Line 481 ⟶ 588:
BEGIN
IO.Put(OSConfig.HostName() & "\n");
END Hostname.</
=={{header|MUMPS}}==
<
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
say InetAddress.getLocalHost.getHostName
</syntaxhighlight>
=={{header|NewLISP}}==
<
=={{header|Nim}}==
There are several ways to get the host name, for instance reading the environment variable HOSTNAME or calling the low level Posix function “gethostname”. The simplest way consists to use the function “getHostName” from module “nativeSockets”:
<syntaxhighlight lang="nim">import nativesockets
echo getHostName()</syntaxhighlight>
=={{header|Oberon-2}}==
Works with oo2c version 2
<
MODULE HostName;
IMPORT
Line 513 ⟶ 618:
Out.Object("Host: " + ProcessParameters.GetEnv("HOSTNAME"));Out.Ln
END HostName.
</syntaxhighlight>
Output:
<pre>
Host: localhost.localdomain
</pre>
=={{header|Objeck}}==
<
use Net;
Line 543 ⟶ 635:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
Cocoa / Cocoa Touch / GNUstep:
<syntaxhighlight lang="objc">
NSLog(@"%@", [[NSProcessInfo processInfo] hostName]);
</syntaxhighlight>
Example Output:
<syntaxhighlight lang="objc">
2010-09-16 16:20:00.000 Playground[1319:a0f] sierra117.local // Hostname is sierra117.local.
</syntaxhighlight>
=={{header|OCaml}}==
<syntaxhighlight lang
=={{header|Octave}}==
Similarly to [[Discover the Hostname#MATLAB|MATLAB]], we could call system command <tt>hostname</tt> to know the hostname. But we can also call the internal function <tt>uname()</tt> which returns a structure holding several informations, among these the hostname (nodename):
<syntaxhighlight lang
=={{header|ooRexx}}==
Line 558 ⟶ 664:
A solution using ActiveX/OLE on Windows
<
and one using the Windows environment variables
<
===UNIX Platform===
Line 572 ⟶ 678:
:'''Note:''' The '''<tt>address command</tt>''' clause causes the contents of the literal string that follows it to be sent to the command shell.
<syntaxhighlight lang
<
Command output can also be captured by the program to allow further processing.
Line 580 ⟶ 686:
In the following examples output written to STDOUT/STDERR is piped into '''<tt>rxqueue</tt>''' which sends it in turn to a Rexx queue for further processing by the program:
<
address command "echo $HOSTNAME | rxqueue"
address command "hostname -f | rxqueue"
Line 587 ⟶ 693:
say q_~right(2)':' hn
end q_
</syntaxhighlight>
A utility class is also provided as a wrapper around the external data queue:
<
qq = .rexxqueue~new()
address command "echo $HOSTNAME | rxqueue"
Line 599 ⟶ 705:
say q_~right(2)':' hn
end q_
</syntaxhighlight>
=={{header|Oz}}==
<
=={{header|PARI/GP}}==
Running the <code>hostname</code> or <code>uname</code> program and capturing its output (the first line of output) in a string.
<
str = externstr("uname -n")[1];</
=={{header|Pascal}}==
For Windows systems see the [[Hostname#Delphi | Delphi]] example.
On Unix systems, FreePascal has the function GetHostName:
<
uses
Line 620 ⟶ 726:
begin
writeln('The name of this computer is: ', GetHostName);
end.</
Output example on Mac OS X:
<pre>
Line 630 ⟶ 736:
{{libheader|Sys::Hostname}}
<
$name = hostname;</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (system_exec, file i/o)</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">tmp</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"hostname.txt"</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">cmd</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">WINDOWS</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"hostname"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"uname -n"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">system_exec</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%s > %s"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">cmd</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">}),</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">host</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">delete_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"hostname.txt"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">host</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"Pete-PC"
</pre>
=={{header|PHP}}==
<syntaxhighlight lang
<syntaxhighlight lang
{{works with|PHP|5.3+}}
<syntaxhighlight lang
=={{header|PicoLisp}}==
This will just print the hostname:
<syntaxhighlight lang
To use it as a string in a program:
<
=={{header|Pike}}==
<
int main(){
write(gethostname() + "\n");
}</
=={{header|PL/SQL}}==
<
BEGIN
DBMS_OUTPUT.PUT_LINE(UTL_INADDR.GET_HOST_NAME);
END;</
=={{header|Pop11}}==
<
=={{header|PowerBASIC}}==
This retreives the localhost's name:
<syntaxhighlight lang
This attempts to retreive the name of an arbitrary machine on the network (assuming ipAddress& is valid):
<
=={{header|PowerShell}}==
Windows systems have the <code>ComputerName</code> environment variable which can be used:
<syntaxhighlight lang
Also PowerShell can use .NET classes and methods:
<syntaxhighlight lang
=={{header|PureBasic}}==
{{works with|PureBasic|4.41}}
<
answer$=Hostname()</
=={{header|Python}}==
{{works with|Python|2.5}}
<
host = socket.gethostname()</
=={{header|R}}==
Sys.info provides information about the platform that R is running on. The following code returns the hostname as a string.
<
Note that Sys.info isn't guaranteed to be available on all platforms. As an alternative, you can call an OS command.
<
... or retrieve an environment variable
<syntaxhighlight lang="r">
env_var <- ifelse(.Platform$OS.type == "windows", "COMPUTERNAME", "HOSTNAME")
Sys.getenv(env_var)
</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket/base
(require
(gethostname)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>my $host = qx[hostname];</syntaxhighlight>
=={{header|REBOL}}==
<syntaxhighlight lang
=={{header|REXX}}==
Line 717 ⟶ 840:
<br>Other names could be used for the 3rd argument.
<br><br>The ''computername'' is the same as the output for the '''hostname.exe''' program.
<
say value('OS',,"ENVIRONMENT")</
'''output''' (using Windows/XP)
<pre>
Line 727 ⟶ 850:
This REXX solution is for R4 and ROO under the Microsoft NT family of Windows (XP, Vista, 7, etc).
<br>Other names could be used for the 3rd argument.
<
say value('OS',,"SYSTEM")</
===MS DOS (without Windows), userid===
Under Microsoft DOS (with no Windows), the closest thing to a name of a host would be the userid.
<syntaxhighlight lang
===MS DOS (without Windows), version of DOS===
But perhaps the name or version of the MS DOS system would be more appropriate than the userid.
<
Each REXX interpreter has their own name (some have multiple names) for the environmental variables.
<br>Different operating systems may call their hostnames by different identifiers.
Line 746 ⟶ 869:
This solution is platform specific and uses features that are available to the Regina implementation of Rexx.
:Tested with Regina on Mac OS X. Should work on other UNIX/Linux distros.
<
address command "hostname -f" with output stem hn.
do q_ = 1 to hn.0
say hn.q_
end q_
exit</
=={{header|Ruby}}==
<
host = Socket.gethostname</
=={{header|Run BASIC}}==
<
print UserInfo$ ' Information about the user's web browser
print UserAddress$ ' IP address of the user</
=={{header|Rust}}==
Works on windows and linux with crate <code>hostname</code> version 0.1.5
<syntaxhighlight lang="rust">fn main() {
match hostname::get_hostname() {
Some(host) => println!("hostname: {}", host),
None => eprintln!("Could not get hostname!"),
}
}</syntaxhighlight>
=={{header|Scala}}==
<
=={{header|Scheme}}==
{{works with|Chicken Scheme}}
<
(get-host-name)</
{{works with|Guile}}
<syntaxhighlight lang
=={{header|Seed7}}==
Line 777 ⟶ 909:
which returns the hostname.
<
include "socket.s7i";
Line 783 ⟶ 915:
begin
writeln(getHostname);
end func;</
=={{header|Sidef}}==
<
var host = sys.hostname;</
Or:
<
=={{header|Slate}}==
<syntaxhighlight lang
=={{header|
<syntaxhighlight lang="slope">(hostname)</syntaxhighlight>
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}
<syntaxhighlight lang
=={{header|SNOBOL4}}==
<syntaxhighlight lang="snobol4">
output = host(4,"HOSTNAME")
end</syntaxhighlight>
=={{header|SQL}}==
{{works with|Oracle}}
<
select host_name from v$instance;
</syntaxhighlight>
=={{header|SQL PL}}==
{{works with|Db2 LUW}}
<syntaxhighlight lang="sql pl">
SELECT HOST_NAME FROM SYSIBMADM.ENV_SYS_INFO
</syntaxhighlight>
Output:
<pre>
HOST_NAME
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
hostname
1 record(s) selected.
</pre>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">NetHostDB.getHostName ()</syntaxhighlight>
=={{header|Swift}}==
Swift 3
<syntaxhighlight lang
=={{header|Tcl}}==
The basic introspection tool in TCL is the <tt>info</tt> command. It can be used to find out about the version of the current Tcl or Tk, the available commands and libraries, variables, functions, the level of recursive interpreter invocation, and, amongst a myriad other things, the name of the current machine:
<syntaxhighlight lang
=={{header|Toka}}==
<
1024 chars is-array foo
foo 1024 gethostname
foo type</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
host=HOST ()
</syntaxhighlight>
=={{header|UNIX Shell}}==
<syntaxhighlight lang
or
<syntaxhighlight lang
=={{header|Ursa}}==
<
=={{header|Ursala}}==
The user-defined hostname function ignores its argument and returns a string.
<
hostname = ~&hmh+ (ask bash)/<>+ <'hostname'>!</
For example, the following function returns the square root of its argument
if it's running on host kremvax, but otherwise returns the square.
<
creative_accounting = (hostname== 'kremvax')?(sqrt,sqr)</
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Set objNetwork = CreateObject("WScript.Network")
WScript.Echo objNetwork.ComputerName
</syntaxhighlight>
=={{header|Vim Script}}==
<syntaxhighlight lang
=={{header|Visual Basic}}==
{{works with|Visual Basic|5}}
{{works with|Visual Basic|6}}
{{works with|VBA|Access 97}}
{{works with|VBA|6.5}}
{{works with|VBA|7.1}}
<syntaxhighlight lang="vb">Option Explicit
Private Declare Function GetComputerName Lib "kernel32.dll" Alias "GetComputerNameW" _
(ByVal lpBuffer As Long, ByRef nSize As Long) As Long
Private Const MAX_COMPUTERNAME_LENGTH As Long = 31
Private Const NO_ERR As Long = 0
Private Function Hostname() As String
Dim i As Long, l As Long, s As String
s = Space$(MAX_COMPUTERNAME_LENGTH)
l = Len(s) + 1
i = GetComputerName(StrPtr(s), l)
Debug.Assert i <> 0
Debug.Assert l <> 0
Hostname = Left$(s, l)
End Function
Sub Main()
Debug.Assert Hostname() = Environ$("COMPUTERNAME")
End Sub</syntaxhighlight>
=={{header|V (Vlang)}}==
In Vlang, the "main()" entry point and declaration can be skipped in one file programs and when used like a script.
<syntaxhighlight lang="v (vlang)">import os
println(os.hostname())</syntaxhighlight>
=={{header|Wren}}==
Wren CLI doesn't currently expose a way to find the host name.
However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to get it for us.
<syntaxhighlight lang="wren">/* Hostname.wren */
class Host {
foreign static name() // the code for this is provided by Go
}
System.print(Host.name())</syntaxhighlight>
which we embed in the following Go program and run it.
{{libheader|WrenGo}}
<syntaxhighlight lang="go">/* Hostname.go */
package main
import (
wren "github.com/crazyinfin8/WrenGo"
"os"
)
type any = interface{}
func hostname(vm *wren.VM, parameters []any) (any, error) {
name, _ := os.Hostname()
return name, nil
}
func main() {
vm := wren.NewVM()
fileName := "Hostname.wren"
methodMap := wren.MethodMap{"static name()": hostname}
classMap := wren.ClassMap{"Host": wren.NewClass(nil, nil, methodMap)}
module := wren.NewModule(classMap)
vm.SetModule(fileName, module)
vm.InterpretFile(fileName)
vm.Free()
}</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang
Or open a server socket, which contains the hostname.
<syntaxhighlight lang
Line 873 ⟶ 1,098:
{{omit from|Unlambda|Does not have network access.}}
{{omit from|ZX Spectrum Basic|Does not have a hostname.}}
{{omit from|Commodore BASIC}}
|