Place Autocomplete

เลือกแพลตฟอร์ม: Android iOS JavaScript บริการเว็บ

ข้อมูลเบื้องต้น

การเติมข้อความอัตโนมัติเป็นฟีเจอร์ของไลบรารี Places ใน Maps JavaScript API คุณสามารถใช้การเติมข้อความอัตโนมัติเพื่อให้แอปพลิเคชันของคุณพิมพ์การค้นหาแบบล่วงหน้าของช่องค้นหาของ Google Maps บริการเติมข้อความอัตโนมัติจะจับคู่คําและสตริงย่อยทั้งหมด แปลค่าชื่อสถานที่ ที่อยู่ และโค้ด Plus ได้ แอปพลิเคชันจึงส่งคําค้นหาเป็นประเภทของผู้ใช้ได้ เพื่อที่จะให้การคาดการณ์เกี่ยวกับสถานที่ได้อย่างรวดเร็ว

เริ่มต้นใช้งาน

ก่อนที่จะใช้ไลบรารี Places ใน Maps JavaScript API ก่อนที่จะเปิดใช้ Places API ใน Google Cloud Console ในโปรเจ็กต์เดียวกับที่คุณตั้งค่าไว้สําหรับ Maps JavaScript API

วิธีดูรายการ API ที่เปิดใช้

  1. ไปที่ Google Cloud Console
  2. คลิกปุ่มเลือกโปรเจ็กต์ แล้วเลือกโปรเจ็กต์เดียวกับที่คุณตั้งค่าสําหรับ Maps JavaScript API แล้วคลิกเปิด
  3. ค้นหา Places API จากรายการ API ในหน้าแดชบอร์ด
  4. หากคุณเห็น API ในรายการ แสดงว่าทุกอย่างเรียบร้อยแล้ว หาก API ไม่ได้แสดงอยู่ ให้เปิดใช้
    1. ที่ด้านบนของหน้า ให้เลือกเปิดใช้ API เพื่อแสดงแท็บไลบรารี หรือเลือกคลังจากเมนูด้านซ้าย
    2. ค้นหา Places API แล้วเลือกจากรายการผลการค้นหา
    3. เลือกเปิดใช้ เมื่อประมวลผลเสร็จแล้ว Places API จะปรากฏในรายการ API ในหน้าแดชบอร์ด

กําลังโหลดไลบรารี

บริการ Places เป็นไลบรารีที่สร้างได้เอง โดยแยกจากรหัส API ของ Maps JavaScript หลัก หากต้องการใช้ฟังก์ชันการทํางานที่มีอยู่ในไลบรารีนี้ ก่อนอื่นคุณต้องโหลดโดยใช้พารามิเตอร์ libraries ใน Maps API Boottrap URL

<script async
    src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=places&callback=initMap">
</script>

ดู ภาพรวมไลบรารีสําหรับข้อมูลเพิ่มเติม

สรุปชั้นเรียน

API มีวิดเจ็ตการเติมข้อความอัตโนมัติ 2 ประเภทซึ่งคุณเพิ่มได้ผ่านคลาส Autocomplete และ SearchBox ตามลําดับ นอกจากนี้ คุณยังสามารถใช้คลาส AutocompleteService เพื่อดึงผลลัพธ์การเติมข้อความอัตโนมัติจากการเขียนโปรแกรมได้ (ดูข้อมูลอ้างอิง API ของ Maps JavaScript: คลาส AutocompleteService)

ด้านล่างนี้เป็นข้อมูลสรุปของชั้นเรียนที่พร้อมให้บริการ

  • Autocomplete เพิ่มช่องป้อนข้อความลงในหน้าเว็บของคุณ และตรวจสอบช่องดังกล่าวสําหรับอักขระที่ป้อน ขณะที่ผู้ใช้ป้อนข้อความ การเติมข้อความอัตโนมัติจะแสดงผลการคาดคะเนสถานที่ในรูปแบบของรายการการเลือกแบบเลื่อนลง เมื่อผู้ใช้เลือกสถานที่จากรายการ ระบบจะส่งกลับข้อมูลเกี่ยวกับสถานที่กลับไปยังวัตถุที่เติมข้อความอัตโนมัติ ซึ่งแอปพลิเคชันของคุณจะดึงข้อมูลได้ โปรดดูรายละเอียดด้านล่าง
    ช่องข้อความที่เติมข้อความอัตโนมัติ และรายการตัวเลือกการคาดคะเนตําแหน่งที่ระบุเมื่อผู้ใช้ป้อนคําค้นหา
    ภาพที่ 1: เติมข้อความอัตโนมัติในช่องข้อความและเลือก
    แบบฟอร์มที่อยู่ที่สมบูรณ์
    ภาพที่ 2: แบบฟอร์มที่อยู่ที่กรอกเสร็จสมบูรณ์แล้ว
  • SearchBox เพิ่มช่องป้อนข้อความลงในหน้าเว็บในลักษณะเดียวกับ Autocomplete ซึ่งมีข้อแตกต่างดังนี้
    • ความแตกต่างที่สําคัญจะแสดงในผลลัพธ์ที่ปรากฏในรายการการเลือก SearchBox จะแสดงรายการการคาดการณ์แบบขยาย ซึ่งอาจรวมถึงสถานที่ (ตามที่ API สถานที่กําหนดไว้) รวมกับข้อความค้นหาที่แนะนํา ตัวอย่างเช่น หากผู้ใช้ป้อน "พิซซ่าในนิวส์" รายการสิ่งที่เลือกอาจประกอบด้วยวลี "พิซซ่าในนิวยอร์ก รัฐนิวยอร์ก" และชื่อของร้านพิซซ่าต่างๆ
    • SearchBox มีตัวเลือกน้อยกว่า Autocomplete สําหรับการจํากัดการค้นหา ในช่วงก่อนหน้านี้ คุณสามารถตั้งความเอนเอียงในการค้นหาภายใน LatLngBounds ได้ ซึ่งช่วงหลังนี้คุณสามารถจํากัดการค้นหาไปยังประเทศและประเภทสถานที่ที่ต้องการ รวมถึงการตั้งค่าขอบเขตได้ ดูข้อมูลเพิ่มเติมได้ที่ด้านล่าง
    แบบฟอร์มที่อยู่ที่สมบูรณ์
    ภาพที่ 3: SearchBox นําเสนอข้อความค้นหาและการคาดคะเนสถานที่
    โปรดดูรายละเอียดด้านล่าง
  • คุณสร้างออบเจ็กต์ AutocompleteService เพื่อดึงข้อมูลการคาดการณ์แบบเป็นโปรแกรมได้ โทรหา getPlacePredictions() เพื่อเรียกสถานที่ที่ตรงกัน หรือโทรหา getQueryPredictions() เพื่อเรียกสถานที่ที่ตรงกันพร้อมข้อความค้นหาที่แนะนํา หมายเหตุ: AutocompleteService ไม่ได้เพิ่มตัวควบคุม UI ใดๆ แต่เมธอดด้านบนจะแสดงอาร์เรย์ของออบเจ็กต์การคาดการณ์แทน ออบเจ็กต์การคาดการณ์แต่ละรายการประกอบด้วยข้อความการคาดการณ์และข้อมูลการอ้างอิง รวมถึงรายละเอียดว่าผลการค้นหาตรงกับอินพุตของผู้ใช้อย่างไร ดูรายละเอียดได้ด้านล่าง

การเพิ่มวิดเจ็ตการเติมข้อความอัตโนมัติ

วิดเจ็ต Autocomplete จะสร้างช่องป้อนข้อความบนหน้าเว็บ แสดงการคาดการณ์สถานที่ในรายการเลือก UI และแสดงผลรายละเอียดสถานที่เพื่อตอบสนองต่อคําขอ getPlace() แต่ละรายการในรายการเลือกจะตรงกับสถานที่เดียว (ตามที่กําหนดโดย Places API)

