Các tính năng ẩn của JavaScript? [đóng cửa]

"Tính năng ẩn" nào của JavaScript mà bạn nghĩ mọi lập trình viên nên biết?

Sau khi thấy chất lượng tuyệt vời của các câu trả lời cho các câu hỏi sau đây, tôi nghĩ rằng đã đến lúc hỏi nó về JavaScript.

• Các tính năng ẩn của HTML
• Các tính năng ẩn của CSS
• Các tính năng ẩn của PHP
• Các tính năng ẩn của ASP.NET
• Các tính năng ẩn của C #
• Các tính năng ẩn của Java
• Các tính năng ẩn của Python

Mặc dù JavaScript được cho là ngôn ngữ phía khách hàng quan trọng nhất hiện nay (chỉ cần hỏi Google), thật đáng ngạc nhiên khi hầu hết các nhà phát triển web đánh giá cao mức độ thực sự của nó.

Bạn không cần xác định bất kỳ tham số nào cho hàm. Bạn chỉ có thể sử dụng argumentsđối tượng giống như mảng của hàm .

function sum() {
    var retval = 0;
    for (var i = 0, len = arguments.length; i < len; ++i) {
        retval += arguments[i];
    }
    return retval;
}

sum(1, 2, 3) // returns 6

Tôi có thể trích dẫn hầu hết cuốn sách tuyệt vời của Douglas Crockford : The Good Parts .

Nhưng tôi sẽ chỉ lấy một cái cho bạn, luôn luôn sử dụng ===và !==thay vì ==và!=

alert('' == '0'); //false
alert(0 == ''); // true
alert(0 =='0'); // true

==không mang tính bắc cầu. Nếu bạn sử dụng ===nó sẽ cung cấp sai cho tất cả các tuyên bố này như mong đợi.

Các hàm là công dân hạng nhất trong JavaScript:

var passFunAndApply = function (fn,x,y,z) { return fn(x,y,z); };

var sum = function(x,y,z) {
  return x+y+z;
};

alert( passFunAndApply(sum,3,4,5) ); // 12

Các kỹ thuật lập trình chức năng có thể được sử dụng để viết javascript thanh lịch .

Đặc biệt, các hàm có thể được truyền dưới dạng tham số, ví dụ Array.filter () chấp nhận gọi lại:

[1, 2, -1].filter(function(element, index, array) { return element > 0 });
// -> [1,2]

Bạn cũng có thể khai báo một hàm "riêng tư" chỉ tồn tại trong phạm vi của một hàm cụ thể:

function PrintName() {
    var privateFunction = function() { return "Steve"; };
    return privateFunction();
}

Bạn có thể sử dụng toán tử in để kiểm tra xem khóa có tồn tại trong một đối tượng không:

var x = 1;
var y = 3;
var list = {0:0, 1:0, 2:0};
x in list; //true
y in list; //false
1 in list; //true
y in {3:0, 4:0, 5:0}; //true

Nếu bạn thấy các đối tượng bằng chữ quá xấu, bạn có thể kết hợp nó với mẹo hàm không tham số:

function list()
 { var x = {};
   for(var i=0; i < arguments.length; ++i) x[arguments[i]] = 0;
   return x
 }

 5 in list(1,2,3,4,5) //true

Gán giá trị mặc định cho các biến

Bạn có thể sử dụng logic hoặc toán tử ||trong biểu thức gán để cung cấp giá trị mặc định:

var a = b || c;

Các abiến sẽ nhận được giá trị của cchỉ nếu blà falsy (nếu là null, false, undefined, 0, empty string, hay NaN), nếu không asẽ nhận được giá trị của b.

Điều này thường hữu ích trong các hàm, khi bạn muốn đưa ra một giá trị mặc định cho một đối số trong trường hợp không được cung cấp:

function example(arg1) {
  arg1 || (arg1 = 'default value');
}

Ví dụ dự phòng IE trong trình xử lý sự kiện:

function onClick(e) {
    e || (e = window.event);
}

