DouKaku?

foo ||= 'hoge'

zero = 25 if zero is None else zero

foo ifNil: [foo := 'hoge']

お題と同じ主旨ということであれば、Common LispというかLISP系では、
orを使うのがイディオムっぽいですが、下記の例では、既にvarに
値が設定されていないとエラーになってしまいます。

;(setq var nil)
;etc 〜

(let ((var (or var 'foo)))
  var)
;=> foo

大域変数については、defvarがあり、既に値が設定されている場合は、
値が上書きされません。

;; 初回
(defvar foo 'foo)
=> foo

;; 以降
(defvar foo 'bar)
=> foo

try:
  var
except NameError:
  var = 'foo'

var var1 = "foo";
var var1 = var1 || 'bar';
alert(var1);

var var2 = var2 || 'bar';
alert(var2);

f <- function(var){
    if(missing(var)){
        var <- 'foo'
    }
    var
}

> f()
[1] "foo"
> f("")
[1] ""
> f(0)
[1] 0

$var = $_REQUEST['var'];
$var = (empty($var))? 'bar' : $var;

%!PS
/DefaultValue { % Symbol val DefaultValue -
  currentdict 2 index known {
    pop pop
  } {
    def
  } ifelse
} bind def

my $var1 = (!defined $var1) ?  'foo' : $var1;
my $var2 = 'foo' unless defined $var2;

rm -rf ${HOME:=~}/tmp/*

:: date.bat
@echo off
  setlocal
    if not defined DATE for /f %%d in ('date /t') do set DATE=%%d
    echo %DATE%
  endlocal
goto :EOF

var = var if 'var' in locals() else 'foo'

test = (test == null) ? "abc" : test;

SELECT id, COALESCE(name, '名無しさん') name FROM namelist ;

static char *Var = "Foo";/*書き換え不可能な文字列"Foo"がセットされる。はず。
ポインタの値は変更できます。さらに保持されます。*/

type 'a t = 'a option ref

let mkvar () = (ref None:'a t)
let get (x:'a t) = !x
let set_normal (x:'a t) y = (x := Some y)
let set_defor (x:'a t) y =
  match !x with
  | None -> x := Some y
  | Some _ -> ()

let (//=) = set_defor;;

(*
  let x = mkvar ();;
  x //= 1;  get x;; (* Some 1*)
  x //= 2;  get x;; (* Some 1*)
*)

<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  >

  <xsl:output method="text" />

  <!-- global variable -->
  <xsl:variable name="hoge" as="xs:integer" select="5" />

  <xsl:template match="/">
    <!-- local variable -->
    <xsl:variable name="hige" as="element()">
      <parent><child>baby</child></parent>
    </xsl:variable>
    
    <!-- call template without parameters -->
    <xsl:call-template name="func" />

    <!-- call template with parameters -->
    <xsl:call-template name="func">
      <xsl:with-param name="param1">6</xsl:with-param>
      <xsl:with-param name="param2" as="xs:string*">
        <xsl:sequence select="('foo','bar','baz')" />
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>

  <xsl:template name="func">
    <!-- parameters -->
    <xsl:param name="param1" as="xs:integer">7</xsl:param>
    <xsl:param name="param2" as="xs:string*" />
  </xsl:template>

</xsl:stylesheet>

import std.stdio;

//デフォルトの初期値
typedef int myint = 100;

void main()
{
  int a;
  myint b;
  //未初期化の変数を宣言
  myint c = void;

  //"a=0 b=100 c=(不定)"
  writefln("a=%d b=%d c=%d",a,b,c);
}

def var ='foo'

(define var #f)

(some-function (or var 100))

class DefinedOr[T] {
    var    _v:Option[T] = None
    def this(n:T) = { this(); this.v = n }
    def v:Option[T] = _v
    def v_=(v:T) = { _v = Some(v) }
    def ||=(n:T) = { v = v match { case None => n; case Some(x) => x } }
}
object Main {
    def main(args:Array[String]) = {
        var    d:DefinedOr[Int] = new DefinedOr
        println(d.v)
        d ||= 0
        println(d.v)
        d ||= 1
        println(d.v)
        d = new DefinedOr(2)
        println(d.v)
        d ||= 0
        println(d.v)
    }
}