ตัวสร้าง Autocomplete รับอาร์กิวเมนต์ 2 ตัว

  • องค์ประกอบ HTML input ของประเภท text นี่คือช่องอินพุตที่บริการเติมข้อความอัตโนมัติ จะตรวจสอบและแนบผลลัพธ์
  • อาร์กิวเมนต์ AutocompleteOptions ที่ไม่บังคับ ซึ่งอาจมีพร็อพเพอร์ตี้ต่อไปนี้
    • อาร์เรย์ของข้อมูล fields ที่จะรวมไว้ในคําตอบ Place Details สําหรับ PlaceResult ที่ผู้ใช้เลือก หากไม่ได้ตั้งค่าพร็อพเพอร์ตี้หรือมีการส่งผ่าน ['ALL'] ระบบจะส่งข้อมูลในช่องที่มีอยู่ทั้งหมดและเรียกเก็บเงินสําหรับ (ไม่แนะนําสําหรับการติดตั้งใช้งานเวอร์ชันที่ใช้งานจริง) ดูรายชื่อช่องได้ที่ PlaceResult
    • อาร์เรย์ของ types ที่ระบุประเภทหรือคอลเล็กชันประเภทที่ชัดเจน ตามที่ระบุไว้ในประเภทที่รองรับ ถ้าไม่ได้ระบุประเภทไว้ จะแสดงทุกประเภท
    • bounds เป็นวัตถุ google.maps.LatLngBounds ที่ระบุพื้นที่สําหรับค้นหาสถานที่ ผลลัพธ์จะมีอคติต่อสถานที่ต่างๆ ภายในขอบเขตเหล่านี้
    • strictBounds คือ boolean ที่กําหนดว่า API จะต้องแสดงผลเฉพาะสถานที่ที่อยู่ภายในภูมิภาคที่กําหนดไว้โดย bounds ที่ให้หรือไม่ และ API นี้จะไม่แสดงผลการค้นหานอกภูมิภาคนี้ แม้ว่าจะตรงกับอินพุตของผู้ใช้
    • componentRestrictions สามารถใช้เพื่อจํากัดผลลัพธ์ ไว้ที่กลุ่มที่ระบุ ปัจจุบันคุณใช้ componentRestrictions เพื่อกรองได้สูงสุด 5 ประเทศ ประเทศต้องส่งผ่านเป็นรหัสประเทศสองหลัก ISO 3166-1 Alpha-2 ต้องส่งผ่านหลายประเทศเป็นรายการรหัสประเทศ

      หมายเหตุ: หากคุณได้รับผลการค้นหาที่ไม่คาดคิดพร้อมรหัสประเทศแล้ว ให้ตรวจสอบว่าคุณใช้โค้ดที่ระบุประเทศ เขตแดนอ้างอิง และพื้นที่ความสนใจพิเศษทางภูมิศาสตร์ตามที่คุณตั้งใจไว้ ดูข้อมูลรหัสได้ที่วิกิพีเดีย: รายการรหัสประเทศตามมาตรฐาน ISO 3166 หรือแพลตฟอร์มการเรียกดูออนไลน์ของ ISO

    • placeIdOnly อาจใช้เพื่อสั่งให้วิดเจ็ต Autocomplete ดึงข้อมูลเฉพาะรหัสสถานที่เท่านั้น เมื่อเรียกใช้ getPlace() ในออบเจ็กต์ Autocomplete PlaceResult ที่ตั้งค่าจะมีการตั้งค่าพร็อพเพอร์ตี้ place id, types และ name เท่านั้น คุณใช้รหัสสถานที่ที่แสดงผลกับการเรียกใช้บริการ Places, การระบุพิกัดทางภูมิศาสตร์, เส้นทาง หรือเมทริกซ์ระยะทาง ได้

การคาดคะเนการเติมข้อความอัตโนมัติ

โดยค่าเริ่มต้น การเติมข้อความอัตโนมัติของสถานที่นี้จะแสดงประเภทสถานที่ทั้งหมด มีการให้น้ําหนักพิเศษกับการคาดการณ์ใกล้กับ ตําแหน่งของผู้ใช้ และดึงข้อมูลช่องข้อมูลที่ใช้ได้ทั้งหมดของสถานที่ที่ผู้ใช้เลือก ตั้งค่าตัวเลือกการเติมข้อความอัตโนมัติของสถานที่เพื่อนําเสนอการคาดคะเนที่เกี่ยวข้องมากขึ้นโดยอิงตามกรณีการใช้งานของคุณ

ตั้งค่าตัวเลือกในขั้นตอนการสร้าง

ตัวสร้าง Autocomplete จะยอมรับพารามิเตอร์ AutocompleteOptions เพื่อกําหนดข้อจํากัดในการสร้างวิดเจ็ต ตัวอย่างต่อไปนี้ตั้งค่าตัวเลือก bounds, componentRestrictions และ types เพื่อส่งคําขอประเภท establishment ประเภท โดยจะสนับสนุนเฉพาะพื้นที่ทางภูมิศาสตร์ที่ระบุและจํากัดการคาดการณ์เฉพาะสถานที่ในสหรัฐอเมริกาเท่านั้น การตั้งค่าตัวเลือก fields จะระบุข้อมูลที่ต้องการแสดงเกี่ยวกับสถานที่ที่ผู้ใช้เลือก

เรียกใช้ setOptions() เพื่อเปลี่ยนค่าตัวเลือกของวิดเจ็ตที่มีอยู่

TypeScript

const center = { lat: 50.064192, lng: -130.605469 };
// Create a bounding box with sides ~10km away from the center point
const defaultBounds = {
  north: center.lat + 0.1,
  south: center.lat - 0.1,
  east: center.lng + 0.1,
  west: center.lng - 0.1,
};
const input = document.getElementById("pac-input") as HTMLInputElement;
const options = {
  bounds: defaultBounds,
  componentRestrictions: { country: "us" },
  fields: ["address_components", "geometry", "icon", "name"],
  strictBounds: false,
  types: ["establishment"],
};

const autocomplete = new google.maps.places.Autocomplete(input, options);

JavaScript

const center = { lat: 50.064192, lng: -130.605469 };
// Create a bounding box with sides ~10km away from the center point
const defaultBounds = {
  north: center.lat + 0.1,
  south: center.lat - 0.1,
  east: center.lng + 0.1,
  west: center.lng - 0.1,
};
const input = document.getElementById("pac-input");
const options = {
  bounds: defaultBounds,
  componentRestrictions: { country: "us" },
  fields: ["address_components", "geometry", "icon", "name"],
  strictBounds: false,
  types: ["establishment"],
};
const autocomplete = new google.maps.places.Autocomplete(input, options);

ระบุช่องข้อมูล

ระบุช่องข้อมูลเพื่อหลีกเลี่ยงการถูกเรียกเก็บเงินของ Places SKUs ที่คุณไม่ต้องการ ใส่พร็อพเพอร์ตี้ fields ใน AutocompleteOptions ที่ส่งไปยังเครื่องมือสร้างวิดเจ็ตตามที่แสดงในตัวอย่างก่อนหน้านี้ หรือเรียกใช้ setFields() ในออบเจ็กต์ Autocomplete ที่มีอยู่

autocomplete.setFields(["place_id", "geometry", "name"]);

กําหนดการให้น้ําหนักและขอบเขตในพื้นที่ค้นหาสําหรับการเติมข้อความอัตโนมัติ

คุณทําให้ผลลัพธ์ของการเติมข้อความอัตโนมัติการให้น้ําหนักตําแหน่งหรือพื้นที่โดยประมาณได้ด้วยวิธีต่อไปนี้

  • กําหนดขอบเขตในการสร้างออบเจ็กต์ Autocomplete
  • เปลี่ยนขอบเขตพื้นที่ Autocomplete ที่มีอยู่
  • กําหนดขอบเขตเป็นวิวพอร์ตของแผนที่
  • จํากัดการค้นหาเฉพาะขอบเขต
  • จํากัดการค้นหาไว้เฉพาะบางประเทศ

