Javascript_기본지식 속 데이터 유형의 여정

Javascript는 약한 유형의 언어이지만 숫자, 문자열, 부울, 객체, Udefined 및 Null과 같은 자체 데이터 유형도 있습니다. 그 중 Object는 복잡한 데이터 유형이며 Object는 순서가 지정되지 않은 키-값 쌍으로 구성됩니다. 나머지 여러 유형은 단순 데이터 유형입니다. 참고: 변수 유형의 첫 글자는 대문자로 표시되고, 변수 값의 첫 글자는 소문자로 표시됩니다.

JavaScript는 맞춤 유형을 지원하지 않으므로 JavaScript의 모든 값은 이 6가지 유형 중 하나에 속합니다.
ECMAScript 5.1 사양에 따르면 JavaScript에는 6가지 데이터 유형(즉, 정의되지 않음, Null, Boolean, Number, String 및 Object)이 있습니다. 처음 5개는 기본 유형이고 마지막은 객체 유형입니다.

최신 ECMAScript 6에는 다른 유형인 Symbol(ECMAScript 6 새 정의)이 추가되었습니다.

기본 데이터 유형

정의되지 않음: 정의되지 않은 값은 하나만 있습니다. 이는 "값 없음"을 의미하고 모든 데이터 유형에 적용됩니다.
Null: null 값은 하나만 있습니다. 이는 "개체 없음"을 의미하며 개체 유형에만 적용됩니다. (문자 그대로)
부울: true와 false의 두 가지 값이 있습니다
숫자: 값은 IEEE 754 표준을 따르는 64비트 부동 소수점 숫자의 모음이며 정수 데이터 구조가 없습니다. 또한 NaN, Infinity, -Infinity
라는 세 가지 특수 값도 포함되어 있습니다. 문자열: 값은 유한한 유니코드 문자 모음입니다. ' 또는 "로 묶어야 합니다.

1. 문자열

JavaScript의 문자열 유형은 텍스트 데이터를 나타내는 데 사용됩니다. 이는 16비트 부호 없는 정수 값 집합의 "요소"입니다. 문자열의 각 요소는 문자열에서 특정 위치를 차지합니다. 첫 번째 요소의 인덱스는 0이고 다음 요소의 인덱스는 1입니다. 문자열의 길이는 해당 요소의 개수입니다

C 언어와 달리 JavaScript의 문자열은 변경할 수 없습니다(주석: 예를 들어 JavaScript의 문자열 작업은 새 문자열을 반환해야 하며 원래 문자열은 변경되지 않았습니다)

Javascript의 모든 것은 객체 기반입니다

문자열 생성에는 두 가지 유형이 있습니다

1. 리터럴 방식으로 생성된 문자열은 문자열의 기본형입니다. //string

2. String()을 사용하여 생성한 문자열은 문자열의 기본형입니다. //string

3. 생성자 new String()을 사용하여 생성된 문자열은 //string

객체 유형입니다.

var str1 = "자바스크립트" //문자열
var str2 = String("javascript"); //문자열은 권장되지 않음
var str3 = new String('javascript'); //객체

객체와 문자열의 차이도 있습니다

s1 = "2 2"; // 문자열 프리미티브를 생성합니다
s2 = new String("2 2"); // 문자열 객체를 생성합니다
console.log(eval(s1)); // 숫자 4를 반환합니다
console.log(eval(s2)); // "2 2" 문자열을 반환합니다
문자열 객체 valueof 변환 -》 string

console.log(eval(s2.valueOf())); // 숫자 4를 반환합니다

2. 부울

원래 값인 true false와 값이 true false인 부울 객체를 혼동하지 마세요

1. 불리언 생성자의 매개변수가 불리언 값이 아닌 경우, 해당 매개변수는 불리언 값으로 변환됩니다

2. 매개변수가 0, -0, null, false, NaN, 정의되지 않음 또는 빈 문자열("")인 경우 생성된 부울 객체의 값은 객체 또는 문자열을 포함하여 false입니다. "false"는 true

값을 갖는 부울 객체를 생성합니다.

var x = new Boolean(false);
if(x){
 console.log(x.valueOf(),typeof x); // false object
}

위의 내용이 실행됩니다. 아주 마법같은 코드입니다

새로운 Boolean 객체를 생성하여 Boolean 값이 아닌 값을 Boolean 값으로 변환하지 말고 Boolean 함수를 직접 사용하는 것이 맞습니다

var x = Boolean(expression);  // 这样用
var x = new Boolean(expression); // 而不要这样!
初始化的时候

//false
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
//true
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");

3.숫자

ECMAScript 표준에 따르면 JavaScript에는 IEEE 754 표준을 기반으로 하는 배정밀도 64비트 이진 값(-(253 -1) ~ 253 -1)의 숫자 유형이 하나만 있습니다. 정수에 대한 특정 유형을 제공하지 않습니다. 부동 소수점 숫자를 표현할 수 있는 것 외에도 Infinity, -Infinity 및 NaN(Not-a-Number)

