let number = null; // zero being a valid number
// something happens
number = 0;

// check if it's false
if (!number) {
    throw new Error('oops, zero is also falsy!');
}

// this will check if it's null or undefined
if(number ?? true){
    throw new Error('now, only null or undefined will throw!')
}

// usually you would use like
const myPossibleNullishValue = someValue ?? 'value if null or undefined'

// you can also do this:
function ItsAError(){ throw new Error("it's a me, error!") }
const myPossibleNullishValue = someValue ?? ItsAError();
// this way you can validate if the value is not null or undefined as you assign it.

const object = {};

// ok, so: as long as object exists, then object.anything won't throw
// object.anything will be undefined if anything doesn't exists, but that's it
// object.anything.anotherThing however, this will throw because anything is undefined
// all this to say that, you start chaining from the objects that may not exist
const myValue = object
  .prop1
  ?.anything
  ?.anotherThing
  ?.prop2 ?? 'combine with nbullish coalescing for when the value is undefined!';

// it doesn't end here!
// you can chain multiple things:
const test = {
  arr: [1, 2, 3, 4],
  function: () => 'hello!',
  obj: {
    something: 'else'
  }
}

// arrays
test.arr?.[0] ?? 'oops' // 1
test.notArr?.[0] ?? 'oops'; // oops

// functions
test.function?.() ?? 'oops' // hello!
test.notFunction?.() ?? 'oops' // oops

// objects
test.obj?.['something'] ?? 'oops' // else
test.notObj?.['something'] ?? 'oops' // oops

const maybe = async (n) => {
  const random = Math.random() > 0.8;
  return Promise[random ? 'resolve' : 'reject'](random ? `yes! ${n}` : `nope =/ ${n}`)
};

const coisa = await Promise.any([
  maybe(1),
  maybe(2),
  maybe(3),
  maybe(4),
])
  .then(val => {
    // on the first one that resolves...
    console.log(val) // yes! n
  })
  .catch(err => {
  // if all fails...
  console.log(err.errors) // [ 'nope =/ 1', 'nope =/ 2', 'nope =/ 3', 'nope =/ 4' ]
});

'abbbaab'.replaceAll('b', 'x') // 'axxxaax'

class Counter {
  static #privateTotal = 0

  constructor() {
    Counter.#add();
  }

  static #add() {
    Counter.#privateTotal++;
  }

  remove() {
    Counter.#privateTotal--
  }

  static get total() {
    return Counter.#privateTotal
  }

}

const number1 = new Counter();
const number2 = new Counter();
const number3 = new Counter();
const number4 = new Counter();
Counter.total2 //?
const number5 = new Counter();
console.log(Counter.total); // 5
number1.remove();
console.log(Counter.total); // 4

Counter.add(); // not a function
Counter.#add(); // SyntaxError: Private field '#add' must be declared in an enclosing class
console.log(Counter.privateTotal); // undefined
console.log(Counter['#privateTotal']); // undefined
console.log(Counter.#privateTotal); // SyntaxError: Private field '#privateTotal' must be declared in an enclosing class

const arr = [1, 2, 3, 4, 5]
const str = 'hello world'

console.log(arr.at(-1)) // 5
console.log(str.at(-1)) // d