ตัวอย่างก่อนหน้านี้แสดงขอบเขตการตั้งค่าขณะสร้าง ตัวอย่างต่อไปนี้จะแสดงเทคนิคการให้น้ําหนักอื่นๆ

เปลี่ยนขอบเขตของการเติมข้อความอัตโนมัติที่มีอยู่

เรียก setBounds() เพื่อเปลี่ยนพื้นที่ค้นหาบน Autocomplete ที่มีอยู่ให้เป็นขอบเขตสี่เหลี่ยมผืนผ้า

TypeScript

const southwest = { lat: 5.6108, lng: 136.589326 };
const northeast = { lat: 61.179287, lng: 2.64325 };
const newBounds = new google.maps.LatLngBounds(southwest, northeast);

autocomplete.setBounds(newBounds);

JavaScript

const southwest = { lat: 5.6108, lng: 136.589326 };
const northeast = { lat: 61.179287, lng: 2.64325 };
const newBounds = new google.maps.LatLngBounds(southwest, northeast);

autocomplete.setBounds(newBounds);
กําหนดขอบเขตเป็นวิวพอร์ตของแผนที่

ใช้ bindTo() เพื่อการให้น้ําหนักผลลัพธ์กับวิวพอร์ตของแผนที่ แม้ในเวลาที่มีการเปลี่ยนแปลงวิวพอร์ต

TypeScript

autocomplete.bindTo("bounds", map);

JavaScript

autocomplete.bindTo("bounds", map);

ใช้ unbind() เพื่อเลิกเชื่อมโยงการคาดคะเนการเติมข้อความอัตโนมัติจากวิวพอร์ตของแผนที่

TypeScript

autocomplete.unbind("bounds");
autocomplete.setBounds({ east: 180, west: -180, north: 90, south: -90 });

JavaScript

autocomplete.unbind("bounds");
autocomplete.setBounds({ east: 180, west: -180, north: 90, south: -90 });

ดูตัวอย่าง

จํากัดการค้นหาไว้ที่ขอบเขตปัจจุบัน

ตั้งค่าตัวเลือก strictBounds เพื่อจํากัดผลลัพธ์ตามขอบเขตปัจจุบัน ไม่ว่าจะอิงตามวิวพอร์ตของแผนที่หรือขอบเขตสี่เหลี่ยมผืนผ้า

autocomplete.setOptions({ strictBounds: true });
จํากัดการคาดการณ์ไว้เฉพาะบางประเทศ

ใช้ตัวเลือก componentRestrictions หรือโทร setComponentRestrictions() เพื่อจํากัดการค้นหาด้วยการเติมข้อความอัตโนมัติไว้เฉพาะใน 5 ประเทศ

TypeScript

autocomplete.setComponentRestrictions({
  country: ["us", "pr", "vi", "gu", "mp"],
});

JavaScript

autocomplete.setComponentRestrictions({
  country: ["us", "pr", "vi", "gu", "mp"],
});

ดูตัวอย่าง

จํากัดประเภทสถานที่

ใช้ตัวเลือก types หรือเรียกใช้ setTypes() เพื่อจํากัดการคาดคะเนของสถานที่บางประเภท ข้อจํากัดนี้ระบุประเภทหรือคอลเล็กชันประเภทตามที่แสดงในประเภทสถานที่ หากไม่มีการระบุข้อจํากัด ระบบจะส่งคืนค่าทุกประเภท

สําหรับค่าของตัวเลือก types หรือค่าที่ส่งไปยัง setTypes() คุณสามารถระบุได้ทั้ง

คําขอจะถูกปฏิเสธในกรณีต่อไปนี้

  • คุณระบุได้มากกว่าห้าประเภท
  • คุณระบุประเภทที่ไม่รู้จัก
  • คุณใช้ประเภทใดก็ได้จากตาราง 1 หรือตาราง 2 ร่วมกับตัวกรองใดก็ได้จากตาราง 3

การสาธิตการเติมข้อความอัตโนมัติของ Places จะแสดงความแตกต่างของการคาดการณ์ระหว่างสถานที่ประเภทต่างๆ

ไปที่การสาธิต

กําลังรับข้อมูลสถานที่

เมื่อผู้ใช้เลือกสถานที่จากการคาดคะเนที่แนบมากับช่องข้อความการเติมข้อความอัตโนมัติ บริการจะเริ่มเหตุการณ์ place_changed วิธีดูรายละเอียดสถานที่

  1. สร้างเครื่องจัดการเหตุการณ์สําหรับเหตุการณ์ place_changed และเรียก addListener() ในออบเจ็กต์ Autocomplete เพื่อเพิ่มเครื่องจัดการ
  2. เรียก Autocomplete.getPlace() บนวัตถุ Autocomplete เพื่อเรียกวัตถุ PlaceResult ซึ่งใช้เพื่อส่งข้อมูลเพิ่มเติมเกี่ยวกับสถานที่ที่เลือกได้

โดยค่าเริ่มต้น เมื่อผู้ใช้เลือกสถานที่ การเติมข้อความอัตโนมัติจะแสดงช่องข้อมูลทั้งหมดที่มีอยู่สําหรับสถานที่ที่เลือก และคุณจะได้รับการเรียกเก็บเงิน ใช้ Autocomplete.setFields() เพื่อระบุช่องข้อมูลที่จะแสดง อ่านเพิ่มเติมเกี่ยวกับออบเจ็กต์ PlaceResult ซึ่งรวมถึงรายการช่องข้อมูลสถานที่ที่คุณจะส่งคําขอได้ เพื่อหลีกเลี่ยงการชําระเงินสําหรับข้อมูลที่ไม่จําเป็น โปรดใช้ Autocomplete.setFields() เพื่อระบุเฉพาะข้อมูลสถานที่ที่คุณจะใช้

พร็อพเพอร์ตี้ name มี description จากการคาดคะเนการเติมข้อความอัตโนมัติของ Places อ่านเพิ่มเติมเกี่ยวกับ description ได้ในเอกสารประกอบเกี่ยวกับการเติมข้อมูลสถานที่

สําหรับฟอร์มที่อยู่ การรับที่อยู่ในรูปแบบที่มีโครงสร้างจะมีประโยชน์ หากต้องการให้ระบบแสดงที่อยู่ที่มีโครงสร้างของสถานที่ที่เลือก ให้เรียก Autocomplete.setFields() และระบุช่อง address_components

ตัวอย่างต่อไปนี้ใช้การเติมข้อความอัตโนมัติเพื่อกรอกข้อมูลในช่องต่างๆ ของแบบฟอร์ม

TypeScript

function fillInAddress() {
  // Get the place details from the autocomplete object.
  const place = autocomplete.getPlace();
  let address1 = "";
  let postcode = "";

  // Get each component of the address from the place details,
  // and then fill-in the corresponding field on the form.
  // place.address_components are google.maps.GeocoderAddressComponent objects
  // which are documented at http://goo.gle/3l5i5Mr
  for (const component of place.address_components as google.maps.GeocoderAddressComponent[]) {
    // @ts-ignore remove once typings fixed
    const componentType = component.types[0];

    switch (componentType) {
      case "street_number": {
        address1 = `${component.long_name} ${address1}`;
        break;
      }

      case "route": {
        address1 += component.short_name;
        break;
      }

      case "postal_code": {
        postcode = `${component.long_name}${postcode}`;
        break;
      }

      case "postal_code_suffix": {
        postcode = `${postcode}-${component.long_name}`;
        break;
      }

      case "locality":
        (document.querySelector("#locality") as HTMLInputElement).value =
          component.long_name;
        break;

      case "administrative_area_level_1": {
        (document.querySelector("#state") as HTMLInputElement).value =
          component.short_name;
        break;
      }

      case "country":
        (document.querySelector("#country") as HTMLInputElement).value =
          component.long_name;
        break;
    }
  }

  address1Field.value = address1;
  postalField.value = postcode;

  // After filling the form with address components from the Autocomplete
  // prediction, set cursor focus on the second address line to encourage
  // entry of subpremise information such as apartment, unit, or floor number.
  address2Field.focus();
}

