Верно ли что js является регистрозависимым

Марафон подготовки 2021

Мы начали марафон подготовки к вступительному тестированию Binary Studio Academy 2021! Раз в неделю мы будем публиковать на нашем блоге вопросы подобные тем, что будут на тестировании, с правильными ответами и пояснениями.

[ JS ] Будут ли ссылаться obj1.prop1 и obj2.prop1 на один и тот же объект?

const obj0 = >; const obj1 =  prop1: obj0, >; const obj2 = Object.assign(>, obj1);

a) Да
b) Нет
c) Да, но не в strict mode
d) Фрагмент кода невозможно интерпретировать Розгорнути правильну відповідь з поясненням

Тема иммутабельности — одна из важнейших тем в программировании, так как этот подход позволяет избегать сайд-эффектов и создавать реиспользуемые модули. Объекты в JS передаются по ссылке, т.е. если перезаписать объект из переменной в переменную, то при изменении любой из этих переменных будут изменяться все переменные, ссылаемые на этот объект:

const obj0 = >; const obj1 = obj0; obj0.prop = 'a'; console.log(obj1.prop); // "a"

Для того, чтобы создать копию объекта, нам нужно создать новый объект и перезаписать все свойства старого объекта на новый:

function copy(obj0)  return Object.keys(obj0).reduce((result, key) =>  result[key] = obj0[key]; return result; >, >); >

Но чтобы не изобретать велосипед, в JS есть для этого метод Object.assign(dist, src, . ), который первым параметром принимает объект (dist), на который копируются все свойства с объекта, переданного вторым параметром (src). Другим способом копирования может быть spread оператор, т.е. следующие две записи абсолютно идентичны:

const obj1 = Object.assign(>, obj0); const obj1 =  . obj0 >;

Обратите внимание на функцию copy, описанную выше,: значения просто перезаписываются на новый объект, т.е. если какой-то из ключей из obj0 будет ссылаться на объект или массив, то в результирующем объекте эти ключи будут ссылаться на этот же объект. Чтобы изменить значение в объекте внутри объекта, нужно делать глубокое копирование:

const obj0 = >; const obj1 =  prop1: obj0, >; const obj2 = Object.assign(>, obj1,  prop1: Object.assign(>, obj1.prop1,  someData: 'a', >), >); console.log(obj2); // < prop1: < someData: "a" >> console.log(obj1); // < prop1: <>> console.log(obj0); // <>

Обратите внимание, что третьим параметром передается тоже объект, с которого копируются свойства, при этом таких параметров может быть неограниченное количество и они будут изменять только первый параметр Object.assign, все остальные останутся неизменны. Исходя из этого можно с полной уверенностью сказать, что код валидный, а значит, вариант d) — неправильный. Режим strict также не имеет никакого влияния на выполнение следующего кода, а значит, вариант c) тоже неправильный. А так как мы разобрались, что при копировании объектов методом Object.assign значения не копируются, то правильный ответ a), ведь свойства prop1 в обоих объектах будут ссылаться на один и тот же объект в памяти.

class User  constructor(username, password)  Object.assign(this,  username, password, >); > > class Admin extends User  constructor(username, password, level)  Object.assign(this,  username, password, level, >); > static doSomething()  // . > >

a) Отсутствует вызов конструктора User
b) Object.assign не применим для this
c) Метод doSomething инкапсулирован и не доступен вне класса Розгорнути правильну відповідь з поясненням

В этом вопросе разберемся с одним из столпов объектно-ориентированного программирования — наследованием. В частности, в JS. Для того, чтобы унаследовать класс от другого класса, в JS используется ключевое слово extends. Но так было не всегда, ключевые слова extends и class пришли в javascript в стандарте ES6 или ES2015, но в ядре осталось все то же прототипное наследование. До ES2015 классы создавались и наследовались следующим образом:

function Person(name)  this.name = name; > function Student(name, track)  Person.call(this, name); this.track = track; > Student.prototype = Object.create(Person.prototype); Student.prototype.constructor = Student; Student.prototype.getTrack = function ()  return this.track; >; const jsStudent = new Student('petro', 'JS'); const dotNetStudent = new Student('ivan', '.NET');

