JavaScript에 대해 덜 대중적인 지식 포인트

네이티브 함수

일반적으로 사용되는 네이티브 함수

String()

Number()

Boolean()

Array()

　　Function()

　　RegExp()

날짜()

　　Error()

　　Symbol()

　 내부 속성 [클래스]

　　 typeof 반환 값이 object 인 모든 개체에는 내부 속성 이 포함되어 있습니다. [클래스], 이 숙소는 다음을 수행할 수 없습니다. 직접 액세스할 수 있습니다. 일반적으로 Object.prototype.toString(..) 을 통해 볼 수 있습니다. 예: :

　　　　Object.prototype.toString .call(null);　　　　　　　　　　　　　　　　　

캡슐화된 객체 래퍼

　　　　기본 유형 값에는

.length 및

.toString( )

방법. ​​​​"abc" ;

　　　　var b = new String(a);

　　　var c = Object(a);

　　 일반적으로 캡슐화된 함수를 직접 사용하는 것은 권장하지 않습니다　　Unpacking 객체의 기본 유형 값을 캡슐화합니다.

valueOf()

함수를 사용할 수 있습니다.

　　　　 var a = new String("abc"); "

　　　　b.valueOf(); // 42　　　　c.valueOf(); // true　　 기본 함수 　　　배열(. .)

　　　var a = new Array( 1,2 ,3);

　　　　　a; // [1,2,3]

　　　 var b = [1,2,3]

　　　b; ,2,3]

　　　Constructor

Array( ..),

는 키워드 new를 포함할 필요가 없으며, 포함되지 않으면

가 자동으로 추가됩니다. Array생성자가 하나의 매개변수만 취하는 경우 매개변수 배열의 요소가 아닌 배열의 기본 길이로 설정됩니다.

　　　　var a = new Array(3);

　　　　a.length; // 3

　　　　a;

　　　　 빈 셀 배열을 생성하거나 사용하지 마세요

객체(..) , 함수(.. ),

및

RegExp(..)

　　　　 꼭 필요한 경우가 아니면

Object(..)/Function(..)/RegExp(..)

　　, Date(..)

and

를 사용하지 마세요.

오류(..)

　　　 생성 시간은 new Date()를 사용해야 하며, 는 주로 현재 Unix timestampDate.new()을 가져온 다음 날짜 개체에서 getTime() 을 통해 가져오는 데 사용됩니다. .

　　 에러 객체 생성(error objec) 주로 현재 실행 중인 컨텍스트를 가져옵니다.

　　기호(..)

　　　　 기본 데이터 유형—— 기호. 기호에는 고유한 특수 값이 있어 속성 이름을 지정하는 데 쉽게 이름이 중복되지 않습니다.

　　　　Symbol , Symbol.create, Symbol.iterator

　　　　obj[Sybol.iterator] = function() {/*..*/}

　　　 기호(..) 사용 기본 생성자는 기호를 사용자 정의하는 데 사용되며 new 키워드를 포함할 수 없습니다. 그렇지 않으면 오류가 보고됩니다.

　　　　var mysym = Symbol("나만의 기호");

　　 mysym; // 기호(나만의 기호)

　　　 mysym.toString() // "symbol"

　　　　var a = { };

　　　a[mysym] = "foobar";

　　　　Object.getOwnPropertySymbols(a);

　　​​​​​​​ // [기호(내 기호)]

​​​​

프로토타입 종류

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 웜 처리

　　　문자열에서 지정된 값 찾기 문자열의 위치. 　　　　String#charAt(..)　　　　문자열의 지정된 위치에 있는 문자를 가져옵니다

　　　String#substr(..), String#substring(..)

및

String# 슬라이스(. .)

　　　문자열의 지정된 부분을 가져옵니다

　　String#toUpperCase() and

String#toLowerCase()　　문자열을 대문자와 소문자로 변환

　　String#trim() string 문자열 전후에 공백을 제거하고 새 문자열을 반환합니다.

　　　　JavaScript의 유형 변환 은 항상 스칼라 기본 유형을 반환합니다. 추상값 연산

메서드가 모든 항목을 포함하도록 재정의되었습니다. 단위가 문자열화된 후 서로 연결됩니다.

　　　　　var a = [1,2,3];

　　　　　a.toString() // "1,2,3"

　　　 JSONstring replacement,

　　　　　 JSON.stringify(..) 객체에서 undefine, 함수 및 symbol 을 만나면 자동으로 무시되고 배열에서는 null을 반환합니다.

　　　　　　　　　　　　　　　　　　　　　　　　　JSON.stringify(정의되지 않음);　　　　 JSON.stringify( ㅋㅋㅋㅋㅋ　　　　　　 in in iniana 불만 ){},4]

　　　　　　　) // "[1,null,null,4]"

　　　　 JSON .stringify(

　　　　　{a:2,b:function(){}}

); // "{"a":2}"

　　　toJSON()

은 적절한 값을 반환해야 합니다. 어떤 유형이든

다음으로

JSON.stringify(..)

