экземпляр

Операнд левой стороны (LHS) - это фактический объект, проверяемый для операнда правой стороны (RHS), который является фактическим конструктором класса. Основное определение:

Checks the current object and returns true if the object
is of the specified object type.

Вот несколько хороших примеров и пример взят непосредственно с сайта разработчиков Mozilla:

var color1 = new String("green");
color1 instanceof String; // returns true
var color2 = "coral"; //no type specified
color2 instanceof String; // returns false (color2 is not a String object)

Стоит упомянуть, что instanceof принимает значение true, если объект наследуется от прототипа класса:

var p = new Person("Jon");
p instanceof Person

То есть p instanceof Person верно, поскольку p наследуется от Person.prototype.

По запросу OP

Я добавил небольшой пример с примерами кода и объяснением.

Когда вы объявляете переменную, вы даете ей определенный тип.

Например:

int i;
float f;
Customer c;

Выше показаны некоторые переменные, а именно i, f и c. Это integer, float и определенный пользователем Customer тип данных. Типы, подобные приведенным выше, могут быть для любого языка, а не только для JavaScript. Однако с помощью JavaScript, когда вы объявляете переменную, вы явно не определяете тип, var x, x может быть числом / строкой / типом данных, определяемым пользователем. Итак, что делает instanceof, это проверяет объект, чтобы увидеть, относится ли он к указанному типу, поэтому мы могли бы сделать сверху Customer объект:

var c = new Customer();
c instanceof Customer; //Returns true as c is just a customer
c instanceof String; //Returns false as c is not a string, it's a customer silly!

Выше мы видели, что c был объявлен с типом Customer. Мы обновили его и проверили, относится ли он к типу Customer или нет. Конечно, вернет истину. Затем, все еще используя объект Customer, мы проверяем, является ли он String. Нет, определенно не String, мы создали Customer объект, а не String объект. В этом случае возвращается false.

Это действительно так просто!

У instanceof есть важный аспект, который, похоже, пока не рассматривается ни в одном из комментариев: наследование. Переменная, оцениваемая с помощью instanceof, может возвращать истину для нескольких «типов» из-за прототипного наследования.

Например, давайте определим тип и подтип:

function Foo(){ //a Foo constructor
    //assign some props
    return this;
}

function SubFoo(){ //a SubFoo constructor
    Foo.call( this ); //inherit static props
    //assign some new props
    return this;
}

SubFoo.prototype = Object.create(Foo.prototype); // Inherit prototype
SubFoo.prototype.constructor = SubFoo;

Теперь, когда у нас есть пара «классов», давайте создадим несколько экземпляров и выясним, какие они экземпляры:

var 
    foo = new Foo()
,   subfoo = new SubFoo()
;

alert( 
    "Q: Is foo an instance of Foo? "
+   "A: " + ( foo instanceof Foo ) 
); // -> true

alert( 
    "Q: Is foo an instance of SubFoo? " 
+   "A: " + ( foo instanceof SubFoo ) 
); // -> false

alert( 
    "Q: Is subfoo an instance of Foo? "
+   "A: " + ( subfoo instanceof Foo ) 
); // -> true

alert( 
    "Q: Is subfoo an instance of SubFoo? "
+   "A: " + ( subfoo instanceof SubFoo ) 
); // -> true

alert( 
    "Q: Is subfoo an instance of Object? "
+   "A: " + ( subfoo instanceof Object ) 
); // -> true

Видите последнюю строчку? Все «новые» вызовы функции возвращают объект, унаследованный от Object. Это справедливо даже при использовании сокращения создания объекта:

alert( 
    "Q: Is {} an instance of Object? "
+   "A: " + ( {} instanceof Object ) 
); // -> true

А как насчет самих определений "классов"? Что они представляют собой экземпляры?

alert( 
    "Q: Is Foo an instance of Object? "
+   "A:" + ( Foo instanceof Object) 
); // -> true

alert( 
    "Q: Is Foo an instance of Function? "
+   "A:" + ( Foo instanceof Function) 
); // -> true

Я считаю, что понимание того, что любой объект может быть экземпляром НЕСКОЛЬКИХ типов, важно, поскольку вы (ошибочно) предполагаете, что вы можете различать, скажем, объект и функцию, используя instanceof. Как ясно видно из этого последнего примера, функция является объектом.

