Типы данных

Синтаксис

                                                    
let age = 100
let decimal = 0.101
let sameDecimal = .101
let billion = 1e9 // 1 миллиард, "e" производит 
операцию умножения числа на 1 с указанным количеством нулей   

или вот так с "e"
let ms = 1e-6 // 0.000001, отрицательное число 
после "e" подразумевает деление на 1 с указанным количеством нулей
                                                    
                                                

                                                        
let number = 0xff // 255, 
при выводе в консоль приводится к десятичной системе счисления                                                  
                                                        
                                                    

                                                        
let number = 0b11111111 // 255                                                  
                                                        
                                                    

                                                        
let number = 0o377 // 255                                                  
                                                        
                                                    

«Специальные числовые значения»:

Методы

При использовании методов для чисел (как и для остальных примитивов) важно понимать механизм работы этих методов. Так, если к примитиву обратиться как к объекту (т.е. через точку), то в памяти ВРЕМЕННО для этого примитива создастся объектная версия (обертка) с помощью конструктора new Number (для других типов другие обертки), это и позволяет применять методы к примитивам.

num.toString(base) возвращает строковое представление числа num в системе счисления base. base может варьироваться от 2 до 36 (по умолчанию 10).

Запись:

                                                        
let number = 255  
number.toString(16) // ff,

либо
255..toString(16)
                                                        
                                                    

num.toFixed([digits]) форматирует число, используя запись с фиксированной запятой. digits — количество цифр после десятичной запятой. Результатом метода будет являться строка. Данный метод позволяет решить в проблемы неточных вычислений в JS.

Запись:

                                                        
let sum = 0.1 + 0.2; 
console.log(sum); // 0.30000000000000004

дроби, такие как 0.1, 0.2, которые выглядят довольно просто 
в десятичной системе счисления, на самом деле являются
бесконечной дробью в двоичной форме.

console.log(sum.toFixed(2)); // 0.30, помог метод toFixed()
                                                        
                                                    

Работа с числами

                                                                
let a = 2
let b = 3
console.log(((a + b) * a % 5) ** 2) // 0                                                        
                                                                
                                                            

                                                            
console.log(5 >= 10) // false
console.log(5 == 10) // false
console.log(5 != 10) // true
console.log(5 !== 10) // true                                                       
                                                            
                                                        

                                                                    
let number = 255.222
Math.trunc(number) // 255
        
                                                                    
                                                                

                                                                    
Math.random() // 0.019904487089602574 или иное
        
                                                                    
                                                                

                                                                    
Math.min(1, 2) // 1   
                                                                    
                                                                

                                                                    
Math.pow(2, 10) // 2 в степени 10 = 1024 
                                                                    
                                                                

Синтаксис

Чтобы создать значение типа BigInt, необходимо добавить n в конец числового литерала или вызвать функцию BigInt, которая создаст число типа BigInt из переданного аргумента. Аргументом может быть число, строка и др.

                                                        
let bigint = 1234567890123456789012345678901234567890n;

let sameBigint = BigInt("1234567890123456789012345678901234567890");

let bigNumber = BigInt(10) // то же самое, что и 10n
                                                        
                                                    

Работа с BigInt

                                                        
console.log(1n + 2n) // 3n
console.log(5n / 2n) // 2n
                                                        
                                                    

                                                            
let bigint = 1n;
let number = 2;

// конвертируем number в bigint
console.log(bigint + BigInt(number)); // 3n

// конвертируем bigint в number
console.log(Number(bigint) + number); // 3
                                                            
                                                        

                                                            
console.log(2n > 1n) // true
console.log(2n > 1) // true
                                                            
                                                        

                                                            
if (0n) {
    // никогда не выполнится, это false
}
                                                            
                                                        

                                                            
let bigNumber = 10n
console.log(bigNumber.toString()) // 10
console.log(bigNumber.valueOf()) // 10n

                                                            
                                                        

Синтаксис

Явное указание значения

                                                        
let truthyValue = true // «Истина»
let falsyValue = false // «Ложь»
                                                        
                                                    

Функция Boolean

                                                        
let truthyValue = Boolean(1) // «Истина»
let falsyValue = Boolean('') // «Ложь»
                                                        
                                                    

