Environment variables: Difference between revisions

=={{header|11l}}==

=={{header|Ada}}==

Print a single environment variable.

with Ada.Text_Io; use Ada.Text_Io;

begin

Put_Line("Path : " & Value("PATH"));

Print all environment variable names and values.

with Ada.Text_Io; use Ada.Text_Io;

begin

Iterate(Print_Vars'access);

Uses [http://forge.ada-ru.org/matreshka Matreshka].

with League.Application;

Ada.Wide_Wide_Text_IO.Put_Line

(League.Application.Environment.Value (+"HOME").To_Wide_Wide_String);

=={{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}}==

⎕ENV 'HOME'

HOME /home/russtopia

=={{header|AppleScript}}==

===Invoking Finder===

tell application "Finder" to get name of home

===Invoking Terminal===

"HOME : " & (do shell script "echo $HOME" & ", PATH : " & (do shell script "echo $PATH" & ", USER : " & (do shell script "echo $USER")))

=={{header|Arturo}}==

print ["user:" env\USER]

{{out}}

=={{header|AutoHotkey}}==

=={{header|AutoIt}}==

Local $sEnvVar = EnvGet("LANG")

Func ShowEnv($N)

ConsoleWrite( StringFormat("%-12s : %s\n", $N, EnvGet($N)) )

{{Out}}

=={{header|AWK}}==

The ENVIRON array contains the values of the current environment:

{{out}}

<pre>

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] ) }

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BaCon}}===

''Case matters and needs to match''

==={{header|IS-BASIC}}===

110 ASK DEFAULT CHANNEL VAR02

120 ASK EDITOR BUFFER VAR03

350 ASK VIDEO MODE VAR26

360 ASK VIDEO X VAR27

or