Các tính năng ngôn ngữ sau đây đã có với chúng tôi trong một thời gian dài, tất cả các triển khai JavaScript đều hỗ trợ chúng, nhưng chúng không phải là một phần của đặc tả cho đến ECMAScript Phiên bản thứ 5 :

các debuggertuyên bố

Được mô tả trong: § 12.15 Tuyên bố trình gỡ lỗi

Tuyên bố này cho phép bạn đặt các điểm dừng theo chương trình trong mã của mình chỉ bằng cách:

// ...
debugger;
// ...

Nếu trình gỡ lỗi có mặt hoặc hoạt động, nó sẽ khiến nó bị hỏng ngay lập tức, ngay trên dòng đó.

Mặt khác, nếu trình gỡ lỗi không có mặt hoặc hoạt động thì câu lệnh này không có hiệu lực quan sát được.

Chuỗi chữ đa dòng

Được mô tả trong: § 7.8.4 Chuỗi ký tự

var str = "This is a \
really, really \
long line!";

Bạn phải cẩn thận vì ký tự bên cạnh \ phải là dấu kết thúc dòng, nếu bạn có một khoảng trắng sau \ví dụ, mã sẽ trông giống hệt nhau, nhưng nó sẽ tăng a SyntaxError.

JavaScript không có phạm vi chặn (nhưng nó đã đóng nên chúng ta gọi nó là chẵn?).

var x = 1;
{
   var x = 2;
}
alert(x); // outputs 2

Bạn có thể truy cập các thuộc tính đối tượng với []thay vì.

Điều này cho phép bạn tra cứu một thuộc tính khớp với một biến.

obj = {a:"test"};
var propname = "a";
var b = obj[propname];  // "test"

Bạn cũng có thể sử dụng điều này để lấy / đặt thuộc tính đối tượng có tên không phải là định danh hợp pháp.

obj["class"] = "test";  // class is a reserved word; obj.class would be illegal.
obj["two words"] = "test2"; // using dot operator not possible with the space.

Một số người không biết điều này và cuối cùng sử dụng eval () như thế này, đây là một ý tưởng thực sự tồi tệ :

var propname = "a";
var a = eval("obj." + propname);

Điều này khó đọc hơn, khó tìm lỗi hơn (không thể sử dụng jslint), thực thi chậm hơn và có thể dẫn đến khai thác XSS.

Nếu bạn đang tìm kiếm một tài liệu tham khảo JavaScript phù hợp về một chủ đề nhất định, hãy bao gồm từ khóa "mdc" trong truy vấn của bạn và kết quả đầu tiên của bạn sẽ từ Trung tâm nhà phát triển Mozilla. Tôi không mang theo bất kỳ tài liệu tham khảo ngoại tuyến hoặc sách nào bên mình. Tôi luôn sử dụng thủ thuật từ khóa "mdc" để trực tiếp đến những gì tôi đang tìm kiếm. Ví dụ:

Google: mdc sắp xếp mảng javascript
(trong hầu hết các trường hợp bạn có thể bỏ qua "javascript")

Cập nhật: Mozilla Developer Center đã được đổi tên thành Mozilla Developer Network . Thủ thuật từ khóa "mdc" vẫn hoạt động, nhưng chúng ta có thể phải bắt đầu sử dụng "mdn" ngay sau đó .

Có lẽ một chút rõ ràng đối với một số ...

Cài đặt Fireorms và sử dụng console.log ("xin chào"). Vì vậy, tốt hơn nhiều so với việc sử dụng cảnh báo ngẫu nhiên (); mà tôi nhớ đã làm rất nhiều năm trước.

Phương pháp riêng tư

Một đối tượng có thể có phương thức riêng.

function Person(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;

    // A private method only visible from within this constructor
    function calcFullName() {
       return firstName + " " + lastName;    
    }

    // A public method available to everyone
    this.sayHello = function () {
        alert(calcFullName());
    }
}

//Usage:
var person1 = new Person("Bob", "Loblaw");
person1.sayHello();

// This fails since the method is not visible from this scope
alert(person1.calcFullName());

Cũng được đề cập trong "Javascript: The Good Parts" của Crockford:

parseInt()là nguy hiểm. Nếu bạn truyền cho nó một chuỗi mà không thông báo cho nó về cơ sở thích hợp, nó có thể trả về các số không mong muốn. Ví dụ parseInt('010')trả về 8, không phải 10. Chuyển một cơ sở cho parseInt làm cho nó hoạt động chính xác:

parseInt('010') // returns 8! (in FF3)
parseInt('010', 10); // returns 10 because we've informed it which base to work with.

Hàm là các đối tượng và do đó có thể có các thuộc tính.

fn = hàm (x) {
   // ...
}

fn.foo = 1;

fn.next = hàm (y) {
  //
}

Tôi phải nói rằng các chức năng tự thực hiện.

(function() { alert("hi there");})();

Vì Javascript không có phạm vi chặn , bạn có thể sử dụng chức năng tự thực thi nếu bạn muốn xác định các biến cục bộ:

(function() {
  var myvar = 2;
  alert(myvar);
})();

Ở đây, myvarkhông can thiệp hoặc làm ô nhiễm phạm vi toàn cầu và biến mất khi chức năng chấm dứt.

Biết có bao nhiêu tham số được mong đợi bởi một hàm

function add_nums(num1, num2, num3 ){
    return num1 + num2 + num3;
}
add_nums.length // 3 is the number of parameters expected.

Biết có bao nhiêu tham số được nhận bởi hàm

function add_many_nums(){
    return arguments.length;
}    
add_many_nums(2,1,122,12,21,89); //returns 6

Dưới đây là một số điều thú vị:

• So sánh NaNvới bất cứ điều gì (thậm chí NaN) luôn luôn là sai, bao gồm ==, <và >.
• NaN Viết tắt của Không phải là Số nhưng nếu bạn hỏi loại đó thực sự sẽ trả về một số.
• Array.sort có thể có chức năng so sánh và được gọi bởi trình điều khiển giống như quicksort (phụ thuộc vào việc thực hiện).
• Biểu thức chính quy "hằng số" có thể duy trì trạng thái, giống như điều cuối cùng mà chúng khớp.
• Một số phiên bản của JavaScript cho phép bạn truy cập $0, $1, $2thành viên trên một regex.
• nulllà không giống như bất cứ điều gì khác. Nó không phải là một đối tượng, boolean, một số, một chuỗi, cũng không undefined. Nó hơi giống như một "thay thế" undefined. (Ghi chú:typeof null == "object" :)
• Trong bối cảnh ngoài cùng, this mang lại đối tượng [Toàn cầu] không thể đặt tên khác.
• Khai báo một biến với var , thay vì chỉ dựa vào khai báo tự động của biến đó mang lại cho bộ thực thi cơ hội thực sự tối ưu hóa quyền truy cập vào biến đó
• Các with trúc sẽ phá hủy các tối ưu hóa như vậy
• Tên biến có thể chứa các ký tự Unicode.
• JavaScript biểu thức chính quy không thực sự thường xuyên. Chúng dựa trên biểu thức chính của Perl và có thể xây dựng các biểu thức với các biểu tượng cần một thời gian rất, rất dài để đánh giá.
• Các khối có thể được dán nhãn và sử dụng làm mục tiêu của break. Vòng lặp có thể được dán nhãn và sử dụng làm mục tiêu của continue.
• Mảng không thưa thớt. Đặt phần tử thứ 1000 của một mảng trống khác sẽ điền vào nó undefined. (phụ thuộc vào việc thực hiện)
• if (new Boolean(false)) {...} sẽ thực thi {...}khối
• Công cụ biểu thức chính quy của Javascript là cụ thể triển khai: ví dụ: có thể viết biểu thức chính quy "không di động".

[cập nhật một chút để đáp lại những bình luận tốt; vui lòng xem bình luận]

Tôi biết tôi đến bữa tiệc muộn, nhưng tôi không thể tin rằng +tính hữu dụng của nhà điều hành đã không được đề cập ngoài việc "chuyển đổi bất cứ thứ gì thành số". Có lẽ đó là một tính năng ẩn tốt như thế nào?

