Расширенный JavaScript: сводка методов оценки и методов преобразования типов данных

Содержание

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

Проверка типа данных

Метод 1: тип

• typeof часто используется для определения базового типа данных, но ссылочные типы могут содержать ошибки.
• typeof null печатает объект, но это всего лишь давняя ошибка JS. Это не означает, что null является ссылочным типом данных, а сам null не является объектом.
• Тип справочных данных не может быть определен. Если используется typeof, это будет «объект», за исключением функции, что правильно.

typeof 1 // 'number'
typeof '1' // 'string'
typeof undefined // 'undefined'
typeof true // 'boolean'
typeof Symbol() // 'symbol'
typeof null // 'object'
typeof [] // 'object'
typeof {} // 'object'
typeof console // 'object'
typeof console.log // 'function'

Метод 2: экземпляр

• instanceof используется для определения ссылочного типа данных
• Оператор instanceof используется для проверки того, появляется ли свойство прототипа конструктора в цепочке прототипов экземпляра объекта.

let Car = function() {}
let benz = new Car()
benz instanceof Car // true
let car = new String('Mercedes Benz')
car instanceof String // true
let str = 'Covid-19'
str instanceof String // false

Рукописный экземпляр

typeof используется для определения базового типа данных. Если да, вернуть false

Получите объект-прототип для параметров и выполните цикл, пока не найдете тот же объект-прототип

function myInstanceof(left, right) {
  // typeof is used to determine the underlying data type. If so, return false
  if(typeof left !== 'object' || left === null) return false;
  // getProtypeOf is the API that comes with the Object object and can get the prototype object for the parameters
  let proto = Object.getPrototypeOf(left);
  while(true) {                  //Loop down until you find the same prototype object
    if(proto === null) return false;
    if(proto === right.prototype) return true;//Find the same prototype object and return true
    proto = Object.getPrototypeof(proto);
    }
}
//Verify that your implementation of myInstanceof is OK
console.log(myInstanceof(new Number(123), Number));    // true
console.log(myInstanceof(123, Number));                // false

• instanceof, который может точно определить сложный ссылочный тип данных, но не может правильно определить базовый тип данных.
• typeof также имеет тот недостаток, что, хотя он может определить базовый тип данных (кроме null), он не может определить ни один из указанных типов данных, кроме типа функции.

Способ 3: Объект. Прототип. Нанизывать

• toString() — это метод-прототип объекта, который возвращает строку в формате «[object Xxx]», где Xxx — тип объекта.
• Для объектов Object вызов toString() напрямую возвращает [object Object]; Для других объектов вам нужно вызвать их

Object.prototype.toString({})       // "[object Object]"
Object.prototype.toString.call({})  // Same result as above, plus call also ok
Object.prototype.toString.call(1)    // "[object Number]"
Object.prototype.toString.call('1')  // "[object String]"
Object.prototype.toString.call(true)  // "[object Boolean]"
Object.prototype.toString.call(function(){})  // "[object Function]"
Object.prototype.toString.call(null)   //"[object Null]"
Object.prototype.toString.call(undefined) //"[object Undefined]"
Object.prototype.toString.call(/123/g)    //"[object RegExp]"
Object.prototype.toString.call(new Date()) //"[object Date]"
Object.prototype.toString.call([])       //"[object Array]"
Object.prototype.toString.call(document)  //"[object HTMLDocument]"
Object.prototype.toString.call(window)   //"[object Window]"

Оптимальное решение: напишите глобальный метод общего суждения.

Принцип:

Если это базовый тип, то возвращается тип

Если это тип объекта, используйте объект. Прототип. Путь оценки ToString, регулярное сопоставление

function getType(obj){
  let type  = typeof obj;
  if (type !== "object") {    // typeof is performed first, and if it is an underlying data type, it is returned directly
    return type;
  }
  // For typeof return result is object, perform the following judgment, the regular return result
  return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1');  // Notice the space between the RE
}
/* Code validation, case sensitive, which are typeof judgments and which are toString judgments? Think about */
getType([])     // "Array" typeof [] is object, so toString returns
getType('123')  // "string" typeof returns directly
getType(window) //"The Window" toString returns
getType(null)   // The first letter of "Null" is uppercase. typeof null is an object and must be determined by toString
getType(undefined)   // "undefined" typeof returns directly
getType()            // "undefined" typeof returns directly
getType(function(){}) //"function" typeof can be determined, so the first letter is lowercase
getType(/123/g)      //"The RegExp" toString returns

Преобразование типов

Давайте начнем с небольшой проблемы, чтобы испытать ее

'123' == 123   // false or true?    
'' == null    // false or true?     
'' == 0        // false or true?   
[] == 0        // false or true?   
[] == ''       // false or true?    
[] == ![]      // false or true?    
null == undefined //  false or true?  
Number(null)     // What does it return?         
Number('')      // What does it return?          
parseInt('');    // What does it return?         
{}+10           // What does it return?          
let obj = {
    [Symbol.toPrimitive]() {
        return 200;
    },
    valueOf() {
        return 300;
    },
    toString() {
        return 'Hello';
    }
}
console.log(obj + 200); // What does it print out here?

