Re: Bug with unset variables

[Felipe Contreras <felipe.contreras@xxxxxxxxx>]

On Thu, Nov 12, 2020 at 1:11 PM Roman Perepelitsa
<roman.perepelitsa@xxxxxxxxx> wrote:
>
> On Thu, Nov 12, 2020 at 7:47 PM Felipe Contreras
> <felipe.contreras@xxxxxxxxx> wrote:
> >
> > This is distinction without a difference, like saying we are not lost,
> > we just don't know where we are. Conceptually it is the same thing,
> > you are just using a different word for it. It's wordplay.
> >
> > An unset variable is for all intents and purposes a variable with a null value.
>
> Only in languages where variables cannot have null values, and only
> because you can declare "null" to be a synonym for "unset" in this
> case.

No. Intents and purposes don't depend on the language you cherry-pick.

> > JavaScript
>
> In JavaScript you unset a variable with `delete foo` and you assign it
> a "null" value (in quotes because javascript has another null) with
> `foo = undefined`. These are not equivalent.
>
> Note that these two snippets have different effect:
>
>   var foo
>
> and
>
>   var foo
>   delete foo
>
> Just line in zsh, and unlike ksh/bash.

No. That code doesn't even work in JavaScript:

  > var foo
  undefined
  > delete foo
  false

Delete foo returns false because it didn't do anything.

  > var foo="test"
  undefined
  > delete foo
  false
  > foo
  'test'

The variable is still there with type and value.

If you turn on the strict mode you get: "SyntaxError: Delete of an
unqualified identifier in strict mode."

The delete operator is there to handle properties of objects, not
variables [1]. The closest to unset is assigning a value of
"undefined".

But the important thing is that foo is *never* an empty string.

> > Python
>
> Same thing but `del var` and `var = None`.
>
> Et cetera. ksh and bash are rather exceptional in this regard.

This is a false equivalence. You are talking about two different
concepts as if they were the same thing. They are not.

  foo="global"

  func () {
    typeset foo
    unset foo
    foo="local"
    echo $foo
  }

  func
  echo $foo

In this example unset does not do the same thing as the del statement
in Python. The scope of "foo" is not changed. The equivalent of "unset
foo" is "foo = None".

A real equivalence is undefined in JavaScript:

  var foo="global";

  function func() {
    var foo;
    foo = undefined;
    foo = "local";
    console.log(foo);
  }

  func();
  console.log(foo);

In both cases "unset foo" and "foo = undefined" do *exactly* the same
thing, which is return the variable to its original state.

And in both cases if you remove "typeset foo" or "var foo" the effect
is *exactly* the same; modifying foo inside the function modifies the
global variable.

If you compare apples to apples the equivalence is obvious.

In JavaScript "var foo" does not set foo to an empty string.

Cheers.

[1] http://ecma-international.org/ecma-262/11.0/#sec-delete-operator

-- 
Felipe Contreras