Т.е. тело функции выполняет роль конструктора, а методы объявляются на прототипе этой функции. А для того, чтобы наследоваться, необходимо скопировать прототип наследуемого класса и восстановить конструктор. При этом, чтобы корректно работало наследование, надо не забыть вызвать конструктор родительского класса, иначе поведение будет неправильное, но исключения никакого не будет. Обратите внимание, что для копирования используется метод Object.create, который копирует все свойства объекта, записывает их в прототип и возвращает новый объект. При этом аналогичный ему Object.assign копирует собственные свойства объекта (не из прототипа) на другой объект и возвращает измененный объект, переданный первым параметром. Object.assign можно применять на любом доступном для записи объекте, поэтому вариант b) можно исключить сразу. Пример выше можно переписать следующим образом:

class Person  constructor(name)  this.name = name; > > class Student extends Person  constructor(name, track)  super(name); this.track = track; > >

Такой синтаксис не только лучше читается, но и накладывает ряд ограничений. Например, нельзя вызвать класс как функцию, несмотря на то, что имеет тип функции:

console.log(typeof Student); // function Student(); // TypeError: Class constructor Student cannot be invoked without 'new'

А также, если при наследовании от другого класса не вызвать его конструктор через встроенную функцию super(), вы получите исключение:

new Student(); // ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructo

В задании также объявлен статический метод doSomething, который недоступен на экземпляре (объекте) класса, но доступен на классе:

Admin.doSomething();

Но он никак не влияет на указанное поведение. Кроме того, в варианте c) сказано, что метод инкапсулирован, но static — это не модификатор доступа, ведь метод остается публичным, поэтому этот вариант ответа точно неправильный. А знаете ли вы, как задать приватный модификатор доступа в современном стандарте ECMAScript? Пишите свой вариант в комментариях. И как вы могли догадаться, правильный ответ a), так как конструктор класса User не вызывается в конструкторе класса Admin, и при попытке создать экземпляр класса Admin мы получим исключение.

function transformer(arr, func)  for (let i = 0; i  arr.length; i++)  if (!func(arr[i], i, arr))  return false; > > return true; >

a) arr.map(func)
b) arr.sort(func)
c) arr.reduce(func)
d) arr.filter(func)
e) arr.every(func) Розгорнути правильну відповідь з поясненням

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

const arr = [4, 9, 16]; arr.map((n) =>  return Math.sqrt(n); >); // [2, 3, 4]

Т.е. ее упрощенная реализация будет выглядеть следующим образом:

function transformer(arr, func)  const result = []; for (let i = 0; i  arr.length; i++)  result.push(func(arr[i], i, arr)); > return result; >

sort — сортирует массив в порядке, который указывается переданной функцией. Если функция возвращает число больше нуля, то значение больше, 0 — если значения равны и меньше нуля, то значение меньше. При этом функция sort — мутирующая и изменяет массив, на котором она вызывается.

const arr = [0, -2, 10, 4]; arr.sort((a, b) => a - b); // [-2, 0, 10, 4] console.log(arr); // [-2, 0, 10, 4]

Т.е. мы отсортировали массив в порядке возрастания, и при этом массив arr также изменился. Упрощенная реализация метода sort могла бы быть следующей:

function transformer(arr, func)  for (let i = 0; i  arr.length - 1; i++)  for (let j = i + 1; j  arr.length; j++)  const result = func(arr[i], arr[j]); if (result > 0)  let buf = arr[i]; arr[i] = arr[j]; arr[j] = buf; > > > return arr; >

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

const arr = [1, 2, 3, 4]; arr.reduce((result, n) => result + n); // 10 arr.reduce((result, n) => result + n, -1); // 9

Заметьте, что во втором случае мы передали инициализирующее значение -1, поэтому результат на 1 меньше. А в первом случае инициализирующего значения нет — значит, в первой итерации result равен 1, а n — 2. Реализация reduce может быть следующей:

