JavaScript语言精粹 笔记06 方法

JS包含了少量可用在标准类型上的标准方法。

Array
Function
Number
Object
RegExp
String

Array

array.concat(item...)

concat方法返回一个新数组，它包含array的浅复制并将1个或多个参数item附加在其后。如果参数item是一个数组，那么他的每个元素会被本别添加。

var a = [‘a‘, ‘b‘, ‘c‘];
var b = [‘x‘, ‘y‘, ‘z‘];
var c = a.concat(b, true);
// c 是 [‘a‘, ‘b‘, ‘c‘, ‘x‘, ‘y‘, ‘z‘, true]

array的浅复制：

var p1={"name":"person1"};
var p2={"name":"person2"};
var arr=[p1];
var arr2=arr.concat(p2);
console.log(arr2[1].name);//person2
p2.name="person";
console.log(arr2[1].name);//person

array.join(separator)

join方法把array构造成一个字符串。

var a = [‘a‘, ‘b‘, ‘c‘];
a.push(‘d‘);
var c = a.join(‘‘);    // ‘abcd‘;

array.pop()

pop和push使数组array像堆栈一样工作。如果array是空，pop会返回undefined。

var a = [‘a‘, ‘b‘, ‘c‘];
var c = a.pop(  );    // a 是 [‘a‘, ‘b‘] & c 是 ‘c‘

pop可以这样实现：

Array.prototype.pop=function(){
    return this.splice(this.length - 1, 1)[0];
}

array.push(item...)

var a = [‘a‘, ‘b‘, ‘c‘];
var b = [‘x‘, ‘y‘, ‘z‘];
var c = a.push(b, true);
// a 是 [‘a‘, ‘b‘, ‘c‘, [‘x‘, ‘y‘, ‘z‘], true]
// c 是 5;

array.reverse()

var a = [‘a‘, ‘b‘, ‘c‘];
var b = a.reverse(  );
//a和b都是 [‘c‘, ‘b‘, ‘a‘]

array.shift()

移除数组中的第一个元素并返回该元素。如果数组array是空，它会返回undefined。shift通常比pop慢得多。

var a = [‘a‘, ‘b‘, ‘c‘];
var c = a.shift(  );    // a 是 [‘b‘, ‘c‘] & c 是 ‘a‘

shift可以这样实现：

Array.prototype.pop=function(){
    return this.splice(0, 1)[0];
}

array.slice(start,end)

slice方法对array中的一段做浅复制,从array[start]复制到array[end-1],end参数可选，默认为数组长度。不要和splice方法混淆。

var a = [‘a‘, ‘b‘, ‘c‘];
var b = a.slice(0, 1);    // b is [‘a‘]
var c = a.slice(1);       // c is [‘b‘, ‘c‘]
var d = a.slice(1, 2);    // d is [‘b‘]

array.sort(comparefn)

JS默认比较函数假定所有要排序的元素都是字符串。

var n = [4, 8, 15, 16, 23, 42];
n.sort(  );
// n is [15, 16, 23, 4, 42, 8]

可以自定义比较函数来代替默认的比较函数。比较函数包含2个参数，相等返回0，如果参数1 应该排在前则返回一个负数，如果参数2 应该排在前则返回一个正数。

n.sort(function (a, b) {
    return a - b;
});
// n is [4, 8, 15, 16, 23, 42];
var m = [‘aa‘, ‘bb‘, ‘a‘, 4, 8, 15, 16, 23, 42];
m.sort(function (a, b) {
    if (a === b) {
        return 0;
    }
    if (typeof a === typeof b) {
        return a < b ? -1 : 1;
    }
    return typeof a < typeof b ? -1 : 1;
});
// m is [4, 8, 15, 16, 23, 42, ‘a‘, ‘aa‘, ‘bb‘]

为对象数组排序：

var by = function (name) {
    return function (o, p) {
        var a, b;
        if (typeof o === ‘object‘ && typeof p === ‘object‘ && o && p) {
            a = o[name];
            b = p[name];
            if (a === b) {
                return 0;
            }
            if (typeof a === typeof b) {
                return a < b ? -1 : 1;
            }
            return typeof a < typeof b ? -1 : 1;
        } else {
            throw {
                name: ‘Error‘,
                message: ‘Expected an object when sorting by ‘ + name
            };
        }
    };
};

