JavaScript:基本包装类型

为了方便操作，JavaScript提供了3个特殊的引用类型：Boolean、Number和String。实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，从而可以调用这些类型的方法来操作数据。

var s1 = "hello javascript";
var s2 = s1.substring(2);

在上面的例子中，s1是一个字符串，是基本类型值。而s1调用了substring()方法，理论上基本类型值不是对象，它们不应该有方法的。其实，为了实现这种操作，后台已经自动完成了一系列的处理。当第二行代码访问s1时，会完成下面一系列操作：

  1. 创建String类型的一个实例；
  2. 在实例上调用指定的方法；
  3. 销毁这个实例

引用类型和基本包装类型的主要区别就是对象的生存期。使用new操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中。而自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁。这意味着不能在运行时为基本类型值添加属性和方法。

var s1 = "hello";
s1.name = "Jack";
alert(s1.name); // undefined

对基本包装类型的实例调用typeof会返回object，所有基本包装类型都会被转换为布尔值true。

Object构造函数会根据传入值的类型返回相应的基本包装类型：

var obj1 = new Object("hello");
var obj2 = new Object(12);
var obj3 = new Object(true);
alert(obj1 instanceof String);  // true
alert(obj2 instanceof Number);  // true
alert(obj3 instanceof Boolean); // true

注意，使用new调用基本包装类型的构造函数，与直接调用同名的转型函数不一样：

var val = "10";
var num = Number(val);  // 转型函数
alert(typeof num);      // number

var obj = new Number(val);  // 构造函数
alert(typeof obj);          // object

Boolean类型

Boolean类型是与布尔值对应的引用类型。创建Boolean类型对象：

var trueObj = new Boolean(true);
var falseObj = new Boolean(false);

Boolean类型的实例重写了valueOf()方法，返回基本类型值true或false；重写toString()方法，返回字符“true”或“false”。

在布尔表达式中使用Boolean对象时要特别注意：布尔表达式中的所有对象都会被转换为true。

var falseObj = new Boolean(false);
var result = falseObj && true;      // ①
alert(result);                      // true

var falseVal = false;
result = falseVal && true;          // ②
alert(result);                      // false

上面的例子中，首先创建了一个false值的Boolean对象falseObj。①处将falseObj与基本类型值true进行&&运算。这里特别要注意：falseObj会转换为true。所以结果为true。②处都是基本类型，进行&&运算结果为false，不需要多解释。

基本类型与引用类型的布尔值还有两个区别：

  • typeof操作符对基本类型返回“boolean”,而引用类型返回“object”
  • 使用instanceof操作符测试Boolean对象会返回true，而测试基本类型的布尔值则返回false

看下面的例子：

alert(typeof falseObj);     // object
alert(typeof falseVal);     // boolean
alert(falseObj instanceof Boolean); // true
alert(falseVal instanceof Boolean); // false

Number类型

Number是与数字值对应的引用类型。创建Number类型对象：

var numObj = new Number(100);

Number类型重写了valueOf()、toLocaleString()和toString()方法，重写后valueOf()返回对象表示的基本类型的数值，另外两个方法会返回字符串形式的数值。

var num = 11;
alert(num.toString());  // "11"
alert(num.toString(2)); // "1011"
alert(num.toString(8)); // "13"
alert(num.toString(10));    // "11"
alert(num.toString(16));    // "b"

另外，Number提供了一些将数值格式化为字符串的方法。

1.toFixed()

toFixed()方法会按照指定的小数位返回值得字符串表示。

var num1 = 11；
alert(num1.toFixed(2)); // "11.00"

var num2 = 11.005;
alert(num1.toFixed(2)); // "11.01"

2.toExponential()

toExponential()方法用于格式化，返回指数表示法,表示的数值的字符串形式。可以传入一个参数，指定输出结果中的小数位数。

var num = 11;
alert(num.toExponential(1));    // “1.0e+1”

3.toPrecision()

toPrecision()方法可能返回固定大小格式，也可能返回指数格式。可以接收一个参数，表示数值的所有数字的位数(不含指数部分)

var num = 99;
alert(num.toPrecision(1));  // "1e+2",即100，无法准确表示99
alert(num.toPrecision(2));  // "99"
alert(num.toPrecision(3));  // "99.0"