function transformer(arr, func, init)  let result = init; let i = 0; if (init === undefined)  result = arr[0]; i = 1; > for (; i  arr.length; i++)  result = func(result, arr[i], i, arr); > return result; >

filter — возвращает новый массив из значений, для которых переданная функция возвращает true. Т.е. filter вызывает на каждом элементе переданную функцию, и если она возвращает true, то записывает значение в результирующий массив. Так следующий пример отфильтровывает все положительные числа массиве:

const arr = [-2, -1, 0, 1, 2]; arr.filter((n) => n >= 0); // [0, 1, 2]

Реализация filter выглядит следующим образом:

function transformer(arr, func)  const result = []; for (let i = 0; i  arr.length; i++)  if (func(arr[i], i, arr))  result.push(arr[i]); > > return result; >

every — возвращает true, если для всех значений массива переданная функция вернула true. Т.е. если нам нужно определить, состоит ли массив из положительных чисел, то мы воспользуемся every(): Реализация же этого метода выглядит следующим образом:

function transformer(arr, func)  for (let i = 0; i  arr.length; i++)  if (!func(arr[i], i, arr))  return false; > > return true; >

Т.е. реализация метода every подходит под заданную — значит, правильный ответ e). Кстати, если нам необходимо найти хотя бы один элемент, для которого переданная функция вернула true, есть встроенный метод some. Например:

const arr = [2, 5, 4, -1]; arr.some((n) => n > 0);

const dateStart = new Date(1976, 2, 20); const dateEnd = new Date(2017, 6, 20);

a) Date.now(dateEnd) — Date.now(dateStart)
b) Невозможно без использования сторонних библиотек
c) dateEnd.valueOf() — dateStart.valueOf()
d) dateEnd — dateStart Розгорнути правильну відповідь з поясненням

Работа с датой и временем — одна из важнейших тем в программировании, независимо от языка. В JS для работы с датой и временем существует класс Date. Базовым значением объекта этого класса является количество миллисекунд, прошедших с 1 января 1970 без учета таймзоны, т.е. в UTC. Важно понимать, что в отличие от unix timestamp, в Date отсчет идет в миллисекундах, а не в секундах. Но чтобы ответить на этот вопрос, также нужно знать о встроенных методах конвертации объектов в JS. Я хотел бы выделить следующие 3: valueOf, toString, toJSON. toString — вызывается при попытке конвертировать объект к строке

String( toString()  return 'yahoo. '; >, >); // 'yahoo. '

toJSON — этот метод вызывается при сериализации объекта в JSON методом JSON.stringify

JSON.stringify( toJSON()  return 'yahoo. '; >, >); // '"yahoo. "'

valueOf — возвращает примитивное значение объекта. Т.е. если выполняется какая-либо операция над объектом (напр. -, +, /, * и т.д.), то вызывается этот метод, если он определен.

( valueOf()  return 1; >, > + 1); // 2

При этом, если определены оба toString и valueOf, то приоритет будет у valueOf над toString, независимо от второго операнда:

( toString()  return '1'; >, valueOf()  return 2; >, > + '2'); // '22'

А если valueOf не определен, то будет вызван toString.

( toString()  return '1'; >, > + '2'); // '12'

Таким образом, примитивным значением класса Date является количество миллисекунд и метод valueOf возвращает это значение. Значит, вариант с) — правильный. Но так как в d) мы выполняем операцию вычитания, то valueOf вызовется автоматически, а значит, и этот вариант правильный. Вариант b) неправильный, потому что задачу можно выполнить стандартными средствами JS. А вариант a) неправильный, потому что метод Date.now() не принимает аргументов и всегда возвращает количество миллисекунд, прошедших с 1 января 1970 года.

function asyncFunc(a, b)  return new Promise((resolve, reject) =>  if (a.name.length  b.name.length)  reject(); > else  resolve(); > >); > asyncFunc( fullName: 'John Mistin' >,  lastName: 'Mistin' >);