var s = [
    {first: ‘Joe‘,   last: ‘Besser‘},
    {first: ‘Moe‘,   last: ‘Howard‘},
    {first: ‘Joe‘,   last: ‘DeRita‘},
    {first: ‘Shemp‘, last: ‘Howard‘},
    {first: ‘Larry‘, last: ‘Fine‘},
    {first: ‘Curly‘, last: ‘Howard‘}
];
s.sort(by(‘first‘));    // s is [
//    {first: ‘Curly‘, last: ‘Howard‘},
//    {first: ‘Joe‘,   last: ‘DeRita‘},
//    {first: ‘Joe‘,   last: ‘Besser‘},
//    {first: ‘Larry‘, last: ‘Fine‘},
//    {first: ‘Moe‘,   last: ‘Howard‘},
//    {first: ‘Shemp‘, last: ‘Howard‘}
// ]

sort方法不稳定，s.sort(by(‘first‘)).sort(by(‘last‘));不能产生我们希望的顺序。要修改by函数：

var by = function (name, minor) {
    return function (o, p) {
        var a, b;
        if (o && p && typeof o === ‘object‘ && typeof p === ‘object‘) {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === ‘function‘ ? minor(o, p) : 0;
            }
            if (typeof a === typeof b) {
                return a < b ? -1 : 1;
            }
            return typeof a < typeof b ? -1 : 1;
        } else {
            throw {
                name: ‘Error‘,
                message: ‘Expected an object when sorting by ‘ + name
            };
        }
    };
};

s.sort(by(‘last‘, by(‘first‘)));    // s is [
//    {first: ‘Joe‘,   last: ‘Besser‘},
//    {first: ‘Joe‘,   last: ‘DeRita‘},
//    {first: ‘Larry‘, last: ‘Fine‘},
//    {first: ‘Curly‘, last: ‘Howard‘},
//    {first: ‘Moe‘,   last: ‘Howard‘},
//    {first: ‘Shemp‘, last: ‘Howard‘}
// ]

array.splice(start,deleteCount,item...)

从array中移除1个或多个元素，并用性的item替换它们。

var a = [‘a‘, ‘b‘, ‘c‘];
var r = a.splice(1, 1, ‘ache‘, ‘bug‘);
// a is [‘a‘, ‘ache‘, ‘bug‘, ‘c‘]
// r is [‘b‘]

array.unshift(item...)

unshift类似于push，但是它是把item插入到array的开始部分，它返回array的新长度。

var a = [‘a‘, ‘b‘, ‘c‘];
var r = a.unshift(‘?‘, ‘@‘);
// a is [‘?‘, ‘@‘, ‘a‘, ‘b‘, ‘c‘]
// r is 5

Function

function.apply(thisArg,argArray)

apply方法调用函数function，传递一个被绑定到this上的对象和一个可选的参数数组。

obj：这个对象将代替function类里this对象
args：这个是数组，它将作为参数传给function（args-->arguments）

var Person=function(name,age){
    this.name=name;
    this.age=age;
    this.sayHi=function(){alert("Hi! My name is "+this.name+", I‘m "+this.age)};
}

var Student=function(name,age,grade){
    Person.apply(this,arguments);//apply使Student类具备了Person类的全部方法和属性
    this.grade=grade;
}

var p1=new Person("Jesse",18);
p1.sayHi();//Hi! My name is Jesse, I‘m 18.
var s1=new Student("Lily",10,5);
s1.sayHi();//Hi! My name is Lily, I‘m 10.

可以利用apply的参数数组来简化程序：

例如

求数组中的最大值

var arr=[1,3,2];
//一般方法
var m=arr[0];
for(var i=1;i<arr.length;i++){
    m=Math.max(max,arr[i]);
}
alert(m);
//利用apply
m=Math.max.apply(null,arr);
alert(m);

Number

number.toExponential(fractionDigits)

toExponential方法把number转换成一个指数形式的字符串。可选参数fractionDigits控制小数点后的位数。

