js引用类型之基本包装类型new Boolean() 、new Number() 和new String()

 基本包装类型

ECMAScript 提供了3 个特殊的引用类型: Boolean 、 Number 和String,既有引用类型的的特点也有各自基本类型的特殊行为,

实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象。

var s1 = "some text";
var s2 = s1.substring(2);

/* 上述步骤相当于以下过程:
 * (1) 创建 String 类型的一个实例;
 * (2) 在实例上调用指定的方法;
 * (3) 销毁这个实例。
 */
var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;

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

var value = "25";
var number = Number(value);          // 转型函数
alert(typeof number);                // "number"
var obj = new Number(value);         // 构造函数
alert(typeof obj);                   // "object"

 Boolean 类型:    

  • 创建引用的Boolean实例:                                  
var booleanObject = new Boolean(true);   // 创建一个引用类型的Boolean实例
booleanObject  instanceof Boolean;       // true, booleanObject 是一个引用类型Boolean实例
typeof booleanObject;                    // "object", typeof 操作引用类型总是返回object
  • 实例方法

   1. 重写了 valueOf() 方法,返回基本类型值 true 或 false ;

       重写了 toString()方法,返回字符串 "true" 和 "false" 

var falseObject= new Boolean(false);     // 创建一个引用类型的Boolean实例

falseObject.valueOf();                   // false
falseObject.toString();                  // "false"
falseObject.toLocaleString();            // "false"

   注意: 基本类型与引用类型的Boolean的两个区别

var falseObject= new Boolean(false);     // 创建一个引用类型的Boolean实例
var falseValue = false;                  // 创建一个基本类型的Boolean实例

typeof falseObject;                      // "object"
typeof falseValue;                       // "boolean"
falseObject instanceof Boolean;          // true
falseValue instanceof Boolean;           // false
var falseObject = new Boolean(false);
var result = falseObject && true;
alert(result);                     // true。因为这里的 falseObject 是对象

var falseValue = false;
result = falseValue && true;
alert(result);                     // false

Number 类型         

  • 创建实例:                                       
var numberObject = new Number(10);           // 创建一个引用类型Number实例
numberObject instanceof Number;              // true, numberObject 是一个引用类型Number实例
typeof numberObject ;                        // "object", typeof 操作引用类型实例总是返回object
  • 实例方法

     1. valueOf() 、 toLocaleString() 、toString()方法。

