Place Autocomplete

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

บทนำ

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

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

ก่อนที่จะใช้ไลบรารี 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 เป็นไลบรารีที่ครอบคลุมในตัวซึ่งแยกจากโค้ดหลักของ JavaScript JavaScript API หากต้องการใช้ฟังก์ชันที่มีอยู่ในไลบรารีนี้ ก่อนอื่นคุณต้องโหลดโดยใช้พารามิเตอร์ libraries ใน URL รองเท้าบู๊ตของ Maps API

<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 อาร์กิวเมนต์ ดังนี้

  • องค์ประกอบ input ของ HTML ประเภท 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 ต้องส่งผ่านหลายประเทศเป็นรายการรหัสประเทศ

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

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

การคาดการณ์ที่เติมข้อความอัตโนมัติ

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

ตั้งค่าตัวเลือกได้เมื่อสร้าง

เครื่องมือสร้าง 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);

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

ระบุช่องข้อมูลเพื่อหลีกเลี่ยงการเรียกเก็บเงินสําหรับ SKU ของข้อมูล Places ที่ไม่จําเป็น ใส่พร็อพเพอร์ตี้ 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() คุณสามารถระบุอย่างใดอย่างหนึ่งต่อไปนี้

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

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

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

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

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

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

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

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

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

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

เครื่องมือสร้าง SearchBox มี 2 อาร์กิวเมนต์ ดังนี้

  • องค์ประกอบ input ของ HTML ประเภท 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);
});

ดูตัวอย่าง

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

การดึงข้อมูลการคาดการณ์บริการเติมข้อความอัตโนมัติของสถานที่

หากต้องการเรียกดูการคาดการณ์แบบเป็นโปรแกรม ให้ใช้คลาส 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 เป็นคําที่ตรงกัน

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

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
      with https://www.npmjs.com/package/@googlemaps/js-api-loader.
      -->
    <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 เซสชันจะส่งผลให้คําขอแต่ละรายการเรียกเก็บเงินแยกกัน

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

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

โดยค่าเริ่มต้น องค์ประกอบ 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 ช่วงใน pac-item ที่เป็นส่วนหลักของการคาดการณ์ สําหรับสถานที่ตั้งทางภูมิศาสตร์ ชื่อนี้จะมีชื่อสถานที่ เช่น "Sydney" หรือชื่อถนนและหมายเลข เช่น "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

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

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

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

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

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

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

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

การใช้ต้นทุนขั้นสูง

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

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

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

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

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

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

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

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

ไม่ ต้องการเฉพาะที่อยู่และสถานที่

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

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

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

ได้

ใช้ฟีเจอร์เติมข้อความอัตโนมัติโดยใช้โปรแกรมโดยไม่มีโทเค็นเซสชันและเรียกใช้ Geocode API ในการคาดการณ์สถานที่ที่เลือก
Geoโค้ด API จะส่งที่อยู่และพิกัดละติจูดและลองจิจูดให้ในราคา $0.005 ต่อคําขอ การทําคําขอเติมข้อความอัตโนมัติ - คําขอ 4 ครั้งมีค่าใช้จ่าย $0.01132 ดังนั้นค่าใช้จ่ายรวมของคําขอ 4 รายการบวกกับการเรียก Geocoding API เกี่ยวกับการคาดการณ์สถานที่ที่เลือกจะเท่ากับ 0.30 บาทสําหรับ 300 ต่อเซสชัน

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

ไม่

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

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

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

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

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

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

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


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

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

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

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

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

โควต้า

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

นโยบาย

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