// Quick hex to dec conversion:
+"0xFF";              // -> 255

// Get a timestamp for now, the equivalent of `new Date().getTime()`:
+new Date();

// Safer parsing than parseFloat()/parseInt()
parseInt("1,000");    // -> 1, not 1000
+"1,000";             // -> NaN, much better for testing user input
parseInt("010");      // -> 8, because of the octal literal prefix
+"010";               // -> 10, `Number()` doesn't parse octal literals 

// A use case for this would be rare, but still useful in cases
// for shortening something like if (someVar === null) someVar = 0;
+null;                // -> 0;

// Boolean to integer
+true;                // -> 1;
+false;               // -> 0;

// Other useful tidbits:
+"1e10";              // -> 10000000000
+"1e-4";              // -> 0.0001
+"-12";               // -> -12

Tất nhiên, Number()thay vào đó , bạn có thể thực hiện tất cả điều này bằng cách sử dụng , nhưng +toán tử này đẹp hơn nhiều!

Bạn cũng có thể xác định giá trị trả về số cho một đối tượng bằng cách ghi đè valueOf()phương thức của nguyên mẫu . Bất kỳ chuyển đổi số nào được thực hiện trên đối tượng đó sẽ không dẫn đến NaN, nhưng giá trị trả về của valueOf()phương thức:

var rnd = {
    "valueOf": function () { return Math.floor(Math.random()*1000); }
};
+rnd;               // -> 442;
+rnd;               // -> 727;
+rnd;               // -> 718;

" Các phương thức mở rộng trong JavaScript " thông qua thuộc tính nguyên mẫu.

Array.prototype.contains = function(value) {  
    for (var i = 0; i < this.length; i++) {  
        if (this[i] == value) return true;  
    }  
    return false;  
}

Điều này sẽ thêm một containsphương thức cho tất cả Arraycác đối tượng. Bạn có thể gọi phương thức này bằng cú pháp này

var stringArray = ["foo", "bar", "foobar"];
stringArray.contains("foobar");

Để xóa đúng một thuộc tính khỏi một đối tượng, bạn nên xóa thuộc tính thay vì chỉ đặt nó thành không xác định :

var obj = { prop1: 42, prop2: 43 };

obj.prop2 = undefined;

