Functions

ฟังก์ชันเป็นหนึ่งในส่วนประกอบหลักของจาวาสคริปต์ หนึ่งฟังก์ชันคือหนึ่งกระบวนการของจาวาสคริปต์ ซึ่งก็คือชุดคำสั่งที่ทำงานหรือคำนวณค่า โดยคุณต้องประกาศใช้ฟังก์ชันที่ใดก็ได้ภายในขอบเขตที่คุณเรียกใช้

การประกาศใช้ฟังก์ชัน

คำจำกัดความของฟังก์ชัน (หรือเรียกได้ว่า การประกาศใช้ฟังก์ชัน) ประกอบด้วยคำสั่ง 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