alignment 로 문자열화합니다.

　　　ToNumber

　　　　　 때로는 수학 연산과 같이 숫자가 아닌 값을 숫자로 사용해야 하는 경우가 있습니다. 　　　　　true 는

1

로 변환되고, false

는 0으로 변환되고, 정의되지 않은 은 NaN 으로 변환됩니다. null 을 0으로 변환합니다. 해당 기본 유형에 대해 추상 연산

ToPrimitive ,

는 먼저 값 에 valueOf() 메소드가 있는지 확인하고, 있으면 해당 값을 강제 유형 변환에 사용합니다. 그렇지 않은 경우

toString()　　　　의 반환 값을 사용하여 강제 유형 변환을 수행합니다. valueOf() 또는 toString() 모두

값을 반환하지 않으면 TypeError 오류가 발생합니다. 　　ToBoolean　　　 False value:　　　 값은 다음 두 가지 범주로 나눌 수 있습니다. 짐

undefine

null

false

+0,-0

및 NaN

""　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 브라우저별 특정 상황에서 일반 JavaScript

구문을 기반으로

은 일부 외부를 생성합니다. 값은 "false 값 개체"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　int는 에 의해 만들어질 것입니다.

　　　노골적인 캐스팅

var a = 42 사이의 명시적인 캐스트;

var b = string (a); var d = Number(c);b; // "42"d: // 3.14

　　　

문자열과 숫자 사이의 표시 변환을 수행하는 다른 방법이 있습니다

var a = 42;

var b = a.toString();

var c = "3.14";

var d = +c;

b; // "42"

d: // 3.14

　　 날짜 표시가 변환됩니다. 숫자

또 다른 단항 연산자

+

로 변환 일반적인 용도는 날짜 객체

(Date)

객체를

숫자로 캐스팅하는 것입니다.

　　　var timestamp = +new Date();

　　숫자 문자열의 명시적 구문 분석

　　　문자열의 숫자를 구문 분석하고 문자열을 숫자로 캐스팅한 결과는 모두 숫자입니다. 　예: var a = "42";

var b = "42px";

Number(a) // 42

parseInt(a); b ); // NaN

parseInt(b); // 42

　　 구문 분석은 문자열에 숫자가 아닌 문자가 포함될 경우 왼쪽에서 오른쪽으로 진행됩니다. 멈출 것이다.

　　　　parseInt(..) 문자열을 목표로 합니다.

parseInt(..)

숫자와 다른 유형의 매개변수를 전달하는 것은 쓸모가 없습니다.

　　부울로 표시 변환

　　ToBoolean

명시적임

ToBoolean 캐스트:

var a = "0";

var b = [];var c = {};

var d = "";

var e = 0;

var f = null;

var g;Boolean(a); // true

Boolean(b); // true

Boolean(c); ); // false

Boolea(e); // false

Boolea(f) // false

Boolea(g); 값을 부울 값으로 명시적으로 캐스팅합니다.

var a = "0";

var b = [];

var c = {};

var d = "";

var e = 0;

var f = null;

var g;

!!a; // true

!!c; // true

!!d; ; // false!!f; // false

　　암시적 캐스팅

　　암묵적으로 단순화

　　　　문자열과 숫자 사이의 암시적 형변환

　　　+ 연산자는 숫자 추가와 문자열 연결 모두에 사용할 수 있습니다.

var a = "42";

var b = "0";

var c= 42;

var d = 0;

a + b; // "42"

c + d; // 42

　　　 객체의 - 연산은 + ;

var a = [3]; // 2

　　　Implicit Cast to Boolean to number

　　　Implicit casting to boolean

　　　 암시적 캐스팅은 다음과 같은 경우에 발생합니다

1.if(..) 문의 조건식.

2.for(..;...;..)문 내 조건부 판단 표현

(

the second)3.while(..) and

합니다. .while(..)

루프의 조건부 판단 표현입니다. 4.? :

5.논리 연산자

|| (

logical OR) 및 (Logical AND) 왼쪽 피연산자(조건부 판단) 표현식) 　　 || 및

&&

|| 및

&&

연산자의 반환 값은 반드시 부울 유형일 필요는 없지만 두 피연산자 중 하나의 값 var a = 42;var b = "abc";

var c = null;

a || b; // 42

a && b; b; // "abc"

c&& b; // null

||

의 경우 조건 판단 결과가

true

이면 첫 번째 숫자의 값이 반환됩니다. false 인 경우 두 번째 피연산자를 반환합니다. && 은 반대입니다. 다음은 ||

매우 일반적인

||

사용법입니다.

function foo(a,b){a = a || "hello";b = b || "world";console.log(a + " " + b );

}

foo(); // "hello world"

foo("yeah","yeah"); // "yeah yeah"

기호의 강제 유형 변환

　　　완전한 평등

　　　　　　== 동등 비교에서 캐스트를 허용하지만 === 는 허용하지 않습니다. ”

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ulousint() 참고

NaN 은

NaN

+0 과 같지 않습니다.

