JavaScript基础数据类型(一)

动态类型

JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。这也意味着你可以使用同一个变量保存不同类型的数据：

var foo = 42;    // foo is a Number now
var foo = "bar"; // foo is a String now
var foo = true;  // foo is a Boolean now

数据类型

最新的ECMAScript 规定了 7 中数据类型:

6种原始数据类型
- Boolean
- Null
- Undefined
- Number
- String
- Symbol(ES6 新定义)
Object

布尔类型：布尔表示一个逻辑实体，可以有两个值：true 和 false。
- 使用 !! 可以强制转换成布尔类型。
- false : undefined、null、false、0、NaN、""
Null 类型： Null 类型只有一个值： null
- 值 null 特指对象的值未设置，是一个字面量。
- null 是表示缺少的标识，指示变量未指向任何对象。
- null 常在返回类型是对象，但没关联值的地方使用。
```
  // foo不存在，它从来没有被定义过或者是初始化过：
  foo;
  >> "ReferenceError: foo is not defined"

  // foo现在已经是存在的，但是它没有类型或者是值：
  var foo = null; 
  foo;
  >> null
```
Undefined 类型：一个没有被赋值的变量会有个默认值 undefined

undefined是全局对象的一个属性。也就是说，它是全局作用域的一个变量。undefined的最初值就是原始数据类型undefined。
- 一个没有被赋值的变量的类型是undefined。
- 方法或者是语句中操作的变量没有被赋值，则会返回undefined。
- 一个函数如果没有使用return语句指定返回值，就会返回一个undefined值。
```
  // 变量没有给初始值，默认是undefined
  var foo; // undefined

  function test(a){
    // 函数没有返回值，默认返回undefined
  }
  test();  // 返回"undefined"
```
Void操作符和undefined - void 操作符是第三种可以替代的方法。
```
  var x;
  if(x === void 0) {
      // 会执行这些语句
  }

  // 没有声明y
  if(y === void 0) {
      // 抛出一个RenferenceError错误(与`typeof`相比)
  }
```
！ null 与 undefined 的不同点：当检测 null 或 undefined 时，注意相等（==）与全等（===）两个操作符的区别，前者会执行类型转换：
```
  typeof null        // "object" (因为一些以前的原因而不是'null')
  typeof undefined   // "undefined"
  null === undefined // false
  null  == undefined // true
  null === null // true
  null == null // true
  !null //true
  isNaN(1 + null) // false
  isNaN(1 + undefined) // true
```

数字类型[Number]：根据 ECMAScript 标准，JavaScript 中只有一种数字类型：基于 IEEE 754 标准的双精度 64 位二进制格式的值（-(2⁶³ -1) 到 2⁶³ -1）。它并没有为整数给出一种特定的类型。除了能够表示浮点数外，还有一些带符号的值：+Infinity，-Infinity 和 NaN (非数值，Not-a-Number)。

常用方法

  class Number {
    toExponential(fractionDigits) {
      // 返回一个以指数表示法返回该数值字符串的表示形式。
      // fractionDigits = 可选。一个整数，用来指定小数点后有几位数字。默认情况下用尽可能多的位数来显示数字。
      var numObj = 77.1234;
      alert(numObj.toExponential());  // >> 输出 7.71234e+1
    }

    toFixed(digits) {
      // 使用定点表示法来格式化一个数
      // digits = 小数点后数字的个数；介于 0 到 20 （包括）之间，实现环境可能支持更大范围。
      // 如果忽略该参数，则默认为 0。
      // 返回值 --> 所给数值的定点数表示法的字符串形式。

      var numObj = 12345.6789;
      numObj.toFixed();         // 返回 "12346"：进行四舍五入，不包括小数部分

      numObj.toFixed(1);        // 返回 "12345.7"：进行四舍五入

      numObj.toFixed(6);        // 返回 "12345.678900"：用0填充

      (1.23e+20).toFixed(2);    // 返回 "123000000000000000000.00"

      (1.23e-10).toFixed(2);    // 返回 "0.00"

      2.34.toFixed(1);          // 返回 "2.3"

      -2.34.toFixed(1);         // 返回 -2.3 （由于操作符优先级，负数不会返回字符串）

      (-2.34).toFixed(1);       // 返回 "-2.3" （若用括号提高优先级，则返回字符串）
    }

    toPrecision(precision) {
      // 以指定的精度返回该数值对象的字符串表示。
      // 四舍五入到 precision 参数指定的显示数字位数
      // precision = 可选。一个用来指定有效数个数的整数。
      var numObj = 5.123456;
      console.log(numObj.toPrecision());  //输出 5.123456
      console.log(numObj.toPrecision(5)); //输出 5.1235
      console.log(numObj.toPrecision(2)); //输出 5.1
      console.log(numObj.toPrecision(1)); //输出 5

      // 注意：在某些情况下会以指数表示法返回
      console.log((1234.5).toPrecision(2)); // "1.2e+3"  
    }

    toString([radix]) {
      // 返回指定 Number 对象的字符串形式。
      // radix 指定要用于数字到字符串的转换的基数(从2到36)。
      // 如果未指定 radix 参数，则默认值为 10。

      var count = 10;

      console.log(count.toString());    // 输出 '10'
      console.log((17).toString());     // 输出 '17'
      console.log((17.2).toString());   // 输出 '17.2'

      var x = 6;

      console.log(x.toString(2));       // 输出 '110'
      console.log((254).toString(16));  // 输出 'fe'

      console.log((-10).toString(2));   // 输出 '-1010'
      console.log((-0xff).toString(2)); // 输出 '-11111111'
    }

    valueOf() {
      // 表示指定 Number 对象的原始值的数字
      var numObj = new Number(10);
      console.log(typeof numObj); // object

      var num = numObj.valueOf();
      console.log(num);           // 10
      console.log(typeof num);    // number
    }

    toLocaleString() {
      // 返回这个数字在特定语言环境下的表示字符串。
      // 根据本地语言环境，格式化数字
      // 兼容性问题
      var number = 3500;
      console.log(number.toLocaleString('en-US')); // >> 3,500
    }

    isFinite(value) {
      // 用来检测传入的参数是否是一个有穷数（finite number）。
      // value 要被检测有穷性的值。
      // 返回 一个 布尔值 表示给定的值是否是一个有穷数。

      Number.isFinite(Infinity);  // false
      Number.isFinite(NaN);       // false
      Number.isFinite(-Infinity); // false

      Number.isFinite(0);         // true
      Number.isFinite(2e64);      // true

      Number.isFinite('0');       // false, 全局函数 isFinite('0') 会返回 true
    }

    isInteger(value) {
      // 用来判断给定的参数是否为整数
      // value 要判断此参数是否为整数
      // 返回 判断给定值是否是整数的 Boolean 值。
      // 兼容性问题 IE
      Number.isInteger(0);         // true
      Number.isInteger(1);         // true
      Number.isInteger(-100000);   // true

      Number.isInteger(0.1);       // false
      Number.isInteger(Math.PI);   // false

      Number.isInteger(Infinity);  // false
      Number.isInteger(-Infinity); // false
      Number.isInteger("10");      // false
      Number.isInteger(true);      // false
      Number.isInteger(false);     // false
      Number.isInteger([1]);       // false
    }
  }