a) try <> catch(err) <>
b) then().catch()
c) Присвоить результат выполнения в переменную и проверить функцией .isValid()
d) Ничего из перечисленного
e) Присвоить результат выполнения в переменную => преобразовать в Boolean => проверить на true/false Розгорнути правильну відповідь з поясненням

Чтобы ответить на этот вопрос, нужно понимать, как работает Promise. Промисы в JS предназначены для обработки асинхронных операций. Объект класса Promise имеет 3 состояния: pending (выполняется), fulfilled (выполнен успешно), rejected (выполнен с ошибкой). Когда мы создаем объект Promise, он имеет состояние pending. В конструктор мы передаем функцию, которая принимает два колбека resolve и reject:

new Promise((resolve, reject) => . >);

resolve — принимает результат выполнения промиса и переводит его в состояние fulfilled (resolve(result)). reject — принимает ошибку и переводит в состояние rejected (reject(new Error(‘error’))). Для того, чтобы обработать успешный результат, у промиса есть метод then(), а для перехвата ошибки catch():

promise .then(result => . >) .catch(error => . >)

Метод then также может принимать вторым параметром функцию, которая вызовется при ошибке, так же, как и catch(). Также важно понимать, что промис всегда возвращает промис, вне зависимости от того, произошла ошибка или нет, т.е.:

try  promise .then(() =>  throw new Error('error'); >) .catch((error) =>  // выполнится >); > catch (error)  // не выполнится >

Метод catch тоже возвращает промис. Если из метода промиса вернуть значение, то оно превратится в промис со статусом fulfilled:

const result = promise.then(() =>  return 2; >); console.log(result instanceof Promise); // true

Еще у промиса есть метод finally() , который выполняется в любом случае, произошла ошибка или нет. Кроме этого, у промиса есть ряд статических методов: Promise.resolve(value) — возвращает промис со статусом fulfilled. Promise.reject(error) — возвращает промис со статусом rejected. Promise.all([]) — возвращает промис после того, как все переданные промисы в массиве выполнятся со статусом fulfilled. А также другие, с которыми вы можете ознакомиться по ссылке. Таким образом, ответ a) неправильный, потому что промис не влияет на конструкцию try<> catch()<>. Ответ с) неправильный, потому что у промиса нет метода isValid(). Ответ e) неправильный, потому что промис всегда возвращает промис, и если объект привести к булевому значению, то ответ всегда будет true. И ответ d) неправильный, потому что правильный ответ b), так как ошибку в промисе можно перехватить или методом catch(), или вторым аргументом метода then().

const arr1 = [1, 150, 3.5]; const arr2 = arr1; arr2.pop();

a) arr1 и arr2 будут ссылаться на один и тот же объект в памяти
b) arr1 и arr2 будут разными массивами, но их методы будут синхронизированы
c) arr2 будет дочерним объектом arr1, поэтому их значения будут изменяться одновременно
d) arr1 и arr2 будут разными массивами, но их значения будут синхронизированы Розгорнути правильну відповідь з поясненням

В JS все объекты передаются по ссылке, т.е. переменная хранит адрес на ячейку в памяти, которая указывает на начало объекта. Таким образом, когда мы записываем объект в переменную или передаем его как аргумент в функцию, его копия не создается, и когда мы выполняем операции над ним, то изменяются все переменные, которые ссылаются на этот объект. Массив в JS тоже представляет собой объект класса Array. Если представить память в виде таблицы ниже, то переменная arr1 будет хранить адрес a1, и когда мы присвоим ее arr2, то и arr2 тоже будет хранить адрес a1.

Адрес	a1	a2	a3
Значение	1	150	3.5

Кстати, когда мы сравниваем два массива, то сравниваются тоже адреса, а не их значения, независимо от строгости сравнения. Поэтому операции над объектами в JS разделяются на изменяемые (mutable) и неизменяемые (immutable). Иммутабельные операции создают копию объекта целиком и после этого выполняют свои действия. В массиве к иммутабельным операциям относятся: slice(), concat(), filter(), map(), reduce()/reduceRight(). А к мутабельным: push(), pop(), sort(), reverse(), shift(), unshift(), splice(), fill(), copyWithin(). Мутирование объектов часто усложняет поиск багов и переиспользование модулей в разных частях приложения, а в реактивных фреймворках способно сломать реактивность, поэтому это считается плохим тоном при разработке. Исходя из вышесказанного, единственный правильный ответ a), потому что в JS ничего само по себе не синхронизируется, а наследуются друг от друга классы, а не объекты.