-0

과 같음 느슨하게 같지 않음 !=

은

==의 반대, !==는 과 같습니다 이유

　　　　　문자열 간의 동등 비교 그리고 숫자

1.

Type(x)

이 숫자이고 Type(y)이 문자열이면 x== ToNumber(y)를 반환합니다. 의 결과 .

2.

Type(x)

이 문자열이고 Type(y) 이 숫자인 경우 ToNumber(x)== y 의 결과를 반환합니다. ㅋㅋㅋㅋㅋㅋㅋㅋㅋ　　　== 가장 오류가 발생하기 쉬운 곳은 true 과

false 과 다른 유형

var a = "42";var b = true; 간의 동등 비교입니다. a == b; // false1. Type(x)

이 부울 유형인 경우

ToNumber(x) == y의 결과

2.If를 반환합니다. Type(y) 은 부울 유형입니다. x == ToNumber(y)

　　　　　First: var x = true;var y = "42" ;x == y; // false

차례로

var x = "42";

var y = false;

x == y ; // false

　　　　및

undefine

　　　　

==

null

과 undefinded Hermit 캐스트도 포함됩니다.

1. x 이 null이고 y 가

undefine이면 결과는

true입니다.

2. x 가 undefine이고 y 가 null, 인 경우 결과는 true

입니다. var a == null;

var b;

a= = b; // 참

a == null; // 참

a == 거짓; // 거짓

a = = "" ; // false

b == ""; // false

b == 0; // false

　　

　　　　 객체 정보 및

(object

/

function/ array) 및 스칼라 기본 유형 ( string /숫자/ 비교 부울 값) 사이에 있습니다. 1. Type(x)

이 문자열 또는 숫자이면

type(y)이 객체이면 는 x == ToPrimitive(y) 의 결과를 반환합니다. 2. Type(x)

이 객체이고

Type(y)가 문자열 또는 숫자인 경우 　　　ToPromitive(x) == y 의 결과를 반환합니다. var a = 42;

var b = [42];a == b; // true

var a = "abc";

var b = Object(a); new String(a)

Same

a === b; // false

a == b; // true　　　　　　a == b

결과는

true,

는

b입니다. ToPromitive , 을 통해 형변환을 수행하고 a 과 동일한 기본 값 "abc" 을 반환합니다. 동일한 false 값의 비교 ​​是는 일상적이고 색다른 비교입니다. "0" == null; // false

"0" == UNDEFINED // false "0 " == false; // 참 --

어지러워!

"0" == NaN; // false

"0" == 0; // true

"0" == ""; // false

false == null;

false == 정의되지 않음; // false

false == NaN; // false

false == 0; // true --

Halo!

false == "" // true -- 어지러워!

false == [] // true -- 어지러워!

false == {} // false

"" == null; // false

"" == 정의되지 않음; // false

"" == NaN; == 0; // 참 --

어지러워!

"" == []; // 참 --

디지!

" == {}; // false

0 == null; // false

0 == 정의되지 않음; // false

0 == NaN; []; 사실 --

어지러워요!

0 == {}; false

　　　　　　왜냐하면 거짓 긍정이기 때문입니다.

　　　극단적인 경우

　　　　[] == ![] // true　　　　

부울 값의 강제 유형 변환

[] == ![]

은

이 됩니다. [] == 거짓 , 　　　　　 2 == [2]　　　 "" == [null]; //true

42 == "43" // false

"foo" == 42; // false

"true" = ' "" // false

42 == "42" // true

"foo" == ["foo"] // true

　　　 암시적 캐스트를 안전하게 사용

1. ​​양쪽에 true

또는 false가 포함됩니다. 절대 ==.2를 사용하지 마세요.양쪽 값에 [],""

또는 0 , ==.을 사용하지 마세요. 이때는 강제 유형 변환을 피하기 위해 === 을 사용하는 것이 가장 좋습니다. 　　추상 관계 비교

　　　양쪽 모두 문자열 비교

var a = ["42"];

var b = ["043"];

a < // false

a

및

b

는 숫자로 변환할 수 없습니다. ToPrimitive 는 문자열을 반환하고 는 "42 " 및

" 043"을 비교하기 때문입니다. 문자열 두 개, "0"이 알파벳순으로 "4"보다 작으므로 최종 결과는 false.

　　　　　　　　　　　　var a = [4,2];

var b = [0,4,3];a < b;

a 는 "4,2"로 변환되고, b 는 "0,4,3" 으로 변환되어 같은 방식으로 알파벳 순서로 비교됩니다.

var a = {b: 42};

var b = {b:43};

a < b ; // false

a 는 [객체 개체], b도 [개체 개체] 따라서 알파벳순으로

a < b 는 사실이 아닙니다.

　　　　　　　　　　　　　　

var a = {b: 42};

var b = {b:43};

a < b;

a == b; // 거짓

a > ; b; // 거짓

a <= b; // 참

a >= b;

위 내용은 JavaScript에 대해 덜 대중적인 지식 포인트의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!