Это также важно, если вы используете какие-либо шаблоны наследования и хотите подтвердить потомство объекта другими методами, кроме утиного ввода.

Надеюсь, это поможет любому, кто исследует instanceof.

Остальные ответы здесь верны, но они не объясняют, как instanceof на самом деле работает, что может быть интересно некоторым языковым юристам.

У каждого объекта в JavaScript есть прототип, доступный через свойство __proto__. Функции также имеют свойство prototype, которое является начальным __proto__ для любых созданных ими объектов. Когда функция создается, ей присваивается уникальный объект для prototype. Оператор instanceof использует эту уникальность, чтобы дать вам ответ. Вот как instanceof мог бы выглядеть, если бы вы написали его как функцию.

function instance_of(V, F) {
  var O = F.prototype;
  V = V.__proto__;
  while (true) {
    if (V === null)
      return false;
    if (O === V)
      return true;
    V = V.__proto__;
  }
}

Это в основном перефразирование ECMA-262 версии 5.1 (также известного как ES5), раздел 15.3.5.3.

Обратите внимание, что вы можете переназначить любой объект свойству prototype функции, и вы можете переназначить свойство __proto__ объекта после его создания. Это даст вам интересные результаты:

function F() { }
function G() { }
var p = {};
F.prototype = p;
G.prototype = p;
var f = new F();
var g = new G();

f instanceof F;   // returns true
f instanceof G;   // returns true
g instanceof F;   // returns true
g instanceof G;   // returns true

F.prototype = {};
f instanceof F;   // returns false
g.__proto__ = {};
g instanceof G;   // returns false

Я думаю, стоит отметить, что instanceof определяется использованием ключевого слова new при объявлении объекта. В примере от JonH;

var color1 = new String("green");
color1 instanceof String; // returns true
var color2 = "coral";
color2 instanceof String; // returns false (color2 is not a String object)

Он не упомянул следующее;

var color1 = String("green");
color1 instanceof String; // returns false

Указание «new» фактически скопировало конечное состояние функции конструктора String в переменную color1, а не просто установило для нее возвращаемое значение. Я думаю, это лучше показывает, что делает новое ключевое слово;

function Test(name){
    this.test = function(){
        return 'This will only work through the "new" keyword.';
    }
    return name;
}

var test = new Test('test');
test.test(); // returns 'This will only work through the "new" keyword.'
test // returns the instance object of the Test() function.

var test = Test('test');
test.test(); // throws TypeError: Object #<Test> has no method 'test'
test // returns 'test'

Использование «new» присваивает значение «this» внутри функции объявленной переменной, в то время как неиспользование этого значения вместо этого присваивает возвращаемое значение.

И вы можете использовать его для обработки ошибок и отладки, например:

try{
    somefunction();
} 
catch(error){
    if (error instanceof TypeError) {
        // Handle type Error
    } else if (error instanceof ReferenceError) {
        // Handle ReferenceError
    } else {
        // Handle all other error types
    }
}

Что это?

Javascript - это прототипный язык, что означает, что он использует прототипы для «наследования». оператор instanceof проверяет, присутствует ли свойство конструктора prototype в цепочке __proto__ объекта. Это означает, что он будет делать следующее (при условии, что testObj является функциональным объектом):

obj instanceof testObj;

1. Проверьте, равен ли прототип объекта прототипу конструктора: obj.__proto__ === testObj.prototype >> если это true instanceof вернет true.
2. Поднимется по цепочке прототипов. Например: obj.__proto__.__proto__ === testObj.prototype >>, если это true, instanceof вернет true.
3. Будет повторять шаг 2 до тех пор, пока не будет исследован полный прототип объекта. Если нигде в цепочке прототипов объекта не соответствует testObj.prototype, тогда оператор instanceof вернет false.

Пример:

function Person(name) {
  this.name = name;
}
var me = new Person('Willem');

console.log(me instanceof Person); // true
// because:  me.__proto__ === Person.prototype  // evaluates true

console.log(me instanceof Object); // true
// because:  me.__proto__.__proto__ === Object.prototype  // evaluates true

console.log(me instanceof Array);  // false
// because: Array is nowhere on the prototype chain

Какие проблемы решает?

Это решило проблему удобной проверки, является ли объект производным от определенного прототипа. Например, когда функция получает объект, который может иметь разные прототипы. Затем, прежде чем использовать методы из цепочки прототипов, мы можем использовать оператор instanceof, чтобы проверить, есть ли эти методы на объекте.

