There was a scripting error on this page. While it is being addressed by site editors, you can view partial content below.

This translation is incomplete. Please help translate this article from English.

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

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

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

ฟังก์ชันพื้นฐาน

จาวาสคริปต์ มีฟังก์ชันพื้นฐานในระดับชั้นนอกสุดให้ใช้หลายตัว

เนื้อหาในส่วนต่อไปจะแนะนำการใช้งานฟังก์ชันเหล่านี้ โดยสามารถดูรายละเอียดเพิ่มเติมของฟังก์ชันเหล่านี้ได้ที่ 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

{{ autoPreviousNext }}

Document Tags and Contributors

ผู้มีส่วนร่วมกับหน้านี้: Zarazi
อัปเดตล่าสุดโดย: Zarazi,