// DEFINING AN ARRAY
// we can make a new Array in the traditional way:
const verbs = new Array("wonder", "jump", "point");

// but we tend to use the Array Literal []:
const verbs = ["wonder", "jump", "point"];

// READING AN ARRAY
// use the array access operator []
// to access the elements of the array
// inside the [] put an index number
// starting at 0 for the first element
zog(verbs[0]); // "wonder"

// CHANGING AN ARRAY
// again, use the array access operator []
verbs[2] = "shrug"; // replace "point" with "shrug"

// ARRAY PROPERTIES
// Arrays have a single property:
zog(verbs.length); // logs 3 to the console

// ARRAY METHODS
// There are many array methods
// Here we add and remove elements
verbs.push("call"); // adds to end of array
verbs.pop(); // removes from end of array (and returns value)
verbs.shift(); // removes from start of array (and returns value)
verbs.unshift("smile"); // adds to start of array

verbs.sort(); // sorts array by alphabet **
verbs.indexOf("shrug"); // returns index of element (2) or -1 if not found
verbs.splice(2, 0, "shout"); // inserts shout at index 2 replacing 0 elements
verbs.concat(["paint", "skip"]); // adds second array to verbs
// etc.

** ZIM provides a shuffle(array) function that shuffles the array

// MULTIDIMENSIONAL ARRAYS
// Arrays can hold arrays which can hold arrays, etc.
const rounds = [["a", "b", "c"], ["d", "e", "f"]];

// we then use multiple array access opertators to access inside:
zog(rounds[1][2]); // logs "f" to the console

// OBJECTS AND ARRAYS
// note that the object holds different properties
// whereas the array holds the same type of values

{color:"red", size:20, dashed:false} // classification
["red", "green", "blue"] // composition

// CLASSIFICATION
// the object holds properties
// belonging to a class of things with these properties
// an object is single thing
// created from this class or that class or that class, etc.
// ors are classification

// COMPOSITION
// the array holds values that can be applied to a set of objects
// such as the colors of three rectangles
// rectangle 1 and rectangle 2 and rectangle 3
// ands are composition

// OPPOSITE
// we can force objects and arrays to hold the opposites
// but it is not very clear in one case or efficient in the other:
["red", 20, false] // we don't know what these things are
{color1:"red", color2:"green", color3:"blue"} // ugg

// FOR LOOP
// this is the most common loop (unless coding in ZIM)
// use let for the variable i as the value changes
// we often use i for iterator - but other variable names are fine too
// (initial condition; condition to keep looping; what to do each loop)
for (let i=0; i<10; i++) {
    zog(i); // logs 0-9 on new lines
}

// FORMAT
// note the similar format:
// for () {}
// function () {}
// if () {}

// LOOP THROUGH ARRAY
const colors = ["red", "green", "blue"];
for (let i=0; i<colors.length; i++) {
    zog(colors[i]); // logs "red", "green", "blue" on new lines
}

// CONTINUE AND BREAK
for (let i=0; i<10; i++) {
    if (i == 2) { // we will see conditionals next lesson
        continue; // go to next loop
    }
    if (i > 5) {
        break; // end the looping
    }
    zog(i); // logs 0, 1, 3, 4, 5
}

// WHILE LOOP
let rand = rand(); // rand changes so use let not const
while (rand > .5) {
    zog(rand); // consecutive numbers bigger than .5
    rand = rand();
}

// and a for loop recreated:
let i = 0;
while (i<10) {
    zog(i); log 0-9 on new lines
    i++;
}

// ZIM LOOP
// a very handy format for looping in a variety of situations
// would recommend using this when coding in ZIM

// NUMBER
loop(10, i=>{
    zog(i); // logs 0-9 on new lines
});

loop(10, (i,t)=>{ // second parameter (after i) is total
    zog(i, t); // logs 9-0 (reverse) and total 10 each line
}, true); // true reverses loop - see docs for more parameters

// ARRAY
const colors = ["red", "green", "blue"];
loop(colors, color=>{ // second parameter is i, third is total
    zog(color); // logs "red", "green", "blue" on new lines
});

// OBJECT
const site = {url:"https://danzen.com", name:"Dan Zen"};
loop(site, (property, value)=>{ // third parameter is i, fourth is total
    zog (property + " has " + value); // the properties and values on new lines
});

// CONTAINER
// imagine a container with 100 circles
loop(circles, circle=>{ // second parameter is i, third is total
    if (circle.hitTestPoint(100, 100)) { // conditionals next lesson
        circle.removeFrom(circles);
        stage.update();
    }
}, false); // always loop backwards when removing objects from containers

// HOW TO CONTINUE AND BREAK
const answer = loop(10, i=>{
    if (i == 2) { // we will see conditionals next lesson
        return; // simple return goes to next loop (instead of continue)
    }
    if (i > 5) {
        return i; // return value to end looping (instead of break)
    }
    zog(i); // logs 0, 1, 3, 4, 5
});
zog(answer); // logs 6
// collecting the return value is optional - but sometimes handy

// FORMAT
// note the similar format:
loop(10, i=>{});
on("click", e=>{});
timeout(1000, obj=>{});
interval(1000, obj=>{});