과 같은 부호 있는 값도 있습니다.

숫자 유형에는 정수가 하나만 있으며 두 가지 방법으로 표현될 수 있습니다. 0은 -0과 0으로 표현될 수 있습니다("0"은 0의 약어입니다). 실제로 이는 거의 영향을 미치지 않습니다. 예를 들어 0 === -0은 참입니다. 하지만 0으로 나눌 때는 주의를 기울이는 것이 좋습니다.

42/0; //무한
42/-0; // -무한대

인수를 숫자로 변환할 수 없으면 NaN이 반환됩니다.

비생성자 컨텍스트(즉, new 연산자가 없는 경우)에서는 Number를 사용하여 유형 변환을 수행할 수 있습니다

isNAN 유형 판단

Number.isNaN(NaN);  // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)  // true
// e.g. these would have been true with global isNaN()
Number.isNaN("NaN");  // false
Number.isNaN(undefined); // false
Number.isNaN({});   // false
Number.isNaN("blabla"); // false
// These all return false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");

原型链继承的关系

console.log(Number.prototype.__proto__ == Object.prototype); //true
console.log(Number.prototype.__proto__.__proto__ == Object.prototype.__proto__);//true
console.log(Object.prototype.__proto__ === null);//true
console.log(typeof Number);//function

使用 Number 转换 Date 对象

var d = new Date("December 17, 1995 03:24:00");
console.log(Number(d));

四、Null

null 是一个 JavaScript 字面量，表示空值（null or an "empty" value），即没有对象被呈现（no object value is present）。它是 JavaScript 原始值 之一。

null 是一个字面量 (而不是全局对象的一个属性，undefined 是 )

console.log(null); //null
console.log(undefined);//undefined
console.log(window.null);//undefined
console.log(window.undefined);//undefined

null与undefined的区别

console.log(foot);//Uncaught ReferenceError: foot is not defined
var foo;
console.log(foo);//undefined
var bar =null;
console.log(bar);//null
typeof null  // object (bug in ECMAScript, should be null)
typeof undefined // undefined
null === undefined // false
null == undefined // true

所以判断null，可以判断类型 + 值

五、Undefined

在JavaScript中,undefined这个词有多重含义.首字母大写的Undefined表示的是一种数据类型,小写的undefined表示的是属于这种数据类型的唯一的一个值.但这两种undefined都只能存在于文档或规范中,不能存在于JavaScript代码中.在JavaScript代码中,你看到的undefined最有可能是全局对象的一个属性,该属性的初始值是就是前面所说的原始值undefined,还有种情况就是,这个undefined是个局部变量,就像其他普通变量一样,没有任何特殊性,它的值不一定是undefined,但通常情况下都是的.下面我们所说的undefined,都指的是window.undefined这个属性.

