Environment variables: Difference between revisions
Content deleted Content added
Added AppleScript implementation to get home |
Add SmallBASIC |
||
(19 intermediate revisions by 14 users not shown) | |||
Line 17:
=={{header|11l}}==
<syntaxhighlight lang
=={{header|Ada}}==
Print a single environment variable.
<
with Ada.Text_Io; use Ada.Text_Io;
Line 27:
begin
Put_Line("Path : " & Value("PATH"));
end Print_Path;</
Print all environment variable names and values.
<
with Ada.Text_Io; use Ada.Text_Io;
Line 39:
begin
Iterate(Print_Vars'access);
end Env_Vars;</
Line 46:
Uses [http://forge.ada-ru.org/matreshka Matreshka].
<
with League.Application;
Line 60:
Ada.Wide_Wide_Text_IO.Put_Line
(League.Application.Environment.Value (+"HOME").To_Wide_Wide_String);
end Main;</
=={{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}}
<
=={{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}}==
<
print ["user:" env\USER]
print ["home:" env\HOME]</
{{out}}
Line 84 ⟶ 95:
=={{header|AutoHotkey}}==
<
MsgBox, %OutputVar%</
=={{header|AutoIt}}==
<
Local $sEnvVar = EnvGet("LANG")
Line 98 ⟶ 109:
Func ShowEnv($N)
ConsoleWrite( StringFormat("%-12s : %s\n", $N, EnvGet($N)) )
EndFunc ;==>ShowEnv</
{{Out}}
Line 108 ⟶ 119:
=={{header|AWK}}==
The ENVIRON array contains the values of the current environment:
<
{{out}}
<pre>
Line 114 ⟶ 125:
Environment variables can also be assigned to awk variables before execution, with (-v) options:
<
{{out}}
<pre>HOME:/home/suchrich USER:SuchRich</pre>
Listing all the environment variables:
<
BEGIN { print "# Environment:"
for (e in ENVIRON) { printf( "%10s = %s\n", e, ENVIRON[e] ) }
}
END { print "# Done." } </
{{out}}
<pre>
Line 140 ⟶ 151:
=={{header|BASIC}}==
<
PRINT x$</
==={{header|BaCon}}===
''Case matters and needs to match''
<
==={{header|IS-BASIC}}===
<
110 ASK DEFAULT CHANNEL VAR02
120 ASK EDITOR BUFFER VAR03
Line 175 ⟶ 186:
350 ASK VIDEO MODE VAR26
360 ASK VIDEO X VAR27
370 ASK VIDEO Y VAR28</
or
<syntaxhighlight lang
==={{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:
<
20 PRINT "The ramtop address is "; PEEK (23730) + 256 * PEEK (23731): REM ramtop
30 POKE 23609,50: REM set keyboard pip to 50</
=={{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
For interactive use one can use <code>set</code> to view all environment variables or all variables starting with a certain string:
<
set Foo</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
PRINT FNenvironment("USERNAME")
END
Line 205 ⟶ 223:
DIM buffer% LOCAL size%
SYS "GetEnvironmentVariable", envar$, buffer%, size%+1
= $$buffer%</
=={{header|C}}==
<
#include <stdio.h>
Line 217 ⟶ 235:
return 0;
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
<
namespace RosettaCode {
Line 229 ⟶ 247:
}
}
}</
=={{header|C++}}==
<
#include <cstdio>
Line 239 ⟶ 257:
puts(getenv("HOME"));
return 0;
}</
=={{header|Clojure}}==
<
=={{header|COBOL}}==
<
PROGRAM-ID. Environment-Vars.
Line 262 ⟶ 280:
GOBACK
.</
=={{header|CoffeeScript}}==
{{works with|node.js}}
<
console.log var_name, process.env[var_name]</
=={{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}}
<
{{works with|SBCL}}
<
{{works with|Clozure CL}}
<
{{works with|CLISP}}
<
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}}
<
void main() {
auto home = getenv("HOME");
}</
{{libheader|tango}}
<
void main() {
auto home = Environment("HOME");
}</
=={{header|Delphi}}/{{header|Pascal}}==
<
{$APPTYPE CONSOLE}
Line 304 ⟶ 322:
begin
WriteLn('Temp = ' + GetEnvironmentVariable('TEMP'));
end.</
=={{header|E}}==
{{works with|E-on-Java}}
<
=={{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.
<
APPLICATION
inherit
Line 324 ⟶ 342:
print (get ("USERNAME"))
end
end</
=={{header|Elixir}}==
<
=={{header|Emacs Lisp}}==
<
=={{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}}==
<
=={{header|F_Sharp|F#}}==
<
[<EntryPoint>]
let main args =
printfn "%A" (Environment.GetEnvironmentVariable("PATH"))
0</
=={{header|Factor}}==
<
=={{header|Forth}}==
{{works with|GNU Forth}}
<
=={{header|Fortran}}==
{{works with|any Fortran compiler}}
<
implicit none
character(len=32) :: home_val ! The string value of the variable HOME
Line 371 ⟶ 405:
write(*,'(a)') 'No HOME to go to!'
end if
end program show_home</
=={{header|FreeBASIC}}==
<
Var v = Environ("SystemRoot")
Print v
Sleep</
{{out}}
Line 387 ⟶ 421:
=={{header|Frink}}==
<
{{out}}
Line 395 ⟶ 429:
=={{header|FunL}}==
<
println( $home )
println( $user )</
=={{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:
<
import (
Line 410 ⟶ 456:
func main() {
fmt.Println(os.Getenv("SHELL"))
}</
{{out}}
<pre>
Line 419 ⟶ 465:
You're on your own then to parse out the one you want.
Example:
<
import (
Line 437 ⟶ 483:
}
fmt.Println(s, "not found")
}</
{{out}}
<pre>
Line 445 ⟶ 491:
=={{header|Gri}}==
Command <code>get env</code> fetches an environment variable into a synonym (a string)
<
show "\foo"</
Quotes can be used in the usual way if the environment variable name contains spaces (which is unusual, but possible).
<
=={{header|Groovy}}==
<
=={{header|Haskell}}==
<
main = do getEnv "HOME" >>= print -- get env var
getEnvironment >>= print -- get the entire environment as a list of (key, value) pairs</
=={{header|hexiscript}}==
<
println env "PATH"
println env "USER"</
=={{header|HicEst}}==
<
string = "PATH="
SYSTEM(GEteNV = string)</
=={{header|i}}==
<
print(load("$HOME"))
print(load("$USER"))
print(load("$PATH"))
}</
=={{header|Icon}} and {{header|Unicon}}==
{{works with|Unicon}}
<
if *envars = 0 then envars := ["HOME", "TRACE", "BLKSIZE","STRSIZE","COEXPSIZE","MSTKSIZE", "IPATH","LPATH","NOERRBUF"]
Line 485 ⟶ 531:
every v := !sort(envars) do
write(v," = ",image(getenv(v))|"* not set *")
end</
=={{header|J}}==
<syntaxhighlight lang
=={{header|Java}}==
<
System.getenv() // get the entire environment as a Map of keys to values</
=={{header|JavaScript}}==
The JavaScript language has no facilities to access the computer: it relies on the host environment to provide it.
{{works with|JScript}}
<
var env = shell.Environment("PROCESS");
WScript.echo('SYSTEMROOT=' + env.item('SYSTEMROOT'));</
=={{header|Joy}}==
<
=={{header|jq}}==
<syntaxhighlight lang
=={{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.
<
puts(Util.getenv("HOME"));
var environment = Util.getenv();
puts(environment.PATH);</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
@show ENV["HOME"]
@show ENV["USER"]</
=={{header|K}}==
<
=={{header|Kotlin}}==
<
// tested on Windows 10
Line 531 ⟶ 577:
fun main(args: Array<String>) {
println(System.getenv("SystemRoot"))
}</
{{out}}
Line 539 ⟶ 585:
=={{header|langur}}==
<syntaxhighlight lang="langur">
writeln "
writeln "PATH: ", _env'PATH
writeln "USER: ", _env'USER
</syntaxhighlight>
=={{header|Lasso}}==
<
define getenv(sysvar::string) => {
Line 564 ⟶ 606:
stdoutnl(getenv('PATH'))
stdoutnl(getenv('USER'))
stdoutnl(getenv('WHAT'))</
{{out}}
<pre>/Users/rosetta
Line 573 ⟶ 615:
=={{header|Liberty BASIC}}==
=== Built-in variables ===
<
print DefaultDir$</
=== Other variables ===
<
print GetEnvironmentVariable$("USERPROFILE") ' equivalent to UNIX HOME variable
print GetEnvironmentVariable$("PATH")
Line 604 ⟶ 646:
GetEnvironmentVariable$ = left$(lpBuffer$, result)
end select
end function</
=={{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])));
}</
Then inside the main functions for repl and nonint (Interactive, Noninteractive):
<
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.
Line 633 ⟶ 675:
=={{header|Lingo}}==
{{libheader|Shell Xtra}}
<
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</
=={{header|Logtalk}}==
Using the standard library:
<
=={{header|LSL}}==
Rez a box on the ground, and add the following as a New Script.
<
state_entry() {
llOwnerSay("llGetTimestamp()="+(string)llGetTimestamp());
Line 653 ⟶ 695:
llOwnerSay("llGetMemoryLimit()="+(string)llGetMemoryLimit());
}
}</
{{out}}
<pre>llGetTimestamp()=2012-07-18T01:26:12.133137Z
Line 661 ⟶ 703:
=={{header|Lua}}==
<
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
\\ using read only variablles
Line 691 ⟶ 733:
}
Checkit
</syntaxhighlight>
=={{header|Make}}==
Make variables are initialized from the environment, so simply
<
foo:
echo $(TARGET)</
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.
<
echo "$$HOME"</
If you mistakenly write just <code>$HOME</code> then it means the makefile <code>$H</code> followed by characters <code>OME</code>.
<
bar:
echo $HOME
# prints oops ... OME</
=={{header|Maple}}==
<
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
=={{header|MATLAB}} / {{header|Octave}}==
<
getenv('PATH')
getenv('USER')</
=={{header|Mercury}}==
<
:- interface.
Line 740 ⟶ 782:
MaybeValue = no,
io.write_string("environment variable HOME not set\n", !IO)
).</
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang
=={{header|Modula-3}}==
<
IMPORT IO, Env;
Line 761 ⟶ 803:
IO.Put(k & " = " & v & "\n")
END
END EnvVars.</
=={{header|MUMPS}}==
Line 767 ⟶ 809:
In Caché on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:
<
Set X=$ZF(-1,"show symbol")</
=={{header|NetRexx}}==
When NetRexx runs under a JVM, system ENVIRONMENT variables are complimented by JVM system properties. This sample shows how to get both.
<
options replace format comments java crossref symbols nobinary
Line 832 ⟶ 874:
say
return
</syntaxhighlight>
{{out}}
<pre>
Line 866 ⟶ 908:
=={{header|NewLISP}}==
<
"/bin/zsh"
> (env "TERM")
"xterm"</
=={{header|Nim}}==
<
echo getEnv("HOME")</
=={{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'''].
<
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.</
=={{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.
<
=={{header|OCaml}}==
<
=={{header|Oforth}}==
<
=={{header|Oz}}==
<
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.6.0 and above}}
<
{{works with|PARI/GP|2.4.3 and above}}
<
{{works with|PARI/GP|2.0.3 and above}}
In older versions, the command must effectively be triple-quoted:
<
The shell sees
<
which causes it to return
<pre>"/home/username"</pre>
Line 910 ⟶ 957:
Leaving out the quotation marks allows external commands to return expressions that are then evaluated by GP. For example,
<
causes the shell to send Pi back to GP, which interprets the result and returns
<pre>%1 = 3.141592653589793238462643383</pre>
Line 916 ⟶ 963:
=={{header|Perl}}==
The <code>%ENV</code> hash maps environment variables to their values:
<
The <code>POSIX</code>module also has <code>getenv()</code> which is the same thing as a function.
<
print getenv("HOME"),"\n";</
=={{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
=={{header|PicoLisp}}==
<
-> "xterm"
: (sys "SHELL")
-> "/bin/bash"</
=={{header|Pike}}==
<
{{Out}}
<pre>
Line 945 ⟶ 1,005:
=={{header|PowerShell}}==
Environment variables can be found in the Env: drive and are accessed using a special variable syntax:
<syntaxhighlight lang
To get a complete listing of all environment variables one can simply query the appropriate drive for its contents:
<syntaxhighlight lang
=={{header|Prolog}}==
Line 956 ⟶ 1,016:
=={{header|PureBasic}}==
PureBasic has the built in funtion
<
'''Example'''
<
PrintN("Path:"+#CRLF$ + GetEnvironmentVariable("PATH"))
PrintN(#CRLF$+#CRLF$+"NUMBER_OF_PROCESSORS= "+ GetEnvironmentVariable("NUMBER_OF_PROCESSORS"))
Line 965 ⟶ 1,025:
Input()
CloseConsole()
EndIf</
=={{header|Python}}==
The <tt>os.environ</tt> dictionary maps environmental variable names to their values:
<
os.environ['HOME']</
=={{header|R}}==
<
=={{header|Racket}}==
<
#lang racket
(getenv "HOME")
</syntaxhighlight>
=={{header|Raku}}==
Line 985 ⟶ 1,045:
{{works with|Rakudo|#24 "Seoul"}}
The <code>%*ENV</code> hash maps environment variables to their values:
<syntaxhighlight lang="raku"
=={{header|REBOL}}==
<
=={{header|Retro}}==
<
here puts</
=={{header|REXX}}==
Line 1,006 ⟶ 1,066:
{{works with|R4}}
{{works with|ROO}}
<
x=value('TEMP',,'SYSTEM')</
The following will work for
::* '''PC/REXX'''
Line 1,020 ⟶ 1,080:
{{works with|Regina}}
{{works with|ooRexx}}
<
x=value('TEMP',,'ENVIRONMENT')</
The brexx interpreter provides a getenv function for accessing environment variables:
{{works with|Brexx}}
<
Other REXX interpreters have their own requirements to identify the SYSTEM environment.
Line 1,036 ⟶ 1,096:
=={{header|Ring}}==
<
see get("path")
</syntaxhighlight>
=={{header|Ruby}}==
The <tt>ENV</tt> hash maps environment variable names to their values:
<syntaxhighlight lang
=={{header|Run BASIC}}==
<
'DefaultDir$ - The folder path where program files are read/written by default
'Platform$ - The operating system on which Run BASIC is being hosted
Line 1,064 ⟶ 1,124:
print "User Address is: ";UserAddress$
print "Event Key is : ";EventKey$
print "Default Dir is : ";DefaultDir$</
<pre>
{{out}}
Line 1,076 ⟶ 1,136:
=={{header|Rust}}==
<
fn main() {
Line 1,085 ⟶ 1,145:
}
}
</syntaxhighlight>
{{out}}
<pre>Ok("/root")
Line 1,096 ⟶ 1,156:
=={{header|Scala}}==
<
=={{header|Seed7}}==
Line 1,106 ⟶ 1,166:
to get the home directory and the search path in an operating system independent manner.
<
const proc: main is func
begin
writeln(getenv("HOME"));
end func;</
=={{header|Sidef}}==
The ''ENV'' hash maps environment variables to their values:
<syntaxhighlight lang
=={{header|Slate}}==
<
"==> '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games'"</
=={{header|Slope}}==
<syntaxhighlight lang="slope">(env "HOME")</syntaxhighlight>
=={{header|Smalltalk}}==
Use the [http://pharo.gemtalksystems.com/book/PharoTools/OSProcess OSProcess] library to gain access to environment variables:
<
OSProcess thisOSProcess environment at: #HOME.
OSProcess thisOSProcess environment at: #PATH.
OSProcess thisOSProcess environment at: #USER.
</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 1,134 ⟶ 1,197:
{{works with|CSnobol}}
The host(4) function returns a known environment variable.
<
end</
=={{header|Standard ML}}==
<
returns an option type which is either SOME value or NONE if variable doesn't exist
Line 1,144 ⟶ 1,207:
Use the '''env''' [http://www.stata.com/help.cgi?extended_fcn extended macro function].
<
display "`:env USERNAME'"
display "`:env USERPROFILE'"</
=={{header|Swift}}==
<
print("PATH: \(ProcessInfo.processInfo.environment["PATH"] ?? "Not set")")</
=={{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
=={{header|TXR}}==
TXR can treat the environment vector as text stream:
<
@(collect)
@VAR=@VAL
@(end)</
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):
<
@(gather)
HOME=@home
USER=@user
PATH=@path
@(end)</
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:
<
@(gather :vars (home user path (shell "/bin/sh")))
HOME=@home
Line 1,177 ⟶ 1,269:
PATH=@path
SHELL=@shell
@(end)</
From TXR Lisp, the environment is available via the <code>(env)</code> function, which returns a raw list of <code>"name=value</code> strings. The <code>(env-hash)</code> function returns a hash from environment keys to their values.
<
("/home/kaz" "kaz" "/home/kaz/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/kaz/bin"</
Here, the hash is being used as a function to filter several environment keys to their values via <code>mapcar</code>.
Line 1,190 ⟶ 1,282:
=={{header|UNIX Shell}}==
In the Unix Shell Language, environment variables are available as ordinary variables:
<
An ordinary variable can be marked as an environment variable with the <code>export</code> command:
<syntaxhighlight lang
Now child processes launched by the shell will have an environment variable called <code>VAR</code>.
Line 1,199 ⟶ 1,291:
=={{header|Ursa}}==
<
out (system.getenv "HOME") endl console</
=={{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.
<
#executable ('parameterized','')
showenv = <.file$[contents: --<''>]>+ %smP+ ~&n-={'TERM','SHELL','X11BROWSER'}*~+ ~environs</
The rest of this application searches for the three variables named
and displays them on standard output.
Line 1,219 ⟶ 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}}==
<
Message(@10)</
Or with short keywords:
<
=={{header|Visual Basic}}==
{{works with|Visual Basic|VB6 Standard}}
<
=={{header|Wren}}==
Line 1,234 ⟶ 1,341:
However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to obtain it for us.
<
class Environ {
foreign static variable(name)
}
System.print(Environ.variable("SHELL"))</
which we embed in the following Go program and run it.
{{libheader|WrenGo}}
<
package main
Line 1,260 ⟶ 1,367:
func main() {
vm := wren.NewVM()
fileName := "
methodMap := wren.MethodMap{"static variable(_)": getEnvironVariable}
classMap := wren.ClassMap{"Environ": wren.NewClass(nil, nil, methodMap)}
Line 1,267 ⟶ 1,374:
vm.InterpretFile(fileName)
vm.Free()
}</
{{out}}
Line 1,280 ⟶ 1,387:
version work the same as the 16-bit real-mode versions.
<
string 0; \use zero-terminated strings
int CpuReg, PspSeg, EnvSeg, I, J, C;
Line 1,307 ⟶ 1,414:
if Peek(EnvSeg,I) = 0 then quit; \double 0 = env. var. not found
];
]</
{{out}}
Line 1,313 ⟶ 1,420:
PATH=\masm6;C:\;C:\CXPL;C:\UTIL;C:\DOS;C:\BORLANDC\BIN
</pre>
=={{header|Yabasic}}==
<code>peek$("env","NAME")</code> Return the environment variable specified by NAME (which may be any string expression).
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}}==
<
/home/craigd
System.getenv() //--> Dictionary of all env vars</
|