console.log(Math.PI.toExponential(0));//3e+0
console.log(Math.PI.toExponential(2));//3.14e+0
console.log(Math.PI.toExponential(7));//3.1415927e+0
console.log(Math.PI.toExponential(16));//3.1415926535897931e+0
console.log(Math.PI.toExponential());//3.141592653589793e+0

member.toFixed(fractionDigits)

toFixed方法把number转换成一个十进制形式的字符串。可选参数fractionDigits控制小数点位数。

console.log(Math.PI.toFixed(0));//3
console.log(Math.PI.toFixed(2));//3.14
console.log(Math.PI.toFixed(7));//3.1415927
console.log(Math.PI.toFixed(16));//3.1415926535897931
console.log(Math.PI.toFixed());//3

member.toPrecision(precision)

toPrecision方法把number转换成一个十进制形式的字符串。可选参数precision控制数字的位数。

console.log(Math.PI.toPrecision(2));//3.1
console.log(Math.PI.toPrecision(7));//3.141593
console.log(Math.PI.toPrecision(16));//3.141592653589793
console.log(Math.PI.toPrecision());//3.141592653589793

numbe.toString(radix)

toSting方法把number转换成一个字符串。可选参数radix控制基数，默认为10。radix参数最常用的是整数，但是他可以用任意数字。

console.log(Math.PI.toString(2));//11.001001000011111101101010100010001000010110100011
console.log(Math.PI.toString(8));//3.1103755242102643
console.log(Math.PI.toString(16));//3.243f6a8885a3
console.log(Math.PI.toString());//3.141592653589793

Object

object.hasOwnProperty(name)

如果object包含一个name属性，那么hasOwnProperty方法返回true。原型链中的同名属性是不会被检查的。

var a={memeber:true};
console.log(a.hasOwnProperty("memeber"));//true

RegExp

regexp.exec(string)

如果它成功匹配regexp和字符串string，它会返回一个数组。数组中下标为0的元素包含正则表达式regexp匹配的子字符串。下标为1的元素是分组1捕获的文本，下标为2的元素是分组2捕获的文本，依此类推。如果匹配失败则返回null。

如果regexp带有一个g标志（全局标志），事情变得更加复杂了。查找不是从字符串的起始位置开始，而是从regexp.lastIndex( 初始值为0 )位置开始。如果匹配成功，那么regexp.lastIndex将被设置为该匹配后第一个字符的位置。不成功的匹配会重置regexp.lastIndex为0。

你可以通过循环调用exec去查询一个匹配模式在一个字符串中发生几次。要注意：如果你提前退出了循环，在次进入这个循环前必须把regexp的lastIndex重置为0。^因子也仅匹配regex.lastIndex为0的情况。

// 把一个简单的HTML文本分解为标签和文本
var text = ‘<html><body bgcolor=linen><p>‘ +‘This is <b>bold<\/b>!<\/p><\/body><\/html>‘;
var tags = /[^<>]+|<(\/?)([A-Za-z]+)([^<>]*)>/g;
var a, i;