Использование выражений, значениями которых будут «истина» или «ложь»

                                                        
let truthyValue = Boolean(4 < 5)
let anotherTruthy = 4 < 5

console.log(truthyValue) // true
console.log(anotherTruthy) // true
                                                        
                                                    

Использование в условных выражениях

                                                        
let isCorrect = true
if (isCorrect) {
    // выполнится,
} else {
    // не выполнится
}
                                                        
                                                    

Логическре преобразование типов

0, -0, null, false, NaN, undefined, пустая строка (""), становятся false. Все остальные значения — true.

                                                        
let falsy1 = Boolean(),
    falsy2 = Boolean(0),
    falsy4 = Boolean(''),
    falsy5 = Boolean(false)

let truthy1 = Boolean(true),
    truthy3 = Boolean('false'),
    truthy5 = Boolean([]),
    truthy6 = Boolean({})
                                                        
                                                    

Методы Bollean

Методы Bollean работают также, как и методы других примитивов. Если к Bollean обратиться как к объекту (т.е. через точку), то в памяти ВРЕМЕННО для этого примитива создастся объектная версия (обертка) что и позволит применить методы.

Примеры:

                                                    
let bool = true
console.log(bool.toString()) // true
console.log(bool.valueOf()) // true
                                                    
                                                

Используется, когда нужно обозначить намеренное отсутствие значения. В контексте логических операций, рассматривается как ложное.

                                                    
let age = null // значение age неизвестно
                                                    
                                                

Важно знать!

Результатом вызова typeof null является «object». Это официально признанная ошибка в typeof, ведущая начало с времён создания JavaScript и сохранённая для совместимости. Конечно, null не является объектом. Это специальное значение с отдельным типом.

Важно знать!

При проверке на null или undefined, помните о различии между операторами равенства (==) и идентичности (===): с первым, выполняется преобразование типов.

                                                    
null === undefined // false
null  == undefined // true
                                                    
                                                

Синтаксис

                                                    
let age
console.log(age) // undefined
                                                    
                                                

Функция возвращает undefined, если она не возвращает какого-либо значения.

                                                    
function findValue() {
    let a = 1
    sum = a + 1
}
console.log(findValue()) // undefined
                                                    
                                                

Синтаксис

«Символ» представляет собой уникальный идентификатор. Для создания символа нужно вызвать функцию Symbol. Создание символа через конструктор new Symbol() не поддерживается.

                                                        
let id = Symbol()
                                                        
                                                    

При создании, символу можно дать описание (имя), в основном использующееся для отладки кода. Символы гарантированно уникальны. Даже если мы создадим множество символов с одинаковым описанием, это всё равно будут разные символы. Описание — это просто метка, которая ни на что не влияет.

                                                        
let id = Symbol("name")
                                                        
                                                    

Использование

Символы используются для создания скрытых свойств объектов. В отличие от свойств, ключом которых является строка, символьные свойства может читать только владелец символа. Символьное свойство не появится в for...in, не будет модифицировано прямым обращением, так как другой скрипт не знает о нашем символе. Таким образом, свойство будет защищено от случайной перезаписи или использования.

Для использования символа при литеральном объявлении объекта {...}, его необходимо заключить в квадратные скобки.

                                                        
let secondaryId = Symbol()

let user = {
    'id': 193,
    'name': 'Ольга',
    [secondaryId]: 'olga-1'
}

for (const prop in user) {
console.log(prop, user[prop])
}
// id 193
// name Ольга

console.log(user[secondaryId]) // olga-1
                                                        
                                                    

Свойства

Symbol.length — содержит длину, всегда равную 0 (нулю).

Symbol.prototype — cодержит прототип конструктора Symbol.

Глобальные символы

                                                            
let secondaryId = Symbol()

let user = {
    'id': 193,
    'name': 'Ольга',
    [secondaryId]: 'olga-1'
}
console.log(Symbol.keyFor(secondaryId)) // undefined

let newSym = Symbol.for('registryKey')
user[newSym] = 'hello'
console.log(Symbol.keyFor(newSym)) // registryKey
                                                            
                                                        

Системные символы

Символы активно используются внутри самого JavaScript, чтобы определять поведение объектов. Самый известный символ Symbol.iterator, который позволяет реализовать обход конструкции с помощью синтаксических конструкций for...of.