==={{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

=={{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:

For interactive use one can use <code>set</code> to view all environment variables or all variables starting with a certain string:

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT FNenvironment("USERNAME")

END

DIM buffer% LOCAL size%

SYS "GetEnvironmentVariable", envar$, buffer%, size%+1

=={{header|C}}==

#include <stdio.h>

return 0;

}

=={{header|C sharp|C#}}==

namespace RosettaCode {

}

}

=={{header|C++}}==

#include <cstdio>

puts(getenv("HOME"));

return 0;

=={{header|Clojure}}==

=={{header|COBOL}}==

PROGRAM-ID. Environment-Vars.

GOBACK

=={{header|CoffeeScript}}==

{{works with|node.js}}

=={{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}

begin

WriteLn('Temp = ' + GetEnvironmentVariable('TEMP'));

=={{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

print (get ("USERNAME"))

end

=={{header|Elixir}}==

=={{header|Emacs Lisp}}==

=={{header|Erlang}}==

os:getenv( "HOME" ).

=={{header|Euphoria}}==

=={{header|F_Sharp|F#}}==

[<EntryPoint>]

let main args =

printfn "%A" (Environment.GetEnvironmentVariable("PATH"))

=={{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

write(*,'(a)') 'No HOME to go to!'

end if

=={{header|FreeBASIC}}==

Var v = Environ("SystemRoot")

Print v

{{out}}

=={{header|Frink}}==

{{out}}

=={{header|FunL}}==

println( $home )

=={{header|Go}}==

;Simply:

import (

func main() {

fmt.Println(os.Getenv("SHELL"))

{{out}}

<pre>

You're on your own then to parse out the one you want.

Example:

import (

}

fmt.Println(s, "not found")

{{out}}

<pre>

=={{header|Gri}}==

Command <code>get env</code> fetches an environment variable into a synonym (a string)

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

=={{header|hexiscript}}==

println env "PATH"

=={{header|HicEst}}==

string = "PATH="

=={{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"]

every v := !sort(envars) do

write(v," = ",image(getenv(v))|"* not set *")

=={{header|J}}==

=={{header|Java}}==

=={{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");

=={{header|Joy}}==

=={{header|jq}}==

=={{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();

=={{header|Julia}}==

{{works with|Julia|0.6}}

@show ENV["HOME"]

=={{header|K}}==

=={{header|Kotlin}}==

// tested on Windows 10

fun main(args: Array<String>) {

println(System.getenv("SystemRoot"))

{{out}}

=={{header|langur}}==

writeln "PATH: ", _env["PATH"]

{{works with|langur|0.9}}

We could also the short-hand form of indexing by string. This is limited to code points used for tokens and does not allow for spaces, nor an index alternate.

writeln "PATH: ", _env'PATH

=={{header|Lasso}}==

define getenv(sysvar::string) => {

stdoutnl(getenv('PATH'))

stdoutnl(getenv('USER'))

{{out}}

<pre>/Users/rosetta

=={{header|Liberty BASIC}}==

=== Built-in variables ===

=== Other variables ===

print GetEnvironmentVariable$("USERPROFILE") ' equivalent to UNIX HOME variable

print GetEnvironmentVariable$("PATH")

GetEnvironmentVariable$ = left$(lpBuffer$, result)

end select

=={{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.

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.

=={{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]

=={{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());

llOwnerSay("llGetMemoryLimit()="+(string)llGetMemoryLimit());

}

{{out}}

<pre>llGetTimestamp()=2012-07-18T01:26:12.133137Z

=={{header|Lua}}==

=={{header|M2000 Interpreter}}==

Module CheckIt {

\\ using read only variablles

}

Checkit

=={{header|Make}}==

Make variables are initialized from the environment, so simply

foo:

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.

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

=={{header|Maple}}==

=={{header|Mathematica}} / {{header|Wolfram Language}}==

=={{header|MATLAB}} / {{header|Octave}}==

getenv('PATH')

=={{header|Mercury}}==

:- interface.

MaybeValue = no,

io.write_string("environment variable HOME not set\n", !IO)

=={{header|min}}==

{{works with|min|0.19.3}}

=={{header|Modula-3}}==

IMPORT IO, Env;

IO.Put(k & " = " & v & "\n")

END

=={{header|MUMPS}}==

In Caché on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:

=={{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

say

return

{{out}}

<pre>

=={{header|NewLISP}}==

"/bin/zsh"

> (env "TERM")

=={{header|Nim}}==

=={{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.

=={{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>

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>

=={{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.

=={{header|Phix}}==

<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>

=={{header|PHP}}==

The <tt>$_ENV</tt> associative array maps environmental variable names to their values:

=={{header|PicoLisp}}==

-> "xterm"

: (sys "SHELL")

=={{header|Pike}}==

{{Out}}

<pre>

=={{header|PowerShell}}==

Environment variables can be found in the Env: drive and are accessed using a special variable syntax:

To get a complete listing of all environment variables one can simply query the appropriate drive for its contents:

=={{header|Prolog}}==

=={{header|PureBasic}}==

PureBasic has the built in funtion

'''Example'''

PrintN("Path:"+#CRLF$ + GetEnvironmentVariable("PATH"))

PrintN(#CRLF$+#CRLF$+"NUMBER_OF_PROCESSORS= "+ GetEnvironmentVariable("NUMBER_OF_PROCESSORS"))

Input()

CloseConsole()

=={{header|Python}}==

The <tt>os.environ</tt> dictionary maps environmental variable names to their values:

=={{header|R}}==

=={{header|Racket}}==

#lang racket

(getenv "HOME")

=={{header|Raku}}==

{{works with|Rakudo|#24 "Seoul"}}

The <code>%*ENV</code> hash maps environment variables to their values:

=={{header|REBOL}}==

=={{header|Retro}}==

=={{header|REXX}}==

{{works with|R4}}

{{works with|ROO}}

The following will work for

::* '''PC/REXX'''

{{works with|Regina}}

{{works with|ooRexx}}

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.

=={{header|Ring}}==

see get("path")

=={{header|Ruby}}==

The <tt>ENV</tt> hash maps environment variable names to their values:

=={{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

print "User Address is: ";UserAddress$

print "Event Key is : ";EventKey$

<pre>

{{out}}

=={{header|Rust}}==

fn main() {

}

}

{{out}}

<pre>Ok("/root")

=={{header|Scala}}==

=={{header|Seed7}}==

to get the home directory and the search path in an operating system independent manner.

const proc: main is func

begin

writeln(getenv("HOME"));

=={{header|Sidef}}==

The ''ENV'' hash maps environment variables to their values:

=={{header|Slate}}==

=={{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.

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

The host(4) function returns a known environment variable.

=={{header|Standard ML}}==

returns an option type which is either SOME value or NONE if variable doesn't exist

Use the '''env''' [http://www.stata.com/help.cgi?extended_fcn extended macro function].

display "`:env USERNAME'"

=={{header|Swift}}==

=={{header|True BASIC}}==

ASK BACK red

ASK COLOR red

ASK TEXT JUSTIFY vble1$, vble2$

ASK WINDOW vble1, vble2, vble3, vble4

=={{header|Tcl}}==

The <code>env</code> global array maps environmental variable names to their values:

=={{header|TXR}}==

TXR can treat the environment vector as text stream:

@(collect)

@VAR=@VAL

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

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

PATH=@path

SHELL=@shell

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.

Here, the hash is being used as a function to filter several environment keys to their values via <code>mapcar</code>.

=={{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:

Now child processes launched by the shell will have an environment variable called <code>VAR</code>.

=={{header|Ursa}}==

=={{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','')

The rest of this application searches for the three variables named

and displays them on standard output.

=={{header|Vlang}}==

// v run environment_variables.v

module main

print('In the $os.environ().len environment variables, ')

println('\$HOME is set to ${os.getenv('HOME')}')

{{out}}<pre>prompt$ v run environment-variables.v

=={{header|Vedit macro language}}==

Or with short keywords:

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

=={{header|Wren}}==

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)

}

which we embed in the following Go program and run it.

{{libheader|WrenGo}}

package main

vm.InterpretFile(fileName)

vm.Free()

{{out}}

version work the same as the 16-bit real-mode versions.

string 0; \use zero-terminated strings

int CpuReg, PspSeg, EnvSeg, I, J, C;

if Peek(EnvSeg,I) = 0 then quit; \double 0 = env. var. not found

];

{{out}}

=={{header|zkl}}==

/home/craigd