// valueOf() ,返回对象表示的基本类型number的数值
// toLocaleString(),返回字符串形式
// toString()方法,若传入参数,表示返回几进制数值的字符串形式
var num = new Number(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"

alert(num.valueOf());          // 10,
alert(num.toLocaleString());   // "10",

    2. 将数值格式化为字符串的方法:  

      toFixed(args):按照 指定的小数位数 返回数值的字符串形式

var num = 10;
alert(num.toFixed(2));      //"10.00",toFixed() 方法传入了数值 2 ,意思是显示几位小数,即以 0 填补了必要的小数位。

var num = 10.005;
alert(num.toFixed(2));      //"10.01",如果数值本身包含的小数位比指定的还多,那么接近指定的最大小数位的值就会舍入

     toExponential(args):按照指定的位数 返回 以指数表示法(也称 e 表示法)表示的数值的字符串形式

var num = 10;
alert(num.toExponential(1));  //"1.0e+1" 

     toPrecision(args):按照指定的位数输出数值的字符串形式(不包括指数部分),

var num = 99;
alert(num.toPrecision(1));   //"1e+2",以一位数来表示 99,结果是 "1e+2" ,即 100。因为一位数无法准确地
表示 99,因此 toPrecision() 就将它向上舍入为 100,这样就可以使用一位数来表示它了
alert(num.toPrecision(2));   //"99"
alert(num.toPrecision(3));   //"99.0"
  • 与基本类型number的区别
var numberObject = new Number(10);
var numberValue = 10;
alert(typeof numberObject);              // "object"
alert(typeof numberValue);               // "number"
alert(numberObject instanceof Number);   // true
alert(numberValue instanceof Number);    // false

String 类型

  • 创建实例:                                    
var stringObject = new String("hello world"); // 创建一个引用类型String的实例

stringObject instanceof String;               // true;
typeof stringObject;                          // "object"                      
  • 实例方法

   1.  valueOf() 、 toLocale-String() 和 toString() 方法

var stringObject= new String("I am a girl");     // 创建一个引用类型的Boolean实例

falseObject.valueOf();                   // "I am a girl"
falseObject.toString();                  // "I am a girl"
falseObject.toLocaleString();            // "I am a girl"

   2.访问指定索引的字符:

    charAt(args)、 charCodeAt(args):返回指定索引args(从0开始)位置的字符、字符的字符编码

var stringValue = "hello world";

stringValue.charAt(1);           // "e",索引为1的字符
stringValue[1];                  // "e",索引为1的字符
stringValue.charCodeAt(1);       // 输出"101",e的字符编码

   3. 字符串操作方法:不改变原字符串

    concat():入参为任意个字符串,返回拼接后的字符串

var stringValue = "hello ";
var result = stringValue.concat("world","!");

alert(result);                     // "hello world!"
alert(stringValue);                // "hello"
"hello " + "world!";               // "hello world!"

    slice():入参为一或两个正负数,返回截取后的字符串

/* 参数若有负数,与字符串长度相加再执行 */
var stringValue = "hello world";

stringValue.slice(3);      // "lo world",返回索引为[3,+Infinity)之间的字符串
stringValue.slice(-3);     // "rld",返回索引为[8(字符串长度加参数-3),+Infinity)之间的字符串
stringValue.slice(3, 7);   // "lo w",返回索引为[3,7)之间的字符串
stringValue.slice(3, -4);  // "lo w",返回索引为[3,7(字符串长度加参数-4))之间的字符串
stringValue.slice(-3, -1); // "rl",返回索引为[8,10)之间的字符串

    substring():入参为一或两个正负数,返回截取后的字符串

/* 参数若有负数,转化为0再执行 */
var stringValue = "hello world";

stringValue.substring(3);      // "lo world",返回索引为[3,+Infinity)之间的字符串
stringValue.substring(-3);     // "hello world",将负数参数转化为0,返回索引为[0,+Infinity)之间的字符串
stringValue.substring(3, 7);   // "lo w",返回索引为[3,7)之间的字符串
stringValue.substring(3, -4);  // "hel",将负数转化为0,返回索引为[0,3)之间的字符串
stringValue.substring(-3, 2);   // "he",将负数转化为0,返回[0,2)之间的字符串

    substr():入参为一或两个正负数,返回截取后的字符串

var stringValue = "hello world";

stringValue.substr(3);       // "lo world",返回索引为[3,Infinity)的子字符串
stringValue.substr(-3);      // "rld",返回索引为[8(=-3 + 字符串长度),Infinity)的子字符串
stringValue.substr(3, 7);    // "lo worl",返回索引从3开始的7个字符
stringValue.substr(3, -4);   // "",将负数转化为0,返回索引从3开始的0个字符
stringValue.substr(-3, 2);   // "rl",返回索引为字符串长度+(-3)开始的两个字符

   3. 字符串位置方法:

    indexOf():入参为一个或者两个,从头开始搜索,返回子字符串索引

/* 从字符串的开头向后搜索子字符串 */
var stringValue = "hello world WoW";

stringValue.indexOf("o");     // 4, 从头开始搜索,返回第一次出现的索引
stringValue.indexOf("o", 6);  // 7,从索引6开始向后搜索,返回第一次出现的索引

    lastIndexOf():入参为一个或者两个,从尾部开始向前搜索,返回子字符串索引

/* 从字符串的结尾向前搜索子字符串 */
var stringValue = "hello world WoW";

stringValue.lastIndexOf("o");     // 13, 从结尾开始向前搜索,返回第一次出现的索引
stringValue.lastIndexOf("o", 6);  // 4,从索引6开始向前搜索,返回第一次出现的索引

    案例:通过循环调用 indexOf() 或 lastIndexOf() 来找到所有匹配的子字符串

var stringValue = "Lorem ipsum dolor sit amet, consectetur adipisicing elit";
var positions = new Array();
var pos = stringValue.indexOf("e");
while(pos > -1){
    positions.push(pos);
    pos = stringValue.indexOf("e", pos + 1);
}
alert(positions);               // "3,24,32,35,52"

   4. trim() 方法:删除前置及后缀的所有空格,不改变原字符串

var stringValue = " hello world ";
var trimmedStringValue = stringValue.trim();
alert(stringValue);                  // " hello world "
alert(trimmedStringValue);           // "hello world"

    注意:Firefox 3.5+、Safari 5+和 Chrome 8+还支持非标准的 trimLeft() 和 trimRight() 方法,

               分别用于删除字符串开头和末尾的空格。

   5. 字符串大小写转换方法: toLowerCase() 、 toLocaleLowerCase() 、

    toUpperCase() 和 toLocaleUpperCase()

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

   6. 字符串的模式匹配方法:

    match():接受一个参数,正则表达式或者 RegExp 对象,返回一个包含匹配项的数组

/* 数组的第一项是与整个模式匹配的字符串,之后的每一项(如果有)保存着与正则表达式中的捕获组匹配的字符串。 */
var text = "cat, bat, sat, fat";
var pattern = /.at/;

//与 pattern.exec(text)相同
var matches = text.match(pattern);// ["cat", index: 0, input: "cat, bat, sat, fat", groups: undefined]
alert(matches.index);             // 0
alert(matches[0]);                // "cat"
alert(pattern.lastIndex);         // 0

    search():入参为一个正则实例或者表达式,返回字符串中第一个匹配项的索引

/*  search() 方法返回字符串中第一个匹配项的索引;如果没有找到匹配项,则返回 -1 。 */
var text = "cat, bat, sat, fat";
var pos = text.search(/at/);
alert(pos);                 // 1

    replace():第一个参数可以是一个 RegExp 对象或者一个字符串,

                      第二个参数可以是一个字符串或者一个函数。

/*  如果第一个参数是字符串,那么只会替换第一个子字符串。
 * 要想替换所有子字符串,唯一的办法就是提供一个正则表达式,而且要指定全局( g )标志 
 */
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"
/* 如果第二个参数是字符串,那么还可以使用一些特殊的字符序列,
 * 将正则表达式操作得到的值插入到结果字符串中。
 */
var text = "cat, bat, sat, fat";
result = text.replace(/(.at)/g, "word ($1)");
alert(result);                        //word (cat), word (bat), word (sat), word (fat)

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

/* split() 方法可以接受可选的第二个参数,用于指定数组的大小
 * 通过使用正则表达式,还可以取得包含逗号字符的数组。
 */
var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(",");         // ["red", "blue", "green", "yellow"]
var colors2 = colorText.split(",", 2);      // ["red", "blue"]
var colors3 = colorText.split(/[^\,]+/);    // ["", ",", ",", ",", ""]

   7.  其他

     localeCompare():

/* 字符串在字母表中应该排在字符串参数之前,则返回一个负数,相等返回0,之后则返回一个正数 */
var stringValue = "yellow";
alert(stringValue.localeCompare("brick"));  //1
alert(stringValue.localeCompare("yellow")); //0
alert(stringValue.localeCompare("zoo"));    //-1

     fromCharCode():

/* 接收一或多个字符编码,然后将它们转换成一个字符串 */
alert(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值