Полезно знать

Чтобы обойти for...in и получить все свойства объекта с ключами-символами можно использовать встроенный метод Object.getOwnPropertySymbols(obj), который возвращает массив символов и позволяет получить символьные свойства конкретного объекта.

                                                        
let object1 = {};
let a = Symbol('a');
let b = Symbol.for('b');

object1[a] = 'localSymbol';
object1[b] = 'globalSymbol';

const objectSymbols = Object.getOwnPropertySymbols(object1);

console.log(objectSymbols) // [Symbol(a), Symbol(b)]
                                                        
                                                    

Синтаксис

Объект может быть создан с помощью:

1. литерала объекта — фигурных скобок {…} с необязательным списком свойств.

   Свойство — это пара «ключ: значение», где ключ/имя/идентификатор – это строка/символ (ограничений к именам нет — можно назвать let и др.), а значение может быть чем угодно (в т.ч. другой объект, массив, функция (об этом далее)).

2. конструктора объекта new Object()

                                                    
const user = new Object({title: 'Война и мир', author: 'Лев Толстой'}) 

const user = {     
    name: "John",  
    age: 30,
    children: ['Rita', 'Alex'],
    favoriteBook: {
        title: '1984',
        author: 'Orwell',
    },
    "likes cats": true, 
};  
// имя свойства может состоять из нескольких слов, 
// но тогда оно должно быть заключено в кавычки (любой их тип)
// последнее свойство может заканчиваться "висячей запятой" 
                                                    
                                                

Важно знать и понимать!

Одно из фундаментальных отличий объектов от примитивов заключается в том, что объекты хранятся и копируются «по ссылке» ("адресу в памяти"), тогда как примитивные значения: строки, числа, логические значения и т.д. — всегда копируются «как целое значение». Поэтому даже если переменная, которой присвоен объект (хранит ссылку на этот объект), объявлена через const, свойства хранимого объекта можно менять. Изменение внутреннего состояния не изменяет ссылку.

Свойства объекта

Для обращения к свойствам используется запись «через точку». Для свойств, имена которых состоят из нескольких слов для доступа к свойствам используются квадратные скобки (внутри них кавычки любого типа). В большинстве случаев, когда имена свойств известны и просты, используется запись через точку (можно и [], если хочется).

                                                        
console.log(user.name) // John
console.log(user.age) // 30
console.log(user["likes cats"]) // true
                                                        
                                                    

Для добавления свойства обращаемся к нему и используем оператор присваивания "=".

                                                        
user.isDev = true
console.log(user.isDev) // true

user["likes dogs"] = true
console.log(user["likes dogs"]) // true
                                                        
                                                    

Для удаления свойства используется оператор delete. Но чаще свойства не удаляют, а сбрасывают значение, устанавливая undefined.

                                                        
delete user.age
delete user["likes cats"];
user["likes cats"] = undefined
                                                        
                                                    

Для проверки существования свойства в объекте используется специальный оператор "in".

                                                        
let user = {name: "John", age: 30};

console.log("age" in user) // true, user.age существует
console.log("blabla" in user) // false, user.blabla не существует
                                                        
                                                    

Для перебора всех свойств объекта используется цикл for...in. При таком переборе свойства с целочисленными ключами сортируются по возрастанию, остальные располагаются в порядке создания.

                                                        
let user = { 
    name: "John",
    age: 30,
};

user.isDev = true

for (let key in user) {
    console.log(key) // name, age, isDev - значения ключей
    console.log(user[key]) // John, 30, true
}
                                                        
                                                    

Методы объекта

Свойства объекта могут быть функциями. Метод — это функция в объекте, которая дает возможность "что-то делать" нашему объекту.

Метод можно создать через присвоение свойству функции, созданной через Function Expression / Function Declaration.

                                                        
// пример 1
let user = {name: "John"};

user.sayHi = function() {
    console.log("Привет!");
}; // присвоили свойству функции созданной через Function Expression.

user.sayHi() // Привет!

// пример 2
let cat = {
    name: 'Кузя',
    
    play: function() {
        console.log('Люблю играть')
    }, // полная запись

    speak() {
        console.log('Мяу')
    } // сокращенная запись
}

