const obj = {
  value: 42,
  getValue() {
    return this.value;
  },
  getValueArrow: () => this.value,
  nested: {
    value: 100,
    getValue() {
      return this.value;
    }
  }
};

const extractedMethod = obj.getValue;
const boundMethod = obj.getValue.bind(obj);

console.log(obj.getValue() + ',' + obj.getValueArrow() + ',' + 
            obj.nested.getValue() + ',' + extractedMethod() + ',' + 
            boundMethod());

const target = { a: 1, b: 2 };
const handler = {
  get(obj, prop) {
    return prop === 'sum' ? obj.a + obj.b : Reflect.get(obj, prop);
  },
  set(obj, prop, value) {
    if (prop === 'a' && value < 0) {
      return false;
    }
    return Reflect.set(obj, prop, value);
  }
};

const proxy = new Proxy(target, handler);
proxy.a = -5;
proxy.b = 10;
console.log(`${proxy.a}, ${proxy.b}, ${proxy.sum}`);

const string = "Hello, World!";

const result = [...string.matchAll(/[HlWrd]/g)]
                 .map(match => match[0])
                 .reverse()
                 .join("");

console.log(result);

const obj = {
  value: 10,
  getValue() {
    return this.value;
  },
  getArrowValue: () => {
    return this.value;
  },
  getMixedValue() {
    const regular = function() { return this.value; };
    const arrow = () => this.value;
    
    return [regular(), arrow()];
  }
};

console.log(obj.getMixedValue());

function recursiveReverseString(str) {
  return str === "" ? str : recursiveReverseString(str.substr(1)) + str;
}

const result = recursiveReverseString("hello");

console.log(result);

const sym = Symbol('unique');
const obj = {
  [sym]: 'symbol value',
  a: 0,
  b: 2,
  c: 1
};

const keys = Object.keys(obj);
const symbols = Object.getOwnPropertySymbols(obj);

console.log(keys.length, symbols.length);

const obj = {
  value: 42,
  getValue() {
    return this.value;
  },
  getArrowValue: () => {
    return this.value;
  },
  getDelayedValue() {
    setTimeout(function() {
      console.log(this.value);
    }, 0);
  },
  getFixedDelayedValue() {
    setTimeout(() => {
      console.log(this.value);
    }, 0);
  }
};

obj.getDelayedValue();

const arr = [1, 2, 3];
const str = arr.join([4]);
console.log(typeof str);
console.log(str);

const target = { name: 'Alice' };

const handler = {
  get(obj, prop) {
    return prop in obj ? obj[prop].toUpperCase() : 'NOT_FOUND';
  },
  set(obj, prop, value) {
    if (typeof value !== 'string') {
      return false;
    }
    obj[prop] = value.trim();
    return true;
  }
};

const proxy = new Proxy(target, handler);
proxy.name = '  Bob  ';
proxy.age = 30;

console.log(`${proxy.name}-${proxy.age}-${proxy.job}`);

var b = 10;
let i = 7;
if (b % 3 == 0) {
   let i = 10;
}

console.log(i);

const inventory = {
  items: ['apple', 'banana', 'orange'],
  [Symbol.iterator]: function() {
    let index = 0;
    const items = this.items;
    
    return {
      next: function() {
        return index < items.length ?
          { value: items[index++].toUpperCase(), done: false } :
          { done: true };
      }
    };
  }
};

const result = [...inventory].join(' + ');
console.log(result);

❓Что будет на выходе?

async function asyncChain() {
   const values = [2, 3, 5, 7, 11];
   const total = await values.reduce(async (acc, values) => {
      const current = await acc;
      return current * value;
   }, Promise.resolve(1));
   return total;
}

asyncChain().then(result => console.log(result));

console.log(console.log(0 || {a: 3} && 1 || ['hello'] * 2 + 5));

const obj = {};
const sym1 = Symbol('description');
const sym2 = Symbol('description');

obj[sym1] = 'Value 1';
obj[sym2] = 'Value 2';
obj.regularProp = 'Regular';

const allKeys = Object.getOwnPropertySymbols(obj).length + Object.keys(obj).length;
const comparison = sym1 === sym2;

console.log(allKeys + ',' + comparison);

❓Что будет на выходе?

const weakMap = new WeakMap();
const obj1 = {};
const obj2 = {};

weakMap.set(obj1, 'value1');
weakMap.set(obj2, 'value2');

const arr = [obj1, obj2];
const result = arr.map(obj => weakMap.get(obj)).join(', ');

console.log(result);

var str="javascript coffeescript vbscript javacode"
var re2=/(?=java)\b\w+script\b/g
console.log(str.match(re2))

var str="dog,cat,pig,cow"
var re2=/\b\w+\b(?=,cat|,pig)/g   
console.log(str.match(re2))

const promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve(3), 1000);
});

promise
  .then(result => {
    console.log(result);
    return result * 3;
  })
  .then(result => {
    console.log(result);
    return new Promise(resolve => setTimeout(() => resolve(result * 3), 1000));
  })
  .then(result => {
    console.log(result);
  });

const user = {
  profile: {
    name: 'Alice',
    social: null,
    getDetails() {
      return { verified: true };
    }
  }
};

const result = [
  user?.profile?.name,
  user?.profile?.social?.handle,
  user.profile.getDetails?.()?.verified,
  user?.nonExistent?.property
];

console.log(result);

var a = 1;
function b() {
   a = 10;
   return;
   function a () {}
}
a = b();
console.log(a);

const team = {
  members: ['Alice', 'Bob', 'Charlie'],
  leader: 'Diana',
  [Symbol.iterator]: function*() {
    yield this.leader;
    for(const member of this.members) {
      yield member;
    }
  }
};

let names = [];
for (const person of team) {
  names.push(person);
}

console.log(names.join(', '));