class New  constructor(someVar)  this.name = someVar; > > const extends = new New();

a) extends — зарезервированное слово, которое нельзя использовать в качестве переменной
b) extends и New — зарезервированные слова, которые нельзя использовать в качестве переменных
c) New — зарезервированное слово, которое нельзя использовать в качестве переменной
d) extends — зарезервированное слово, которое нельзя использовать в качестве переменной, а someVar не передано в качестве аргумента при создании нового объекта Розгорнути правильну відповідь з поясненням

В JS существует ряд зарезервированных ключевых слов, которые нельзя использовать в качестве идентификаторов, т.е. в названии переменных, функций, классов. Все управляющие конструкции JS по умолчанию зарезервированы, это означает, что следующий код приведет к ошибке:

function function() > // SyntaxError: Unexpected token 'function'

При этом есть ряд слов, которые зарезервированы на будущее, например implements, interface, package и т.д. С полным списком вы можете ознакомиться по ссылке: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#keywords Кроме этого, язык JS по умолчанию использует кодировку UTF-8 и является регистрозависимым. Это значит, что следующий код будет работать без ошибок:

function функция() function Function()

Таким образом, в ответе a) утверждается, что extends — зарезервированное слово, и так и есть, потому что extends используется при наследовании классов. В ответе b) говорится, что extends и New — зарезервированы, и действительно new зарезервировано, так как используется для инстанцирования классов, но так как JS регистрозависимый, то New не зарезервировано и может использоваться в качестве идентификатора. Соответственно, b) и c) ответы — неправильные. В варианте d) также утверждается, что ошибка из-за того, что не передали someVar в конструктор класса, но если не передать аргумент функции, то он будет иметь значение undefined, но к ошибке не приведет. Итого получается, что единственный правильный вариант — a).

var a = 0; a = b; var b = 3;

a) Hoisting свойственнен только переменным var
b) Переменные let невозможно перезадать
c) Значение переменной let можно назначить только одновременно с объявлением
d) По всем вышеуказанным причинам Розгорнути правильну відповідь з поясненням

Один из самых популярных вопросов на собеседованиях связан со всплытием или hoisting’ом. Поэтому и мы не стоим в стороне от современных трендов, так что во вступительном тесте вы можете встретить подобные вопросы. Ну что ж, давайте разберемся, что это за зверь такой �� Hoisting — это механизм JS, который перемещает объявление переменных и функций вверх области видимости. Т.е. можно обратиться к переменной или функции до ее объявления и не получить ошибку. В примере выше интерпретатор видит код так:

var a; var b; a = 0; a = b; b = 3;

В стандарте ES6 в игру вступили let и const, и изменили ее правила. С let и const hoisting не работает, т.е. мы обязаны сперва объявить переменную, а потом уже к ней обращаться. Кроме этого, переменные будут доступны только внутри блока, т.е. следующий код c let/const приведет к ошибке:

if (true)  var a = 12; > console.log(a); // 12 if (true)  const a = 12; > console.log(a); // ReferenceError: a is not defined

Отличие же let от const только в том, что переменные объявленные с const не могут быть перезаписаны:

const a = 2; a = 3; // нельзя (TypeError: Assignment to constant variable.) let b = 2; b = 3; // можно

Верно ли что js является регистрозависимым

Document details

Самоучитель JavaScript

Published on Dec 7, 2013

Follow this publisher

Строгий режим — «use strict»

На протяжении долгого времени JavaScript развивался без проблем с обратной совместимостью. Новые функции добавлялись в язык, в то время как старая функциональность не менялась.

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