while ((a = tags.exec(text))) {
    for (i = 0; i < a.length; i += 1) {
        console.log(‘// [‘ + i + ‘] ‘ + a[i]);
    }
    console.log(  );
}

// 结果:

// [0] <html>
// [1]
// [2] html
// [3]

// [0] <body bgcolor=linen>
// [1]
// [2] body
// [3]  bgcolor=linen

// [0] <p>
// [1]
// [2] p
// [3]

// [0] This is
// [1] undefined
// [2] undefined
// [3] undefined

// [0] <b>
// [1]
// [2] b
// [3]

// [0] bold
// [1] undefined
// [2] undefined
// [3] undefined

// [0] </b>
// [1] /
// [2] b
// [3]

// [0] !
// [1] undefined
// [2] undefined
// [3] undefined

// [0] </p>
// [1] /
// [2] p
// [3]

// [0] </body>
// [1] /
// [2] body
// [3]

// [0] </html>
// [1] /
// [2] html
// [3]

regex.test(string)

var b = /&.+;/.test(‘frank &amp; beans‘);
// b is true

String

string.charAt(pos)

返回string中pos位置的字符。

var name=‘Curly‘;
var c0=name.charAt(0);
console.log(c0);//C

var c1=name.charAt(-1);
console.log(c1);//空字符串
console.log(c1.length);//0

var c2=name.charAt(10);console.log(c2);//空字符串

string charCodeAt(pos)

返回一个以整数形式表示的在string中的pos位置上的字符码位。

var name=‘Curly‘;
var c0=name.charCodeAt(0);
console.log(c0);//67

var c1=name.charCodeAt(-1);
console.log(c1);//NaN

var c2=name.charCodeAt(10);
console.log(c2);//NaN

string.concat(string...)

var s = ‘C‘.concat(‘a‘, ‘t‘);    // s is ‘Cat‘

string.indexOf(searchString,position)

从string的postion（可选，默认为0）位置开始查找字符串searchString，如果找到返回第一个匹配字符的位置，否则返回-1。

var text = ‘Mississippi‘;
var p = text.indexOf(‘ss‘);    // p is 2
p = text.indexOf(‘ss‘, 3);     // p is 5
p = text.indexOf(‘ss‘, 6);     // p is -1

string.lastIndexOf(searchString,position)

var text = ‘Mississippi‘;
var p = text.lastIndexOf(‘ss‘);    //从字符串末尾向前找 p is 5
p = text.lastIndexOf(‘ss‘, 3);     //从字符串位置3处向前找 p is 2
p = text.lastIndexOf(‘ss‘, 6);     //从字符串位置6处向前找 p is 5
p = text.lastIndexOf(‘ss‘, -2);     // p is -1
p = text.lastIndexOf(‘ss‘, 20);     //20大于字符串长度，从字符串末尾向前找 p is 5

string.localCompare(this)

该函数采用底层操作系统提供的排序规则进行比较。

var m = [‘AAA‘, ‘A‘, ‘aa‘, ‘a‘, ‘Aa‘, ‘aaa‘];
m.sort(function (a, b) {
    return a.localeCompare(b);//a<b结果为负，相等为0，a>b为正
});

// 在某些本地环境下 m 为[‘a‘, ‘A‘, ‘aa‘, ‘Aa‘, ‘aaa‘, ‘AAA‘]

string.match(regexp)

如果没有g标识，调用string.match(regexp)的结果与string.exec(regexp)的结果相同，如果regexp有g标识，那么它返回一个包含除捕获分组之外的所有匹配的数组。

var text = ‘<html><body bgcolor=linen><p>‘ +
        ‘This is <b>bold<\/b>!<\/p><\/body><\/html>‘;
var tags = /[^<>]+|<(\/?)([A-Za-z]+)([^<>]*)>/g;
var a, i;

a = text.match(tags);
for (i = 0; i < a.length; i += 1) {
    console.log(‘// [‘ + i + ‘] ‘ + a[i]);
}

// 结果

// [0] <html>
// [1] <body bgcolor=linen>
// [2] <p>
// [3] This is
// [4] <b>
// [5] bold
// [6] </b>
// [7] !
// [8] </p>
// [9] </body>
// [10] </html>

string.replace(regexp/substr,replacement)

参数regexp/substr规定子字符串或要替换的模式的 RegExp 对象。如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。 replacement规定了替换文本或生成替换文本的函数。replace方法返回一个新的字符串。

它将在 string 中查找与 regexp 相匹配的子字符串，然后用 replacement 来替换这些子串。如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串。

replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义。如下表所示，它说明从模式匹配得到的字符串将用于替换。

字符 替换文本

$1、$2、...、$99
与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。

$&
与 regexp 相匹配的子串。

$`
位于匹配子串左侧的文本。

$‘
位于匹配子串右侧的文本。

$$
直接量符号。

示例代码：

var str="Visit Microsoft!".replace("Microsoft", "Windows");//Visit Windows!

执行一次全局替换，每当 "Microsoft" 被找到，它就被替换为 "W3School"：

var str="Welcome to Microsoft! "
+ "We are proud to announce that Microsoft has "
+ "one of the largest Web Developers sites in the world."

var str=str.replace(/Microsoft/g, "W3School");
//"Welcome to W3School! We are proud to announce that W3School has one of the largest Web Developers sites in the world."

确保匹配字符串大写字符的正确：

text = "javascript Tutorial";
text.replace(/javascript/i, "JavaScript");

把 "Doe, John" 转换为 "John Doe" 的形式：

name = "Doe, John";
name =name.replace(/(\w+)\s*,\s*(\w+)/, "$2 $1");//John Doe

把字符串中所有单词的首字母都转换为大写：

name = ‘aaa bbb ccc‘;
uw=name.replace(/\b\w+\b/g, function(word){
  return word.substring(0,1).toUpperCase()+word.substring(1);}
  //"Aaa Bbb Ccc"
  );

以上关于replace的内容来自于W3School

string.search(regexp)

类似于indexOf，如果找到返回第一个匹配的首字符位置。找不到则返回-1，此方法会忽略掉g标识。

var text = ‘and in it he says "Any damn fool could‘;
var pos = text.search(/["‘]/);    // pos is 18

string.slice(start,end)

复制string中的一部分来构造一个新的字符串，从string的start位置到end-1位置。

var str=‘0123456789‘;
var s1=str.slice(1);//123456789
var s2=str.slice(9);//9
var s3=str.slice(2,5);//234
var s4=str.slice(5,2);//空字符串
var s5=str.slice(10);//空字符串

string.split(separator,limit)

把string依据separator分割成limit段，limit可选。separator可以是一个值字符串或者正则表达式。

var digits = ‘012345‘;
var a = digits.split(‘‘, 5);
// a is [‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘]
var b = digits.split(‘‘);
// b is [‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘,‘5‘]
var ip = ‘192.168.1.0‘;
var b = ip.split(‘.‘);
// b is [‘192‘, ‘168‘, ‘1‘, ‘0‘]

var c = ‘|a|b|c|‘.split(‘|‘);
// c is [‘‘, ‘a‘, ‘b‘, ‘c‘, ‘‘]

var text = ‘last,  first ,middle‘;
var d = text.split(/\s*,\s*/);
// d is [
//    ‘last‘,
//    ‘first‘,
//    ‘middle‘
// ]

注意，来自分组捕获的文本将会被包含在分割后的数组中：

var e = text.split(/\s*(,)\s*/);
// e is [
//    ‘last‘,
//    ‘,‘,
//    ‘first‘,
//    ‘,‘,
//    ‘middle‘
// ]

当separator是一个正则表达式时，有一些JS的实现在输出数组中会禁止空字符串：

var f = ‘|a|b|c|‘.split(/\|/);
//一些系统中 f is [‘a‘, ‘b‘, ‘c‘]
//另外一些系统中 f is [‘‘, ‘a‘, ‘b‘, ‘c‘, ‘‘]

string.substring(start,end)

用法同slice。与 slice不同的是，substring 不接受负的参数。建议用slice代替它。

string.toLowerCase()

返回一个新的字符串，把string中的字母都转成小写。

string.toUpperCase()

返回一个新的字符串，把string中的字母都转成小写。

String.fromCharCode(char...)

从一串数字中返回一个字符串。

var a = String.fromCharCode(67, 97, 116);
// a is ‘Cat‘

参考：《JavaScript语言精粹》Douglas Crockford著    赵泽欣 鄢学鹍 译

转载请注明出处：

作者：JesseLZJ
出处：http://jesselzj.cnblogs.com

时间： 2024-10-05 22:26:14

JavaScript语言精粹 笔记06 方法的相关文章

javascript语言精粹----笔记【转载】

javascript语言精粹----笔记 1.6种值会为假(==false),分别是false,null,undefined,' ',0,NaN 2.typeof有6种值,分别是'number','string','boolean','undefined','function','object';其中typeof(null),结果是'object' 3.number类型总是64位浮点数,两个整数相除也可能出现非整数结果 4.如果第一个运算数的值为假,那么运算符&&产生它的第一个运算数的值.

JavaScript语言精粹笔记

JavaScript语言精粹笔记 掌握语言的每个特性可以让你出风头,但是并不推荐,因为一部分的特性带来的麻烦可能远超本身的价值.正如书中所言,坏的材料并不能雕刻出好的作品,要成为一名更好的程序员,要取其精华去其糟粕.当你知道要做什么的时候,它还能表现的更好,编程时一件相对困难的事情,绝不应该在懵懂的状态下开始编程之旅. JS中的注意为//或者/*content*/,注释一定要精确地描述代码,不然没有用的注释比没有注释更糟糕. JS中的代码块不会创建新的作用域,因此变量应该被定义在函数的头部,而不

JavaScript语言精粹 笔记01

内容比较简单,只是从头梳理一下JS的知识 语法空白标识符数字字符串语句 对象对象字面量检索更新引用原型反射枚举删除减少全局变量污染  语法 1 空白 空白可能表现为格式化字符或注释的形式.空白通常没有意义,但是偶尔必须用它来分割字符序列,否则它们就会被合并成一个单一的符号.例如: var that = this; var 和that之间的空格是不能去掉的,其他的空格都可以被移除. JS提供两种注释: /* */ // 建议使用//,因为/* */中要注释的内容可能包括字符 */ 而报错,例如:

JavaScript语言精粹 笔记03

继承伪类对象说明符原型函数化部件 继承 JS不是基于类的,而是基于原型的,这意味着对象直接从其他对象继承. 1 伪类 JS提供了一套丰富的代码重用模式,它可以模拟那些基于类的模式,因为JS实际上没有类,所以把模拟的类称为伪类.我们可以定义一个构造器并扩充它的原型: var Mammal = function (name) { this.name = name; }; Mammal.prototype.get_name = function ( ) { return this.name; }; M

JavaScript语言精粹 笔记02

函数函数对象函数字面量调用参数返回异常给类型增加方法递归作用域闭包回调模块级联套用记忆   函数 1 函数对象 在JS中函数就是对象.对象是“名/值”对的集合并拥有一个连接到原型对象的隐藏连接.对象字面量产生的对象连接到Object.prototype.函数对象连接到Function.prototype(该原型本身连接到Object.prototype).每个函数在创建时附有两个附加的隐藏属性:函数上下文和实现函数行为的代码. 因为函数是对象,所以它可以像任何其他的值一样被使用.函数可以存放在变

javascript 语言精粹 笔记推荐。。

http://www.cnblogs.com/Cohlint/archive/2012/11/26/2788790.html 这篇javascript 语言精粹 学习笔记不错..不过看上去就是读书笔记,没有深入研究某个点..比如闭包..我还是不懂噢.. 比如17条:“add_the_handles 函数目的是给每个时间处理器一个唯一值(i).它未能达到目的是因为事件处理器函数绑定了变量i,而不是函数在构造时的变量i的值.” 这是原书的翻译过来的理解,但是感觉还是很艰涩,不太理解. 闭包这个变量作

JavaScript语言精粹 笔记05 正则表达式

正则表达式 正则表达式以方法的形式被用于对字符串中的信息进行查找.替换画图提取操作.可处理正则表达式的方法有:regexp.exec, regexp.test,string.match, string.replace, string.search, 和string.split. 结构 有两个方法来创建一个RegExp对象.优先方法是使用正则表达式字面量.正则表达式被包围在一对斜杠中.有3个标志能在RegExp中设置,分别为g.i.m. // 构造一个匹配JavaScript字符串的正则表达式对象

JavaScript语言精粹 笔记04 数组

数组1 数组字面量2 长度3 删除4 列举5 混淆的地方6 方法7 维度 数组1 数组字面量 var empty = []; var numbers = [ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine' ]; empty[1] // undefined numbers[1] // 'one' empty.length // 0 numbers.length // 10 数组字面量可以出

《JavaScript语言精粹》读书笔记——给类型增加方法一节的疑问

最近,在学习<JavaScript语言精粹>这本书,发现译者虽然有很好地翻译文章,却没有对文中有疑问的地方进行改正或加以注释.我接触JavaScript只有一年左右,可能无法很好的理解这门语言,而今天,读到第四章中4.7节——给类型增加方法时遇到了疑问之处: 文中给出了对类型增加方法的示例: Function.prototype.method = function (name, func) { this.prototype[name] = func; return this; }; 这里的示例