Variables

Think of variables as a tracker of values. Typically, we say that we create a variable and we assign a value to that variable. We also often can say that we intialize a variable with a value if we want to be specific and say that memory is allocated to a variable and it will automatically keep track of a specific value.

To use a variable, you have to make sure it is declared (and most likely defined in the same process).

Prerequisites

If you didn’t understand the paragraph above then, do some searches to understand the vocabulary. Most likely however, you haven’t read the previous two concepts:

• Values
• Data Types

Modifiers

Variables in many programming languages can be created differently by being modified.

Scope

Different kinds of variables can be created. In both dynamically-typed and statically-typed languages, there’s often a way to make a variable global or local to a specific kind of scope.

Dynamically-typed vs. Statically-typed

Dynamically-typed languages figure out what type of data your variable hold automatically while statically-typed languages require you to specify what the type is.

Variables referring to an integer in some different programming languages.

my_number = 10

def hello():
    global my_number
    # global operator makes
    # variable global.
    my_number = 20

hello()
print(my_number) # We expect 20 now

-- Outside of any scope (function, loops, if-statements...)
myNumber = 10

function foo()
    local myLocal = 20
end

print(myNumber) -- Legal
print(myLocal) -- Gives nil. Not what we intended

// block-scoped
if (true) {
    let myNumber = 1
}

console.log(myNumber) // will error

// function-scope
function bar() {
    if (true) {
        var hey = 10
    }
    print(hey) // does not error because of var
}

Debrief

This quiz checks your understanding of variables, assignment, initialization, scope, and how variables behave across different programming languages.

Questions are ordered approximately from easiest to hardest.

1. What is the main purpose of a variable?

A. To track or refer to a value B. To permanently store an entire program C. To determine which operating system is running D. To automatically print values

2. Which statement best describes assignment?

A. Giving a value to a variable B. Creating a new programming language C. Printing a variable D. Removing the variable from the program

3. After the second assignment, what value does score refer to?

score = 10
score = 20

score = 10
score = 20

let score = 10
score = 20

int score = 10;
score = 20;

A. 10 B. 20 C. 30 D. Both 10 and 20

4. Which word describes giving a variable its first value when it is created?

A. Iteration B. Initialization C. Comparison D. Invocation

5. In each example, what is the initial value of score?

score = 10

local score = 10

let score = 10

int score = 10;

A. 0 B. 1 C. 10 D. The variable has no value

6. What does the scope of a variable determine?

A. Its exact numerical value B. Where its name can be used in the program C. How quickly it changes D. What operating system the program requires

7. What best describes a local variable?

A. A variable available everywhere in the program B. A variable restricted to some particular scope C. A variable that can only contain integers D. A variable stored on another computer

8. What best describes a global variable?

A. A variable declared in a broad program scope B. A variable that can only contain strings C. A variable that cannot change D. A variable that only exists inside a loop

9. Which statements about variables are true? (Mark all that apply.)

A. Variables can keep track of values B. Variables can often be assigned new values C. Variables can exist in different scopes D. Every variable must be global

10. In each example, which variable is local to the function?

outside = 10

def foo():
    inside = 20

outside = 10

function foo()
    local inside = 20
end

let outside = 10

function foo() {
    let inside = 20
}

int outside = 10;

void foo() {
    int inside = 20;
}

A. outside B. inside C. Both variables D. Neither variable

11. What should happen if code tries to access the local variable after leaving its scope?

def foo():
    inside = 20

foo()
print(inside)

function foo()
    local inside = 20
end

foo()
print(inside)

function foo() {
    let inside = 20
}

foo()
console.log(inside)

void foo() {
    int inside = 20;
}

int main() {
    foo();
    // inside cannot be named here
}

A. The local variable automatically becomes global B. The local variable is not accessible through that local name C. The variable always becomes 0 D. The variable becomes a string

12. Which of the following can affect scope? (Mark all that apply.)

A. Functions B. Blocks C. Loops D. Conditional statements

13. What is one major difference between dynamically-typed and statically-typed languages?

A. Dynamically-typed languages do not have data types B. Statically-typed languages determine variable types statically C. Statically-typed languages cannot use strings D. Dynamically-typed languages cannot use functions

14. Which tabs contain dynamically-typed languages? (Mark all that apply.)

score = 10

score = 10

let score = 10

int score = 10;

A. Python B. Lua C. JavaScript D. C++

15. In each example, what value will number have after change() is called?

number = 10

def change():
    global number
    number = 20

change()

number = 10

function change()
    number = 20
end

change()

let number = 10

function change() {
    number = 20
}

change()

int number = 10;

void change() {
    number = 20;
}

int main() {
    change();
}

A. 10 B. 20 C. 30 D. The variable disappears

16. Python What does the global statement do?

global number

A. Converts number into an integer B. Tells Python that assignments should refer to the global binding C. Makes number constant D. Creates a new function

17. Lua What does local do in this declaration?

local score = 10

A. Makes score global B. Creates score in a local scope C. Makes score constant D. Changes score into a string

18. JavaScript Consider the following code.

if (true) {
    let score = 10
}

console.log(score)

What happens?

A. It prints 10 B. It prints true C. Accessing score outside the block causes an error D. score becomes global

19. JavaScript Why can score be accessed after the if block here?

function foo() {
    if (true) {
        var score = 10
    }

    console.log(score)
}

A. var is function-scoped B. Every JavaScript variable is global C. if statements do not create blocks D. Numbers ignore scope

20. C++ Which description of this statement is most accurate?

int score = 10;

A. score is declared as an int and initialized with 10 B. score is assigned without being declared C. 10 is the variable D. The statement gives score no value

21. C++ What is the important difference between these two cases?

int a = 10;

int b;
b = 10;

A. There is no conceptual difference B. a is initialized with 10, while b is defined first and assigned 10 afterward C. a is global and b is local D. b is initialized twice

int a = 10;

int b;
b = 10;

22. C++ What happens in this code?

int score = 10;

{
    int score = 20;
}

A. The second declaration permanently replaces the first variable B. The inner score is a separate variable that shadows the outer score C. C++ forbids two variables with the same name anywhere D. Both declarations name the same object

23. C++ What is the value of value afterward?

int value = 10;
int& reference = value;

reference = 20;

A. 10 B. 20 C. 0 D. Undefined

24. C++ What is the value of value afterward?

int value = 10;
int* pointer = &value;

*pointer = 30;

A. 10 B. 20 C. 30 D. The pointer modifies only a copy

25. C++ Why is this code dangerous?

int* getNumber() {
    int value = 10;
    return &value;
}

A. Integers cannot be used inside functions B. value’s lifetime ends when the function returns C. Pointers cannot point to integers D. Local variables automatically become global

26. C++ Which statement best distinguishes scope from lifetime?

A. Scope concerns where a name can be used; lifetime concerns when an object exists B. Scope and lifetime always mean exactly the same thing C. Scope determines an object’s data type D. Lifetime only applies to dynamically allocated objects