cat.play() // Люблю играть
cat.speak() // Мяу
                                                        
                                                    

Методу объекта обычно требуется доступ к информации, хранящейся в объекте. Для доступа к ней внутри объекта метод может использовать ключевое слово this. Подробнее о нем тут.

Сравнение объектов

JavaScript сравнивает не значения свойств объектов, а адреса в памяти, по которым эти объекты хранятся. Поэтому любое сравнение двух объектов будет возвращать false, даже если они выглядят одинаково.

                                                        
const book = {title: 'Дюна'} // один объект
const anotherBook = {title: 'Дюна'} // другой объект

console.log(book === anotherBook) // false
                                                        
                                                    

Сравнение будет возвращать true, только если мы сравниваем переменные, указывающие на один и тот же объект.

                                                        
const book = {title: 'Дюна'}
const anotherBook = book // в anotherBook записывается ссылка на тот же объект

console.log(book === anotherBook) // true
                                                        
                                                    

Копирование объекта

При копировании переменной копируется ссылка, но сам объект не дублируется.

                                                        
let user = {name: 'John'};

let admin = user;

admin.name = 'Pete'; // изменено по ссылке из переменной "admin"

console.log(user.name); // 'Pete', изменения видны по ссылке из переменной "user"
                                                        
                                                    

Клонирование объекта

                                                        
let user = {
    name: "John",
    age: 30
};
    
let clone = {}; // новый пустой объект

for (let key in user) {
clone[key] = user[key];
} // копируем все свойства user в него

clone.name = "Pete"; // изменим в нём данные

console.log(user.name); // все ещё John в первоначальном объекте
                                                        
                                                    

                                                        
Object.assign(dest, [src1, src2, src3...])
// dest — целевой объект.
// аргументы src1, ..., srcN - исходные объекты
                                                        
                                                    

                                                        
let user = {name: "John"};
let permissions1 = {canView: true};
let permissions2 = {canEdit: true};

Object.assign(user, permissions1, permissions2);

// теперь user = {name: "John", canView: true, canEdit: true}
                                                        
                                                    

                                                        
// можно использовать для замены цикла for..in для простого клонирования
let user = {
    name: "John",
    age: 30
};
    
let clone = Object.assign({}, user);
                                                        
                                                    

Объект — прародитель

В JavaScript объект является прародителем всех других сущностей. Все типы данных и структуры, кроме примитивных, являются потомками объекта. Так как объект — это сущность с набором свойств то, т.о., массив и функция — это тоже объекты.

                                                    
const shows = ['Breakind Bad', 'The Office', 'Silicon Valley']
shows.length // это свойство массива
                                                        
                                                    
                                                

Про функцию еще можно сказать, что это объект первого класса. Это означает, что функцию можно использовать так же, как и другие типы данных: сохранять в переменную, передавать аргументом и возвращать из функции.

                                                    
function sum(a, b) {
return a + b
}

sum.arguments // можно вызвать свойство функции
sum.someField = 'value' // можно присвоить значение в поле
console.log(sum.name) // sum
console.log(sum.length) // 2
console.dir(sum) // способ посмотреть свойства заданного объекта

ответ консоли

ƒ sum(a, b)
someField: "value"
arguments: null
caller: null
length: 2
name: "sum"
prototype: {constructor: ƒ}
[[Prototype]]: ƒ ()                                                        
                                                    
                                                

В выводе консоли есть и свойство someField, которое мы присвоили, и набор встроенных свойств и методов.

Если развернуть [[Prototype]]: ƒ (), то прототипом текущего прототипа как раз является объект, поэтому его и можно назвать прародителем (о прототипах подробнее тут).

Объект также является прототипом прототипов Map, Set, WeakMap, WeakSet.

Кроме того, в JS есть еще встроенные объекты, такие как Date и Math.

Объекты-обёртки

Каждый примитив имеет свой собственный «объект-обёртку» (кроме null и undefined). Конструкторы для примитива являются наследниками объекта и предназначены только для внутреннего пользования. Создание «объектов-обёрток» для примитивов при помощи такого синтаксиса как, например, new Number(1) или new Boolean(false) в JavaScript, очень не рекомендуется.

                                                        
console.log(typeof 0) // "число"
console.log(typeof new Number(0)) // "object"!