JavaScript

function fillInAddress() {
  // Get the place details from the autocomplete object.
  const place = autocomplete.getPlace();
  let address1 = "";
  let postcode = "";

  // Get each component of the address from the place details,
  // and then fill-in the corresponding field on the form.
  // place.address_components are google.maps.GeocoderAddressComponent objects
  // which are documented at http://goo.gle/3l5i5Mr
  for (const component of place.address_components) {
    // @ts-ignore remove once typings fixed
    const componentType = component.types[0];

    switch (componentType) {
      case "street_number": {
        address1 = `${component.long_name} ${address1}`;
        break;
      }

      case "route": {
        address1 += component.short_name;
        break;
      }

      case "postal_code": {
        postcode = `${component.long_name}${postcode}`;
        break;
      }

      case "postal_code_suffix": {
        postcode = `${postcode}-${component.long_name}`;
        break;
      }
      case "locality":
        document.querySelector("#locality").value = component.long_name;
        break;
      case "administrative_area_level_1": {
        document.querySelector("#state").value = component.short_name;
        break;
      }
      case "country":
        document.querySelector("#country").value = component.long_name;
        break;
    }
  }

  address1Field.value = address1;
  postalField.value = postcode;
  // After filling the form with address components from the Autocomplete
  // prediction, set cursor focus on the second address line to encourage
  // entry of subpremise information such as apartment, unit, or floor number.
  address2Field.focus();
}

window.initAutocomplete = initAutocomplete;

ดูตัวอย่าง

การปรับแต่งข้อความตัวยึดตําแหน่ง

โดยค่าเริ่มต้น ช่องข้อความที่สร้างโดยบริการเติมข้อความอัตโนมัติจะมีข้อความตัวยึดตําแหน่งมาตรฐาน หากต้องการแก้ไขข้อความ ให้ตั้งค่าแอตทริบิวต์ placeholder ในองค์ประกอบ input ดังนี้

<input id="searchTextField" type="text" size="50" placeholder="Anything you want!">

หมายเหตุ: ข้อความตัวยึดตําแหน่งที่เป็นค่าเริ่มต้นจะแปลเป็นภาษาท้องถิ่นโดยอัตโนมัติ หากคุณระบุค่าตัวยึดตําแหน่งของคุณเอง คุณต้องจัดการการแปลค่านั้นในแอปพลิเคชันของคุณ สําหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ Google Maps JavaScript API เลือกภาษาที่จะใช้ โปรดอ่านเอกสารประกอบเกี่ยวกับ การแปล

ดูการจัดรูปแบบของวิดเจ็ตการเติมข้อความอัตโนมัติและช่องค้นหา เพื่อปรับแต่งลักษณะของวิดเจ็ต

SearchBox ช่วยให้ผู้ใช้ทําการค้นหาทางภูมิศาสตร์โดยใช้ข้อความ เช่น "พิซซ่าในนิวยอร์ก" หรือ "ร้านรองเท้าใกล้ถนนโรบินสัน" คุณแนบ SearchBox ลงในช่องข้อความได้ และเมื่อป้อนข้อความแล้ว บริการจะส่งการคาดคะเนกลับมาในรูปแบบของรายการแบบเลื่อนลง

SearchBox ให้รายการการคาดการณ์เพิ่มเติม ซึ่งอาจรวมถึงสถานที่ (ตามที่ API สถานที่กําหนด) รวมกับข้อความค้นหาที่แนะนํา ตัวอย่างเช่น หากผู้ใช้ป้อน "พิซซ่าในนิวส์" รายการสิ่งที่เลือกอาจประกอบด้วยวลี "พิซซ่าในนิวยอร์ก รัฐนิวยอร์ก" และชื่อของร้านพิซซ่าต่างๆ เมื่อผู้ใช้เลือกสถานที่จากรายการ ระบบจะส่งกลับข้อมูลเกี่ยวกับสถานที่นั้นกลับไปยังออบเจ็กต์ SearchBox ซึ่งแอปพลิเคชันสามารถดึงข้อมูลได้

ตัวสร้าง SearchBox รับอาร์กิวเมนต์ 2 ตัว

  • องค์ประกอบ HTML input ของประเภท text นี่คือช่องอินพุตที่บริการ SearchBox จะตรวจสอบและแนบผลลัพธ์ไปด้วย
  • อาร์กิวเมนต์ options ซึ่งอาจมีพร็อพเพอร์ตี้ bounds: bounds คือออบเจ็กต์ google.maps.LatLngBounds ที่ระบุพื้นที่สําหรับค้นหาสถานที่ จะเอนเอียงผลลัพธ์ไปยังสถานที่ต่างๆ ที่อยู่ภายในขอบเขตเหล่านี้

โค้ดต่อไปนี้ใช้พารามิเตอร์ขอบเขตเพื่อการให้น้ําหนักผลลัพธ์กับสถานที่ต่างๆ ภายในพื้นที่ทางภูมิศาสตร์ที่กําหนด ซึ่งระบุผ่านพิกัดละติจูด/ลองจิจูด

var defaultBounds = new google.maps.LatLngBounds(
  new google.maps.LatLng(-33.8902, 151.1759),
  new google.maps.LatLng(-33.8474, 151.2631));

var input = document.getElementById('searchTextField');

var searchBox = new google.maps.places.SearchBox(input, {
  bounds: defaultBounds
});

การเปลี่ยนพื้นที่ค้นหาสําหรับ SearchBox

หากต้องการเปลี่ยนพื้นที่การค้นหาสําหรับ SearchBox ที่มีอยู่ ให้เรียกใช้ setBounds() ในออบเจ็กต์ SearchBox และส่งผ่านออบเจ็กต์ LatLngBounds ที่เกี่ยวข้อง

ดูตัวอย่าง

กําลังรับข้อมูลสถานที่

เมื่อผู้ใช้เลือกรายการจากการคาดการณ์ที่แนบกับช่องค้นหา บริการจะเริ่มทํางานเหตุการณ์ places_changed คุณเรียก getPlaces() ในออบเจ็กต์ SearchBox เพื่อเรียกอาร์เรย์ที่มีการคาดการณ์หลายรายการได้ โดยออบเจ็กต์แต่ละรายการเป็นออบเจ็กต์ PlaceResult

ดูข้อมูลเพิ่มเติมเกี่ยวกับออบเจ็กต์ PlaceResult ได้จากเอกสารประกอบเรื่อง ผลการค้นหารายละเอียดสถานที่

TypeScript

// Listen for the event fired when the user selects a prediction and retrieve
// more details for that place.
searchBox.addListener("places_changed", () => {
  const places = searchBox.getPlaces();

  if (places.length == 0) {
    return;
  }

  // Clear out the old markers.
  markers.forEach((marker) => {
    marker.setMap(null);
  });
  markers = [];

  // For each place, get the icon, name and location.
  const bounds = new google.maps.LatLngBounds();

  places.forEach((place) => {
    if (!place.geometry || !place.geometry.location) {
      console.log("Returned place contains no geometry");
      return;
    }

    const icon = {
      url: place.icon as string,
      size: new google.maps.Size(71, 71),
      origin: new google.maps.Point(0, 0),
      anchor: new google.maps.Point(17, 34),
      scaledSize: new google.maps.Size(25, 25),
    };

    // Create a marker for each place.
    markers.push(
      new google.maps.Marker({
        map,
        icon,
        title: place.name,
        position: place.geometry.location,
      })
    );

    if (place.geometry.viewport) {
      // Only geocodes have viewport.
      bounds.union(place.geometry.viewport);
    } else {
      bounds.extend(place.geometry.location);
    }
  });
  map.fitBounds(bounds);
});

JavaScript