for (var key in obj) {
    ...

Thuộc tính prop2 vẫn sẽ là một phần của phép lặp. Nếu bạn muốn loại bỏ hoàn toàn prop2 , thay vào đó bạn nên làm:

delete obj.prop2;

Thuộc tính prop2 sẽ không còn xuất hiện khi bạn lặp qua các thuộc tính.

with.

Nó hiếm khi được sử dụng, và thẳng thắn, hiếm khi hữu ích ... Nhưng, trong trường hợp hạn chế, nó có công dụng của nó.

Ví dụ: đối tượng bằng chữ khá tiện dụng để nhanh chóng thiết lập các thuộc tính trên một đối tượng mới . Nhưng nếu bạn cần thay đổi một nửa các thuộc tính trên một đối tượng hiện có thì sao?

var user = 
{
   fname: 'Rocket', 
   mname: 'Aloysus',
   lname: 'Squirrel', 
   city: 'Fresno', 
   state: 'California'
};

// ...

with (user)
{
   mname = 'J';
   city = 'Frostbite Falls';
   state = 'Minnesota';
}

Alan Storm chỉ ra rằng điều này có thể hơi nguy hiểm: nếu đối tượng được sử dụng làm bối cảnh không có một trong các thuộc tính được gán, nó sẽ được giải quyết trong phạm vi bên ngoài, có thể tạo hoặc ghi đè một biến toàn cục. Điều này đặc biệt nguy hiểm nếu bạn đã quen viết mã để làm việc với các đối tượng trong đó các thuộc tính có giá trị mặc định hoặc trống không được xác định:

var user = 
{
   fname: "John",
// mname definition skipped - no middle name
   lname: "Doe"
};

with (user)
{
   mname = "Q"; // creates / modifies global variable "mname"
}

Do đó, có lẽ nên tránh sử dụng withcâu lệnh cho bài tập đó.

Xem thêm: Có sử dụng hợp pháp cho câu lệnh JavaScript với JavaScript không?

Các phương thức (hoặc hàm) có thể được gọi trên đối tượng không thuộc loại mà chúng được thiết kế để làm việc. Điều này thật tuyệt khi gọi các phương thức gốc (nhanh) trên các đối tượng tùy chỉnh.

var listNodes = document.getElementsByTagName('a');
listNodes.sort(function(a, b){ ... });

Mã này gặp sự cố vì listNodeskhông phải là mộtArray

Array.prototype.sort.apply(listNodes, [function(a, b){ ... }]);

Mã này hoạt động vì listNodesđịnh nghĩa đủ các thuộc tính giống như mảng (toán tử []) được sử dụng bởi sort().

Kế thừa nguyên mẫu (được phổ biến bởi Douglas Crockford) hoàn toàn cách mạng hóa cách bạn nghĩ về vô số thứ trong Javascript.

Object.beget = (function(Function){
    return function(Object){
        Function.prototype = Object;
        return new Function;
    }
})(function(){});

Đó là một kẻ giết người! Đáng tiếc làm sao hầu như không ai sử dụng nó.

Nó cho phép bạn "quên" các thể hiện mới của bất kỳ đối tượng nào, mở rộng chúng, trong khi duy trì liên kết thừa kế nguyên mẫu (trực tiếp) với các thuộc tính khác của chúng. Thí dụ:

var A = {
  foo : 'greetings'
};  
var B = Object.beget(A);

alert(B.foo);     // 'greetings'

// changes and additionns to A are reflected in B
A.foo = 'hello';
alert(B.foo);     // 'hello'

A.bar = 'world';
alert(B.bar);     // 'world'


// ...but not the other way around
B.foo = 'wazzap';
alert(A.foo);     // 'hello'

B.bar = 'universe';
alert(A.bar);     // 'world'

Một số người sẽ gọi đây là vấn đề của hương vị, nhưng:

aWizz = wizz || "default";
// same as: if (wizz) { aWizz = wizz; } else { aWizz = "default"; }

Toán tử ba có thể bị xiềng xích để hành động như Scheme's (cond ...):

(cond (predicate  (action  ...))
      (predicate2 (action2 ...))
      (#t         default ))

có thể được viết như...

predicate  ? action( ... ) :
predicate2 ? action2( ... ) :
             default;

Điều này rất "chức năng", vì nó phân nhánh mã của bạn mà không có tác dụng phụ. Vì vậy, thay vì:

if (predicate) {
  foo = "one";
} else if (predicate2) {
  foo = "two";
} else {
  foo = "default";
}

Bạn có thể viết:

foo = predicate  ? "one" :
      predicate2 ? "two" :
                   "default";

Hoạt động tốt với đệ quy, quá :)

Số cũng là đối tượng. Vì vậy, bạn có thể làm những thứ tuyệt vời như:

// convert to base 2
(5).toString(2) // returns "101"

// provide built in iteration
Number.prototype.times = function(funct){
  if(typeof funct === 'function') {
    for(var i = 0;i < Math.floor(this);i++) {
      funct(i);
    }
  }
  return this;
}


(5).times(function(i){
  string += i+" ";
});
// string now equals "0 1 2 3 4 "

var x = 1000;

x.times(function(i){
  document.body.innerHTML += '<p>paragraph #'+i+'</p>';
});
// adds 1000 parapraphs to the document

Làm thế nào về việc đóng trong JavaScript (tương tự như các phương thức ẩn danh trong C # v2.0 +). Bạn có thể tạo một hàm tạo một hàm hoặc "biểu thức".

Ví dụ về việc đóng cửa :

//Takes a function that filters numbers and calls the function on 
//it to build up a list of numbers that satisfy the function.
function filter(filterFunction, numbers)
{
  var filteredNumbers = [];

  for (var index = 0; index < numbers.length; index++)
  {
    if (filterFunction(numbers[index]) == true)
    {
      filteredNumbers.push(numbers[index]);
    }
  }
  return filteredNumbers;
}

//Creates a function (closure) that will remember the value "lowerBound" 
//that gets passed in and keep a copy of it.
function buildGreaterThanFunction(lowerBound)
{
  return function (numberToCheck) {
    return (numberToCheck > lowerBound) ? true : false;
  };
}

var numbers = [1, 15, 20, 4, 11, 9, 77, 102, 6];

var greaterThan7 = buildGreaterThanFunction(7);
var greaterThan15 = buildGreaterThanFunction(15);

numbers = filter(greaterThan7, numbers);
alert('Greater Than 7: ' + numbers);

numbers = filter(greaterThan15, numbers);
alert('Greater Than 15: ' + numbers);

Bạn cũng có thể mở rộng (kế thừa) các lớp và ghi đè các thuộc tính / phương thức bằng cách sử dụng chuỗi nguyên mẫu Spoon16 được ám chỉ.

Trong ví dụ sau, chúng ta tạo một lớp Pet và định nghĩa một số thuộc tính. Chúng tôi cũng ghi đè phương thức .toString () được kế thừa từ Object.

Sau đó, chúng ta tạo một lớp Dog mở rộng Pet và ghi đè phương thức .toString () một lần nữa thay đổi hành vi của nó (đa hình). Ngoài ra, chúng tôi thêm một số thuộc tính khác cho lớp con.

Sau đó, chúng tôi kiểm tra chuỗi thừa kế để cho thấy rằng Dog vẫn thuộc loại Dog, loại Pet và loại Object.

// Defines a Pet class constructor 
function Pet(name) 
{
    this.getName = function() { return name; };
    this.setName = function(newName) { name = newName; };
}

// Adds the Pet.toString() function for all Pet objects
Pet.prototype.toString = function() 
{
    return 'This pets name is: ' + this.getName();
};
// end of class Pet

// Define Dog class constructor (Dog : Pet) 
function Dog(name, breed) 
{
    // think Dog : base(name) 
    Pet.call(this, name);
    this.getBreed = function() { return breed; };
}

// this makes Dog.prototype inherit from Pet.prototype
Dog.prototype = new Pet();

// Currently Pet.prototype.constructor
// points to Pet. We want our Dog instances'
// constructor to point to Dog.
Dog.prototype.constructor = Dog;

// Now we override Pet.prototype.toString
Dog.prototype.toString = function() 
{
    return 'This dogs name is: ' + this.getName() + 
        ', and its breed is: ' + this.getBreed();
};
// end of class Dog

var parrotty = new Pet('Parrotty the Parrot');
var dog = new Dog('Buddy', 'Great Dane');
// test the new toString()
alert(parrotty);
alert(dog);

// Testing instanceof (similar to the `is` operator)
alert('Is dog instance of Dog? ' + (dog instanceof Dog)); //true
alert('Is dog instance of Pet? ' + (dog instanceof Pet)); //true
alert('Is dog instance of Object? ' + (dog instanceof Object)); //true

Cả hai câu trả lời cho câu hỏi này là các mã được sửa đổi từ một bài viết MSDN tuyệt vời của Ray Djajadinata.

Bạn có thể bắt ngoại lệ tùy thuộc vào loại của họ. Trích dẫn từ MDC :

try {
   myroutine(); // may throw three exceptions
} catch (e if e instanceof TypeError) {
   // statements to handle TypeError exceptions
} catch (e if e instanceof RangeError) {
   // statements to handle RangeError exceptions
} catch (e if e instanceof EvalError) {
   // statements to handle EvalError exceptions
} catch (e) {
   // statements to handle any unspecified exceptions
   logMyErrors(e); // pass exception object to error handler
}

LƯU Ý: Các mệnh đề bắt có điều kiện là một phần mở rộng Netscape (và do đó Mozilla / Firefox) không phải là một phần của đặc tả ECMAScript và do đó không thể dựa vào ngoại trừ trên các trình duyệt cụ thể.

Off đỉnh đầu của tôi...

Chức năng

argument.callee đề cập đến hàm lưu trữ biến "argument", vì vậy nó có thể được sử dụng để lặp lại các hàm ẩn danh:

var recurse = function() {
  if (condition) arguments.callee(); //calls recurse() again
}

Điều đó hữu ích nếu bạn muốn làm một cái gì đó như thế này:

//do something to all array items within an array recursively
myArray.forEach(function(item) {
  if (item instanceof Array) item.forEach(arguments.callee)
  else {/*...*/}
})

Các đối tượng

Một điều thú vị về các thành viên đối tượng: họ có thể có bất kỳ chuỗi nào như tên của họ:

//these are normal object members
var obj = {
  a : function() {},
  b : function() {}
}
//but we can do this too
var rules = {
  ".layout .widget" : function(element) {},
  "a[href]" : function(element) {}
}
/* 
this snippet searches the page for elements that
match the CSS selectors and applies the respective function to them:
*/
for (var item in rules) {
  var elements = document.querySelectorAll(rules[item]);
  for (var e, i = 0; e = elements[i++];) rules[item](e);
}

Dây

String.split có thể lấy các biểu thức chính quy làm tham số:

"hello world   with  spaces".split(/\s+/g);
//returns an array: ["hello", "world", "with", "spaces"]

String.replace có thể lấy một biểu thức chính quy làm tham số tìm kiếm và hàm làm tham số thay thế:

var i = 1;
"foo bar baz ".replace(/\s+/g, function() {return i++});
//returns "foo1bar2baz3"

Bạn có thể sử dụng các đối tượng thay vì chuyển đổi hầu hết thời gian.

function getInnerText(o){
    return o === null? null : {
        string: o,
        array: o.map(getInnerText).join(""),
        object:getInnerText(o["childNodes"])
    }[typeis(o)];
}

Cập nhật: nếu bạn lo lắng về các trường hợp đánh giá trước là không hiệu quả (tại sao bạn lo lắng về hiệu quả này sớm trong thiết kế chương trình ??) thì bạn có thể làm điều gì đó như sau:

function getInnerText(o){
    return o === null? null : {
        string: function() { return o;},
        array: function() { return o.map(getInnerText).join(""); },
        object: function () { return getInnerText(o["childNodes"]; ) }
    }[typeis(o)]();
}

Điều này phù hợp hơn để gõ (hoặc đọc) hơn là một công tắc hoặc một đối tượng, nhưng nó bảo tồn các lợi ích của việc sử dụng một đối tượng thay vì một công tắc, chi tiết trong phần bình luận bên dưới. Phong cách này cũng làm cho nó trở nên đơn giản hơn để biến điều này thành một "lớp" thích hợp một khi nó phát triển đủ.

update2: với các phần mở rộng cú pháp được đề xuất cho ES.next, điều này trở thành

let getInnerText = o -> ({
    string: o -> o,
    array: o -> o.map(getInnerText).join(""),
    object: o -> getInnerText(o["childNodes"])
}[ typeis o ] || (->null) )(o);

Hãy chắc chắn sử dụng phương thức hasOwnProperty khi lặp qua các thuộc tính của đối tượng:

for (p in anObject) {
    if (anObject.hasOwnProperty(p)) {
        //Do stuff with p here
    }
}

Điều này được thực hiện để bạn sẽ chỉ truy cập các thuộc tính trực tiếp của anObject và không sử dụng các thuộc tính nằm dưới chuỗi nguyên mẫu.

Biến riêng với Giao diện chung

Nó sử dụng một mẹo nhỏ gọn gàng với định nghĩa chức năng tự gọi. Mọi thứ bên trong đối tượng được trả về đều có sẵn trong giao diện công cộng, trong khi mọi thứ khác là riêng tư.

var test = function () {
    //private members
    var x = 1;
    var y = function () {
        return x * 2;
    };
    //public interface
    return {
        setx : function (newx) {
            x = newx;
        },
        gety : function () {
            return y();
        }
    }
}();

assert(undefined == test.x);
assert(undefined == test.y);
assert(2 == test.gety());
test.setx(5);
assert(10 == test.gety());