与Boolean类型相似，使用typeof和instanceof操作基本类型数值和引用类型数值时，得到的结果完全不同。

var numObj = new Number(11);
var numVal = 11;
alert(typeof numObj);   // "object"
alert(typeof numVal);   // "number"
alert(numObj instanceof Number);    // true
alert(numObj instanceof Number);    // false

String类型

String类型是字符串的对象包装类型，创建String类型：

var strObj = new String("hello javascript");

String类型提供了很多方法，用于完成字符串的解析和操作：

1.字符方法

两个用于访问字符串中特定字符的方法：charAt()和charCodeAt()。

  • charAt()：以单字符串的形式返回给定位置的那个字符
  • charCodeAt():返回字符的编码

举例：

var strVal = "hello";
alert(strVal.char(1));  // "e"
alert(strVal.charCodeAt(1));    // "101"

2.字符串操作方法

  • concat():用于将一个或多个字符串拼接起来，返回拼接得到的新字符串，但是原来的字符串不变。

示例：

var strVal = "hello ";
var result = strVal.concat("javascript");
alert(result);  // "hello javascript"
alert(strVal);  // "hello "

concat()可以接收多个参数：

var result1 = strVal.concat("world", "!")
alert(result1); // "hello world!"

下面的三个方法都返回被操作字符串的子字符串，接收1或2个字符串。不同的是：

  • slice():第一个参数表示起始位置，第二个参数表示结束位置(不包含)
  • substr()：第一个参数表示起始位置，第二个参数表示返回的字符个数(不包含)
  • substring():第一个参数表示起始位置，第二个参数表示子字符串最后一个字符后面的位置(不包含)

示例：

var str = "hello world";
alert(str.slice(3));        // "lo world"
alert(str.slice(3, 7));     // "lo w"
alert(str.substr(3));       // "lo world"
alert(str.substr(3, 7));    // "lo worl"
alert(str.substring(3));    // "lo world"
alert(str.substring(3, 7)); // "lo w"

当参数为负数时，上面的三个方法行为各不相同：

  • slice():将传入的负值与字符串的长度相加
  • substr()：将负的第一个参数加上字符串的长度，将负的第二个参数转换为0
  • substring():将所有负值参数都转换为0

示例：

var strVal = "hello world";
alert(strVal.slice(-3));    // "rld"
alert(strVal.substr(-3));   // "rld"
alert(strVal.substring(-3));// "hello world"

alert(strVal.slice(3, -4)); // "lo w"
alert(strVal.substr(3, -4));// ""
alert(strVal.substring(3, -4));// "hel"

下面对第二个参数是负值的情况作出解释，由于slice()会将第二个负的参数加上字符串的长度，所以strVal.slice(3,-4)会转换为strVal.slice(3, 7)，因此返回“lo w”。substr()会将第二个参数转换为0，strVal.substr(3, -4)会转换为strVal.substr(3, 0),因此返回的是空串。substring()会将第二个负的参数转换为0，strVal.substring(3, -4)会转换为strVal.substring(3, 0),但是，substring()会将较小的数作为开始位置，将较大的数作为结束位置，因此，最终转换为strVal.substring(0, 3)，所以返回结果为“hel”。

3.字符串位置方法

从字符串查找子字符串的方法：indexOf()和lastIndexOf()。它们都从字符串中查找子字符串，返回子字符串的位置（如果没有找到子字符串，则返回-1），区别在于：

  • indexOf()字符串开头向后搜索子字符串
  • lastIndexOf()从字符串的末尾向前搜索子字符串

示例：

var strVal = "hello world";
alert(strVal.indexOf("o"));     // 4
alert(strVal.lastIndexOf("o")); // 7

这两个方法可以接收可选的第二个参数，表示搜索的开始位置。

var strVal = "hello world";
alert(strVal.indexOf("o"， 6));     // 7
alert(strVal.lastIndexOf("o"， 6)); // 4

在使用第二个参数的情况下，可以通过循环来调用indexOf()或lastIndexOf()来找到所有匹配的子字符串：

var strVal = "Only hard work forever as a necessary of life; even if there is no hope of harvest, but also a calm to continue farming.";
var positions = new Array();
var pos = strVal.indexOf("o");

