Rosetta Code

Environment variables: Difference between revisions

Page Discussion

Environment variables (view source)

Revision as of 13:50, 21 June 2024

20,605 bytes added ,  16 days ago
Add SmallBASIC
m (→‎{{header|REXX}}: clarified the sentence about (the pool of) environmental variables. -- ~~~~)
(Add SmallBASIC)
 
(95 intermediate revisions by 57 users not shown)
Line 1:
{{task|Programming environment operations}}[[Category: Environment variables]][[Category:Initialization]]
[[Category:Environment variables]]
Show how to get one of your process's [[wp:Environment variable|environment variables]]. The available variables vary by system; some of the common ones available on Unix include PATH, HOME, USER.
[[Category:Initialization]]
[[Category:Simple]]
{{omit from|M4}}
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have an environment other than regular global variables. -->
{{omit from|Unlambda|Does not provide access to environment variables.}}
 
;Task:
Show how to get one of your process's [[wp:Environment variable|environment variables]].
 
The available variables vary by system; &nbsp; some of the common ones available on Unix include:
:::* &nbsp; PATH
:::* &nbsp; HOME
:::* &nbsp; USER
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">print(os:getenv(‘HOME’))</syntaxhighlight>
 
=={{header|Ada}}==
Print a single environment variable.
<langsyntaxhighlight lang="ada">with Ada.Environment_Variables; use Ada.Environment_Variables;
with Ada.Text_Io; use Ada.Text_Io;
 
Line 10 ⟶ 27:
begin
Put_Line("Path : " & Value("PATH"));
end Print_Path;</langsyntaxhighlight>
Print all environment variable names and values.
<langsyntaxhighlight lang="ada">with Ada.Environment_Variables; use Ada.Environment_Variables;
with Ada.Text_Io; use Ada.Text_Io;
 
