원생 JS 영혼 의 질문 -- 당신 은 정말 이 JS 들 을 알 고 있 습 니까?

최근 ES6 (회사 에 처음 와 서 그런 지 기분 이 좋 고 바 쁜 일 로 인 한 무력 감 에 빠 져 있다........................................................
JS 데이터 형식 부터 말씀 드 리 겠 습 니 다.
원본 데이터 형식 과 참조 데이터 형식
원본 데이터 형식 (6 가지)

boolean

null

undefined

number

string

symbol

참조 데이터 형식:

대상 object (object, Array, RegExp, Date, Math 포함)

함수 함수 함수

여기 'null' 이 대상 인가요?저 희 는 console.log(typeof null); 출력 할 것 입 니 다: object.그러나 이것 은 JS 가 오랫동안 존재 해 온 Bug 일 뿐 대상 이 아니다.그러나 JS 초기 에 사 용 된 32 비트 시스템 은 성능 을 위해 낮은 비트 저장 변수의 유형 정 보 를 사용 하 는 것 을 고려 하여 000 시작 은 대상 이지 만 null 은 0 이 므 로 object 로 판단 합 니 다.
type: of 유형 을 정확하게 판단 할 수 있 습 니까?
우 리 는 원본 유형 에 대해 null 을 제외 하고 모두 정확하게 판단 할 수 있다 는 것 을 알 고 있다.그러나 인용 데이터 형식 은 함 수 를 제외 하고 모두 object 입 니 다.이렇게 해서 type of 를 사용 하 는 것 은 좀 적합 하지 않다.우 리 는 인 스 턴 스 of - 원형 체인 을 바탕 으로 하 는 조 회 를 생각 했다.

var str='hello!';
str instanceof String   // false

const Person=function(){}
const p1=new Person()
p1 instanceof Person   // true

그것 은 물론 기본 데이터 형식 도 판단 할 수 있다.

class PrimitiveNum{
	static [Symbol.hasInstance](x){
		return typeof x==='number'
	}
}
console.log(111 instanceof PrimitiveNum)   // true

사실 저 희 는 Symbol 을 통 해 기 존의 인 스 턴 스 of 를 type of 로 다시 정의 하 는 것 입 니 다. 이것 은 인 스 턴 스 of 행 위 를 사용자 정의 하 는 방식 입 니 다.
자 극적인 걸 로..
수 동 으로 instanceof 구현
나 는 원형 체인 을 바탕 으로 위로 찾 을 생각 을 했다.

function myInstanceof(left,right){
	//          false
	if(typeof left !== 'object' || left === null) return false;
	//  Object              
	let proto=Object.getPrototypeOf(left);
	while(true){
		if(proto==null) return false;   //        null
		if(proto==right.prototype) return true;
		proto=Object.getPrototypeOf(proto);   //     ，    “    ”，     
	}
}

테스트 해 보기:

console.log(myInstanceof("111",String));   // false
console.log(myInstanceof(new String("111"),String));   // true

재 미 있 는 것 은 에 대해 서도 하나의 예 가 있다. (ES5 는 기본 매개 변 수 를 모 의 하고 type: of 를 통 해 매개 변수 유형 을 검사 합 니 다)

function makeRequest(url,timeout,callback){
	timeout=(typeof timeout !== "undefined") ? timeout : 2000;
	callback=(typeof callback !== "undefined") ? callback : function(){};
	//    
}

운용: instanceof 왼쪽 조작 수 는 하나의 클래스 이 고 오른쪽 조작 수 는 표지 대상 의 클래스 입 니 다. 왼쪽 대상 이 오른쪽 클래스 의 실례 라면 true 로 돌아 갑 니 다. 따라서 일반적으로 typeof 로 기본 유형 을 판단 하고 나머지 는 instanceof 로 판단 합 니 다.
Object. is 와 = =
ES6 의 새로운 방법 으로 Object. is () 와 Object. assign () 은 ES 에서 '간결 하고 편리 한 바람' 을 일 으 켰 다.Object. is () 방법 을 다시 한번 말씀 드 리 겠 습 니 다.
'깊이 들 어가 기 쉬 운 ES6' 에 서 는 자바 스 크 립 트 에서 두 값 을 비교 하고 싶 을 때 같은 연산 자 (=) 나 전체 연산 자 (= = =) 를 사용 하 는 데 익숙 할 수 있 으 며 많은 개발 자 들 이 후 자 를 더 좋아 하여 비교 할 때 강제 유형 전환 을 하 는 행 위 를 피 할 수 있다 고 언급 했다.
그러나 전체 연산 자 도 정확 하지 않 습 니 다. + 0 과 - 0 은 자바 스 크 립 트 엔진 에서 완전히 다른 실체 로 표시 되 고 전체 연산 자 는 이 를 하나의 유형 으로 분류 합 니 다.NaN = = = NaN 의 반환 값 은 true 여야 하지만 자 바스 크 립 트 에서 도 isNaN () 을 사용 해 표시 해 야 합 니 다.
ES6 는 Object. is () 방법 을 도입 하여 전체 연산 자의 부정 확 한 연산 을 보완 했다.

console.log(+0 == -0);   // true
console.log(+0 === -0);   // false
console.log(Object.is(+0,-0));   // false

console.log(NaN == NaN);   // false
console.log(NaN === NaN);   // false
console.log(Object.is(NaN,NaN));   // true

console.log(5 == "5");   // true
console.log(5 === "5");   // false
console.log(Object.is(5,"5"));   // false

0.1+0.2！==0.3？
의심 할 필요 없어, 확실히 그래.내부 원 리 는 무엇 입 니까?우리 컴퓨터 의 정 보 는 모두 바 이 너 리 로 저장 되 었 다. 그러면 0.1 의 바 이 너 리 는 무한 순환 소 수 를 나타 낸다. JS 는 부동 소수점 기준 을 사용 하여 이런 무한 순환 의 바 이 너 리 를 절취 해 야 하기 때문에 정밀도 가 잃 어 버 려 0.1 이 더 이상 0.1 (실제 적 으로 조금 크다) - 절취 후 0.1 이 0.100... 001 이 되 었 다.02 는 0.200... 002 가 되 었 기 때문에 더 한 수 는 0.3 보다 많 습 니 다. 왜 0.3 + 0.4 = = 0.5 입 니까?위 에서 알 수 있 듯 이 컴퓨터 는 '합 리 적' 인 값 을 얻 기 위해 데 이 터 를 절취 해 야 한다.실제 적 으로 0.3 절 취 된 값 에 0.4 절 취 된 값 을 더 하면 0.5 절 취 된 값 과 맞 먹는다.그런데 왜 콘 솔 console. log (0.1) 에서 0.1 일 까요?입력 내용 을 변환 할 때 이 진 을 10 진 으로 변환 한 다음 10 진 을 문자열 로 변환 합 니 다. 이 변환 과정 에서 유사 값 을 가 져 옵 니 다.그래서 인쇄 된 것 은 근사치 이다.