// Listen for the event fired when the user selects a prediction and retrieve
// more details for that place.
searchBox.addListener("places_changed", () => {
  const places = searchBox.getPlaces();

  if (places.length == 0) {
    return;
  }

  // Clear out the old markers.
  markers.forEach((marker) => {
    marker.setMap(null);
  });
  markers = [];

  // For each place, get the icon, name and location.
  const bounds = new google.maps.LatLngBounds();

  places.forEach((place) => {
    if (!place.geometry || !place.geometry.location) {
      console.log("Returned place contains no geometry");
      return;
    }

    const icon = {
      url: place.icon,
      size: new google.maps.Size(71, 71),
      origin: new google.maps.Point(0, 0),
      anchor: new google.maps.Point(17, 34),
      scaledSize: new google.maps.Size(25, 25),
    };

    // Create a marker for each place.
    markers.push(
      new google.maps.Marker({
        map,
        icon,
        title: place.name,
        position: place.geometry.location,
      })
    );
    if (place.geometry.viewport) {
      // Only geocodes have viewport.
      bounds.union(place.geometry.viewport);
    } else {
      bounds.extend(place.geometry.location);
    }
  });
  map.fitBounds(bounds);
});

ดูตัวอย่าง

ดูการจัดรูปแบบของวิดเจ็ตการเติมข้อความอัตโนมัติและช่องค้นหา เพื่อปรับแต่งลักษณะของวิดเจ็ต

การดึงข้อมูลการคาดคะเนบริการเติมข้อความอัตโนมัติโดยใช้โปรแกรม

หากต้องการดึงข้อมูลการคาดการณ์แบบเป็นโปรแกรม ให้ใช้คลาส AutocompleteService AutocompleteService ไม่เพิ่มตัวควบคุม UI แต่จะแสดงอาร์เรย์ของออบเจ็กต์การคาดการณ์แทน ซึ่งแต่ละรายการจะมีข้อความการคาดการณ์ ข้อมูลอ้างอิง และรายละเอียดว่าผลลัพธ์ตรงกับอินพุตของผู้ใช้อย่างไร วิธีนี้มีประโยชน์หากคุณต้องการควบคุมอินเทอร์เฟซผู้ใช้มากกว่าที่ Autocomplete และ SearchBox อธิบายไว้ข้างต้น

AutocompleteService ใช้วิธีการต่อไปนี้

  • getPlacePredictions() จะแสดงผลการคาดการณ์สถานที่ หมายเหตุ: "สถานที่" อาจเป็นที่ตั้ง สถานที่ตั้งทางภูมิศาสตร์ หรือจุดสนใจที่โดดเด่น ตามที่ Places API กําหนด
  • getQueryPredictions() จะแสดงรายการการคาดการณ์แบบขยาย ซึ่งอาจรวมถึงสถานที่ (ตามที่ Places API กําหนด) รวมถึงข้อความค้นหาที่แนะนํา ตัวอย่างเช่น หากผู้ใช้ป้อน "พิซซ่าในนิวส์" รายการสิ่งที่เลือกอาจประกอบด้วยวลี "พิซซ่าในนิวยอร์ก รัฐนิวยอร์ก" และชื่อของร้านพิซซ่าต่างๆ

ทั้ง 2 วิธีนี้ข้างต้นจะแสดงอาร์เรย์ของออบเจ็กต์การคาดการณ์ในรูปแบบต่อไปนี้

  • description เป็นการคาดการณ์ที่ตรงกัน
  • distance_meters คือระยะทางเมตรเป็นเมตรจาก AutocompletionRequest.origin ที่ระบุ
  • matched_substrings มีชุดสตริงย่อยในคําอธิบายที่ตรงกับองค์ประกอบในอินพุตของผู้ใช้ ซึ่งจะเป็นประโยชน์สําหรับการไฮไลต์สตริงย่อยในแอปพลิเคชันของคุณ ในหลายกรณี คําค้นหาจะปรากฏเป็นสตริงย่อยของช่องคําอธิบาย
    • length คือความยาวของสตริงย่อย
    • offset คือออฟเซ็ตอักขระที่วัดจากจุดเริ่มต้นของสตริงคําอธิบายที่แสดงสตริงย่อยที่ตรงกัน
  • place_id คือตัวระบุข้อความที่ระบุสถานที่แบบไม่ซ้ํา หากต้องการดึงข้อมูลเกี่ยวกับสถานที่ ให้ส่งตัวระบุนี้ในช่อง placeId ของคําขอรายละเอียดสถานที่ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีอ้างอิงสถานที่โดยใช้รหัสสถานที่
  • terms คืออาร์เรย์ที่มีองค์ประกอบของคําค้นหา สําหรับสถานที่ แต่ละองค์ประกอบมักจะเป็นส่วนของที่อยู่
    • offset คือออฟเซ็ตอักขระที่วัดจากจุดเริ่มต้นของสตริงคําอธิบายที่แสดงสตริงย่อยที่ตรงกัน
    • value เป็นคําที่ตรงกัน

ตัวอย่างด้านล่างจะส่งคําขอการคาดการณ์การค้นหาสําหรับวลี "pizza near" และแสดงผลลัพธ์ในรายการ

TypeScript

// This example retrieves autocomplete predictions programmatically from the
// autocomplete service, and displays them as an HTML list.
// This example requires the Places library. Include the libraries=places
// parameter when you first load the API. For example:
// <script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=places">
function initService(): void {
  const displaySuggestions = function (
    predictions: google.maps.places.QueryAutocompletePrediction[] | null,
    status: google.maps.places.PlacesServiceStatus
  ) {
    if (status != google.maps.places.PlacesServiceStatus.OK || !predictions) {
      alert(status);
      return;
    }

    predictions.forEach((prediction) => {
      const li = document.createElement("li");

      li.appendChild(document.createTextNode(prediction.description));
      (document.getElementById("results") as HTMLUListElement).appendChild(li);
    });
  };

  const service = new google.maps.places.AutocompleteService();

  service.getQueryPredictions({ input: "pizza near Syd" }, displaySuggestions);
}

declare global {
  interface Window {
    initService: () => void;
  }
}
window.initService = initService;

JavaScript

// This example retrieves autocomplete predictions programmatically from the
// autocomplete service, and displays them as an HTML list.
// This example requires the Places library. Include the libraries=places
// parameter when you first load the API. For example:
// <script src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&libraries=places">
function initService() {
  const displaySuggestions = function (predictions, status) {
    if (status != google.maps.places.PlacesServiceStatus.OK || !predictions) {
      alert(status);
      return;
    }

    predictions.forEach((prediction) => {
      const li = document.createElement("li");

      li.appendChild(document.createTextNode(prediction.description));
      document.getElementById("results").appendChild(li);
    });
  };

  const service = new google.maps.places.AutocompleteService();

  service.getQueryPredictions({ input: "pizza near Syd" }, displaySuggestions);
}

window.initService = initService;

CSS

HTML

<html>
  <head>
    <title>Retrieving Autocomplete Predictions</title>
    <script src="https://polyfill.io/v3/polyfill.min.js?features=default"></script>

    <link rel="stylesheet" type="text/css" href="./style.css" />
    <script type="module" src="./index.js"></script>
  </head>
  <body>
    <p>Query suggestions for 'pizza near Syd':</p>
    <ul id="results"></ul>
    <!-- Replace Powered By Google image src with self hosted image. https://developers.google.com/maps/documentation/places/web-service/policies#other_attribution_requirements -->
    <img
      class="powered-by-google"
      src="https://storage.googleapis.com/geo-devrel-public-buckets/powered_by_google_on_white.png"
      alt="Powered by Google"
    />

    <!-- 
      The `defer` attribute causes the callback to execute after the full HTML
      document has been parsed. For non-blocking uses, avoiding race conditions,
      and consistent behavior across browsers, consider loading using Promises.
      See https://developers.google.com/maps/documentation/javascript/load-maps-js-api
      for more information.
      -->
    <script
      src="https://maps.googleapis.com/maps/api/js?key=AIzaSyB41DRUbKWJHPxaFjMAwdrzWzbVKartNGg&callback=initService&libraries=places&v=weekly"
      defer
    ></script>
  </body>
