Jasmine.matchersUtil.equals vs ===

Мы разработали довольно большой набор специальных жасминовых коннекторов, которые помогают сделать наш код более чистым и избежать дублирования кода. Я заметил, что некоторые пользовательские составители жасмина используют === тестирование равенства и некоторые jasmine.matchersUtil.equals. Пример:

toHaveHandCursor: function() {
    return {
        compare: function(actual) {
            return {
                pass: actual.getCssValue("cursor").then(function(cursor) {
                    return cursor === "pointer";
                })
            };
        }
    };
},

toBeActive: function() {
    return {
        compare: function(elm) {
            return {
                pass: protractor.promise.all([
                    elm.getId(),
                    browser.driver.switchTo().activeElement().getId()
                ]).then(helpers.spread(function (currentElementID, activeElementID) {
                    return jasmine.matchersUtil.equals(currentElementID, activeElementID);
                })),
                message: "Element is not active."
            };
        }
    };
}

Вопрос:

В чем разница между тестированием равенства jasmine.matchersUtil.equals и === и какой метод должен быть предпочтительнее?

Другими словами, мы вообще рискуем, если используем только ===?

Ответ 1

Насколько я понимаю, вот несколько вещей, которые я нашел для jasmine.matchersUtil.equals и ===:

По определению === сравнивает два объекта на основе его value и type. Его оператор сравнения strict. Для примера:

2 === 2 //true
2 === 3 //false
2 === '2' //false
0 === -0 //true

(Пример сценария, в котором могут появляться +0, 0 и -0)

С другой стороны, jasmine.matchersUtil.equals реализуется на основе логики _.isEqual underscorejs и тестов для равенства на основе логики, которая определяет, должны ли объекты, переданные ей, считаться равными, даже если их types различны, Что-то вроде этого -

jasmine.matchersUtil.equals(2, 2) //true
jasmine.matchersUtil.equals(2, 3) //false
jasmine.matchersUtil.equals(2, '2') //false
jasmine.matchersUtil.equals(0, -0) //false

Здесь выдержка из git repo -

// Identical objects are equal. `0 === -0`, but they aren't identical.
if (a === b) { return a !== 0 || 1 / a == 1 / b; }

EDIT: Дополнительным преимуществом jasmine.matchersUtil.equals() является то, что мы можем фактически реализовать собственные собственные тестеры равенства, чтобы можно было избежать нескольких сценариев, которые, как считается, создают проблемы. Здесь образец пользовательского тестера равенства, который используется с приведенными ниже примерами -

var customTester = function(first, second) {
    return first == second;
};

Несколько сценариев -

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

"5" === 5 //if operation on elem returns "5" then custom matcher gives false
jasmine.matchersUtil.equals("5", 5, customTester) //true when implemented with custom equality testers

undefined === null //if operation on elem returns undefined then custom matcher gives false
jasmine.matchersUtil.equals("", null, customTester) //true when implemented with custom equality testers

NaN === NaN //if operation on elem returns NaN then custom matcher gives false
jasmine.matchersUtil.equals(NaN, NaN) //true

Проверка равенства объектов проще с помощью пользовательских совпадений. Для примера:
```
{name: 'hill'} === {name: 'hill'} //false
jasmine.matchersUtil.equals({name: 'hill'}, {name: 'hill'}) //true
```
Проверить равенство возвращаемого значения элемента с помощью регулярных выражений проще с помощью пользовательских совпадений вместо реализации логики с помощью ===.
Сравнение конструкторов проще.
Проверка ошибок обрабатывается, если возникновение ошибки необходимо протестировать, передав объект ошибки пользовательскому совпадению.

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