Пример:

function Person1 (name) {
  this.name = name;
}

function Person2 (name) {
  this.name = name;
}

Person1.prototype.talkP1 = function () {
  console.log('Person 1 talking');
}

Person2.prototype.talkP2 = function () {
  console.log('Person 2 talking');
}


function talk (person) {
  if (person instanceof Person1) {
    person.talkP1();
  }
  
  if (person instanceof Person2) {
    person.talkP2();
  }
  
  
}

const pers1 = new Person1 ('p1');
const pers2 = new Person2 ('p2');

talk(pers1);
talk(pers2);

Здесь в функции talk() сначала проверяется, находится ли прототип на объекте. После этого выбирается соответствующий метод для выполнения. Невыполнение этой проверки может привести к выполнению несуществующего метода и, следовательно, к ошибке ссылки.

Когда это уместно, а когда нет?

Мы как бы уже рассмотрели это. Используйте его, когда вам нужно проверить прототип объекта, прежде чем что-то с ним делать.

На вопрос «Когда это уместно, а когда нет?» Мои 2 цента:

instanceof редко используется в производственном коде, но полезен в тестах, где вы хотите убедиться, что ваш код возвращает / создает объекты правильных типов. Если четко указать типы объектов, которые ваш код возвращает / создает, ваши тесты становятся более мощным инструментом для понимания и документирования вашего кода.

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

Если вы используете события jQuery, иногда вам нужно написать более общую функцию, которая также может вызываться напрямую (без события). Вы можете использовать instanceof, чтобы проверить, является ли первый параметр вашей функции экземпляром jQuery.Event, и отреагировать соответствующим образом.

var myFunction = function (el) {                
    if (el instanceof $.Event) 
        // event specific code
    else
        // generic code
};

$('button').click(recalc);    // Will execute event specific code
recalc('myParameter');  // Will execute generic code

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

var recalc = function (el) { 
    el = (el == undefined || el instanceof $.Event) ? $('span.allItems') : $(el);
    // calculate...
};

instanceof - это просто синтаксический сахар для isPrototypeOf:

function Ctor() {}
var o = new Ctor();

o instanceof Ctor; // true
Ctor.prototype.isPrototypeOf(o); // true

o instanceof Ctor === Ctor.prototype.isPrototypeOf(o); // equivalent

instanceof просто зависит от прототипа конструктора объекта.

Конструктор - это обычная функция. Строго говоря, это функциональный объект, поскольку в Javascript все является объектом. И у этого функционального объекта есть прототип, потому что у каждой функции есть прототип.

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

function f() {} //  ordinary function
var o = {}, // ordinary object
 p;

f.prototype = o; // oops, o is a prototype now
p = new f(); // oops, f is a constructor now

o.isPrototypeOf(p); // true
p instanceof f; // true

Следует избегать оператора instanceof, поскольку он подделывает классы, которых нет в Javascript. Несмотря на то, что ключевого слова class нет и в ES2015, поскольку class снова просто синтаксический сахар для ... но это уже другая история.

@SebastianSimon, мой последний ответ - 8 лет (когда я хромал), и, возможно, я написал какой-то бычий хит :)

Вкратце - в настоящее время единственные случаи, когда я использую instanceof, - это когда я использую class экземпляры, и поведение зависит от класса, который я получу, например. Я хочу различать, является ли 404 ErrorA (ресурс не существует) или ErrorB (служба не найдена) - коды ответов библиотеки сбивали с толку, но, к моему счастью, он был выдан с использованием разных классов ошибок.

Определенно (в настоящее время) я НЕ буду использовать его для проверки типов, отражающих примитивы - вы не можете быть уверены, возвращает ли библиотека 'msg' или new String('msg').

У обоих есть методы, принадлежащие классу String, потому что примитив 'msg' внутренне заключен в строковый объект. Внутренне означает переводчиком. Они оба Strings, но оператора instanceof здесь явно недостаточно - чтобы проверить, есть ли sth. является примитивом или классом, я бы использовал сочетание typeof && instanceof - но только для того, что возвращается из внешней библиотеки JS.

Currenlty TypeScript решает эту проблему, и вам больше не нужно использовать такие служебные проверки с typeof и instanceof.