</html>

ลองใช้ตัวอย่าง

ดูตัวอย่าง

โทเค็นเซสชัน

AutocompleteService.getPlacePredictions() ใช้โทเค็นเซสชันเพื่อจัดกลุ่มคําขอการเติมข้อความอัตโนมัติเพื่อวัตถุประสงค์ด้านการเรียกเก็บเงิน โทเค็นเซสชันจะจัดกลุ่มคําค้นหาและเฟสการเลือกของผู้ใช้ ที่เติมข้อความอัตโนมัติลงในเซสชันที่แยกจากกันเพื่อวัตถุประสงค์ในการเรียกเก็บเงิน เซสชันจะเริ่มต้นเมื่อผู้ใช้เริ่มพิมพ์คําค้นหา และจบลงเมื่อเลือกสถานที่ แต่ละเซสชันอาจมีการค้นหาได้หลายรายการ ตามด้วยการเลือกสถานที่ 1 แห่ง เมื่อเซสชันสิ้นสุดลง โทเค็นจะใช้งานไม่ได้อีกต่อไป แอปของคุณต้องสร้างโทเค็นใหม่ให้กับแต่ละเซสชัน เราขอแนะนําให้ใช้โทเค็นเซสชัน สําหรับการเติมข้อความอัตโนมัติทั้งหมด หากละเว้นพารามิเตอร์ sessionToken หรือหากคุณนําโทเค็นเซสชันมาใช้ซ้ํา ระบบจะเรียกเก็บเงินเซสชันเสมือนว่าไม่ได้มอบโทเค็นเซสชันให้ (คําขอแต่ละรายการจะเรียกเก็บเงินแยกกัน)

คุณสามารถใช้โทเค็นเซสชันเดียวกันเพื่อส่งคําขอรายละเอียดสถานที่เดียวสําหรับสถานที่ที่เกิดจากการโทรหา AutocompleteService.getPlacePredictions() ในกรณีนี้ คําขอเติมข้อความอัตโนมัติจะรวมอยู่กับคําขอรายละเอียดสถานที่ และการโทรจะเป็นคําขอรายละเอียดสถานที่ตามปกติ ไม่มีค่าใช้จ่ายสําหรับคําขอ เติมข้อความอัตโนมัติ

โปรดตรวจสอบว่าได้ส่งโทเค็นเซสชันที่ไม่ซ้ํากันสําหรับแต่ละเซสชันใหม่ การใช้โทเค็นเดียวกันสําหรับเซสชันการเติมข้อความอัตโนมัติมากกว่า 1 เซสชันจะทําให้เซสชันของการเติมข้อความอัตโนมัติดังกล่าวหมดอายุ และคําขอการเติมข้อความอัตโนมัติทั้งหมดในเซสชันที่ไม่ถูกต้องจะถูกเรียกเก็บเงินแยกกันโดยใช้ SKU ต่อคําขออัตโนมัติ อ่านเพิ่มเติมเกี่ยวกับโทเค็นเซสชัน

ตัวอย่างต่อไปนี้สร้างโทเค็นเซสชัน จากนั้นส่งต่อใน AutocompleteService (ระบบข้ามฟังก์ชัน displaySuggestions() เพื่อความสั้น)

// Create a new session token.
var sessionToken = new google.maps.places.AutocompleteSessionToken();

// Pass the token to the autocomplete service.
var autocompleteService = new google.maps.places.AutocompleteService();
autocompleteService.getPlacePredictions({
  input: 'pizza near Syd',
  sessionToken: sessionToken
},
displaySuggestions);

โปรดตรวจสอบว่าได้ส่งโทเค็นเซสชันที่ไม่ซ้ํากันสําหรับแต่ละเซสชันใหม่ การใช้โทเค็นเดียวกันสําหรับเซสชันมากกว่า 1 เซสชันจะทําให้ระบบเรียกเก็บเงินคําขอแต่ละรายการแยกกัน

อ่านเพิ่มเติมเกี่ยวกับโทเค็นเซสชัน

การจัดรูปแบบวิดเจ็ตเติมข้อความอัตโนมัติและช่องค้นหา

โดยค่าเริ่มต้น องค์ประกอบ UI ที่ระบุโดย Autocomplete และ SearchBox ได้รับการออกแบบมาให้รวมอยู่ใน Google Maps คุณอาจต้องปรับรูปแบบให้เข้ากับเว็บไซต์ของคุณเอง คลาส CSS ต่อไปนี้พร้อมใช้งาน คลาสทั้งหมดที่แสดงด้านล่างใช้ได้กับทั้งวิดเจ็ต Autocomplete และวิดเจ็ต SearchBox

ภาพกราฟิกของคลาส CSS สําหรับวิดเจ็ตการเติมข้อความอัตโนมัติและ SearchBox
คลาส CSS สําหรับวิดเจ็ตการเติมข้อความอัตโนมัติและ SearchBox
คลาส CSS คำอธิบาย
pac-container องค์ประกอบภาพที่มีรายการการคาดการณ์ที่แสดงผลโดยบริการเติมข้อความอัตโนมัติของสถานที่ รายการนี้จะปรากฏเป็นรายการแบบเลื่อนลงใต้วิดเจ็ต Autocomplete หรือ SearchBox
pac-icon ไอคอนด้านซ้ายของแต่ละรายการในรายการการคาดการณ์
pac-item รายการที่อยู่ในรายการการคาดการณ์ที่วิดเจ็ต Autocomplete หรือ SearchBox ให้ไว้
pac-item:hover รายการเมื่อผู้ใช้เลื่อนเมาส์ไปวางไว้เหนือรายการ
pac-item-selected รายการเมื่อผู้ใช้เลือกผ่านแป้นพิมพ์ หมายเหตุ: รายการที่เลือกเป็นสมาชิกของชั้นเรียนนี้และชั้นเรียน pac-item
pac-item-query Span ภายใน pac-item ที่เป็นส่วนหลักของการคาดการณ์ สําหรับสถานที่ตั้งทางภูมิศาสตร์ สถานที่นี้จะใช้ชื่อสถานที่ เช่น "ซิดนีย์" หรือชื่อถนน เช่น "10 King Street" สําหรับการค้นหาแบบข้อความ เช่น "พิซซ่าในนิวยอร์ก" จะมีข้อความที่สมบูรณ์ของข้อความค้นหา โดยค่าเริ่มต้น pac-item-query จะเป็นสีดํา หากมีข้อความเพิ่มเติมใน pac-item ข้อความนั้นจะอยู่นอก pac-item-query และรับค่าการจัดรูปแบบมาจาก pac-item ตามค่าเริ่มต้นจะเป็นสีเทา ข้อความเพิ่มเติมมักจะเป็นที่อยู่
pac-matched ส่วนของการคาดการณ์ที่แสดงซึ่งตรงกับอินพุตของผู้ใช้ โดยค่าเริ่มต้น ข้อความที่ตรงกันนี้จะไฮไลต์เป็นข้อความตัวหนา โปรดทราบว่าข้อความที่ตรงกันอาจอยู่ที่ใดก็ได้ภายใน pac-item ข้อความไม่จําเป็นต้องเป็นส่วนหนึ่งของ pac-item-query และบางส่วนอาจอยู่ใน pac-item-query และเป็นส่วนหนึ่งของข้อความที่เหลือใน pac-item

การเพิ่มประสิทธิภาพการเติมข้อความอัตโนมัติของสถานที่

ส่วนนี้จะอธิบายแนวทางปฏิบัติแนะนําที่จะช่วยให้คุณใช้ประโยชน์จากบริการเติมข้อความอัตโนมัติได้

