mozilla
Your Search Results

    Functions

    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

    Document Tags and Contributors

    Contributors to this page: Zarazi
    Last updated by: Zarazi,