Place Autocomplete

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

บทนำ

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

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

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

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

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

กำลังโหลดคลัง

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

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

ดูข้อมูลเพิ่มเติมได้ที่ ภาพรวมของไลบรารี

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

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

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

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

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

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

ตัวสร้าง Autocomplete จะใช้อาร์กิวเมนต์ 2 รายการดังนี้

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

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

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

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

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

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

ตัวสร้าง 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,
};

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,
};
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() คุณสามารถระบุค่าใดค่าหนึ่งต่อไปนี้

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

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

ดูการสาธิต

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

เมื่อผู้ใช้เลือกสถานที่จากการคาดคะเนที่แนบมากับช่องข้อความที่เติมข้อความอัตโนมัติ บริการจะเรียกเหตุการณ์ 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 ช่วยให้ผู้ใช้ทำการค้นหาตามภูมิศาสตร์แบบข้อความได้ เช่น "พิซซ่าในนิวยอร์ก" หรือ "ร้านรองเท้าใกล้ถนน Robson" คุณสามารถแนบ SearchBox กับช่องข้อความได้ และเมื่อป้อนข้อความ บริการจะแสดงการคาดการณ์ในรูปแบบรายการตัวเลือกแบบเลื่อนลง

SearchBox แสดงรายการการคาดคะเนเพิ่มเติม ซึ่งอาจรวมถึงสถานที่ (ตามที่ Places API กำหนด) บวกกับข้อความค้นหาที่แนะนำ เช่น หากผู้ใช้ป้อน "pizza in new" รายการตัวเลือกอาจประกอบด้วยวลี "pizza in New York, NY" รวมถึงชื่อร้านพิซซ่าต่างๆ เมื่อผู้ใช้เลือกสถานที่จากรายการ ระบบจะแสดงข้อมูลเกี่ยวกับสถานที่นั้นไปยังออบเจ็กต์ 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);
});

ดูตัวอย่าง

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

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

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

AutocompleteService แสดงเมธอดต่อไปนี้

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

ทั้ง 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>

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

การเพิ่มประสิทธิภาพ Place Autocomplete

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

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

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

แนวทางปฏิบัติแนะนำในการใช้ต้นทุนให้เกิดประโยชน์สูงสุด

การใช้ต้นทุนให้เกิดประโยชน์สูงสุดขั้นพื้นฐาน

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

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

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

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

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

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

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

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

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

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

ไม่ ต้องใช้เฉพาะที่อยู่และตำแหน่ง

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

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

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

ใช่

ใช้ Place Autocomplete แบบเป็นโปรแกรมโดยไม่ต้องใช้โทเค็นเซสชัน และเรียกใช้ Geocoding API ในการคาดคะเนสถานที่ที่เลือก
Geocoding API จะแสดงที่อยู่และพิกัดละติจูด/ลองจิจูดในราคา $0.005 ต่อคำขอ การส่งคําขอ Place Autocomplete - ต่อคําขอ 4 รายการมีค่าใช้จ่าย $0.01132 ดังนั้นต้นทุนทั้งหมดของคําขอ 4 รายการบวกการเรียกใช้ Geocoding API เกี่ยวกับการคาดคะเนสถานที่ที่เลือกจะเป็น $0.01632 ซึ่งน้อยกว่าราคาของฟีเจอร์ Autocomplete ต่อเซสชันที่ $0.017 ต่อเซสชัน1

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

ไม่ได้

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

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

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

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

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

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

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


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

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

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

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

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

โควต้า

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

นโยบาย

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