หลักเกณฑ์ทั่วไปมีดังนี้

  • วิธีที่รวดเร็วที่สุดในการพัฒนาอินเทอร์เฟซผู้ใช้ที่ใช้งานได้คือ ใช้วิดเจ็ตเติมข้อความอัตโนมัติใน Maps JavaScript API, SDK สําหรับการเติมข้อความอัตโนมัติของ Places สําหรับ Android หรือ การควบคุม UI ของการเติมข้อความอัตโนมัติของ SDK สําหรับ iOS
  • ทําความเข้าใจช่องข้อมูลการเติมข้อความอัตโนมัติของ Place ที่สําคัญตั้งแต่ต้น
  • ช่องการให้น้ําหนักตําแหน่งและการจํากัดตําแหน่งเป็นตัวเลือกที่ไม่บังคับ แต่อาจมีผลกระทบอย่างมากต่อประสิทธิภาพการเติมข้อความอัตโนมัติ
  • ใช้การจัดการข้อผิดพลาดเพื่อดูแลให้แอปลดระดับอย่างสุภาพหาก API แสดงข้อผิดพลาด
  • ตรวจสอบว่าแอปมีการจัดการเมื่อไม่มีการเลือกและเสนอวิธีดําเนินการต่อแก่ผู้ใช้

แนวทางปฏิบัติที่ดีที่สุดในการเพิ่มประสิทธิภาพต้นทุน

การเพิ่มประสิทธิภาพต้นทุนพื้นฐาน

หากต้องการเพิ่มประสิทธิภาพค่าใช้จ่ายในการใช้บริการเติมข้อความสถานที่โดยอัตโนมัติ ให้ใช้มาสก์ของช่องในรายละเอียดสถานที่และวิดเจ็ตการเติมข้อความอัตโนมัติเพื่อแสดงผลเฉพาะช่องข้อมูลสถานที่ที่คุณต้องการ

การเพิ่มประสิทธิภาพต้นทุนขั้นสูง

โปรดพิจารณาการใช้การเติมข้อความอัตโนมัติของ Place แบบเป็นโปรแกรมเพื่อเข้าถึงการกําหนดราคาต่อคําขอและขอผลลัพธ์ของ Geocoding API เกี่ยวกับสถานที่ที่เลือกแทนรายละเอียดสถานที่ การกําหนดราคาต่อคําขอที่จับคู่กับ Geocoding API จะมีประสิทธิภาพด้านราคามากกว่าต่อเซสชัน (ตามเซสชัน) หากเป็นไปตามเงื่อนไขทั้งสองข้อต่อไปนี้

  • หากคุณต้องการเพียงละติจูด/ลองจิจูดหรือที่อยู่ของสถานที่ที่ผู้ใช้เลือกเท่านั้น Geocoding API จะส่งข้อมูลนี้ให้คุณในการเรียกรายละเอียดสถานที่น้อยกว่า
  • หากผู้ใช้เลือกการคาดคะเนการเติมข้อความอัตโนมัติภายในโดยเฉลี่ยแล้ว 4 คําขอในการเติมข้อความอัตโนมัติหรือน้อยกว่านั้น การกําหนดราคาต่อคําขออาจคุ้มค่ากว่าการกําหนดราคาต่อเซสชัน
หากต้องการความช่วยเหลือในการเลือกการใช้การเติมข้อความอัตโนมัติที่ตรงกับความต้องการของคุณ ให้เลือกแท็บที่ตรงกับคําตอบสําหรับคําถามต่อไปนี้

แอปพลิเคชันของคุณต้องการข้อมูลอื่นนอกเหนือจากที่อยู่และละติจูด/ลองจิจูดของการคาดการณ์ที่เลือกใช่ไหม

ใช่ ต้องการรายละเอียดเพิ่มเติม

ใช้การเติมข้อความอัตโนมัติตามตําแหน่งโดยอิงจากรายละเอียดสถานที่
เนื่องจากแอปพลิเคชันของคุณต้องการรายละเอียดสถานที่ เช่น ชื่อสถานที่ สถานะธุรกิจ หรือเวลาทําการ การใช้งานการเติมข้อความอัตโนมัติจากสถานที่จึงควรใช้โทเค็นเซสชัน (แบบเป็นโปรแกรมหรือวิดเจ็ต JavaScript, Android หรือ iOS) รวมค่าใช้จ่ายทั้งหมด $0.017 ต่อเซสชัน บวกด้วย SKU ของข้อมูลสถานที่ โดยขึ้นอยู่กับช่องข้อมูลสถานที่ 1}

การใช้งานวิดเจ็ต
การจัดการเซสชันจะสร้างขึ้นโดยอัตโนมัติในวิดเจ็ต JavaScript, Android หรือ iOS ซึ่งรวมทั้งคําขอเติมข้อความอัตโนมัติของสถานที่และคําขอรายละเอียดสถานที่ในการคาดการณ์ที่เลือก อย่าลืมระบุพารามิเตอร์ fields เพื่อให้แน่ใจว่าคุณกําลังขอช่องข้อมูลที่คุณต้องการเท่านั้น

การใช้งานแบบเป็นโปรแกรม
ใช้โทเค็นเซสชันกับคําขอการเติมข้อความอัตโนมัติใน Place ของคุณ เมื่อขอรายละเอียดสถานที่เกี่ยวกับการคาดการณ์ที่เลือก ให้ใส่พารามิเตอร์ต่อไปนี้ด้วย

  1. รหัสสถานที่จากการตอบกลับการเติมข้อความสถานที่โดยอัตโนมัติ
  2. โทเค็นเซสชันที่ใช้ในคําขอเติมข้อความสถานที่โดยอัตโนมัติ
  3. พารามิเตอร์ fields ที่ระบุช่องข้อมูลสถานที่ที่คุณต้องการ

ไม่ ต้องการเพียงที่อยู่และตําแหน่งเท่านั้น

Geocoding API อาจเป็นตัวเลือกที่มีค่าใช้จ่ายมากกว่ารายละเอียดสถานที่สําหรับแอปพลิเคชันของคุณ ทั้งนี้ขึ้นอยู่กับประสิทธิภาพของการเติมข้อความอัตโนมัติจาก Place ของคุณ ประสิทธิภาพการเติมข้อความอัตโนมัติของแอปพลิเคชันจะแตกต่างกันไปขึ้นอยู่กับสิ่งที่ผู้ใช้ป้อน ตําแหน่งที่ใช้แอปพลิเคชัน และการใช้งานแนวทางปฏิบัติที่ดีที่สุดสําหรับการเพิ่มประสิทธิภาพ

ตอบคําถามต่อไปนี้เพื่อวิเคราะห์จํานวนอักขระที่ผู้ใช้พิมพ์โดยเฉลี่ยก่อนเลือกการคาดคะเนการเติมข้อความอัตโนมัติใน Place ในแอปพลิเคชันของคุณ

โดยเฉลี่ยแล้ว ผู้ใช้ของคุณเลือกการคาดคะเนการเติมข้อความอัตโนมัติของสถานที่ภายในคําขอไม่เกิน 4 คําขอใช่ไหม

ใช่

เติมข้อความอัตโนมัติในสถานที่โดยใช้โปรแกรมโดยไม่มีโทเค็นเซสชัน และเรียกใช้ Geocoding API ในการคาดการณ์สถานที่ที่เลือก
Geocoding API จะส่งที่อยู่และพิกัดละติจูด/ลองจิจูดให้ $0.005 ต่อคําขอ การขอ เติมข้อความอัตโนมัติเกี่ยวกับสถานที่ - คําขอ 4 ครั้งมีค่าใช้จ่าย 0.40 บาท ค่าใช้จ่ายรวมของคําขอ 4 รายการบวกกับการเรียกใช้ API การระบุพิกัดทางภูมิศาสตร์ 1 ครั้งเกี่ยวกับการคาดการณ์สถานที่ที่เลือกจะเป็น 10.60 บาท ซึ่งต่ํากว่าราคาการเติมข้อความอัตโนมัติต่อเซสชัน 0.4 บาท1