在ES3中(Firefox4之前),window.undefined就是一个普通的属性,你完全可以把它的值改变成为任意的真值,但在ES5中((Firefox4之后),window.undefined成了一个不可写,不可配置的数据属性,它的值永远是undefined.

一个未初始化的变量的值为undefined,一个没有传入实参的形参变量的值为undefined,如果一个函数什么都不返回,则该函数默认返回undefined.

你可以使用严格相等运算符来判断一个值是否是undefined:

var foo;
console.log(foo === undefined);//true
console.log(typeof foo === 'undefined');//true
console.log(window.foo === undefined);//true
console.log(bar === undefined);//Uncaught ReferenceError: bar is not defined
console.log(typeof bar === 'undefined');//true
console.log(window.bar === undefined);//true
console.log(typeof undefined == 'undefined'); //true
console.log(typeof null == 'object');//true
console.log(null == undefined);//true
console.log(null === undefined);//false

总结

Null的值是null，表示一个空对象指针，没有指向任何对象
Undefined的值是undefined，表示申明变量或对象的属性却未初始化
undefined值是派生自null的，所以对他们执行相等测试会返回true
数值、布尔值、对象和字符串值都有toString()方法。但null和undefined值没有这个方法
多数情况下，调用toString()方法不必传递参数。但是，在调用数值的toString()方法时，可以传递一个参数：输出数值的基数

var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"

在不知道要转换的值是不是null或undefined的情况下，还可以使用转型函数String()，这个函数能够将任何类型的值转换为字符串。String()函数遵循下列转换规则：

　　● 如果值有toString()方法，则调用该方法（没有参数）并返回相应的结果

　　● 如果值是null，则返回"null"

　　● 如果值是undefined，则返回"undefined"

六、Object

Javascript中一切皆Object

// Objects
typeof {a:1} === 'object';
// 使用Array.isArray或者Object.prototype.toString.call方法可以从基本的对象中区分出数组类型
typeof [1, 2, 4] === 'object';
typeof new Date() === 'object';
// 下面的容易令人迷惑，不要这样使用！
typeof new Boolean(true) === 'object';
typeof new Number(1) ==== 'object';
typeof new String("abc") === 'object';
// 函数
typeof function(){} === 'function';
typeof Math.sin === 'function';

实例化一个空Object

var o = new Object();
var o = new Object(undefined);
var o = new Object(null);
var o = {};

原型

定义属性为__proto__: 值 或 "__proto__": 值 时，不会创建名为__proto__属性。如果给出的值是对象或者null，那么对象的[[Prototype]]会被设置为给出的值。（如果给出的值不是对象也不是null，那么对象的原型不会改变。）

var obj1 = {};
assert(Object.getPrototypeOf(obj1) === Object.prototype);
var obj2 = { __proto__: null };
assert(Object.getPrototypeOf(obj2) === null);
var protoObj = {};
var obj3 = { "__proto__": protoObj };
assert(Object.getPrototypeOf(obj3) === protoObj);
 var obj4 = { __proto__: "not an object or null" };
assert(Object.getPrototypeOf(obj4) === Object.prototype);
assert(!obj4.hasOwnProperty("__proto__"));

在对象字面值中，仅有一次变更原型的机会；多次变更原型，会被视为语法错误。

不使用冒号记法的属性定义，不会变更对象的原型；而是和其他具有不同名字的属性一样是普通属性定义。

var __proto__ = "variable";
var obj1 = { __proto__ };
assert(Object.getPrototypeOf(obj1) === Object.prototype);
assert(obj1.hasOwnProperty("__proto__"));
assert(obj1.__proto__ === "variable");
var obj2 = { __proto__() { return "hello"; } };
assert(obj2.__proto__() === "hello");
var obj3 = { ["__prot" + "o__"]: 17 };
assert(obj3.__proto__ === 17);

与JSON的区别

JSON 只允许"property": value syntax形式的属性定义。属性名必须用双引号括起来。且属性定义不允许使用简便写法。
JSON中，属性的值仅允许字符串，数字，数组，true，false，或者其他JSON对象。
JSON中，不允许将值设置为函数。
Date 等对象，经JSON.parse()处理后，会变成字符串。
JSON.parse() 不会处理计算的属性名，会当做错误抛出。

defineProperty

Object.defineProperty() 方法直接在一个对象上定义一个新属性，或者修改一个已经存在的属性， 并返回这个对象
// 使用 __proto__
Object.defineProperty(obj, "key", {
 __proto__: null, // 没有继承的属性
 value: "static" // 没有 enumerable
     // 没有 configurable
     // 没有 writable
     // 作为默认值
});
// 显式
Object.defineProperty(obj, "key", {
 enumerable: false,
 configurable: false,
 writable: false,
 value: "static"
});
// 回收同一对象
function withValue(value) {
 var d = withValue.d || (
 withValue.d = {
  enumerable: false,
  writable: false,
  configurable: false,
  value: null
 }
 );
 d.value = value;
 return d;
}
// ... 和 ...
Object.defineProperty(obj, "key", withValue("static"));
// 如果 freeze 可用, 防止代码添加
// value, get, set, enumerable, writable, configurable
// 到对象原型上
(Object.freeze||Object)(Object.prototype);

configurable当且仅当这个属性描述符值为 true 时，该属性可能会改变，也可能会被从相应的对象删除。默认为 false。

enumerabletrue 当且仅当该属性出现在相应的对象枚举属性中。默认为 false。

value 与属性相关的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined。

writable true 当且仅当可能用 赋值运算符 改变与属性相关的值。默认为 false。

存取描述符同时具有以下可选键值：

get 一个给属性提供 getter 的方法，如果没有 getter 则为 undefined。方法将返回用作属性的值。默认为 undefined。
set 一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。该方法将收到作为唯一参数的新值分配给属性。默认为 undefined。

ps：js中的变量定义

在JavaScript中，使用var来定义任何类型的变量，每一个变量只是用于保存数据的占位符。

var temp; //这句代码定义了一个变量，但其类型是未知的，可以存放任何类型的值，没有初始化的时候，test中存储是undefined。
var temp=2; //这句代码定义了一个变量，并直接初始化为数值型。
var temp="javascript"; // 这句代码定义了一个变量，并直接初始化微string型，单引号和双引号都可以，只要成对出现就行。

2、变量的作用域

在Javascript中，使用var定义的变量，其作用域是在定义该变量的方法或函数内。也就是说，使用var定义的变量是局部变量。
例：

function test()
{
　var temp="Hello, Javascript!";
}

test(); //方法调用的时候创建变量并初始化，执行结束后变量被销毁。
alert(temp); //undefined。因为变量temp已经被销毁，所以是未定义（undefined）。

如果在定义变量时，不使用var，那么定义的变量是全局变量。

例：

function test2() 
 { 
  temp2="Hello, Javascript!"; 
 } 
test2(); //调用方法时，创建变量并初始化，执行结束后变量依然存在。 
alert(temp2); //Hello, Javascript! 变量值依然存在 

以上内容是小编给大家介绍的Javascript中的数据类型之旅，希望大家喜欢。