while(pos > -1) {
    positions.push(pos);
    pos = strVal.indexOf("o", pos + 1);
}
alert(positions);           // 11,16,38,65,68,72,91,101,104

4.trim()

trim()会创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果。

var strVal = "   hello world    ";
var trimStrVal = strVal.trim();
alert(strVal);      // "   hello world    "
alert(trimStrVal);  // "hello world"

5.字符串大小写转换方法

var strVal = "heLLo woRLd";
alert(strVal.toLocaleUpperCase());  // "HELLO WORLD"
alert(strVal.toUpperCase());        // "HELLO WORLD"
alert(strVal.toLocaleLowerCase());  // "hello world"
alert(strVal.toLowerCase())         // "hello world"

6.字符串模式匹配方法

  • match()方法

看一个例子：

var text = "cat, bat, sat, fat";
var pattern = /.at/;

// 与pattern.exec(text)相同
var matches = text.match(pattern);
alert(matches.index);           // 0
alert(matches[0]);              // "cat"
alert(pattern.lastIndex);       // 0

match()接收一个正则表达式，返回一个数组，数组的第一项是与整个模式匹配的字符串，之后的每一项保存着与正则表达式中的捕获组匹配的字符串。

  • search()

search()接收一个正则表达式，返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1

var text = "cat, bat, sat, fat";
var pos = text.search(/at/);
alert(pos);     // 1
  • replace()

JavaScript还提供了replace()方法。该方法接收两个参数，第一个参数是RegExp对象或字符串，第二个参数可以是字符串或一个函数。当第一个参数是一个字符串时，只会替换第一个子字符串。

var text = "cat, bat, sat, fat";
var result = text.replace("at", "ond");
alert(result);  // cond, bat, sat, fat

result = text.replace(/at/g, "ond");
alert(result);  // cond, bond, sond, fond

当第二个参数是一个函数时，在只有一个匹配项的情况下，会向这个函数传递3个参数：模式的匹配项、模式匹配项在字符串中的位置和原始字符串。在正则表达式中定义了多个捕获组的情况下，传递给函数的参数一次是模式的匹配项、第一个捕获组的匹配项、第二个捕获组的匹配项……，但
最后两个参数仍然分别是模式匹配项在字符串中的位置和原始字符串。

function htmlEscape(text) {
    return text.replace(/[<>"&]/g, function(match, pos, originalText) {
        switch (match) {
            case "<":
                return "&lt;";
            case ">":
                return "&gt;";
            case "&":
                return "&amp;";
            case "\"":
                return "&quot;";
        }
    });
}
alert(htmlEscape("<p class=\"greeting\">Hello world!</p>"));
// &lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;
  • split()

split()可以指定基于指定的分隔符将一个字符串分割成多个子字符串，并将结果放在一个数组中。

var colorText = "red, blue, green, yellow";
var colors1 = colorText.split(",");
alert(colors1);     // ["red", "blue", "green", "yellow"]

split()还可以接收可选的第二个参数， 用于指定数组的大小。

var colors2 = colorText.split(",", 2);  //   ["red", "blue"]

7.localeCompare()方法

localeCompare()用于比较两个字符串，并返回下列结果之一：

  • 如果字符串在字母表中应该排在字符串参数之前，则返回一个负数（多数情况为-1,具体由实现而定）
  • 如果字符串等于字符串的参数，则返回0；
  • 如果字符串在字母表中应该排在字符串参数之后，则返回一个整数（多数情况为1，具体由实现而定）

下面看一个例子：

var strVal = "yellow";
alert(strVal.localeCompare("brick"));   // -1
alert(strVal.localeCompare("yellow"));  // 0
alert(strVal.localeCompare("zoo"));     // 1

8.fromCharCode()

String构造函数本身有一个静态方法：fromCharCode()。这个方法的任务是接收一或多个字符编码，然后将它们转换成一个字符串。

alert(String.fromCharCode(104, 101, 108, 108, 111));    // "hello"

原文地址：https://www.cnblogs.com/bbc66/p/9498696.html

时间： 2024-10-11 21:17:19

JavaScript:基本包装类型的相关文章

javascript基本包装类型及其操作方法