ลองใช้แนวทางปฏิบัติแนะนําเกี่ยวกับประสิทธิภาพเพื่อช่วยให้ผู้ใช้ได้รับการคาดคะเนที่ต้องการโดยใช้อักขระน้อยลง

ไม่ได้

ใช้การเติมข้อความอัตโนมัติตามตําแหน่งโดยอิงจากรายละเอียดสถานที่
เนื่องจากจํานวนคําขอโดยเฉลี่ยที่คุณคาดไว้ก่อนที่ผู้ใช้จะเลือกการคาดคะเนการเติมข้อความอัตโนมัตินั้นเกินค่าใช่จ่ายต่อเซสชัน การใช้งานการเติมข้อความอัตโนมัติของ Place ของคุณจึงควรใช้โทเค็นเซสชันสําหรับทั้งคําขอการเติมข้อความอัตโนมัติจากสถานที่และคําขอรายละเอียดสถานที่ที่เกี่ยวข้องรวมเป็น $0.017 ต่อเซสชัน1

การใช้งานวิดเจ็ต
การจัดการเซสชันจะสร้างขึ้นโดยอัตโนมัติในวิดเจ็ต JavaScript, Android หรือ iOS ซึ่งรวมทั้งคําขอเติมข้อความอัตโนมัติของสถานที่และคําขอรายละเอียดสถานที่ในการคาดการณ์ที่เลือก โปรดระบุพารามิเตอร์ fields เพื่อให้แน่ใจว่าคุณร้องขอเฉพาะช่องข้อมูลพื้นฐาน

การใช้งานแบบเป็นโปรแกรม
ใช้โทเค็นเซสชันกับคําขอการเติมข้อความอัตโนมัติใน Place ของคุณ เมื่อขอรายละเอียดสถานที่เกี่ยวกับการคาดการณ์ที่เลือก ให้ใส่พารามิเตอร์ต่อไปนี้ด้วย

  1. รหัสสถานที่จากการตอบกลับการเติมข้อความสถานที่โดยอัตโนมัติ
  2. โทเค็นเซสชันที่ใช้ในคําขอเติมข้อความสถานที่โดยอัตโนมัติ
  3. พารามิเตอร์ fields ที่ระบุช่องข้อมูลพื้นฐาน เช่น ที่อยู่และเรขาคณิต

พิจารณาเลื่อนคําขอการเติมข้อความอัตโนมัติสถานที่
คุณใช้กลยุทธ์ต่างๆ ได้ เช่น เลื่อนคําขอเติมข้อความอัตโนมัติลงในสถานที่จนกว่าผู้ใช้จะพิมพ์อักขระ 3 หรือ 4 ตัวแรกแล้ว เพื่อให้แอปพลิเคชันส่งคําขอน้อยลง ตัวอย่างเช่น การส่งคําขอเติมข้อความอัตโนมัติให้กับอักขระแต่ละตัวหลังจาก ผู้ใช้พิมพ์อักขระตัวที่ 3 หมายความว่าหากผู้ใช้พิมพ์ 7 อักขระ แล้วเลือกการคาดคะเนที่คุณกําหนดคําขอ API การระบุพิกัดทางภูมิศาสตร์ 1 รายการ ค่าใช้จ่ายรวมคือ 0.01632 บาท (4 * 0.00283 การเติมข้อความอัตโนมัติต่อคําขอ + การระบุพิกัดทางภูมิศาสตร์ $0.005)1

หากคําขอที่หน่วงเวลาอาจทําให้คําขอแบบเป็นโปรแกรมเฉลี่ยต่ํากว่า 4 ทําตามได้โดยทําตามคําแนะนําเกี่ยวกับการเติมข้อความอัตโนมัติในสถานที่ด้วย Geocoding API โปรดทราบว่าผู้ใช้ที่อาจคาดหวังว่าจะเห็นคําขอที่มีการหน่วงเวลาคือการกดแป้นพิมพ์แต่ละครั้ง

ลองใช้แนวทางปฏิบัติแนะนําเกี่ยวกับประสิทธิภาพเพื่อช่วยให้ผู้ใช้ได้รับการคาดคะเนที่ต้องการโดยใช้อักขระจํานวนน้อยลง


  1. ค่าใช้จ่ายที่แสดงในรายการนี้แสดงเป็นสกุลเงิน USD โปรดดูข้อมูลราคาเต็มในหน้าการเรียกเก็บเงิน Google Maps Platform

แนวทางปฏิบัติแนะนําสําหรับประสิทธิภาพ

หลักเกณฑ์ต่อไปนี้อธิบายวิธีการเพิ่มประสิทธิภาพการเติมข้อความอัตโนมัติของสถานที่

  • เพิ่มข้อจํากัดด้านประเทศ การให้น้ําหนักตําแหน่ง และ (สําหรับการใช้แบบเป็นโปรแกรม) ในการตั้งค่าการใช้การเติมข้อความอัตโนมัติของ Place ของคุณ ค่ากําหนดภาษาไม่จําเป็นต้องใช้กับวิดเจ็ตเนื่องจากเลือกค่ากําหนดภาษาจากเบราว์เซอร์หรืออุปกรณ์เคลื่อนที่ของผู้ใช้
  • หากการเติมข้อความอัตโนมัติของสถานที่แสดงพร้อมกับแผนที่ คุณสามารถตั้งตําแหน่งการให้น้ําหนักตามวิวพอร์ตแผนที่ได้
  • ในกรณีที่ผู้ใช้ไม่ได้เลือกการคาดคะเนจากการเติมข้อความอัตโนมัติ โดยทั่วไปจะเป็นเพียงเพราะการคาดคะเนเหล่านี้ไม่ใช่ที่อยู่ผลลัพธ์ที่ต้องการ คุณจึงนําอินพุตเดิมของผู้ใช้มาใช้ซ้ําได้เพื่อให้ได้ผลลัพธ์ที่เกี่ยวข้องมากขึ้น ดังนี้
    • หากคุณคาดหวังให้ผู้ใช้ป้อนเฉพาะข้อมูลที่อยู่ ให้ใช้อินพุตเดิมของผู้ใช้ซ้ําในการเรียก Geocoding API
    • หากคุณให้ผู้ใช้ป้อนการค้นหาสําหรับสถานที่ที่ต้องการตามชื่อหรือที่อยู่ ให้ใช้ค้นหาคําขอสถานที่ หากคาดว่าจะพบผลลัพธ์ในบางภูมิภาคเท่านั้น ให้ใช้การให้น้ําหนักตําแหน่ง
    สถานการณ์อื่นๆ เมื่อวิธีที่ดีที่สุดคือการเปลี่ยนไปใช้ Geocoding API ได้แก่
    • ผู้ใช้ป้อนที่อยู่ย่อยในประเทศที่การรองรับสถานที่ในการเติมข้อความย่อยของ Place ไม่สมบูรณ์ เช่น เช็กเกีย เอสโตเนีย และลิทัวเนีย เช่น ที่อยู่เช็ก "Stroupežnického 3191/17, Praha" ให้ผลการคาดคะเนบางส่วนในการเติมข้อความอัตโนมัติของสถานที่
    • ผู้ใช้ป้อนที่อยู่ที่มีคํานําหน้าส่วนถนน เช่น "23-30 29th St, Queens" ในนิวยอร์กซิตี้ หรือ "47-380 Kamehameha Hwy, Kaneohe" บนเกาะคาไวใน Hawai'i

ขีดจํากัดและนโยบายการใช้งาน

โควต้า

สําหรับข้อมูลเกี่ยวกับโควต้าและราคา โปรดดู เอกสารการใช้งานและการเรียกเก็บเงินสําหรับ Places API

นโยบาย

การใช้ Places ใน Maps API ของ Maps JavaScript ต้องเป็นไปตามนโยบายที่อธิบายเกี่ยวกับ Places API