Please enable JavaScript.

Coggle requires JavaScript to display documents.

(Введение в классы JS (Наследование в производных классах (унаследованные…

- - - - видимость только в блоке
    - - conct
    - - привязка один раз
      - const and let
        
        с let на const ошибка
      - const obj = {}
        
        изменять
        
        можно
        
        содержимое
        
        нельзя
        
        объект
    - - вызов до объявления
        
        ошибка
  - - - с let без замыкания
    - - for
        
        создает новую перtменную i
    - - for
        
        i++
        
        ошибка
        
        перезапись
      - for-of
        for-in
        
        создает новую переменную
        
        ошибки нет
  - - - по умолчанию
    - - только если известно,
        что переменная будет
        меняться
        
        for(let i = 0, i < 10, i++){}
- - - - codePointAt()
        
        полный код
      - String.rfomCodePoint()
        
        обратно в текст
      - normalize()
        
        Форма нормализации
        
        каноничесукой
        
        композицией (NFD), по умолчанию
        
        декомпозицией (NFD)
        
        совместимой
        
        композицией (NFKC)
        
        декомпозицией (NFKD)
    - - действие флага u
        
        переключение работы
        
        с символами, а не строками
      - подсчет кодовых пуктов
        
        один символ за один
      - определение поддержки флага u
        
        new RegExp(".", "u")
  - - - includes()
        
        true
        
        текст в строке
      - startsWith()
        
        true
        
        текс в начале
      - endsWith()
        
        true
        
        тест в конце
    - - "hello".repeat(2) // hellohello
  - - - воздействует на sticky
      - требует указать позицию в lastIndex
    - - let re1 = /ad/i
      - let new RegExp(re1, "g")
    - - возвращает флаг из регулярки
      - let re = /ab/g
      - re.flags // g
  - - - Лбратные кавычки
    - - Перенос текста
      - Без +
    - - let name ='serj'
      - let mes = 'hello ${ name}'
      - med // hello serj
    - - let med = teg'hello worb'
      - function tag(literal, ...substitutions) {}
      - Всего лиш функция
- - - - ES5
        
        callback = callback || function () {}
        
        callback = (typeof callback !== 'undefined') ? callback : function () {}
      - ES6
        
        function name (url, callback = function () {})
      - Виляние на arguments
        
        режимы
        
        нестрогий
        
        first === arguments[0] // true
        
        строгий и ES6
        
        first === arguments[0] // false
      - Вырожения
        
        let value = 5
        
        function getValue() { return value ++ }
        
        function (first, second = getValue()) { return first + second }
        
        add(1, 1) // 2
        add(1) // 6
        add(1) // 7
        
        second = getValue
        
        ()
        
        без
        
        ссылка на функцию
        
        с
        
        результат функции
      - Временная мертва зона
        
        как с let
        
        function add (first = second, second) {return first + second}
        
        add(1, 1) // 2
        
        add(undefined, 1) // ошибка
        
        собственная область видемости
        
        собственная мертвая зона
  - - - arguments
    - - ...arg
  - - - let value = [25, 50, 75, 100]
      - math.max(25, 50, 75, 100) // 100
      - math.max(...value)
  - - - .name
        
        function doSomething () {}
        
        let doAnotherThing = function () {}
        
        doSomething.name // "doSomething"
        
        doAnotherThing.name // "doAnotherThing"
    - - .name
        
        person.firstName.name // "get firstName"
        
        doSomething.bind().name // "bound doSomething"
        
        (new Function ()).nema // "anonymous"
  - - - instanceaf
      - if (this instanceaf Person)
    - - цель new
      - if (typeof new.target !== "undefined")
  - - - "use strit"
        
        удаляется, когда поток в блоке выполнен
        
        через let, функция не поднимается в начало блока
    - - поднимается в глобальную область видимости
  - - - let reflect = value => value;
        // тоже самое что
        let reflect = function (value) {return value}
      - let sum = (num1, num2) => num1 + num2;
      - let getTempItem = id => ({ id: id; temp: "temp" })
        // тоже самое
        let getTempItem = function (id) { return id: id; temp: "temp" }
    - - let person = ((name) => {...})("serj")
        // Тоже самое
        let person = function(name) {...}("serj")
    - - тоже самое что (function(event){...}).bind(this)
    - - var result = values.sort((a, b) => a - b);
    - - function fun () { return () => arguments[0] }
      - fun(5) // 5
    - - обычная функция
      - методы
        
        call()
        
        apply
        
        bind()
    - - this
      - super
      - arguments
      - new.target
    - - не имеют [[Constructor]]
  - - - function doSomething() {}
        
        оптимизация
        
        return doSomethinEls()
        
        не оптимизируется
        
        doSomethinEls()
        
        return 1 + doSomethinEls()
        
        var result = doSomethinEls()
        return result
        
        var num = 1
        func = () => num
        return func()
    - - не оптимизируеться
        
        function factorial (n){
        if ( n <= 1 ){
        retun 1
        }else{
        return n * factorial(n - 1)
        }
        }
      - оптимизируется
        
        function factorial (n, p = 1) {
        if ( n <= 1 ){
        retun 1 p
        }else{
        let result = n p
        return factorial(n - 1, result)
        }
        }
- - - - инициализации свойств
        
        function newObj (name, age) { return { name, age } }
      - определения методов
        
        var person = { name, sayName() { console.log('this.name') } }
    - - var suffix = " name"
      - var = person = {
        //["first" + suffix]: "Сергей",
        //["last" + suffix]: "Суматохин"
        }
      - person["first name"] // Сергей
        person["last name"] // Суматохин
  - - - Object.is()
        
        +0 === -0 // true
        Object.is(+0, -0) // false
        
        NaN === NaN // false
        Object.is(NaN, NaN) // true
        isNaN(NaN) // true
      - Object.assing()
        
        миксин
        
        копирует и затирает значения
        
        похоже
        
        extend()
        
        mix()
        
        var receiver = {}
        
        Object.assing(receiver, {type: "js", name: "file.js" })
        
        receiver.type // js
  - - - Object.create()
      - Object.getPrototypeOf()
      - Object.setPrototyeOf()
    - - let friend = { getGreeting() { return super.getGreeting() + ", hi!" } }
        // тоже самое что
        Object.getPrototypeOf(this).getGreeting.call(this)
- - - - let node = { type: "Identifier", name: "foo" }
      - type = "Literal"
        name = 5
      - ({ type, name } = node)
      - type // "Identifier"
        name // "foo"
    - - let node = { type: "Identifier", name: "foo" }
      - let { type, name, value = true } = node
    - - let node = { type: "Identifier", name: "foo" }
      - let { type: localType, name: localName } = node
      - localType // "Identifier"
        localName // "foo"
    - - let { loc: { status } } = node
        
        let { loc: {} } = node
        
        синтаксическая ловушка
      - start.line // 1
        start.colum // 2
  - - - так же как с объектом
    - - let [ firstColor, secondColor = "green "] = colors
    - - let [ firstColor, [ secondColor ] ] = colors
    - - let [ firstColor, ...restColors ] = colors
      - firstColors // "red"
      - restColors.length // 2
      - restColors[0] // "green"
      - restColors[1] // "blue"
      - restColors // "[green, blue]"
- - - - Object.defineProperty()
      - Object.defineProperties()
  - - - let uid = Symbol.for("uid");
        let uid2 = Symbol.for("uid");
      - let obj = {}
        obj[uid] = "123"
      - obj[uid] // 123
        obj[uid2] // 123
      - uid // Symbol(uid)
        uid2 // Symbol(uid)
      - uid === uid2 // true
  - - - Object.keys()
      - Object.getOwnPtopertyNames()
      - ES6
        
        Object.getOwnPtopertySymbol()
  - - - Symbol.hasInstance
        
        является ли объект экземпляром функции
      - Symbol.toPrimitive
        
        изменить поведения по умолчанию механизма преобразования
    - - Symbol.isConcatSpreadable
        
        concat()
        
        слияние двух массивов
        
        let colors1 = [ "red", "green" ]
        colors2 = colors.concat1([ "blue", "black" ])
        
        colors2 // [ "red", "green", "blue", "black" ]
        
        влияет на поведение метода concat()
        
        если у объекта есть
        
        length
        
        index
        
        //[Symbol.isConcatSpreadable]: true
      - Symbol
        
        .match(regex)
        
        определяет, соответствует ли данная строка регулярному выражению
        
        .replace(regex, replacement)
        
        замещает совпадение с регулярном выражением строкой replacement
        
        .search(regex)
        
        отыскивает в строке совпадение с регулярным выражением
        
        .sprit(regex)
        
        преобразует строку в массив, разбивая ее по совпадениям с регулярным выражением
      - Symbol.toStringTag
        
        решения проблем идентификации
        
        определение строковых меток для объектов в ES6
      - Symbol.unscopables
        
        инструкция with не создает локальной привязки
- - - - new Set()
      - добавить элемент
        
        add()
      - количество элементов
        
        size
      - let set = new Set()
        set.add(5) // число
        set.add("5") // строка
        set.add(5) // повторяющиеся значения игнорируются
      - set.size // 2
        
        сравнение через Object.is()
      - проверка на наличие значения во множеств true или false
        
        has()
    - - один элемент
        
        delete()
      - все
        
        clear()
    - - три параметра
        
        значение текущего элемента в множестве
        
        то же значение, что и в первом аргументе
        
        ссылка на множество, которому принадлежит аргумент
        
        let set = new Set([ 1, 2 ])
        
        set.forEach( function( value, key, ownerSet ) ){
        // console.log(key + " " + value)
        // console.log(ownerSet === set)
        }
        
        1 1
        true
        2 2
        true
    - - let set = new Set([ 1, 2, 3, 3, 3, 4, 5 ]),
        array = [...set]
      - array // [ 1, 2, 3, 4, 5 ]
    - - создание множеств со слабыми ссылками
        
        new WeakSet()
        
        add()
        
        has()
        
        delete()
        
        нет утечки памяти
        
        let key1 = {},
        key2 = {}
        set = WeakSet([ key1, key2 ])
        
        слабые ссылки на объект
        
        set.has(key1) // true
        set.has(key1) // true
  - - - has(key)
      - delete(key)
      - clear()
    - - три параметра
        
        значения текущего элемента в массеве
        
        ключ этого значения
        
        ссылка на массив, из которого извлечен элемент
        
        map.forEach( function( value, key, ownerMap ) ){
        // console.log(key + " " + value)
        // console.log(ownerMap === set)
        }
        
        name Serdj
        true
        age 25
        true
    - - ипользование
        
        let map WeakMap(),
        element = document.querySelector(".element")
        
        map.set(element, "Original")
        
        let value = map.get(element)
        value // "Original"
        
        // удалить элемент element
        element.parentNodes.removeChild(element)
        element = null
      - new WeakMap()
      - инициализация
        
        let key1 = {}
        key2 = {}
        map = new WeakMap( [ [ key1, "hello" ], [ key2, 42 ] ] )
        
        map.get(key1) // "Hello"
        map.has(key1) // true
        map.get(key2) // 42
        map.has(key2) // true
      - методы
        
        hes()
        
        delete()
        
        clear()
      - приватные данные объекта
        
        let Person ( function() {
        / let privateData = new WeakMap()
        / function Person(name){
        // privateData.set( this, { name: name } )
        / }
        / Person.prototype.getName = function() {
        // return privateData.get( this ).name
        / }
        / return Person
        }() )
    - - let map = new Map([ [ "name", "Serdji" ], [ "age", 25 ] ])
- - - - let create = function * () {}
      - create - это выражение функции-генератора. Функция не имеет имяни
    - - let 0 = {
        // /*/ create (items){
        // // for (){
        // // // yield items[i]
        // // }
        // }
        }
  - - - let values = [1, 2, 3]
        let iter = values[Symbol.iterator])_
      - iterator.next() // { value: 1, done: false }
    - - let collection = { * [Symbol.iterator () {}] }
      - по умолчанию не являются итерируемыми
      - добавить свойство Symbol.iterator
  - - - типы объектов коллекции
        
        массивы
        
        итераторы
        
        entries()
        
        возвращает двухэлементный массив
        
        [0, "red"]
        [1' "green"]
        
        values()
        
        значение
        
        "red"
        "green"
        
        keys()
        
        возвращает ключ
        
        для множеств values() и keys() одно и тоже
        
        0
        1
        
        ассоциативные массивы
        
        множества
    - - лучший способ через for-of
    - - так же for-of
  - - - function * createIterator() {
        // let first = yield 1;
        // let second = yield first + 2;
        // yield second + 3
        }
      - iterator.next() { value: 1, done: false }
        iterator.next(4) { value: 6, done: false }
        iterator.next(5) { value: 8, done: false }
        iterator.next() { value: undefined, done: true }
    - - iterator.throw(new Error("Boom")) //Ошибка, возбужденная генератором
    - - инструкция return остонавливает генератор
    - - yield * createNumberIterator()
- - - - class PersonType {
        constructor(name){ //
        this.mane = name // //
        } //
        sayName(){ //
        console.log(this.name) // //
        { //
        }
      - let person = new PersonClass("Serdji")
        person.sayName() // Serdji
    - - объявление классов
      - весь код в объявление класса
      - все методы являются не перечислимыми
      - у всех методов отсутствует внутренний метод [[Construct]]
      - вызов без new будет ошибка
      - затереть имя внутри метода класса завершается ошибкой
  - - - let PersonClass = class { constructor() {} }
      - typeof PersonClass // function
    - - let PersonClass = class PersonClass2 { constructor() {} }
      - typeof PersonClass // function
        typeof PersonClass2 // undefined
  - - - getArea() { return super.getArea() }
    - - наследуются методы и свойства
      - Square.create() действует точно так же как Rectangle.create()
      - class Square extend Rectangle
    - - class MyArray extend Array {}
      - MyArray унаследован от встроенного класса Array со всеми методами
    - - стандартный символ Symbol.species использует для определения статического свойства с методом доступа, который возвращает функцию
    - - после extend можно узнать любой выражение, при условии, что оно возвращает функцию с методом [[Construct]] и прототипом
- - - - Array.from()
        
        преобразует итерируемы объект в массив
      - Array.of()
        
        создает массив
        
        тоже самое как let arr = []
  - - - find() и findIndex()
        
        принимает колбек
        
        при условии возвращает занчение или инекс
        
        numbers.find(n => n > 33) // 35
      - fill()
        
        заполняет один или несколько элементов массива определенными значениями
      - copyWithin()
        
        позволяет копировать элементы массива
- - - - onclick
    - - callback вызов
  - - - как толь асинхронная операция равершиться
        
        выполнено
        
        отклонено
    - - new Promis()
        
        принимает
        
        resolve()
        
        успешно
        
        reject()
        
        неудачно
    - - let promise = Promise.resolve(42)
        promise.then((val)=>console.log(val)) // 42
      - let promise = Promise.reject(42)
        promise.catch((val)=>console.log(val)) // 42
    - - throw new Error('Explosion!');
        promise.then((error)=>console.log(error.message)) // Explosion
  - - - unhandledRejection
      - rejectionHandled
      - process.on('unhandledRejection', (reason, promise)=>{})
    - - unhandledRejection
      - rejectionHandled
      - addEventListener('unhandledRejection', (reason, promise)=>{})
  - - - .catch( error => {})
    - - .then( val => val + 1 ) // 42
        .then( val => val ) // 43
    - - .then( val => p2 ) // 42
        .then( val => val ) // 43
  - - - Promise.all()
        
        принимает массив прописов Promise.all([p1, p2, p3])
      - Promise.race()
        
        принимает массив прописов Promise.race([p1, p2, p3])
- - - - import { sum } from './example.js'
    - - import { sum, multiply, magicNumber } from './example.js'
    - - Только для чтения
      - не оригинальный объект
    - - import * as example from './example.js'
        example.sum(1, 2) // 3
  - - - export { sum as add }
      - import { add as sum } from './example.js'
      - переименовать передаваемый объект
  - - - export default sum
    - - import sum from './example.js'
  - - - как сценарий
  - - - <script type='module' src='module.js'></script>
    - - c /
      - c ./
      - c ../