You’re reading the English version of this content since no translation exists yet for this locale. Help us translate this article!
ฟังก์ชันเป็นหนึ่งในส่วนประกอบหลักของจาวาสคริปต์ หนึ่งฟังก์ชันคือหนึ่งกระบวนการของจาวาสคริปต์ ซึ่งก็คือชุดคำสั่งที่ทำงานหรือคำนวณค่า โดยคุณต้องประกาศใช้ฟังก์ชันที่ใดก็ได้ภายในขอบเขตที่คุณเรียกใช้
การประกาศใช้ฟังก์ชัน
คำจำกัดความของฟังก์ชัน (หรือเรียกได้ว่า การประกาศใช้ฟังก์ชัน) ประกอบด้วยคำสั่ง function และตามด้วย
- ชื่อของฟังก์ชัน
- รายชื่อตัวแปรทั้งหมดที่ส่งเข้าฟังก์ชัน อยู่ในวงเล็บและคั่นด้วยคอมมา
- คำสั่งจาวาสคริปต์ของฟังก์ชัน อยู่ในวงเล็บปีกกา,
{ }
ตัวอย่าง, ในโค้ดนี้ประกาศใช้ฟังก์ชันอย่างง่ายชื่อ square:
function square(number) {
return number * number;
}
ฟังก์ชัน square จะรับตัวแปรเข้าหนึ่งตัวชื่อ number ฟังก์ชันนี้มีคำสั่งเดียว ทำหน้าที่คืนค่าผลลัพธ์ของตัวแปรที่รับเข้ามา (number) คูณกับตัวมันเอง โดยคำสั่ง return ใช้คืนค่าจากฟังก์ชัน
return number * number;
ตัวแปรที่ส่งเข้าฟังก์ชัน ที่มีค่าเป็นข้อมูลพื้นฐาน (เช่น ตัวเลข) จะถูกส่งเข้าฟังก์ชันในแบบ by value, หมายความได้ว่า เมื่อค่านี้ถูกส่งเข้าฟังก์ชัน และฟังก์ชันมีการเปลี่ยนแปลงค่า การเปลี่ยนแปลงนี้จะไม่ส่งผลต่อค่าของตัวแปรนอกฟังก์ชัน (ในขอบเขตส่วนกลาง หรือในโค้ดที่เรียกใช้ฟังก์ชัน)
ถ้าคุณส่งอ็อบเจกต์ (ที่ไม่ใช่ค่าข้อมูลพื้นฐาน non-primitive value, เช่น อาร์เรย์ หรืออ็อบเจกต์ที่กำหนดเอง) เป็นตัวแปรที่ส่งเข้าฟังก์ชัน, และฟังก์ชันทำการเปลี่ยนค่าคุณสมบัติของอ็อบเจกต์นั้น ค่าที่เปลี่ยนแปลงนั้นจะปรากฎนอกฟังก์ชันด้วย ดังแสดงในตัวอย่างต่อไปนี้:
function myFunc(theObject) {
theObject.make = "Toyota";
}
var mycar = {make: "Honda", model: "Accord", year: 1998},
x,
y;
x = mycar.make; // x gets the value "Honda"
myFunc(mycar);
y = mycar.make; // y gets the value "Toyota"
// (the make property was changed by the function)
สังเกตุว่า การกำหนดให้ตัวแปรที่ส่งเข้าฟังก์ชัน มีค่าเป็นอ็อบเจกต์ใหม่ จะไม่มีผลนอกฟังก์ชัน เพราะเป็นการเปลี่ยนค่าของตัวแปร ไม่ใช่การเปลี่ยนค่าคุณสมบัติของอ็อบเจกต์
function myFunc(theObject) {
theObject = {make: "Ford", model: "Focus", year: 2006};
}
var mycar = {make: "Honda", model: "Accord", year: 1998},
x,
y;
x = mycar.make; // x gets the value "Honda"
myFunc(mycar);
y = mycar.make; // y still gets the value "Honda"
ในขณะที่การประกาศฟังก์ชันด้านบนเขียนเหมือนการใช้คำสั่ง, ฟังก์ชันยังสามารถถูกสร้างได้จาก นิพจน์ฟังก์ชัน (function expression) ซึ่งเป็น ฟังก์ชันนิรนาม (anonymous) ที่ไม่ต้องมีชื่อ จากตัวอย่าง, เราสามารถประกาศฟังก์ชัน square ได้ดังนี้:
var square = function(number) {return number * number};
var x = square(4) //x gets the value 16
อย่างไรก็ตาม, เรายังสามารถใส่ชื่อในนิพจน์ฟังก์ชัน และเรียกใช้ได้จากภายในฟังก์ชันเอง หรือเพื่อให้ดีบักเกอร์แสดงชื่อฟังก์ชันใน stack traces ได้:
var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};
console.log(factorial(3));
นิพจน์ฟังก์ชันอำนวยความสะดวกเมื่อเราส่งฟังก์ชันเป็นตัวแปรไปให้อีกฟังก์ชัน โดยตัวอย่างต่อไปนี้แสดง การสร้างฟังก์ชัน map และเรียกใช้โดยส่งตัวแปรเข้าตัวแรกเป็นฟังก์ชันนิรนาม:
function map(f,a) {
var result = [], // Create a new Array
i;
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
โค้ดต่อไปนี้:
map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
จะคืนค่า [0, 1, 8, 125, 1000].
ในจาวาสคริปต์ ฟังก์ชันสามารถถูกสร้างขึ้นตามเงื่อนไขได้ โดยตัวอย่าง, การประกาศฟังก์ชันต่อไปนี้สร้างฟังก์ชัน myFunc ถ้าตัวแปร num มีค่าเป็น 0:
var myFunc;
if (num == 0){
myFunc = function(theObject) {
theObject.make = "Toyota"
}
}
นอกจากการประกาศฟังก์ชันในแบบที่กล่าวมาแล้ว, คุณยังสามารถใช้ตัวสร้างฟังก์ชัน (Function constructor) เพื่อสร้างฟังก์ชันจากสตริงตอนที่โปรแกรมกำลังทำงาน คล้ายกับการใช้ eval()
เมธอด ก็คือฟังก์ชันที่เป็นคุณสมบัติของอ็อบเจกต์ อ่านเพิ่มเติมเรื่องอ็อบเจกต์และเมธอดได้ที่ Working with Objects
การเรียกใช้ฟังก์ชัน
การประกาศฟังก์ชันไม่ทำให้เกิดการทำงานใดๆ เป็นเพียงการตั้งชื่อและกำหนดว่าฟังก์ชันต้องทำอะไรเมื่อถูกเรียกใช้ การเรียกใช้ฟังก์ชันเป็นการสั่งให้ฟังก์ชันทำงานด้วยค่าที่ระบุให้ ตัวอย่างเช่น, ถ้าคุณประกาศฟังก์ชัน square คุณสามารถเรียกใช้งานได้ดังนี้:
square(5);
การเรียกใช้ฟังก์ชันข้างต้นด้วยค่า 5, ฟังก์ชันจะทำงานตามคำสั่งของมันและคืนค่า 25
ฟังก์ชันต้องอยู่ในขอบเขตที่สามารถเรียกใช้ได้ แต่การประกาศฟังก์ชันสามารถทำได้หลังจากการเรียกใช้ เช่นในตัวอย่าง:
console.log(square(5));
/* ... */
function square(n){return n*n}
ขอบเขตของฟังก์ชันคือ บริเวณที่มีการประกาศใช้ หรือทั้งโปรแกรมถ้าประกาศฟังก์ชันไว้ที่ชั้นนอกสุด โดยใช้ได้กับกรณีที่ประกาศฟังก์ชันด้วยรูปแบบข้างบนเท่านั้น (รูปแบบ function funcName(){}) ซึ่งทำให้โค้ดด้านล่างใช้งานไม่ได้
console.log(square(5));
square = function (n) {
return n * n;
}
ตัวแปรที่ส่งเข้าฟังก์ชันไม่ได้จำกัดอยู่แค่สตริงและตัวเลขเท่านั้น คุณสามารถส่งทั้งอ็อบเจกต์เข้าฟังก์ชันได้ด้วย โดยฟังก์ชัน show_props (ประกาศใช้ใน Working with Objects) คือตัวอย่างการใช้ฟังก์ชันที่รับค่าเป็นอ็อบเจกต์
ฟังก์ชันสามารถทำงานแบบซ้ำได้ คือเรียกใช้ตัวเองได้ ตัวอย่างเช่น, ฟังก์ชันที่คำนวณค่าแฟกตอเรียลดังนี้:
function factorial(n){
if ((n == 0) || (n == 1))
return 1;
else
return (n * factorial(n - 1));
}
คุณสามารถคำนวณค่าแฟกตอเรียลของหนึ่งถึงห้าได้ดังนี้:
var a, b, c, d, e; a = factorial(1); // a gets the value 1 b = factorial(2); // b gets the value 2 c = factorial(3); // c gets the value 6 d = factorial(4); // d gets the value 24 e = factorial(5); // e gets the value 120
ยังมีอีกหลายวิธีในการเรียกใช้ฟังก์ชัน เช่น บ่อยครั้งฟังก์ชันถูกเรียกใช้แบบ dynamic, หรือตัวแปรที่ส่งเข้าฟังก์ชันมีจำนวนไม่แน่นอน, หรือในกรณีที่บริบทของการเรียกใช้ฟังก์ชันจำเป็นต้องกำหนดด้วยอ็อบเจกต์ตอนที่โปรแกรมทำงาน และฟังก์ชันก็ยังใช้งานได้หลายรูปแบบคือ แบบฟังก์ชัน, แบบอ็อบเจกต์, และแบบที่เป็นเมธอดในออบเจกต์ (ดูที่ Function object) ซึ่งหนึ่งในรูปแบบที่กล่าวมานี้ สามารถใช้เมธอด apply()เรียกใช้ฟังก์ชันในแบบที่ต้องการได้
ขอบเขตของฟังก์ชัน
ตัวแปรที่กำหนดภายในฟังก์ชันไม่สามารถใช้งานได้จากนอกฟังก์ชัน เพราะตัวแปรถูกสร้างในฟังก์ชัน อย่างไรก็ตามฟังก์ชันสามารถใช้งานตัวแปรและฟังก์ชันที่อยู่ในขอบเขตเดียวกับที่ตัวมันถูกสร้างขึ้นได้ ในทำนองเดียวกัน, ฟังก์ชันที่ถูกสร้างขึ้นในขอบเขตส่วนกลาง ก็สามารถใช้งานตัวแปรที่สร้างขึ้นในขอบเขตส่วนกลางได้ ส่วนฟังก์ชันที่ถูกสร้างขึ้นในฟังก์ชันอื่น ก็สามารถใช้งานตัวแปรที่สร้างขึ้นในฟังก์ชันแม่ และตัวแปรที่ฟังก์ชันแม่สามารถใช้งานได้ด้วย
// The following variables are defined in the global scope
var num1 = 20,
num2 = 3,
name = "Chamahk";
// This function is defined in the global scope
function multiply() {
return num1 * num2;
}
multiply(); // Returns 60
// A nested function example
function getScore () {
var num1 = 2,
num2 = 3;
function add() {
return name + " scored " + (num1 + num2);
}
return add();
}
getScore(); // Returns "Chamahk scored 5"
Closures
Closures คือหนึ่งในคุณสมบัติเด่นของจาวาสคริปต์ โดยจาวาสคริปต์ยอมให้มีฟังก์ชันซ้อนกันได้ และให้ฟังก์ชันตัวในเรียกใช้ตัวแปรและฟังก์ชันที่สร้างในฟังก์ชันตัวนอกได้ (รวมทั้งตัวแปรและฟังก์ชันอื่นที่ฟังก์ชันตัวนอกเข้าถึงได้) อย่างไรก็ตาม, ฟังก์ชันตัวนอกไม่มีสิทธิใช้งานตัวแปรและฟังก์ชันที่สร้างขึ้นภายในฟังก์ชันตัวใน ซึ่งช่วยป้องกันการเข้าถึงตัวแปรของฟังก์ชันตัวในได้ ด้วยเหตุที่ฟังก์ชันตัวในเข้าถึงขอบเขตของฟังก์ชันตัวนอกได้, เมื่อฟังก์ชันตัวในถูกเรียกใช้ในขณะที่ฟังก์ชันตัวนอกทำงานจบแล้ว ตัวแปรและฟังก์ชันที่สร้างขึ้นในขอบเขตของฟังก์ชันตัวนอกจะยังคงเรียกใช้งานได้จากฟังก์ชันตัวใน นั่นคือ closure จะถูกสร้างขึ้นเมื่อฟังก์ชันตัวในถูกใช้งานในขอบเขตอื่นข้างนอกฟังก์ชันตัวนอก
var pet = function(name) { // The outer function defines a variable called "name"
var getName = function() {
return name; // The inner function has access to the "name" variable of the outer function
}
return getName; // Return the inner function, thereby exposing it to outer scopes
},
myPet = pet("Vivie");
myPet(); // Returns "Vivie"
อาจจะดูซับซ้อนมากกว่าโค้ดด้านบน ถ้าอ็อบเจกต์มีเมธอด (ฟังก์ชันตัวใน) ที่จัดการกับตัวแปรภายในอ็อบเจกต์ (ฟังก์ชันตัวนอก) และคืนค่าตัวแปรภายในออกมาได้
var createPet = function(name) {
var sex;
return {
setName: function(newName) {
name = newName;
},
getName: function() {
return name;
},
getSex: function() {
return sex;
},
setSex: function(newSex) {
if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
sex = newSex;
}
}
}
}
var pet = createPet("Vivie");
pet.getName(); // Vivie
pet.setName("Oliver");
pet.setSex("male");
pet.getSex(); // male
pet.getName(); // Oliver
ในโค้ดด้านบน, ตัวแปร name ของฟังก์ชันตัวนอกถูกเรียกใช้ได้จากฟังก์ชันตัวในทุกตัว และไม่มีทางอื่นที่จะเข้าถึงตัวแปรนี้ นอกจากจะเรียกผ่านฟังก์ชันตัวใน โดยตัวแปรภายในของฟังก์ชันตัวนอก (เช่น name, sex) ทำหน้าที่เป็นแหล่งเก็บข้อมูลที่ปลอดภัยให้ฟังก์ชันตัวใน โดยมันจะเก็บค่าข้อมูลอย่างถาวรและปลอดภัยเพื่อเรียกใช้งานได้จากฟังก์ชันตัวในเท่านั้น โดยฟังก์ชันตัวในเหล่านี้ไม่จำเป็นต้องมีชื่อ หรือถูกกำหนดค่าให้กับตัวแปรใดๆ
var getCode = (function(){
var secureCode = "0]Eal(eh&2"; // A code we do not want outsiders to be able to modify...
return function () {
return secureCode;
};
})();
getCode(); // Returns the secret code
แต่ก็ยังมีข้อควรระวังอยู่บ้างเมื่อใช้งาน closures โดยถ้าฟังก์ชันตัวในสร้างตัวแปรชื่อเดียวกับชื่อตัวแปรในขอบเขตของฟังก์ชันตัวนอกแล้ว, จะไม่มีทางที่จะเรียกใช้ตัวแปรนี้จากฟังก์ชันตัวในได้อีกเลย
var createPet = function(name) { // Outer function defines a variable called "name"
return {
setName: function(name) { // Enclosed function also defines a variable called "name"
name = name; // ??? How do we access the "name" defined by the outer function ???
}
}
}
ตัวแปร this มีประโยชน์มากใน closures แต่ต้องใช้อย่างระมัดระวัง, เนื่องจากสิ่งที่ this อ้างถึง จะขึ้นอยู่กับตำแหน่งที่ฟังก์ชันถูกเรียกใช้งาน มากกว่าตำแหน่งที่มันถูกสร้างขึ้น สำหรับรายละเอียดเพิ่มเติมเรื่อง closures มีบทความที่น่าสนใจอยู่ที่นี่
การใช้งานอ็อบเจกต์ arguments
คุณสามารถเรียกใช้ตัวแปรที่ส่งเข้าฟังก์ชันจากอ็อบเจกต์ arguments ซึ่งทำงานคล้ายอาร์เรย์ โดยใช้รูปแบบดังนี้:
arguments[i]
โดยที่ i คือหมายเลขของตัวแปรมีค่าเริ่มต้นที่ศูนย์ ดังนั้นตัวแปรตัวแรกที่ส่งเข้าฟังก์ชั่นคือ arguments[0] และจำนวนตัวแปรทั้งหมดแทนด้วย arguments.length
การใช้งานอ็อบเจกต์ arguments ทำให้คุณสามารถเรียกใช้ฟังก์ชันด้วยจำนวนตัวแปรมากกว่าตอนที่ประกาศไว้ ซึ่งช่วยได้ในกรณีที่คุณไม่รู้จำนวนตัวแปรก่อนเรียกใช้ฟังก์ชัน โดยคุณสามารถใช้ arguments.length เพื่อหาจำนวนตัวแปรที่ส่งเข้าฟังก์ชัน และเข้าถึงตัวแปรแต่ละตัวด้วยอ็อบเจกต์ arguments
ในตัวอย่าง, ฟังก์ชันหนึ่งทำหน้าที่เชื่อมสตริงหลายตัวเข้าด้วย มีตัวแปรที่ส่งเข้าฟังก์ชันตามที่ประกาศไว้หนึ่งตัว (separator) มีค่าเป็นสตริงและถูกใช้เป็นอักษรคั่นสตริงที่จะนำมาเชื่อมต่อกัน โดยฟังก์ชันนี้ถูกสร้างขึ้นดังนี้
function myConcat(separator) {
var result = "", // initialize list
i;
// iterate through arguments
for (i = 1; i < arguments.length; i++) {
result += arguments[i] + separator;
}
return result;
}
คุณสามารถส่งค่าตัวแปรเข้าไปในฟังก์ชันนี้ได้หลายตัว โดยจะได้ผลลัพธ์เป็นสตริงที่มีค่าตัวแปรแต่ละตัวมาเชื่อมต่อกัน
// returns "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");
// returns "elephant; giraffe; lion; cheetah; "
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
สังเกตุด้วยว่า, อ็อบเจกต์ arguments คล้ายอาร์เรย์ แต่ไม่ใช่อาร์เรย์ โดยคล้ายอาร์เรย์ตรงที่มีหมายเลขดัชนี และคุณสมบัติ length แต่อย่างไรก็ตาม, มันไม่สามารถใช้เมธอดที่จัดการกับอาร์เรย์ได้ทั้งหมด
ดูข้อมูลเพิ่มเติมเรื่อง Function object ในบทอ้างอิงจาวาสคริปต์
ฟังก์ชันพื้นฐาน
จาวาสคริปต์ มีฟังก์ชันพื้นฐานในระดับชั้นนอกสุดให้ใช้หลายตัว
- eval
- isFinite
- isNaN
- parseInt and parseFloat
- Number and String
- encodeURI, decodeURI, encodeURIComponent, and decodeURIComponent (all available with Javascript 1.5 and later).
เนื้อหาในส่วนต่อไปจะแนะนำการใช้งานฟังก์ชันเหล่านี้ โดยสามารถดูรายละเอียดเพิ่มเติมของฟังก์ชันเหล่านี้ได้ที่ JavaScript Reference
ฟังก์ชัน eval
ฟังก์ชัน eval ทำหน้าที่ประมวลผล โค้ดจาวาสคริปต์ที่อยู่ในสตริง โดยไม่ต้องอ้างถึงอ็อบเจกต์ใดๆ มีรูปแบบการใช้งานดังนี้:
eval(expr);
เมื่อ expr คือสตริงที่จะทำการประมวลผล
ถ้าในสตริงเป็นนิพจน์, eval จะประมวลผลนิพจน์นั้น แต่ถ้าในสตริงเป็นคำสั่งจาวาสคริปต์อย่างน้อยหนึ่งคำสั่ง, eval จะประมวลคำสั่งนั้น โดยขอบเขตของโค้ด eval จะเหมือนกับขอบเขตของโค้ดที่เรียกใช้ และไม่จำเป็นต้องเรียกใช้ eval เพื่อประมวลผลนิพจน์คณิตศาสตร์ เพราะจาวาสคริปต์จะประมวลผลนิพจน์คณิตศาสตร์โดยอัตโนมัติให้อยู่แล้ว
ฟังก์ชัน isFinite
ฟังก์ชัน isFinite ประมวลผลตัวแปรที่ส่งเข้ามา เพื่อพิจารณาว่าเป็นค่าตัวเลขจำกัดหรือไม่ โดยมีรูปแบบการใช้ดังนี้:
isFinite(number);
เมื่อ number เป็นค่าตัวเลขที่ใช้ในการประมวลผล
ถ้าค่า number เป็น Nan, ค่าบวกอนันต์, หรือค่าลบอนันต์ เมธอดนี้จะคืนค่า false, นอกเหนือจากนี้จะคืนค่า true
โค้ดต่อไปนี้ตรวจสอบการป้อนข้อมูล เพื่อพิจารณาว่าข้อมูลเป็นตัวเลขจำกัดหรือไม่
if(isFinite(ClientInput)){
/* take specific steps */
}
ฟังก์ชัน isNaN
ฟังก์ชัน isNan ประมวลผลตัวแปรที่ส่งเข้ามา เพื่อพิจารณาว่าเป็น NaN (not a number -- ไม่ใช่ตัวเลข) หรือไม่ โดยมีรูปแบบการใช้ดังนี้
isNaN(testValue);
โดยที่ testValue เป็นค่าที่คุณต้องการประมวลผล
ทั้งฟังก์ชัน parseFloat และ parseInt จะคืนค่า NaN เมื่อประมวลผลแล้วได้ค่าที่ไม่ใช่ตัวเลข และ isNaN จะคืนค่า true ถ้าค่าที่รับเข้ามาเป็น NaN, และคืนค่า false ถ้าไม่ใช่
โค้ดต่อไปนี้ทำการประมวลค่า floatValue เพื่อพิจารณาว่าเป็นตัวเลขหรือไม่ และเรียกใช้ฟังก์ชันที่เหมาะสมดำเนินการต่อไป:
var floatValue = parseFloat(toFloat);
if (isNaN(floatValue)) {
notFloat();
} else {
isFloat();
}
ฟังก์ชัน parseInt และ parseFloat
ทั้งสองฟังก์ชัน parse, parseInt และ parseFloat, จะคืนค่าตัวเลข เมื่อค่าตัวแปรที่รับเข้ามาเป็นสตริง
รูปแบบการใช้งานของ parseFloat เป็นดังนี้:
parseFloat(str);
โดยที่ parseFloat จะแปลงค่าที่รับเข้ามาคือ สตริง str และพยายามคืนค่าเป็นตัวเลขทศนิยม, ถ้ามันพบตัวอักษรอื่นที่ไม่ใช่เครื่องหมาย (+ หรือ -), ตัวเลข (0-9), จุดทศนิยม, หรือตัวยกกำลัง, ก็จะคืนค่าข้อมูลถึงแค่ตำแหน่งนั้น ละทิ้งตัวอักษรนั้นกับตัวอักษรที่ตามมาทั้งหมด และถ้าตัวอักษรตัวแรกไม่สามารถแปลงเป็นตัวเลขได้, ก็จะคืนค่าเป็น NaN (not a number)
รูปแบบการใช้งานของ parseInt เป็นดังนี้:
parseInt(str [, radix]);
parseInt จะแปลงค่าที่รับเข้ามาตัวแรกคือ สตริง str และพยายามคืนค่าเป็นตัวเลขจำนวนเต็มตามฐานเลขใน radix ซึ่งกำหนดโดยค่าที่รับเข้ามาตัวที่สอง radix (ที่ไม่ระบุก็ได้) ตัวอย่าง เช่น, ค่าฐานเป็นสิบ แสดงว่าต้องการให้แปลงเป็นเลขฐานสิบ, แปด คือฐานแปด, สิบหก คือฐานสิบหก, และอื่นๆ โดยค่าฐานที่มากกว่าสิบ จะใช้ตัวอักษรแทนค่าเลขที่มากกว่าเก้า เช่น, เลขฐานสิบหก จะใช้ A-F แทน 10-15
ถ้า parseInt พบตัวอักษรที่ไม่ใช่ตัวเลขในฐานเลขที่ระบุ, มันจะละทิ้งตัวอักษรตัวนั้นและที่ตามมาทั้งหมด และคืนค่าจำนวนเต็มจนถึงตำแหน่งนั้น แต่ถ้าไม่สามารถแปลงตัวอักษรตัวแรกให้เป็นตัวเลขในฐานที่ระบุได้, ก็จะคืนค่า NaN โดย parseInt จะปัดค่าที่ได้จากสตริงให้เป็นเลขจำนวนเต็ม
ฟังก์ชัน Number และ String
ฟังก์ชัน Number และ String ช่วยให้คุณแปลงอ็อบเจกต์ไปเป็นตัวเลขหรือสตริงได้ โดยมีรูปแบบการใช้งานของฟังก์ชันทั้งสองดังนี้:
var objRef; objRef = Number(objRef); objRef = String(objRef);
เมื่อ objRef เป็นตัวแปรอ็อบเจกต์ โดย Number ใช้เมธอด valueOf() ของอ็อบเจกต์ และ String จะใช้เมธอด toString() ของอ็อบเจกต์
ตัวอย่างต่อไปนี้ แปลงอ็อบเจกต์ Date ให้เป็นข้อความที่อ่านได้
var D = new Date(430054663215),
x;
x = String(D); // x equals "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
ตัวอย่างต่อไปนี้ แปลงอ็อบเจกต์ String ให้เป็นอ็อบเจกต์ Number
var str = "12",
num;
num = Number(str);
คุณสามารถลองดูได้, โดยใช้เมธอด write() ของ DOM และตัวดำเนินการ typeOf ของจาวาสคริปต์
var str = "12",
num;
document.write(typeof str);
document.write("<br/>");
num = Number(str);
document.write(typeof num);
ฟังก์ชัน escape และ unescape (ยกเลิกใช้แล้วในจาวาสคริปต์ที่สูงกว่า 1.5)
ฟังก์ชัน escape และ unescape จะทำงานไม่ถูกต้องกับอักขระที่ไม่ใช่ ASCII และถูกยกเลิกการใช้แล้ว ในจาวาสคริปต์ตั้งแต่ 1.5 ขึิ้นไปให้ใช้ฟังก์ชันต่อไปนี้แทน encodeURI, decodeURI, encodeURIComponent, และ decodeURIComponent
โดยฟังก์ชัน escape และ unescape ช่วยให้คุณเข้ารหัสและถอดรหัสสตริงได้ ซึ่ง ฟังก์ชัน escape จะคืนค่าการเข้ารหัสฐานสิบหกของค่าที่รับเข้ามาในชุดอักขระ ISO Latin ส่วนฟังก์ชัน unescape จะคืนค่าสตริง ASCII ของค่าข้อมูลที่เข้ารหัสฐานสิบหกนั้น
โดยมีรูปแบบการใช้งานดังนี้:
escape(string); unescape(string);
ฟังก์ชันเหล่านี้ใช้กับจาวาสคริปต์บน server เป็นหลัก เพื่อเข้ารหัสและถอดรหัสคู่ข้อมูล (ชื่อ/ค่าข้อมูล) ใน URL