Line 22 ⟶ 39:
begin
Iterate(Print_Vars'access);
end Env_Vars;</langsyntaxhighlight>
 
 
Line 29 ⟶ 46:
Uses [http://forge.ada-ru.org/matreshka Matreshka].
 
<langsyntaxhighlight Adalang="ada">with Ada.Wide_Wide_Text_IO;
 
with League.Application;
Line 43 ⟶ 60:
Ada.Wide_Wide_Text_IO.Put_Line
(League.Application.Environment.Value (+"HOME").To_Wide_Wide_String);
end Main;</langsyntaxhighlight>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - ''getenv'' is not part of the standard's prelude}}
<langsyntaxhighlight lang="algol68">print((getenv("HOME"), new line))</langsyntaxhighlight>
 
=={{header|APL}}==
<syntaxhighlight lang="apl">
⎕ENV 'HOME'
HOME /home/russtopia
</syntaxhighlight>
 
=={{header|AppleScript}}==
===Invoking Finder===
<syntaxhighlight lang="applescript">
tell application "Finder" to get name of home
</syntaxhighlight>
===Invoking Terminal===
<syntaxhighlight lang="applescript">
"HOME : " & (do shell script "echo $HOME" & ", PATH : " & (do shell script "echo $PATH" & ", USER : " & (do shell script "echo $USER")))
</syntaxhighlight>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">print ["path:" env\PATH]
print ["user:" env\USER]
print ["home:" env\HOME]</syntaxhighlight>
 
{{out}}
 
<pre>path: /Users/drkameleon/.arturo/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
user: drkameleon
home: /Users/drkameleon</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight lang="autohotkey">EnvGet, OutputVar, Path
MsgBox, %OutputVar%</langsyntaxhighlight>
 
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">ConsoleWrite("# Environment:" & @CRLF)
 
Local $sEnvVar = EnvGet("LANG")
ConsoleWrite("LANG : " & $sEnvVar & @CRLF)
 
ShowEnv("SystemDrive")
ShowEnv("USERNAME")
 
Func ShowEnv($N)
ConsoleWrite( StringFormat("%-12s : %s\n", $N, EnvGet($N)) )
EndFunc ;==>ShowEnv</syntaxhighlight>
 
{{Out}}
<pre># Environment:
LANG : DE
SystemDrive : C:
USERNAME : HaJo</pre>
 
=={{header|AWK}}==
The ENVIRON array contains the values of the current environment:
<langsyntaxhighlight lang="awk">$ awk 'BEGIN{print "HOME:"ENVIRON["HOME"],"USER:"ENVIRON["USER"]}' </syntaxhighlight>
{{out}}
HOME:/home/suchrich USER:SuchRich</lang>
<pre>
HOME:/home/suchrich USER:SuchRich</pre>
 
Environment variables can also be assigned to awk variables before execution, with (-v) options:
<langsyntaxhighlight lang="awk">$ awk -v h=$HOME -v u=$USER 'BEGIN{print "HOME:"h,"USER:"u}' </syntaxhighlight>
{{out}}
HOME:/home/suchrich USER:SuchRich</lang>
<pre>HOME:/home/suchrich USER:SuchRich</pre>
 
Listing all the environment variables:
<syntaxhighlight lang="awk"># http://ideone.com/St5SHF
BEGIN { print "# Environment:"
for (e in ENVIRON) { printf( "%10s = %s\n", e, ENVIRON[e] ) }
}
END { print "# Done." } </syntaxhighlight>
{{out}}
<pre>
# Environment:
AWKPATH = .:/usr/share/awk
AWKLIBPATH = /usr/lib/i386-linux-gnu/gawk
LANG = en_US.UTF-8
PATH = /usr/local/bin:/usr/bin:/bin
HOME = /home/guest
PWD = /home/guest
SHLVL = 0
TMPDIR = /home/guest
# Done.
 
</pre>
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="qbasic">x$ = ENVIRON$("path")
PRINT x$</langsyntaxhighlight>
 
==={{header|BaCon}}===
''Case matters and needs to match''
<syntaxhighlight lang="freebasic">PRINT GETENVIRON$("PATH")</syntaxhighlight>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 ASK BORDER VAR01
110 ASK DEFAULT CHANNEL VAR02
120 ASK EDITOR BUFFER VAR03
130 ASK EDITOR KEY VAR04
140 ASK EDITOR VIDEO VAR05
150 ASK FAST SAVE VAR06
160 ASK INTERRUPT KEY VAR07
170 ASK INTERRUPT NET VAR08
180 ASK INTERRUPT STOP VAR09
190 ASK KEY CLICK VAR10
200 ASK KEY DELAY VAR11
210 ASK KEY RATE VAR12
220 ASK NET CHANNEL VAR13
230 ASK NET MACHINE VAR14
240 ASK REM1 VAR15
250 ASK REM2 VAR16
260 ASK SERIAL BAUD VAR17
270 ASK SERIAL FORMAT VAR18
280 ASK STATUS VAR19
290 ASK SOUND BUFFER VAR20
300 ASK SPEAKER VAR21
310 ASK TAPE LEVEL VAR22
320 ASK TAPE SOUND VAR23
330 ASK TIMER VAR24
340 ASK VIDEO COLOR VAR25
350 ASK VIDEO MODE VAR26
360 ASK VIDEO X VAR27
370 ASK VIDEO Y VAR28</syntaxhighlight>
 
or
 
<syntaxhighlight lang="is-basic">ASK machine-option-code var</syntaxhighlight>
 
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
print env("HOME")
print env("PATH")
print env("USER")
</syntaxhighlight>
 
=== {{header|ZX Spectrum Basic}} ===
The ZX Spectrum does not use environmental variables in a traditional sense. However, it does provide a set of system variables held at a fixed memory address:
<langsyntaxhighlight lang="zxbasic">10 PRINT "The border colour is "; PEEK (23624): REM bordcr
20 PRINT "The ramtop address is "; PEEK (23730) + 256 * PEEK (23731): REM ramtop
30 POKE 23609,50: REM set keyboard pip to 50</langsyntaxhighlight>
 
=={{header|Batch File}}==
Batch files don't have any other kind of variables except environment variables. They can be accessed by enclosing the variable name in percent signs:
<syntaxhighlight lang ="dos">echo %Foo%</langsyntaxhighlight>
For interactive use one can use <code>set</code> to view all environment variables or all variables starting with a certain string:
<langsyntaxhighlight lang="dos">set
set Foo</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang="bbcbasic"> PRINT FNenvironment("PATH")
PRINT FNenvironment("USERNAME")
END
Line 89 ⟶ 223:
DIM buffer% LOCAL size%
SYS "GetEnvironmentVariable", envar$, buffer%, size%+1
= $$buffer%</langsyntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdlib.h>
#include <stdio.h>
 
int main() {
puts(getenv("HOME"));
puts(getenv("PATH"));
puts(getenv("USER"));
return 0;
}
}</lang>
</syntaxhighlight>
 
=={{header|C++}}==
<lang cpp>#include <cstdlib>
#include <cstdio>
 
int main()
{
puts(getenv("HOME"));
return 0;
}</lang>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
 
namespace RosettaCode {
Line 120 ⟶ 247:
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <cstdlib>
#include <cstdio>
 
int main()
{
puts(getenv("HOME"));
return 0;
}</syntaxhighlight>
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="lisp">(System/getenv "HOME")</langsyntaxhighlight>
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. Environment-Vars.
 
Line 143 ⟶ 280:
 
GOBACK
.</langsyntaxhighlight>
 
=={{header|CoffeeScript}}==
{{works with|node.js}}
<langsyntaxhighlight lang="coffeescript">for var_name in ['PATH', 'HOME', 'LANG', 'USER']
console.log var_name, process.env[var_name]</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Access to environment variables isn't a part of the Common Lisp standard, but most implementations provide some way to do it.
{{works with|LispWorks}}
<syntaxhighlight lang="lisp">(lispworks:environment-variable "USER")</syntaxhighlight>
{{works with|SBCL}}
<syntaxhighlight lang="lisp">(sb-ext:posix-getenv "USER")</syntaxhighlight>
{{works with|Clozure CL}}
<syntaxhighlight lang="lisp">(ccl:getenv "USER")</syntaxhighlight>
{{works with|CLISP}}
<syntaxhighlight lang="lisp">(getenv "HOME")</syntaxhighlight>
Ways to do this in some other implementations are listed in the [http://cl-cookbook.sourceforge.net/os.html#env Common Lisp Cookbook].
 
=={{header|D}}==
{{libheader|phobos}}
<langsyntaxhighlight lang="d">import std.stdio, std.process;
 
void main() {
auto home = getenv("HOME");
}</langsyntaxhighlight>
{{libheader|tango}}
<langsyntaxhighlight lang="d">import tango.sys.Environment;
 
void main() {
auto home = Environment("HOME");
}</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Access to environment variables isn't a part of the Common Lisp standard, but most implementations provide some way to do it.
{{works with|LispWorks}}
<lang lisp>(lispworks:environment-variable "USER")</lang>
{{works with|SBCL}}
<lang lisp>(sb-ext:posix-getenv "USER")</lang>
{{works with|Clozure CL}}
<lang lisp>(ccl:getenv "USER")</lang>
{{works with|CLISP}}
<lang lisp>(getenv "HOME")</lang>
Ways to do this in some other implementations are listed in the [http://cl-cookbook.sourceforge.net/os.html#env Common Lisp Cookbook].
 
=={{header|Delphi}}/{{header|Pascal}}==
<langsyntaxhighlight Delphilang="delphi">program EnvironmentVariable;
 
{$APPTYPE CONSOLE}
Line 185 ⟶ 322:
begin
WriteLn('Temp = ' + GetEnvironmentVariable('TEMP'));
end.</langsyntaxhighlight>
 
=={{header|E}}==
{{works with|E-on-Java}}
<langsyntaxhighlight lang="e"><unsafe:java.lang.System>.getenv("HOME")</langsyntaxhighlight>
 
=={{header|Eiffel}}==
The feature <code lang="eiffel">get</code> returns the value of an environment variable. <code lang="eiffel">get</code> is defined in the library class EXECUTION_ENVIRONMENT. So the class APPLICATION inherits from EXECUTION_ENVIRONMENT in order to make <code lang="eiffel">get</code> available.
<langsyntaxhighlight lang="eiffel ">class
APPLICATION
inherit
Line 205 ⟶ 342:
print (get ("USERNAME"))
end
end</langsyntaxhighlight>
 
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">System.get_env("PATH")</syntaxhighlight>
 
=={{header|Emacs Lisp}}==
<langsyntaxhighlight lang="lisp">(getenv "HOME")</langsyntaxhighlight>
 
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun showVariable = <text variable|writeLine(variable + ": '" + Runtime.get(variable) + "'")
showVariable("SystemDrive")
showVariable("USERNAME")
# we can get the environment variables as a map
Map variables = Runtime.variables()
writeLine(variables["TEMP"])
</syntaxhighlight>
{{Out}}
<pre>
SystemDrive: 'C:'
USERNAME: 'XXXYYY'
C:\Users\xxxyyy\AppData\Local\Temp
</pre>
 
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
os:getenv( "HOME" ).
</syntaxhighlight>
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">puts(1,getenv("PATH"))</langsyntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
let main args =
printfn "%A" (Environment.GetEnvironmentVariable("PATH"))
0</langsyntaxhighlight>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">"HOME" os-env print</langsyntaxhighlight>
 
=={{header|Forth}}==
{{works with|GNU Forth}}
<langsyntaxhighlight lang="forth">s" HOME" getenv type</langsyntaxhighlight>
 
=={{header|Fortran}}==
{{works with|any Fortran compiler}}
<langsyntaxhighlight lang="fortran">program show_home
implicit none
character(len=32) :: home_val ! The string value of the variable HOME
Line 244 ⟶ 405:
write(*,'(a)') 'No HOME to go to!'
end if
end program show_home</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Var v = Environ("SystemRoot")
Print v
Sleep</syntaxhighlight>
 
{{out}}
<pre>
C:\WINDOWS
</pre>
 
=={{header|Frink}}==
 
<syntaxhighlight lang="funl">callJava["java.lang.System", "getenv", ["HOME"]]</syntaxhighlight>
 
{{out}}
<pre>
/home/frink
</pre>
 
=={{header|FunL}}==
<syntaxhighlight lang="funl">println( System.getenv('PATH') )
println( $home )
println( $user )</syntaxhighlight>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
 
NSLog(@"%@",fn NSUserName)
NSLog(@"%@",fn NSFullUserName)
NSLog(@"%@",fn NSHomeDirectory)
NSLog(@"%@",fn NSTemporaryDirectory)
 
HandleEvents
</syntaxhighlight>
 
=={{header|Go}}==
;Simply:
<langsyntaxhighlight lang="go">package main
 
import (
Line 257 ⟶ 456:
func main() {
fmt.Println(os.Getenv("SHELL"))
}</langsyntaxhighlight>
{{out}}
Output:
<pre>
/bin/bash
</pre>
;Alternatively:
Library function os.Environ returns all environment variables. You're on your own then to parse out the one you want. Example:
You're on your own then to parse out the one you want.
<lang go>package main
Example:
<syntaxhighlight lang="go">package main
 
import (
Line 282 ⟶ 483:
}
fmt.Println(s, "not found")
}</langsyntaxhighlight>
{{out}}
Output:
<pre>
SHELL has value /bin/bash
</pre>
 
=={{header|Gri}}==
Command <code>get env</code> fetches an environment variable into a synonym (a string)
<syntaxhighlight lang="gri">get env \foo HOME
show "\foo"</syntaxhighlight>
 
Quotes can be used in the usual way if the environment variable name contains spaces (which is unusual, but possible).
<syntaxhighlight lang="gri">get env \foo "X Y Z"</syntaxhighlight>
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">System.getenv().each { property, value -> println "$property = $value"}</langsyntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import System.Environment
main = do getEnv "HOME" >>= print -- get env var
getEnvironment >>= print -- get the entire environment as a list of (key, value) pairs</langsyntaxhighlight>
 
=={{header|hexiscript}}==
<syntaxhighlight lang="hexiscript">println env "HOME"
println env "PATH"
println env "USER"</syntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">CHARACTER string*255
 
string = "PATH="
SYSTEM(GEteNV = string)</langsyntaxhighlight>
 
=={{header|i}}==
<syntaxhighlight lang="i">software {
print(load("$HOME"))
print(load("$USER"))
print(load("$PATH"))
}</syntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
{{works with|Unicon}}
<langsyntaxhighlight Iconlang="icon">procedure main(arglist)
 
if *envars = 0 then envars := ["HOME", "TRACE", "BLKSIZE","STRSIZE","COEXPSIZE","MSTKSIZE", "IPATH","LPATH","NOERRBUF"]
Line 310 ⟶ 531:
every v := !sort(envars) do
write(v," = ",image(getenv(v))|"* not set *")
end</langsyntaxhighlight>
 
=={{header|J}}==
<syntaxhighlight lang ="j">2!:5'HOME'</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">System.getenv("HOME") // get env var
System.getenv() // get the entire environment as a Map of keys to values</langsyntaxhighlight>
 
=={{header|JavaScript}}==
The JavaScript language has no facilities to access the computer: it relies on the host environment to provide it.
{{works with|JScript}}
<langsyntaxhighlight lang="javascript">var shell = new ActiveXObject("WScript.Shell");
var env = shell.Environment("PROCESS");
WScript.echo('SYSTEMROOT=' + env.item('SYSTEMROOT'));</langsyntaxhighlight>
 
=={{header|Joy}}==
<langsyntaxhighlight lang="joy">"HOME" getenv.</langsyntaxhighlight>
 
=={{header|jq}}==
<syntaxhighlight lang="jq">env.HOME</syntaxhighlight>If the environment variable name has spaces or special characters, the name must be given as a string, e.g. <tt>env."HOME"</tt>.
 
=={{header|jsish}}==
The Jsi ''Util'' module provides access to set ''Util.setenv(name, value)'' and get ''Util.getenv(name)'' process environment variables. ''Util.getenv()'', with no argument will return an object with all available name:value pairs.
<syntaxhighlight lang="javascript">/* Environment variables, in Jsi */
puts(Util.getenv("HOME"));
var environment = Util.getenv();
puts(environment.PATH);</syntaxhighlight>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
 
<syntaxhighlight lang="julia">@show ENV["PATH"]
@show ENV["HOME"]
@show ENV["USER"]</syntaxhighlight>
 
=={{header|K}}==
<langsyntaxhighlight Klang="k">_getenv "HOME"</langsyntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
 
// tested on Windows 10
 
fun main(args: Array<String>) {
println(System.getenv("SystemRoot"))
}</syntaxhighlight>
 
{{out}}
<pre>
C:\WINDOWS
</pre>
 
=={{header|langur}}==
<syntaxhighlight lang="langur">
writeln "HOME: ", _env'HOME
writeln "PATH: ", _env'PATH
writeln "USER: ", _env'USER
</syntaxhighlight>
 
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">#!/usr/bin/lasso9
 
define getenv(sysvar::string) => {
local(regexp = regexp(
-find = `(?m)^` + #sysvar + `=(.*?)$`,
-input = sys_environ -> join('\n'),
-ignorecase
))
return #regexp ->find ? #regexp -> matchString(1)
}
 
stdoutnl(getenv('HOME'))
stdoutnl(getenv('PATH'))
stdoutnl(getenv('USER'))
stdoutnl(getenv('WHAT'))</syntaxhighlight>
{{out}}
<pre>/Users/rosetta
/opt/local/bin:/opt/local/sbin:/usr/local/bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/X11/bin
rosetta
</pre>
 
=={{header|Liberty BASIC}}==
=== Built-in variables ===
<langsyntaxhighlight lang="lb">print StartupDir$
print DefaultDir$</langsyntaxhighlight>
=== Other variables ===
<langsyntaxhighlight lang="lb">print GetEnvironmentVariable$("USERNAME")
print GetEnvironmentVariable$("USERPROFILE") ' equivalent to UNIX HOME variable
print GetEnvironmentVariable$("PATH")
Line 365 ⟶ 646:
GetEnvironmentVariable$ = left$(lpBuffer$, result)
end select
end function</langsyntaxhighlight>
 
=={{header|LIL}}==
LIL does not ship with a command to retrieve process environment variables. The '''system''' command could be used, but here is an extension in C for the lil shell.
 
<syntaxhighlight lang="c">
static LILCALLBACK lil_value_t fnc_env(lil_t lil, size_t argc, lil_value_t* argv)
{
if (!argc) return NULL;
return lil_alloc_string(getenv(lil_to_string(argv[0])));
}</syntaxhighlight>
 
Then inside the main functions for repl and nonint (Interactive, Noninteractive):
<syntaxhighlight lang="c">lil_register(lil, "env", fnc_env);</syntaxhighlight>
 
Now lil can get at the environment. That could fairly easily be extended further to return the entire environment array if no arguments are passed to '''env''', this just returns an empty result for that case. Defaults values could also be supported if the named environment variable is empty. Etcetera. Setting variables would be similar, a few lines of lil C to wrap a call to libc setenv in a new command, and registering the command.
 
{{out}}
<pre>prompt$ make
cc -c -g3 -std=c99 -pedantic -Wall -Wextra -Wno-format -Wno-long-long -Wno-unused-parameter main.c -o main.o
cc -g -L. -o lil main.o -llil -lm
 
prompt$ lil
Little Interpreted Language Interactive Shell
# env TERM
xterm-256color</pre>
 
=={{header|Lingo}}==
{{libheader|Shell Xtra}}
<syntaxhighlight lang="lingo">sx = xtra("Shell").new()
if the platform contains "win" then
path = sx.shell_cmd("echo %PATH%").line[1]
else
path = sx.shell_cmd("echo $PATH").line[1]
end if</syntaxhighlight>
 
=={{header|Logtalk}}==
Using the standard library:
<syntaxhighlight lang="logtalk">os::environment_variable('PATH', Path).</syntaxhighlight>
 
=={{header|LSL}}==
Rez a box on the ground, and add the following as a New Script.
<langsyntaxhighlight LSLlang="lsl">default {
state_entry() {
llOwnerSay("llGetTimestamp()="+(string)llGetTimestamp());
Line 376 ⟶ 695:
llOwnerSay("llGetMemoryLimit()="+(string)llGetMemoryLimit());
}
}</langsyntaxhighlight>
{{out}}
Output:
<pre>llGetTimestamp()=2012-07-18T01:26:12.133137Z
llGetEnergy()=1.230000
Line 384 ⟶ 703:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">print( os.getenv( "PATH" ) )</langsyntaxhighlight>
 
=={{header|MathematicaM2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
<lang Mathematica>Environment["PATH"]</lang>
Module CheckIt {
\\ using read only variablles
Print "Platform: ";Platform$
Print "Computer Os: "; Os$
Print "Type of OS: ";OsBit;" bit"
Print "Computer Name:"; Computer$
Print "User Name: "; User.Name$
\\ using WScript.Shell
Declare objShell "WScript.Shell"
With objShell, "Environment" set env ("Process")
With env, "item" as Env$()
Print Env$("PATH")
Print Env$("HOMEPATH")
Declare objShell Nothing
\\ using internal Information object
Declare OsInfo INFORMATION
With OsInfo, "build" as build, "NtDllVersion" as NtDllVersion$
Method OsInfo, "GetCurrentProcessSID" as PID$
Method OsInfo, "IsProcessElevated" as isElevated
Print "Os build number: ";build
Print "Nr Dll version: ";NtDllVersion$
Print "ProcessSID: ";pid$
Print "Is Process Eleveted: ";isElevated
Declare OsInfo Nothing
}
Checkit
</syntaxhighlight>
 
=={{header|Make}}==
Make variables are initialized from the environment, so simply
<syntaxhighlight lang="make">TARGET = $(HOME)/some/thing.txt
foo:
echo $(TARGET)</syntaxhighlight>
 
The shell code in a rule can use the shell's environment in the usual way ([[Environment variables#Unix Shell|Unix Shell]]), but remember <code>$</code> must be doubled <code>$$</code> to get a literal <code>$</code> in that code.
<syntaxhighlight lang="make">bar:
echo "$$HOME"</syntaxhighlight>
 
If you mistakenly write just <code>$HOME</code> then it means the makefile <code>$H</code> followed by characters <code>OME</code>.
 
<syntaxhighlight lang="make">H = oops ...
bar:
echo $HOME
 
# prints oops ... OME</syntaxhighlight>
 
=={{header|Maple}}==
<syntaxhighlight lang="maple">getenv("PATH");</syntaxhighlight>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Environment["PATH"]</syntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
<langsyntaxhighlight MATLABlang="matlab"> getenv('HOME')
getenv('PATH')
getenv('USER')</langsyntaxhighlight>
 
=={{header|Mercury}}==
<langsyntaxhighlight lang="mercury">:- module env_var.
:- interface.
 
Line 412 ⟶ 782:
MaybeValue = no,
io.write_string("environment variable HOME not set\n", !IO)
).</langsyntaxhighlight>
 
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">$PATH</syntaxhighlight>
 
=={{header|Modula-3}}==
<syntaxhighlight lang="modula3">MODULE EnvVars EXPORTS Main;
 
IMPORT IO, Env;
 
VAR
k, v: TEXT;
 
BEGIN
IO.Put(Env.Get("HOME") & "\n");
 
FOR i := 0 TO Env.Count - 1 DO
Env.GetNth(i, k, v);
IO.Put(k & " = " & v & "\n")
END
END EnvVars.</syntaxhighlight>
 
=={{header|MUMPS}}==
Line 418 ⟶ 809:
 
In Caché on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:
<langsyntaxhighlight MUMPSlang="mumps"> Set X=$ZF(-1,"show logical")
Set X=$ZF(-1,"show symbol")</langsyntaxhighlight>
 
=={{header|NetRexx}}==
When NetRexx runs under a JVM, system ENVIRONMENT variables are complimented by JVM system properties. This sample shows how to get both.
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
Line 483 ⟶ 874:
say
return
</syntaxhighlight>
</lang>
{{out}}
'''Output:'''
<pre>
---- Environment "CLASSPATH" ---------------------------------------------------
Line 517 ⟶ 908:
 
=={{header|NewLISP}}==
<langsyntaxhighlight NewLISPlang="newlisp">> (env "SHELL")
"/bin/zsh"
> (env "TERM")
"xterm"</langsyntaxhighlight>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import os
echo getEnv("HOME")</syntaxhighlight>
 
=={{header|NSIS}}==
While common environment variables exist as constants within the NSIS script compilation environment [http://nsis.sourceforge.net/Docs/Chapter4.html#4.2.3 (see NSIS documentation)], arbitrarily-named environment variables' values may be retrieved using [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.2.7 '''ExpandEnvStrings'''].
<langsyntaxhighlight lang="nsis">ExpandEnvStrings $0 "%PATH%" ; Retrieve PATH and place it in builtin register 0.
ExpandEnvStrings $1 "%USERPROFILE%" ; Retrieve the user's profile location and place it in builtin register 1.
ExpandEnvStrings $2 "%USERNAME%" ; Retrieve the user's account name and place it in builtin register 2.</langsyntaxhighlight>
 
=={{header|Nu}}==
<syntaxhighlight lang="nu">
$env.HOME
</syntaxhighlight>
 
=={{header|Objective-C}}==
<code>[[NSProcessInfo processInfo] environment]</code> returns an <tt>NSDictionary</tt> of the current environment.
<langsyntaxhighlight lang="objc">[[[NSProcessInfo processInfo] environment] objectForKey:@"HOME"]</langsyntaxhighlight>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">Sys.getenv "HOME"</langsyntaxhighlight>
 
=={{header|Oforth}}==
 
<syntaxhighlight lang="oforth">System getEnv("PATH") println</syntaxhighlight>
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">{System.showInfo "This is where Mozart is installed: "#{OS.getEnv 'OZHOME'}}</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.6.0 and above}}
<langsyntaxhighlight lang="parigp">getenv("HOME")</langsyntaxhighlight>
{{works with|PARI/GP|2.4.3 and above}}
<langsyntaxhighlight lang="parigp">externstr("echo $HOME")</langsyntaxhighlight>
{{works with|PARI/GP|2.0.3 and above}}
In older versions, the command must effectively be triple-quoted:
<langsyntaxhighlight lang="parigp">extern("echo \"\\\"$HOME\\\"\"")</langsyntaxhighlight>
The shell sees
<langsyntaxhighlight lang="bash">echo "\"$HOME\""</langsyntaxhighlight>
which causes it to return
<pre>"/home/username"</pre>
Line 553 ⟶ 957:
 
Leaving out the quotation marks allows external commands to return expressions that are then evaluated by GP. For example,
<langsyntaxhighlight lang="parigp">extern("echo Pi")</langsyntaxhighlight>
causes the shell to send Pi back to GP, which interprets the result and returns
<pre>%1 = 3.141592653589793238462643383</pre>
Line 559 ⟶ 963:
=={{header|Perl}}==
The <code>%ENV</code> hash maps environment variables to their values:
<langsyntaxhighlight lang="perl">print $ENV{HOME}, "\n";</langsyntaxhighlight>
 
The <code>POSIX</code>module also has <code>getenv()</code> which is the same thing as a function.
=={{header|Perl 6}}==
<syntaxhighlight lang="perl">use POSIX 'getenv';
{{works with|Rakudo|#24 "Seoul"}}
print getenv("HOME"),"\n";</syntaxhighlight>
The <code>%*ENV</code> hash maps environment variables to their values:
 
<lang perl6>say %*ENV<HOME>;</lang>
=={{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;">-- none such in a browser, that I know of</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">getenv</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"PATH"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
 
=={{header|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/Environment_variables
by Galileo, 10/2022 #/
 
def getenv
" > output.txt" chain cmd if "Error!" else "output.txt" "r" fopen dup fgets swap fclose endif
enddef
 
"path" getenv print</syntaxhighlight>
 
=={{header|PHP}}==
The <tt>$_ENV</tt> associative array maps environmental variable names to their values:
<syntaxhighlight lang ="php">$_ENV['HOME']</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">: (sys "TERM")
-> "xterm"
 
: (sys "SHELL")
-> "/bin/bash"</langsyntaxhighlight>
 
=={{header|Pike}}==
<syntaxhighlight lang="pike">write("%s\n", getenv("SHELL"));</syntaxhighlight>
{{Out}}
<pre>
/bin/bash
</pre>
 
=={{header|PowerShell}}==
Environment variables can be found in the Env: drive and are accessed using a special variable syntax:
<syntaxhighlight lang ="powershell">$Env:Path</langsyntaxhighlight>
To get a complete listing of all environment variables one can simply query the appropriate drive for its contents:
<syntaxhighlight lang ="powershell">Get-ChildItem Env:</langsyntaxhighlight>
 
=={{header|Prolog}}==
Line 587 ⟶ 1,013:
<pre> ?- getenv('TEMP', Temp).
</pre>
 
=={{header|PureBasic}}==
PureBasic has the built in funtion
<langsyntaxhighlight PureBasiclang="purebasic">GetEnvironmentVariable("Name")</langsyntaxhighlight>
'''Example'''
<langsyntaxhighlight PureBasiclang="purebasic">If OpenConsole()
PrintN("Path:"+#CRLF$ + GetEnvironmentVariable("PATH"))
PrintN(#CRLF$+#CRLF$+"NUMBER_OF_PROCESSORS= "+ GetEnvironmentVariable("NUMBER_OF_PROCESSORS"))
Line 598 ⟶ 1,025:
Input()
CloseConsole()
EndIf</langsyntaxhighlight>
 
=={{header|Python}}==
The <tt>os.environ</tt> dictionary maps environmental variable names to their values:
<langsyntaxhighlight lang="python">import os
os.environ['HOME']</langsyntaxhighlight>
 
=={{header|R}}==
<langsyntaxhighlight Rlang="r">Sys.getenv("PATH")</langsyntaxhighlight>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(getenv "HOME")
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|#24 "Seoul"}}
The <code>%*ENV</code> hash maps environment variables to their values:
<syntaxhighlight lang="raku" line>say %*ENV<HOME>;</syntaxhighlight>
 
=={{header|REBOL}}==
<langsyntaxhighlight REBOLlang="rebol">print get-env "HOME"</langsyntaxhighlight>
 
=={{header|Retro}}==
<langsyntaxhighlight Retrolang="retro">here "HOME" getEnv
here puts</langsyntaxhighlight>
 
=={{header|REXX}}==
Each REXX interpreter sets its own rules by what identifies the pool in which the environmental variables are named. In addition, each operation system (OS) has their own definition as well. This makes it problamaticproblematic in the acessingaccessing/acquiring of environmental variables. Most programmers know what REXX interpreter they are using, and furthermore, they also know what operating system they are writing the REXX program for, so most programmers hard-wire (explicitly code) the "access-name" of the system environmental variables into the program.
 
The following will work for
Line 633 ⟶ 1,066:
{{works with|R4}}
{{works with|ROO}}
<langsyntaxhighlight lang="rexx">/*REXX program shows how to get an environmental variable under Windows*/
 
x=value('TEMP',,'SYSTEM')</langsyntaxhighlight>
The following will work for
::* '''PC/REXX'''
Line 647 ⟶ 1,080:
{{works with|Regina}}
{{works with|ooRexx}}
<langsyntaxhighlight lang="rexx">/*REXX program shows how to get an environmental variable under Windows*/
 
x=value('TEMP',,'ENVIRONMENT')</langsyntaxhighlight>
 
The brexx interpreter provides a getenv function for accessing environment variables:
{{works with|Brexx}}
<langsyntaxhighlight lang="rexx">x=getenv("PATH") /* Get the contents of the path environment variable */</langsyntaxhighlight>
 
Other REXX interpreters have their own requirements to identify the SYSTEM environment.
Line 661 ⟶ 1,094:
::* permanent
As such, CMS has its own command interface for these variables.
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
see get("path")
</syntaxhighlight>
 
=={{header|Ruby}}==
The <tt>ENV</tt> hash maps environment variable names to their values:
<syntaxhighlight lang ="ruby">ENV['HOME']</langsyntaxhighlight>
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">' ------- Major environment variables -------------------------------------------
'DefaultDir$ - The folder path where program files are read/written by default
'Platform$ - The operating system on which Run BASIC is being hosted
Line 686 ⟶ 1,124:
print "User Address is: ";UserAddress$
print "Event Key is : ";EventKey$
print "Default Dir is : ";DefaultDir$</langsyntaxhighlight>
<pre>
{{out}}
Output:
User Info is : Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.79 Safari/535.11
Platform is : win32
Line 696 ⟶ 1,134:
Default Dir is : c:\rbp101
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::env;
 
fn main() {
println!("{:?}", env::var("HOME"));
println!();
for (k, v) in env::vars().filter(|(k, _)| k.starts_with('P')) {
println!("{}: {}", k, v);
}
}
</syntaxhighlight>
{{out}}
<pre>Ok("/root")
 
PATH: /root/.cargo/bin:/root/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PLAYGROUND_EDITION: 2018
PLAYGROUND_TIMEOUT: 10
PWD: /playground</pre>
Note that <code>var_os</code> and <code>vars_os</code> are also available, which produce <code>OsString</code> instead of <code>String</code>, offering compatibility with non-utf8 systems.
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">sys.env.get("HOME")</syntaxhighlight>
 
=={{header|Seed7}}==
Line 702 ⟶ 1,163:
dependent. Some variables such as HOME are not always defined and others like PATH use
an operating system dependent format (different delimiters). Seed7 provides the functions
[http://seed7.sourceforge.net/libraries/osfiles.htm#homeDir homeDir] and [http://seed7.sourceforge.net/libraries/process.htm#getSearchPath getSearchPath]
to get the home directory and the search path in an operating system independent manner.
 
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
const proc: main is func
begin
writeln(getenv("HOME"));
end func;</langsyntaxhighlight>
 
=={{header|Sidef}}==
The ''ENV'' hash maps environment variables to their values:
<syntaxhighlight lang="ruby">say ENV{'HOME'};</syntaxhighlight>
 
=={{header|Slate}}==
<langsyntaxhighlight lang="slate">Environment variables at: 'PATH'.
"==> '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games'"</langsyntaxhighlight>
 
=={{header|Standard MLSlope}}==
<syntaxhighlight lang="slope">(env "HOME")</syntaxhighlight>
<lang sml>OS.Process.getEnv "HOME"</lang>
 
returns an option type which is either SOME value or NONE if variable doesn't exist
=={{header|Smalltalk}}==
Use the [http://pharo.gemtalksystems.com/book/PharoTools/OSProcess OSProcess] library to gain access to environment variables:
 
<syntaxhighlight lang="smalltalk">
OSProcess thisOSProcess environment at: #HOME.
OSProcess thisOSProcess environment at: #PATH.
OSProcess thisOSProcess environment at: #USER.
</syntaxhighlight>
 
=={{header|SNOBOL4}}==
Line 724 ⟶ 1,197:
{{works with|CSnobol}}
The host(4) function returns a known environment variable.
<langsyntaxhighlight SNOBOL4lang="snobol4"> output = host(4,'PATH')
end</langsyntaxhighlight>
 
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">OS.Process.getEnv "HOME"</syntaxhighlight>
returns an option type which is either SOME value or NONE if variable doesn't exist
 
=={{header|Stata}}==
Use the '''env''' [http://www.stata.com/help.cgi?extended_fcn extended macro function].
 
<syntaxhighlight lang="stata">display "`:env PATH'"
display "`:env USERNAME'"
display "`:env USERPROFILE'"</syntaxhighlight>
 
=={{header|Swift}}==
 
<syntaxhighlight lang="swift">print("USER: \(ProcessInfo.processInfo.environment["USER"] ?? "Not set")")
print("PATH: \(ProcessInfo.processInfo.environment["PATH"] ?? "Not set")")</syntaxhighlight>
 
=={{header|True BASIC}}==
<syntaxhighlight lang="qbasic">ASK #1: ACCESS type$
ASK BACK red
ASK COLOR red
ASK COLOR MIX (2) red, green, blue
ASK CURSOR vble1, vble2
ASK #2: DATUM type$
ASK DIRECTORY dir$
ASK #3: ERASABLE type$
ASK #4: FILESIZE vble09
ASK #5: FILETYPE vble10
ASK FREE MEMORY vble11
ASK #61: MARGIN vble12
ASK MAX COLOR vble13
ASK MAX CURSOR vble1, vble2
ASK MODE vble15$
ASK NAME vble16$
ASK #7: ORGANIZATION vble17$
ASK PIXELS vble1, vble2
ASK #8: POINTER vble19$
ASK #9: RECORD vble20
ASK #1: RECSIZE vble21
ASK #2: RECTYPE vble22$
ASK SCREEN vble1, vble2, vble3, vble4
ASK #3: SETTER vble24$
ASK TEXT JUSTIFY vble1$, vble2$
ASK WINDOW vble1, vble2, vble3, vble4
ASK #4: ZONEWIDTH vble27</syntaxhighlight>
 
=={{header|Tcl}}==
The <code>env</code> global array maps environmental variable names to their values:
<syntaxhighlight lang ="tcl">$env(HOME)</langsyntaxhighlight>
 
=={{header|TXR}}==
TXR can treat the environment vector as text stream:
<langsyntaxhighlight lang="txr">@(next :env)
@(collect)
@VAR=@VAL
@(end)</langsyntaxhighlight>
A recently added <code>gather</code> directive is useful for extracting multiple items of data from an unordered stream of this kind (not only the environment vector):
<langsyntaxhighlight lang="txr">@(next :env)
@(gather)
HOME=@home
USER=@user
PATH=@path
@(end)</langsyntaxhighlight>
What if some of the variables might not exist? Gather has some discipline for that. The following means that three variables are required (the gather construct fails if they are not found), but <code>shell</code> is optional with a default value of <code>/bin/sh</code> if it is not extracted from the data:
<langsyntaxhighlight lang="txr">@(next :env)
@(gather :vars (home user path (shell "/bin/sh")))
HOME=@home
Line 751 ⟶ 1,269:
PATH=@path
SHELL=@shell
@(end)</langsyntaxhighlight>
OnFrom POSIXTXR Lisp, the environment variables,is whichavailable arevia extracted usingthe <code>extern char **environ(env)</code> arefunction, assumedwhich toreturns containa UTF-8.raw Onlist Windows,of the<code>"name=value</code> strings. The <code>GetEnvironmentStringsW(env-hash)</code> function isreturns useda tohash obtain thefrom environment vectorkeys as wideto charactertheir datavalues.
 
<syntaxhighlight lang="bash">$ ./txr -p "(mapcar (env-hash) '(\"HOME\" \"USER\" \"PATH\"))"
("/home/kaz" "kaz" "/home/kaz/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/kaz/bin"</syntaxhighlight>
 
Here, the hash is being used as a function to filter several environment keys to their values via <code>mapcar</code>.
 
 
Platform note: On POSIX, environment variables, which are extracted using <code>extern char **environ</code> are assumed to contain UTF-8. On Windows, the <code>GetEnvironmentStringsW</code> function is used to obtain the environment vector as wide character data.
 
=={{header|UNIX Shell}}==
In the Unix Shell Language, environment variables are available as ordinary variables:
<langsyntaxhighlight lang="bash">echo "$HOME"</langsyntaxhighlight>
An ordinary variable can be marked as an environment variable with the <code>export</code> command:
<syntaxhighlight lang ="bash">export VAR</langsyntaxhighlight>
Now child processes launched by the shell will have an environment variable called <code>VAR</code>.
 
The Unix command "env" will print out all of the environment variables as key=value pairs on standard output.
as key=value pairs on standard output.
 
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">import "system"
out (system.getenv "HOME") endl console</syntaxhighlight>
 
=={{header|Ursala}}==
The argument to the main program is a record initialized by the run-time system in which one of the fields (environs) contains the environment as a list of key:value pairs.
<langsyntaxhighlight Ursalalang="ursala">#import std
 
#executable ('parameterized','')
 
showenv = <.file$[contents: --<''>]>+ %smP+ ~&n-={'TERM','SHELL','X11BROWSER'}*~+ ~environs</langsyntaxhighlight>
The rest of this application searches for the three variables named and displays them on standard output.
and displays them on standard output.
Here is a bash session.
 
{{out|Here is a bash session}}
<pre>
$ showenv
Line 778 ⟶ 1,311:
'SHELL': '/bin/bash',
'X11BROWSER': '/usr/bin/firefox'></pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">// Environment variables in V
// v run environment_variables.v
module main
 
import os
 
pub fn main() {
print('In the $os.environ().len environment variables, ')
println('\$HOME is set to ${os.getenv('HOME')}')
}</syntaxhighlight>
 
{{out}}<pre>prompt$ v run environment-variables.v
In the 64 environment variables, $HOME is set to /home/btiffin</pre>
 
=={{header|Vedit macro language}}==
<langsyntaxhighlight lang="vedit">Get_Environment(10,"PATH")
Message(@10)</langsyntaxhighlight>
Or with short keywords:
<langsyntaxhighlight lang="vedit">GE(10,"PATH") M(@10)</langsyntaxhighlight>
 
=={{header|Visual Basic}}==
{{works with|Visual Basic|VB6 Standard}}
<syntaxhighlight lang="vb">Debug.Print Environ$("PATH")</syntaxhighlight>
 
=={{header|Wren}}==
Wren CLI doesn't currently expose a way to obtain the value of an environment variable.
 
However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to obtain it for us.
<syntaxhighlight lang="wren">/* Environment_variables.wren */
class Environ {
foreign static variable(name)
}
 
System.print(Environ.variable("SHELL"))</syntaxhighlight>
 
which we embed in the following Go program and run it.
{{libheader|WrenGo}}
<syntaxhighlight lang="go">/* Environment_variables.go */
package main
 
import (
wren "github.com/crazyinfin8/WrenGo"
"os"
)
 
type any = interface{}
 
func getEnvironVariable(vm *wren.VM, parameters []any) (any, error) {
name := parameters[1].(string)
return os.Getenv(name), nil
}
 
func main() {
vm := wren.NewVM()
fileName := "Environment_variables.wren"
methodMap := wren.MethodMap{"static variable(_)": getEnvironVariable}
classMap := wren.ClassMap{"Environ": wren.NewClass(nil, nil, methodMap)}
module := wren.NewModule(classMap)
vm.SetModule(fileName, module)
vm.InterpretFile(fileName)
vm.Free()
}</syntaxhighlight>
 
{{out}}
<pre>
/bin/bash
</pre>
 
=={{header|XPL0}}==
Line 791 ⟶ 1,387:
version work the same as the 16-bit real-mode versions.
 
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
string 0; \use zero-terminated strings
int CpuReg, PspSeg, EnvSeg, I, J, C;
Line 818 ⟶ 1,414:
if Peek(EnvSeg,I) = 0 then quit; \double 0 = env. var. not found
];
]</langsyntaxhighlight>
 
{{out}}
Output:
<pre>
PATH=\masm6;C:\;C:\CXPL;C:\UTIL;C:\DOS;C:\BORLANDC\BIN
</pre>
 
=={{header|Yabasic}}==
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have an environment other than regular global variables. -->
<code>peek$("env","NAME")</code> Return the environment variable specified by NAME (which may be any string expression).
{{omit from|M4}}
 
{{omit from|Unlambda|Does not provide access to environment variables.}}
Which kind of environment variables are available on your system depends, as well as their meaning, on your system; however typing env on the command line will produce a list (for Windows and Unix alike).
 
Note, that peek$("env",...) can be written as peek$("environment",...) too.
 
=={{header|zkl}}==
<syntaxhighlight lang="zkl">System.getenv("HOME")
/home/craigd
System.getenv() //--> Dictionary of all env vars</syntaxhighlight>
J7M
29

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/94492...365606"