字符串类型[String]：JavaScript的字符串类型用于表示文本数据。一组16位的无符号整数值的“元素”。字符串的长度是它的元素的数量。

常用方法

  class String {
    // 字符串中第一个字符的位置为 0， 第二个字符位置为 1，以此类推。

    length // 获取字符串长度

    charAt(index) {
      // index 必需。表示字符串中某个位置的数字，即字符在字符串中的位置。
      // 返回String 在指定位置的字符

      var str = "HELLO WORLD";
      var n = str.charAt(str.length-1); // --> D
    }

    charCodeAt(index) {
      // 可返回指定位置的字符的 Unicode 编码。
      // index 必需。表示字符串中某个位置的数字，即字符在字符串中的下标。
      // 返回Number 在指定的位置的字符的 Unicode 编码。

      var str = "HELLO WORLD";
      var n = str.charCodeAt(str.length-1); // --> 68
    }

    concat(string1, string2, ..., stringX) {
      // 用于连接两个或多个字符串。
      // 【该方法没有改变原有字符串】，但是会返回连接两个或多个字符串新字符串。
      // string1, string2, ..., stringX 必需。
      // 将被连接为一个字符串的一个或多个字符串对象。
      // 返回String 两个或多个字符串连接后生成的新字符串。
      var str1="Hello ";
      var str2="world!";
      var str3=" Have a nice day!";
      var n = str1.concat(str2,str3); // --> Hello world! Have a nice day!
    }

    fromCharCode(n1, n2, ..., nX) {
      // 接受一个指定的 Unicode 值，然后返回一个字符串。
      // n1, n2, ..., nX 必需。
      // 一个或多个 Unicode 值，即要创建的字符串中的字符的 Unicode 编码。
      // 返回String 代表 Unicode 编码的字符。
      var n = String.fromCharCode(72,69,76,76,79);
      console.log(n) // --> HELLO
    }

    indexOf(searchvalue,start) {
      // 可返回某个指定的字符串值在字符串中首次出现的位置。
      // 如果没有找到匹配的字符串则返回 -1。
      // 注意： indexOf() 方法区分大小写。
      // searchvalue 必需。规定需检索的字符串值。
      // start 可选的整数参数。规定在字符串中开始检索的位置。
      // 返回Number 查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。
      var str="Hello world, welcome to the universe.";
      var n=str.indexOf("e");
      console.log(n) // --> 1

      var str="Hello world, welcome to the universe.";
      var n=str.indexOf("e",5);
      console.log(n) // --> 14
    }

    lastIndexOf(searchvalue,start) {
      // 可返回一个指定的字符串值最后出现的位置，
      // 如果指定第二个参数 start，则在一个字符串中的指定位置从后向前搜索。
      //  该方法将从后向前检索字符串，但返回是从起始位置 (0) 开始计算子字符串最后出现的位置。 看它是否含有字符串。
      // 开始检索的位置在字符串的 start 处或字符串的结尾（没有指定 start 时）。
      // searchvalue 必需。规定需检索的字符串值。
      // start 可选的整数参数。规定在字符串中开始检索的位置。
      // 返回Number 查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。

      // 从第 10 个字符开始从后向前查找字符串 "runoob" 最后出现的位置：
      var str="I am from runoob，welcome to runoob site.";
      var n=str.lastIndexOf("runoob", 20); // --> -1
    }

    match(regexp) {
      // 在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。
      // 必需。规定要匹配的模式的 RegExp 对象。如果该参数不是 RegExp 对象，则需要首先把它传递给 RegExp 构造函数，将其转换为 RegExp 对象。
      // 返回Array 存放匹配结果的数组。该数组的内容依赖于 regexp 是否具有全局标志 g。 如果没找到匹配结果返回 null 。

      var str="The rain in SPAIN stays mainly in the plain"; 
      var n=str.match(/ain/gi); // --> ain,AIN,ain,ain

    }

    replace(searchvalue, newvalue) {
      // 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
      // searchvalue 必须。规定子字符串或要替换的模式的 RegExp 对象。
      // newvalue 必需。一个字符串值。规定了替换文本或生成替换文本的函数。
      // 返回String 一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。

      var str="Mr Blue has a blue house and a blue car";
      var n=str.replace(/blue/g,"red"); 
      // --> Mr Blue has a red house and a red car

    }

    search(searchvalue) {
      // 用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。
      // 如果没有找到任何匹配的子串，则返回 -1。
      // searchvalue 必须。查找的字符串或者正则表达式。
      // 返回Number 与指定查找的字符串或者正则表达式相匹配的 String 对象起始位置。

      var str="Mr. Blue has a blue house";
      console.log(str.search("blue")); // --> 15
    }

    slice(start,end) {
      // 提取字符串的某个部分，并以新的字符串返回被提取的部分。
      // 使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分。
      // 字符串中第一个字符位置为 0, 第二个字符位置为 1, 以此类推。
      // start 必须. 要抽取的片断的起始下标。第一个字符位置为 0
      // end  可选。 紧接着要截取的片段结尾的下标。
      // end 若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。
      // end 如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置
      // 返回String     提取的字符串

      var str="Hello world!";
      var n=str.slice(1); // --> ello world!

    }

    split(separator,limit) {
      // 把一个字符串分割成字符串数组
      // 注意： split() 方法不改变原始字符串。
      // separator 可选。字符串或正则表达式，从该参数指定的地方分割 string Object。
      // limit 可选。该参数可指定返回的数组的最大长度。
      // 如果设置了该参数，返回的子串不会多于这个参数指定的数组。
      // 如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
      // 返回Array 一个字符串数组。该数组是通过在 separator 指定的边界处将字符串分割成子串创建的。返回的数组中的字串不包括 separator 自身。

      var str="How are you doing today?";
      var n=str.split("o"); // --> H,w are y,u d,ing t,day?
      // 返回的字符串不包括 o 本身

      var str="How are you doing today?";
      var n=str.split(" ",3); // How,are,you
      // 3 指定返回的数组的最大长度
    }

    substr(start,length) {
      // 在字符串中抽取从 开始 下标开始的指定数目的字符。
      // 注意： substr() 方法不会改变源字符串。
      // substr() 的参数指定的是子串的开始位置和长度，
      // 因此它可以替代 substring() 和 slice() 来使用
      // start 必需。要抽取的子串的起始下标。必须是数值。
      // 如果是负数，那么该参数声明从字符串的尾部开始算起的位置。
      // 也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
      // length 可选。子串中的字符数。必须是数值。
      // 如果省略了该参数，那么返回从字符串的开始位置到结尾的字串。
      // 返回String 包含文本的提取部分的新字符串

      var str="Hello world!";
      var n=str.substr(2) // --> llo world!

    }

    substring(from, to) {
      // 提取字符串中介于两个指定下标之间的字符。
      // from 必需。一个非负的整数，规定要提取的子串的第一个字符在中的位置。
      // to 可选。一个非负的整数，比要提取的子串的最后一个字符在中的位置多 1。
      // 如果省略该参数，那么返回的子串会一直到字符串的结尾。
      // 返回的子串包括 开始 处的字符，但不包括 结束 处的字符。

      var str="Hello world!";
      console.log(str.substring(3)); // --> lo world!
      console.log(str.substring(3,7)); // --> lo w
    }

    toLowerCase() {
      // 把字符串转换为小写。

      var str="Hello World!";
      console.log(str.toLowerCase()); // --> hello world!

    }

    toUpperCase() {
      // 把字符串转换为大写。

      var str="Hello World!";
      console.log(str.toUpperCase()); // --> HELLO WORLD!
    }

    valueOf() {
      // 可返回 String 对象的原始值。
      // 注意： valueOf() 方法通常由 JavaScript 在后台自动进行调用，而不是显式地处于代码中。
    }
  }

------ 未完待续------>

JavaScript基础数据类型(一)

动态类型

数据类型

常用方法

常用方法

猜你喜欢