1.为了便于操作基本类型值,ECMAScript还提供了3个特殊的因哟用类型:Boolean.Number.Striung. 这些类型与其他引用类型相似,但同时也具有各自的基本类型相应的特殊行为,实际上每当读取一个基本类型值得时候, 后台就会创建一个对应的基本包装类型的对象,从而让我们能够调用一些方法来操作这些数据. 2.举例示意. <!DOCTYPE html> <html lang="en"> <head> <title></t

javascript——基本包装类型

1 <script type="text/javascript"> 2 //1.Boolean 类型 3 //2.Number 类型 4 //3.String 类型 5 6 //Boolean类型容易与基本类型混淆,所以建议永远不要使用Boolean对象. 7 8 //Number是与数字对应的引用类型 9 var numberObj=new Number(10); 10 //重写toString方法 传入的参数是告诉它放回几进制数字的字符串类型 11 var num=10

javascript基本包装类型

①Number类型 Number 类型有一些静态属性(直接通过Number 调用的属性,无需new运算符)和方法. //var box = 1000.789; //alert(box.toString());//转换成字符串,传参可以转换进制 //alert(box.toLocaleString());//本地形式,1,000.789 //alert(box.toFixed(2));//1000.79,保留两位小数,四舍五入 //alert(box.toExponential());//指数形式

javaScript对象－基本包装类型的详解

本人按书上的内容大致地把javaScript对象划分成“引用类型”.“基本包装类型”和“内置对象”三块内容. 我们这篇先了解下基本包装类型的详细用法吧! 一.我们先解下相关概念: 1.引用类型的值(对象)是一个引用类型的一个实例. 在ECMAScript中,引用类型是一种数据结构,用于将数据和功能组织在一起.它也通常称为类. 尽管ECMASript中,从技术上讲是一门面向对象的语言,但它不具备传统的面向对象语言所支持的类和接口等基本结构.引用类型有时候也被称为对象定义,因为它们描述是一类对象所具

javascript类型系统之基本数据类型与包装类型

javascript的数据类型可以分为两种:原始类型和引用类型 原始类型也称为基本类型或简单类型,因为其占据空间固定,是简单的数据段,为了便于提升变量查询速度,将其存储在栈(stack)中(按值访问).其中,javascript基本数据类型包括Undefined.Null.Boolean.Number和String五种 引用类型由于其值的大小会改变,所以不能将其存放在栈中,否则会降低变量查询速度,因此其存储在堆(heap)中,存储在变量处的值是一个指针,指向存储对象的内存处(按址访问) [注意]

Javascript中的几种包装类型

 Javascript中的几种包装类型 一:String string类型是属于基本类型,不属于引用类型,那就说明string的值是保存在"栈"上面的,而很多语言不是这样,比如C#,我觉得js不作为引用类型也是情有可原,毕竟它玩不了多线程,而C#中一个线程栈空间只分配1M,如果string在C#中是值类型的话,那就有爆栈的可能,而js却没有栈空间限制,所以也就不存在爆栈的情况了. 那么下一个问题来了,我们经常会对string进行一系列的操作,比如substring. 那刚才也说了,st

JavaScript的基本包装类型概述

为了便于操作基本类型值,javaScript 提供了 3 个特殊的引用类型:Boolean.Number和 String. 这些类型与其他引用类型相似,但同时也具有与各自的基本类型相应的特殊行为. 实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象,从而能够调用一些方法来操作这些数据.比如: var box = 'Mr. Lee'; //定义一个字符串 var box2 = box.substring(2); //截掉字符串前两位  alert(box2); //输出

JavaScript学习--Item4 基本类型和基本包装类型（引用类型）

1.基本类型和引用类型 基本的数据类型有5个:undefined,boolean,number,string,null typeof null; //"object" typeof undefined; //"undefined" typeof 1; //"number" typeof false //"boolean" typeof "1" //"string" (令人困惑的是,对nu

JavaScript基础——引用类型（四）基本包装类型（Boolean、Number、String）、单体内置对象（Global、Math）

基本包装类型 为了便于操作基本类型值,ECMAScript还提供了3个特殊的引用类型:Boolean.Number和String.这些类型与其它引用类型相似,但同时也具有与各自的基本类型相应的特殊行为.实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象,从而让我们能够调用一些方法来操作这些数据.如: var s1 = "some text"; var s2 = s1.substring(2); 这个例子中的变量s1包含一个字符串,字符串当然是基本类型值.而下