Ответы внизу. Посмотрите, сколько вы можете сделать правильно

Принудительное преобразование типа

Методы приведения включают Number(), parseInt(), parseFloat(), toString(), String(), Boolean().

Неявное преобразование типов

Логическими операторами &&, | |,! Операторы +, -, *, /, операторы отношения ›, ‹, ‹=, ›=, оператор равенства == или условие if/while являются неявными преобразованиями.

Несколько неявных правил преобразования типов для == и +

Правило неявного преобразования типа для ==

1 · Если типы одинаковы, преобразование не требуется.

2. Если один из операторов имеет значение null или не определено, то другой оператор должен иметь значение null или значение undefined, чтобы вернуть значение true, в противном случае оба оператора вернут значение false;

3 · Если любой имеет тип Symbol, то возвращается false;

4. Если два значения операции имеют тип строки и числа, то строка преобразуется в число;

5. Если значение операции является логическим, преобразуйте его в число;

6. Если операция имеет значение объекта и строку, число или символ на другой стороне, объект преобразуется в исходный тип (вызовите метод объекта valueOf/toString для преобразования).

null == undefined       // true  Rule 2
null == 0               // false Rule 2
'' == null              // false Rule 2
'' == 0                 // true  Rule 4 The string transfer is implicitly converted to Number and then compared
'123' == 123            // true  Rule 4 The string transfer is implicitly converted to Number and then compared
0 == false              // true  Rule 5 The Boolean type is implicitly converted to Number and then compared
1 == true               // true  Rule 5 The Boolean type is implicitly converted to Number and then compared
var a = {
  value: 0,
  valueOf: function() {
    this.value++;
    return this.value;
  }
};
// Notice here a could be 1, 2, 3 again
console.log(a == 1 && a == 2 && a ==3);  //true Rule 6 Object implicit conversion
// Note: However, after 3 times, reexecuting a==3 or the number before is false, because the value has been added, which should be noted here

Правило неявного преобразования типа для +

Оператор «+» можно использовать не только для сложения чисел, но и для объединения строк. Только если знак «+» имеет числа с обеих сторон, вы выполняете сложение; Если обе стороны являются строками, конкатенация выполняется без неявного преобразования типов.

В дополнение к более обычным случаям, описанным выше, существуют некоторые специальные правила, а именно:

• Если один из них является строкой, а другой — неопределенным, нулевым или логическим значением, то вызовите конкатенацию строк метода toString(); В случае чистых объектов, массивов, reG и т. д. метод преобразования, вызывающий объект по умолчанию, будет иметь приоритет (рассматривается в следующей лекции), а затем будет объединен.
• Если одно из них числовое, а другое неопределенное, нулевое, логическое или числовое, оно будет преобразовано в число для операции сложения, объекта или ссылки на последнее правило.
• Если один является строкой, а другой числом, конкатенация выполняется в соответствии со строковым правилом.

The following is a combination of code to understand the above rules, as shown below.
  1 + 2        // 3  normal situation
  '1' + '2'    // '12' normal situation
  // Let's look at special cases
  '1' + undefined   // "1undefined" rule 1, undefined conversion string
  '1' + null        // "1null"  rule 1, null conversion string
  '1' + true        // "1true"  rule 1, true convert string
  '1' + 1n          //'11'      compares special strings and adds BigInt, BigInt is converted to string
  1 + undefined     // NaN      rule 2, undefined conversion numbers add NaN
  1 + null          // 1        Rule 2, null is converted to 0
  1 + true          // 2        Rule 2, true is converted to 1, and the sum of the two is 2
  1 + 1n            // Error    Cannot directly mix and add BigInt and Number types
  '1' + 3           // '13'     Rule 3, string concatenation

Отвечать

'123' == 123   // false or true?    true
'' == null    // false or true?     false
'' == 0        // false or true?    true
[] == 0        // false or true?    true
[] == ''       // false or true?    true
[] == ![]      // false or true?    true
null == undefined //  false or true?  true
Number(null)     // What does it return?         0
Number('')      // What does it return?          0
parseInt('');    // What does it return?         NaN
{}+10           // What does it return?          10
let obj = {
    [Symbol.toPrimitive]() {
        return 200;
    },
    valueOf() {
        return 300;
    },
    toString() {
        return 'Hello';
    }
}
console.log(obj + 200); // What does it print out here?  400

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

Дополнительные материалы на PlainEnglish.io. Подпишитесь на нашу бесплатную еженедельную рассылку новостей. Подпишитесь на нас в Twitter, LinkedIn, YouTube и Discord. Заинтересованы в Взлом роста? Ознакомьтесь с разделом Схема.