Так было до 2009 года, когда появился ECMAScript 5 (ES5). Он добавил новые возможности в язык и изменил некоторые из существующих. Чтобы устаревший код работал, как и раньше, по умолчанию подобные изменения не применяются. Поэтому нам нужно явно их активировать с помощью специальной директивы: «use strict» .

«use strict»

Директива выглядит как строка: «use strict» или ‘use strict’ . Когда она находится в начале скрипта, весь сценарий работает в «современном» режиме.

"use strict"; // этот код работает в современном режиме .

Совсем скоро мы начнём изучать функции (способ группировки команд), поэтому заранее отметим, что в начале большинства видов функций можно поставить «use strict» . Это позволяет включить строгий режим только в конкретной функции. Но обычно люди используют его для всего файла.

Убедитесь, что «use strict» находится в начале

Проверьте, что «use strict» находится в первой исполняемой строке скрипта, иначе строгий режим может не включиться.

Здесь строгий режим не включён:

alert("some code"); // "use strict" ниже игнорируется - он должен быть в первой строке "use strict"; // строгий режим не активирован

Над «use strict» могут быть записаны только комментарии.

Нет никакого способа отменить use strict

Нет директивы типа «no use strict» , которая возвращала бы движок к старому поведению.

Как только мы входим в строгий режим, отменить это невозможно.

Консоль браузера

В дальнейшем, когда вы будете использовать консоль браузера для тестирования функций, обратите внимание, что use strict по умолчанию в ней выключен.

Иногда, когда use strict имеет значение, вы можете получить неправильные результаты.

Итак, как можно включить use strict в консоли?

Можно использовать Shift + Enter для ввода нескольких строк и написать в верхней строке use strict :

'use strict'; // . ваш код.

В большинстве браузеров, включая Chrome и Firefox, это работает.

Если этого не происходит, например, в старом браузере, есть некрасивый, но надежный способ обеспечить use strict . Поместите его в следующую обёртку:

(function() < 'use strict'; // . ваш код. >)()

Всегда ли нужно использовать «use strict»?

Вопрос кажется риторическим, но это не так.

Кто-то посоветует начинать каждый скрипт с «use strict» … Но есть способ покруче.

Современный JavaScript поддерживает «классы» и «модули» — продвинутые структуры языка (и мы, конечно, до них доберёмся), которые автоматически включают строгий режим. Поэтому в них нет нужды добавлять директиву «use strict» .

Подытожим: пока очень желательно добавлять «use strict»; в начале ваших скриптов. Позже, когда весь ваш код будет состоять из классов и модулей, директиву можно будет опускать.

Пока мы узнали о use strict только в общих чертах.

В следующих главах, по мере расширения знаний о возможностях языка, мы яснее увидим отличия между строгим и стандартным режимом. К счастью, их не так много, и все они делают жизнь разработчика лучше.

Все примеры в этом учебнике подразумевают исполнение в строгом режиме, за исключением случаев (очень редких), когда оговорено иное.

JavaScript — Урок 1. Основные понятия

Программы (сценарии) на этом языке обрабатываются встроенным в браузер интерпретатором. К сожалению, не все сценарии выполняются корректно во всех браузерах, поэтому тестируйте свои javascript-программы в различных браузерах.

Язык JavaScript регистрозависимый, т.е. заглавные и прописные буквы алфавита считаются разными символами.

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

Литералы целого типа — целые числа в представлении:

десятичном, например: 15, +5, -174.
шестнадцатеричном, например: 0х25, 0хff. Шестнадцатеричные числа включают цифры 0 — 9 и буквы a, b, c, d, e, f. Записываются они с символами 0х перед числом.
восьмеричном, например: 011, 0543. Восьмеричные числа включают только цифры 0 — 7.

Переменные используются для хранения данных. Переменные определяются с помощью оператора var, после которого следует имя переменной. Имя переменной должно начинаться с буквы латинского алфавита или с символа подчеркивания. Само имя может включать буквы латинского алфавита, цифры и знак подчеркивания.

Например:
var test
var _test
var _my_test1

Каждой переменной можно присвоить значение либо при ее инициализации (объявлении), либо в коде самой программы. Оператор присваивания обозначается знаком равно (=), но знак равенства здесь не имеет своего прямого значения. В данном случае он лишь указывает на то, что данной переменной присвоили значение.

Например:
var a=15
var b=23.15
var c=’выполнено’
var s=true

Каждая переменная имеет тип, определяемый значением переменной. Так в нашем примере: переменные a и b имеют тип number, переменная c имеет тип string, а переменная s — логический тип.

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

В выражении a*b, a и b называются операндами, а * — знак операции. В javascript определены следующие операции:

операция	название
+	сложение
—	вычитание
*	умножение
/	деление
%	остаток от деления целых чисел
++	увеличение значения операнда на единицу
—	уменьшение значения операнда на единицу

Операторы в выражении вычисляются слева направо в соответствии с приоритетами арифметических операций. Изменить порядок вычисления можно с помощью скобок.

Для каждого из арифметических операторов есть форма, в которой одновременно с заданной операцией выполняется присваивание:

оператор	эквивалентный оператор присваивания
X+=Y	X=X+Y
X-=Y	X=X-Y
X*=Y	X=X*Y
X/=Y	X=X/Y
X%=Y	X=X%Y

В данном случае сначала вычисляется правый операнд, а затем полученное значение присваивается левому операнду.

Для того, чтобы можно было сравнивать два значения в javascript определены операции сравнения, результатом которых может быть только логическое значение: true или false:

операция	название
=	больше или равно
>	больше

В javascript определены логические операции:

&& — логическое И (AND),

|| — логическое ИЛИ (OR),

! — логическое НЕ (NOT).

Результаты воздействия логических операторов на различные комбинации значений операндов показаны в таблице:

A	B	A&&B	A\|\|B	!A
true	true	true	true	false
true	false	false	true	false
false	true	false	true	true
false	false	false	false	true

Проще говоря, значение выражения A&&B истинно, если истинны оба оператора, и ложно в противном случае. Значение выражения A||B истинно, если значение хотя бы одного операнда истинно, и ложно в противном случае. Если значение операнда А истинно, то !A — ложно и наоборот.

Для строковых литералов определена операция конкатенация строк, т.е. их объединение. Обозначается эта операция знаком плюс (+). Результатом выполнения операции является также строка. Пример:

var st1=»Привет»;
var st2=»Вася»;
var st3=st1+st2;

В результате в переменной st3 будет значение «Привет Вася».

В конце приведем таблицу приоритетов операций в порядке их убывания. Приоритет операций определяет порядок, в котором выполняются операции в выражении.

название	обозначение
инкремент	++
декремент	—
отрицание	!
унарный минус	—
умножение	*
деление, остаток от деления	/,%
сложение	+
вычитание	—
сравнение	, =
равенство	==
не равенство	!=
логическое И	&&
логическое ИЛИ	\|\|
присваивание	=, +=, -=, *=, /=, %=, !=

Первый урок подошел к концу, он получился теоретическим, но без теории невозможно перейти к практике.

Следующий урок Вернуться в раздел
Теперь нажмите кнопку, что бы не забыть адрес и вернуться к нам снова.

admin@site-do.ru
site-do.ru © 2009-2019 Копировать материалы сайта запрещено!
За нарушение авторских прав предусмотрена уголовная ответственность!
Телефон редакции +7(499)346-89-56
127051, г.Москва, Цветной бульвар, д. 11, стр. 6, офис 405.

Верно ли что js является регистрозависимым

Марафон подготовки 2021

Верно ли что js является регистрозависимым

Document details

Самоучитель JavaScript

More from

HTML и CSS на примерах

Основы языка PureBasic 4.00

Самоучитель C++ Part 001

Open gl графика в проектах delphi

Delphi. Быстрый старт

Read more

Строгий режим — «use strict»

«use strict»

Консоль браузера

Всегда ли нужно использовать «use strict»?

JavaScript — Урок 1. Основные понятия

Добавить комментарий Отменить ответ