สำหรับเอกสารรุ่นที่เสถียร โปรดใช้รายการแบบเลื่อนลง "เอกสารที่มีเวอร์ชัน" มุมมองเริ่มต้นจะแสดงเวอร์ชันล่าสุดที่ HEAD

หน้านี้ได้รับการแปลโดย Cloud Translation API

ฟังก์ชัน

เนื้อหา

แพ็กเกจ
package_group
exports_files
glob
เลือก
แพ็กเกจย่อย

พัสดุ

package(default_deprecation, default_package_metadata, default_testonly, default_visibility, features)

ฟังก์ชันนี้ประกาศข้อมูลเมตาที่ใช้กับทุกกฎในแพ็กเกจ โดยมีการใช้มากที่สุด 1 ครั้งภายในแพ็กเกจ (ไฟล์ BUILD)

สำหรับสำเนาที่ประกาศข้อมูลเมตาที่ใช้กับทุกกฎในที่เก็บทั้งหมด ให้ใช้ฟังก์ชัน repo() ในไฟล์ REPO.bazel ที่รูทของที่เก็บ ฟังก์ชัน repo() จะใช้อาร์กิวเมนต์เดียวกันกับ package()

ควรเรียกฟังก์ชัน package() ตามหลังคำสั่งload() ทั้งหมดที่ด้านบนของไฟล์ก่อนกฎใดๆ

อาร์กิวเมนต์

แอตทริบิวต์	คำอธิบาย
`default_applicable_licenses`	ชื่อแทนของ `default_package_metadata`
`default_visibility`	รายการป้ายกำกับ ค่าเริ่มต้นคือ `[]` ระดับการเข้าถึงเริ่มต้นของกฎในแพ็กเกจนี้ กฎทุกกฎในแพ็กเกจนี้มีระดับการเข้าถึงที่ระบุในแอตทริบิวต์นี้ เว้นแต่จะระบุไว้เป็นอย่างอื่นในแอตทริบิวต์ `visibility` ของกฎ อ่านข้อมูลโดยละเอียดเกี่ยวกับไวยากรณ์ของแอตทริบิวต์นี้ได้ในเอกสารประกอบเกี่ยวกับระดับการเข้าถึง ระดับการเข้าถึงเริ่มต้นของแพ็กเกจจะไม่มีผลกับ exports_files ซึ่งเป็นสถานะสาธารณะโดยค่าเริ่มต้น
`default_deprecation`	สตริง ค่าเริ่มต้นคือ `""` ตั้งค่าข้อความ `deprecation` เริ่มต้นสำหรับกฎทั้งหมดในแพ็กเกจนี้
`default_package_metadata`	รายการป้ายกำกับ ค่าเริ่มต้นคือ `[]` ตั้งค่ารายการเริ่มต้นของเป้าหมายข้อมูลเมตาที่ใช้กับเป้าหมายอื่นๆ ทั้งหมดในแพ็กเกจ ซึ่งโดยปกติแล้วจะเป็นเป้าหมายที่เกี่ยวข้องกับการประกาศแพ็กเกจและใบอนุญาต OSS ลองดูตัวอย่างใน rules_license
`default_testonly`	บูลีน ค่าเริ่มต้นคือ `False` ยกเว้นที่ระบุไว้ ตั้งค่าพร็อพเพอร์ตี้ `testonly` เริ่มต้นสำหรับกฎทั้งหมดในแพ็กเกจนี้ ในแพ็กเกจที่ราคาต่ำกว่า `javatests` ค่าเริ่มต้นคือ `True`
`features`	รายการสตริง ค่าเริ่มต้นคือ `[]` ตั้งค่าการทำเครื่องหมายต่างๆ ที่มีผลต่อความหมายของไฟล์ BUILD นี้ โดยส่วนใหญ่แล้วผู้ที่ใช้งานระบบบิลด์จะใช้ฟีเจอร์นี้เพื่อติดแท็กแพ็กเกจที่ต้องมีการจัดการพิเศษบางประเภท โปรดอย่าใช้ตัวเลือกนี้ เว้นแต่จะขออย่างชัดแจ้งจากคนที่ทำงานในระบบบิลด์

ตัวอย่าง

การประกาศด้านล่างเป็นการประกาศว่าเฉพาะสมาชิกของกลุ่มแพ็กเกจ //foo:target เท่านั้นที่จะเห็นกฎในแพ็กเกจนี้ การประกาศระดับการเข้าถึงแต่ละรายการในกฎหนึ่งๆ (หากมี) จะลบล้างข้อกำหนดนี้

package(default_visibility = ["//foo:target"])

package_group

package_group(name, packages, includes)

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

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

ระบบจะถือว่าแพ็กเกจหนึ่งๆ อยู่ในกลุ่มหากตรงกับแอตทริบิวต์ packages หรือรวมอยู่ในกลุ่มแพ็กเกจอื่นๆ ที่กล่าวถึงในแอตทริบิวต์ includes อยู่แล้ว

ในทางเทคนิค กลุ่มแพ็กเกจเป็นกลุ่มเป้าหมายในทางเทคนิค แต่ไม่ได้สร้างโดยกฎ และไม่มีการป้องกันการมองเห็นในตัวเอง

อาร์กิวเมนต์

แอตทริบิวต์ คำอธิบาย

แอตทริบิวต์	คำอธิบาย
`name`	ต้องระบุชื่อ ชื่อที่ไม่ซ้ำกันของเป้าหมายนี้
`packages`	รายการสตริง ค่าเริ่มต้นคือ `[]` รายการข้อกำหนดของแพ็กเกจที่เป็นศูนย์ขึ้นไป สตริงข้อกำหนดแพ็กเกจแต่ละรายการมีรูปแบบใดรูปแบบหนึ่งต่อไปนี้ได้ ชื่อเต็มของแพ็กเกจที่ไม่มีที่เก็บ ซึ่งขึ้นต้นด้วยเครื่องหมายทับคู่ เช่น `//foo/bar` จะระบุแพ็กเกจที่มีชื่อดังกล่าวและอยู่ในที่เก็บเดียวกันกับกลุ่มแพ็กเกจ เหมือนกับด้านบน แต่ต่อท้ายด้วย `/...` เช่น `//foo/...` ระบุชุดของ `//foo` และแพ็กเกจย่อยทั้งหมด `//...` ระบุแพ็กเกจทั้งหมดในที่เก็บปัจจุบัน สตริง `public` หรือ `private` ซึ่งระบุแพ็กเกจทั้งหมดหรือไม่มีแพ็กเกจตามลำดับ (แบบฟอร์มนี้จำเป็นต้องมีการตั้งค่าแฟล็ก `--incompatible_package_group_has_public_syntax`) นอกจากนี้ ข้อกำหนดเฉพาะของแพ็กเกจ 2 ประเภทแรกอาจมี `-` นำหน้าด้วยเพื่อระบุว่ามีการปฏิเสธ กลุ่มแพ็กเกจมีแพ็กเกจที่ตรงกับข้อกำหนดเชิงบวกอย่างน้อย 1 รายการและไม่มีข้อกำหนดเชิงลบ เช่น ค่า `[//foo/..., -//foo/tests/...]` มีแพ็กเกจย่อยทั้งหมดของ `//foo` ที่ไม่ใช่แพ็กเกจย่อยของ `//foo/tests` (`//foo` เองก็รวมอยู่ แต่ //foo/tests เองไม่ได้รวมอยู่) นอกเหนือจากระดับการเข้าถึงแบบสาธารณะแล้ว ไม่มีวิธีระบุแพ็กเกจโดยตรงนอกที่เก็บปัจจุบัน หากไม่มีแอตทริบิวต์นี้ ก็เหมือนกับการตั้งค่าเป็นรายการที่ว่างเปล่า ซึ่งเหมือนกับการตั้งค่าเป็นรายการที่มี `private` เท่านั้น หมายเหตุ: ก่อน Bazel 6.0 ข้อกำหนด `//...` มีลักษณะการทำงานเดิมเหมือนกับ `public` ลักษณะการทำงานนี้จะแก้ไขเมื่อเปิดใช้ `--incompatible_fix_package_group_reporoot_syntax` ซึ่งเป็นค่าเริ่มต้นหลังจาก Bazel 6.0 หมายเหตุ: ก่อน Bazel 6.0 เมื่อแอตทริบิวต์นี้เป็นแบบอนุกรมโดยเป็นส่วนหนึ่งของ `bazel query --output=proto` (หรือ `--output=xml`) ระบบจะไม่ใส่เครื่องหมายทับนำหน้า ตัวอย่างเช่น `//pkg/foo/...` จะแสดงผลเป็น `\"pkg/foo/...\"` ลักษณะการทำงานนี้จะแก้ไขเมื่อเปิดใช้ `--incompatible_package_group_includes_double_slash` ซึ่งเป็นค่าเริ่มต้นหลังจาก Bazel 6.0
`includes`	รายการป้ายกำกับ ค่าเริ่มต้นคือ `[]` กลุ่มแพ็กเกจอื่นๆ ที่รวมอยู่ในกลุ่มนี้ ป้ายกำกับในแอตทริบิวต์นี้ต้องอ้างอิงถึงกลุ่มแพ็กเกจอื่นๆ ระบบจะย้ายแพ็กเกจในกลุ่มแพ็กเกจที่อ้างอิงเป็นส่วนหนึ่งของกลุ่มแพ็กเกจนี้ เงื่อนไขนี้จะเปลี่ยนแปลง หากกลุ่มแพ็กเกจ `a` มีกลุ่มแพ็กเกจ `b` และ `b` มีกลุ่มแพ็กเกจ `c` แพ็กเกจทุกรายการใน `c` จะเป็นสมาชิกของ `a` ด้วย เมื่อใช้ร่วมกับข้อกำหนดของแพ็กเกจที่ลบล้าง ระบบจะคำนวณชุดแพ็กเกจสำหรับแต่ละกลุ่มแยกกันก่อน และผลลัพธ์ที่ได้จะรวมกัน ซึ่งหมายความว่าข้อกำหนดที่ลบล้างในกลุ่มหนึ่งจะไม่มีผลกับข้อกำหนดเฉพาะในอีกกลุ่มหนึ่ง

name

ต้องระบุชื่อ

ชื่อที่ไม่ซ้ำกันของเป้าหมายนี้

packages

รายการสตริง ค่าเริ่มต้นคือ []

รายการข้อกำหนดของแพ็กเกจที่เป็นศูนย์ขึ้นไป

สตริงข้อกำหนดแพ็กเกจแต่ละรายการมีรูปแบบใดรูปแบบหนึ่งต่อไปนี้ได้

ชื่อเต็มของแพ็กเกจที่ไม่มีที่เก็บ ซึ่งขึ้นต้นด้วยเครื่องหมายทับคู่ เช่น //foo/bar จะระบุแพ็กเกจที่มีชื่อดังกล่าวและอยู่ในที่เก็บเดียวกันกับกลุ่มแพ็กเกจ
เหมือนกับด้านบน แต่ต่อท้ายด้วย /... เช่น //foo/... ระบุชุดของ //foo และแพ็กเกจย่อยทั้งหมด //... ระบุแพ็กเกจทั้งหมดในที่เก็บปัจจุบัน
สตริง public หรือ private ซึ่งระบุแพ็กเกจทั้งหมดหรือไม่มีแพ็กเกจตามลำดับ (แบบฟอร์มนี้จำเป็นต้องมีการตั้งค่าแฟล็ก --incompatible_package_group_has_public_syntax)

นอกจากนี้ ข้อกำหนดเฉพาะของแพ็กเกจ 2 ประเภทแรกอาจมี - นำหน้าด้วยเพื่อระบุว่ามีการปฏิเสธ

กลุ่มแพ็กเกจมีแพ็กเกจที่ตรงกับข้อกำหนดเชิงบวกอย่างน้อย 1 รายการและไม่มีข้อกำหนดเชิงลบ เช่น ค่า [//foo/..., -//foo/tests/...] มีแพ็กเกจย่อยทั้งหมดของ //foo ที่ไม่ใช่แพ็กเกจย่อยของ //foo/tests (//foo เองก็รวมอยู่ แต่ //foo/tests เองไม่ได้รวมอยู่)

นอกเหนือจากระดับการเข้าถึงแบบสาธารณะแล้ว ไม่มีวิธีระบุแพ็กเกจโดยตรงนอกที่เก็บปัจจุบัน

หากไม่มีแอตทริบิวต์นี้ ก็เหมือนกับการตั้งค่าเป็นรายการที่ว่างเปล่า ซึ่งเหมือนกับการตั้งค่าเป็นรายการที่มี private เท่านั้น

หมายเหตุ: ก่อน Bazel 6.0 ข้อกำหนด //... มีลักษณะการทำงานเดิมเหมือนกับ public ลักษณะการทำงานนี้จะแก้ไขเมื่อเปิดใช้ --incompatible_fix_package_group_reporoot_syntax ซึ่งเป็นค่าเริ่มต้นหลังจาก Bazel 6.0

หมายเหตุ: ก่อน Bazel 6.0 เมื่อแอตทริบิวต์นี้เป็นแบบอนุกรมโดยเป็นส่วนหนึ่งของ bazel query --output=proto (หรือ --output=xml) ระบบจะไม่ใส่เครื่องหมายทับนำหน้า ตัวอย่างเช่น //pkg/foo/... จะแสดงผลเป็น \"pkg/foo/...\" ลักษณะการทำงานนี้จะแก้ไขเมื่อเปิดใช้ --incompatible_package_group_includes_double_slash ซึ่งเป็นค่าเริ่มต้นหลังจาก Bazel 6.0

includes

รายการป้ายกำกับ ค่าเริ่มต้นคือ []

กลุ่มแพ็กเกจอื่นๆ ที่รวมอยู่ในกลุ่มนี้

ป้ายกำกับในแอตทริบิวต์นี้ต้องอ้างอิงถึงกลุ่มแพ็กเกจอื่นๆ ระบบจะย้ายแพ็กเกจในกลุ่มแพ็กเกจที่อ้างอิงเป็นส่วนหนึ่งของกลุ่มแพ็กเกจนี้ เงื่อนไขนี้จะเปลี่ยนแปลง หากกลุ่มแพ็กเกจ a มีกลุ่มแพ็กเกจ b และ b มีกลุ่มแพ็กเกจ c แพ็กเกจทุกรายการใน c จะเป็นสมาชิกของ a ด้วย

เมื่อใช้ร่วมกับข้อกำหนดของแพ็กเกจที่ลบล้าง ระบบจะคำนวณชุดแพ็กเกจสำหรับแต่ละกลุ่มแยกกันก่อน และผลลัพธ์ที่ได้จะรวมกัน ซึ่งหมายความว่าข้อกำหนดที่ลบล้างในกลุ่มหนึ่งจะไม่มีผลกับข้อกำหนดเฉพาะในอีกกลุ่มหนึ่ง

ตัวอย่าง

การประกาศ package_group ต่อไปนี้ระบุกลุ่มแพ็กเกจที่เรียกว่า "เขตร้อน" ที่มีผลไม้เขตร้อน

package_group(
    name = "tropical",
    packages = [
        "//fruits/mango",
        "//fruits/orange",
        "//fruits/papaya/...",
    ],
)

ประกาศต่อไปนี้ระบุกลุ่มแพ็กเกจของแอปพลิเคชันสมมติ

package_group(
    name = "fooapp",
    includes = [
        ":controller",
        ":model",
        ":view",
    ],
)

package_group(
    name = "model",
    packages = ["//fooapp/database"],
)

package_group(
    name = "view",
    packages = [
        "//fooapp/swingui",
        "//fooapp/webui",
    ],
)

package_group(
    name = "controller",
    packages = ["//fooapp/algorithm"],
)

exports_files

exports_files([label, ...], visibility, licenses)

exports_files() ระบุรายการไฟล์ที่เป็นของแพ็กเกจนี้ที่ส่งออกไปยังแพ็กเกจอื่นๆ

ไฟล์ BUILD สำหรับแพ็กเกจอาจอ้างถึงไฟล์ต้นฉบับที่เป็นของแพ็กเกจอื่นโดยตรงเท่านั้น หากไฟล์เหล่านั้นส่งออกมาอย่างชัดเจนด้วยคำสั่ง exports_files() อ่านข้อมูลเพิ่มเติมเกี่ยวกับการเปิดเผยไฟล์

ตามลักษณะการทำงานเดิม ไฟล์ที่ระบุเป็นอินพุตไปยังกฎจะถูกส่งออกด้วยระดับการเข้าถึงเริ่มต้นจนกว่าจะมีการพลิกแฟล็ก --incompatible_no_implicit_file_export อย่างไรก็ตาม คุณไม่ควรยึดถือการทำงานนี้และย้ายข้อมูลออกจากกันอย่างต่อเนื่อง

อาร์กิวเมนต์

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

ตัวอย่าง

ตัวอย่างต่อไปนี้ส่งออก golden.txt ซึ่งเป็นไฟล์ข้อความจากแพ็กเกจ test_data เพื่อให้แพ็กเกจอื่นๆ นำไปใช้ได้ เช่น ในแอตทริบิวต์ data ของการทดสอบ

# from //test_data/BUILD

exports_files(["golden.txt"])

Glob

glob(include, exclude=[], exclude_directories=1, allow_empty=True)

Glob เป็นฟังก์ชันตัวช่วยซึ่งจะค้นหาไฟล์ทั้งหมดที่ตรงกับรูปแบบเส้นทางหนึ่งๆ และแสดงผลรายการเส้นทางของเส้นทางทั้งหมดที่เปลี่ยนแปลงและจัดเรียงตามเส้นทางใหม่ได้ Glob จะค้นหาเฉพาะไฟล์ในแพ็กเกจของตัวเองและดูเฉพาะไฟล์แหล่งที่มา (ไม่ใช่ไฟล์ที่สร้างขึ้นหรือเป้าหมายอื่นๆ)

ป้ายกำกับของไฟล์ต้นฉบับจะรวมอยู่ในผลลัพธ์หากเส้นทางที่สัมพันธ์กับแพ็กเกจของไฟล์ตรงกับรูปแบบ include ใดๆ และไม่มีรูปแบบ exclude เลย

รายการ include และ exclude มีรูปแบบเส้นทาง ที่สัมพันธ์กับแพ็กเกจปัจจุบัน ทุกรูปแบบอาจประกอบด้วยกลุ่มเส้นทางอย่างน้อย 1 กลุ่ม และเช่นเคยสำหรับเส้นทาง Unix กลุ่มเหล่านี้จะคั่นด้วย / กลุ่มในรูปแบบนี้จะถูกจับคู่กับส่วนของเส้นทาง กลุ่มอาจมีไวลด์การ์ด * ซึ่งจะตรงกับสตริงย่อยในกลุ่มเส้นทาง (แม้สตริงย่อยที่ว่างเปล่า) โดยไม่รวมตัวคั่นไดเรกทอรี / ไวลด์การ์ดนี้จะใช้ได้หลายครั้ง ภายในกลุ่มเส้นทางเดียว นอกจากนี้ ไวลด์การ์ด ** จะจับคู่กับกลุ่มเส้นทางที่สมบูรณ์ตั้งแต่ 0 กลุ่มขึ้นไปได้ แต่ต้องประกาศเป็นกลุ่มเส้นทางแบบสแตนด์อโลน

ตัวอย่างเช่น

foo/bar.txt ตรงกับไฟล์ foo/bar.txt ในแพ็กเกจนี้ทุกประการ (เว้นแต่ว่า foo/ จะเป็นแพ็กเกจย่อย)
foo/*.txt จะตรงกับทุกไฟล์ในไดเรกทอรี foo/ หากไฟล์ลงท้ายด้วย .txt (เว้นแต่ว่า foo/ จะเป็นแพ็กเกจย่อย)
foo/a*.htm* จะจับคู่ทุกไฟล์ในไดเรกทอรี foo/ ที่ขึ้นต้นด้วย a และมีสตริงที่กำหนดเอง (อาจว่างเปล่า) และมี .htm และสิ้นสุดด้วยสตริงที่กำหนดเองอื่น (เว้นแต่ว่า foo/ เป็นแพ็กเกจย่อย) เช่น foo/axx.htm และ foo/a.html หรือ foo/axxx.html
foo/* ตรงกับทุกไฟล์ในไดเรกทอรี foo/ (เว้นแต่ว่า foo/ จะเป็นแพ็กเกจย่อย) ซึ่งจะไม่ตรงกับไดเรกทอรี foo เลยแม้ว่าจะตั้งค่า exclude_directories เป็น 0 ก็ตาม
foo/** ตรงกับทุกไฟล์ในทุกไดเรกทอรีย่อยที่ไม่ใช่แพ็กเกจย่อยภายใต้ไดเรกทอรีย่อยระดับแรกของแพ็กเกจ foo/ หากตั้งค่า exclude_directories เป็น 0 ตัวไดเรกทอรี foo เองก็ตรงกับรูปแบบด้วย ในกรณีนี้ ** จะถือว่าตรงกับกลุ่มเส้นทางที่เป็น 0
**/a.txt ตรงกับ a.txt ไฟล์ในไดเรกทอรีของแพ็กเกจนี้บวกกับไดเรกทอรีย่อยที่ไม่ใช่แพ็กเกจย่อย
**/bar/**/*.txt ตรงกับไฟล์ .txt ทุกไฟล์ในทุกไดเรกทอรีย่อยที่ไม่ใช่แพ็กเกจย่อยของแพ็กเกจนี้ หากไดเรกทอรีอย่างน้อย 1 รายการบนเส้นทางผลลัพธ์มีชื่อว่า bar เช่น xxx/bar/yyy/zzz/a.txt หรือ bar/a.txt (อย่าลืมว่า ** ตรงกับ 0 กลุ่มด้วย) หรือ bar/zzz/a.txt
** ตรงกับทุกไฟล์ในไดเรกทอรีย่อยที่ไม่ใช่แพ็กเกจย่อยทั้งหมดของแพ็กเกจนี้
foo**/a.txt เป็นรูปแบบที่ไม่ถูกต้อง เนื่องจาก ** ต้องแสดงเดี่ยวๆ เป็นกลุ่ม
foo/ เป็นรูปแบบที่ไม่ถูกต้อง เนื่องจากกลุ่มที่ 2 ที่กำหนดไว้หลังจาก / เป็นสตริงว่างเปล่า

หากเปิดใช้อาร์กิวเมนต์ exclude_directories (ตั้งค่าเป็น 1) ไฟล์ของไดเรกทอรีประเภทจะไม่แสดงในผลลัพธ์ (ค่าเริ่มต้น 1)

หากตั้งค่าอาร์กิวเมนต์ allow_empty เป็น False ฟังก์ชัน glob จะแสดงข้อผิดพลาดหากผลลัพธ์เป็นรายการที่ว่างเปล่า

โดยมีข้อจำกัดและคำเตือนที่สำคัญหลายประการดังนี้

เนื่องจาก glob() ทำงานระหว่างการประเมินไฟล์ BUILD ดังนั้น glob() จึงจะจับคู่ไฟล์เฉพาะในโครงสร้างแหล่งที่มา และจะไม่มีการสร้างไฟล์ หากคุณกำลังสร้างเป้าหมายที่ต้องใช้ทั้งไฟล์ต้นฉบับและไฟล์ที่สร้างขึ้น คุณต้องต่อท้ายรายการไฟล์ที่สร้างขึ้นอย่างชัดเจนใน glob ดูตัวอย่างด้านล่างที่มี :mylib และ :gen_java_srcs
หากกฎมีชื่อเหมือนกับไฟล์ต้นฉบับที่ตรงกัน กฎนั้นจะ "เงา" กับไฟล์

โปรดทราบว่า glob() จะแสดงผลรายการเส้นทาง ดังนั้นการใช้ glob() ในแอตทริบิวต์ของกฎอื่นๆ (เช่น srcs = glob(["*.cc"])) จะมีผลเหมือนกับการแสดงเส้นทางที่ตรงกันอย่างชัดเจน เช่น glob() ให้ผลที่ได้ ["Foo.java", "bar/Baz.java"] แต่มีกฎในแพ็กเกจชื่อ "Foo.java" ด้วย (ซึ่ง Bazel จะเตือน) ผู้บริโภคของ glob() จะใช้กฎ "Foo.java" (เอาต์พุต) แทนไฟล์ "Foo.java" ดูรายละเอียดเพิ่มเติมได้ที่ปัญหาของ GitHub #10395
GlOB อาจตรงกับไฟล์ในไดเรกทอรีย่อย และชื่อไดเรกทอรีย่อยอาจใช้ไวลด์การ์ดได้ อย่างไรก็ตาม...
ไม่อนุญาตให้ป้ายกำกับข้ามขอบเขตของแพ็กเกจและ glob ไม่ตรงกับไฟล์ในแพ็กเกจย่อย

เช่น นิพจน์ glob **/*.cc ในแพ็กเกจ x จะไม่รวม x/y/z.cc หากมี x/y เป็นแพ็กเกจ (เป็น x/y/BUILD หรือที่อื่นในเส้นทางแพ็กเกจ) ซึ่งหมายความว่าผลลัพธ์ของนิพจน์ glob นั้นจะขึ้นอยู่กับการมีอยู่ของไฟล์ BUILD กล่าวคือ นิพจน์ glob เดียวกันจะรวม x/y/z.cc หากไม่มีแพ็กเกจที่เรียกว่า x/y หรือมีการทำเครื่องหมายว่าลบแล้วโดยใช้แฟล็ก --deleted_packages
ข้อจำกัดข้างต้นจะมีผลกับนิพจน์ glob ทั้งหมด ไม่ว่าจะใช้ไวลด์การ์ดใด
ไฟล์ที่ซ่อนอยู่ซึ่งมีชื่อไฟล์ขึ้นต้นด้วย . จะได้รับการจับคู่อย่างสมบูรณ์โดยทั้งไวลด์การ์ด ** และไวลด์การ์ด * หากต้องการจับคู่ไฟล์ที่ซ่อนอยู่กับรูปแบบแบบผสม รูปแบบของคุณจะต้องขึ้นต้นด้วย . ตัวอย่างเช่น * และ .*.txt จะตรงกับ .foo.txt แต่ *.txt จะไม่จับคู่ ไดเรกทอรีที่ซ่อนจะมีการจับคู่ในลักษณะเดียวกัน ไดเรกทอรีที่ซ่อนอาจรวมถึงไฟล์ที่ไม่จำเป็นต้องใช้เป็นอินพุต และอาจเพิ่มจำนวนไฟล์ที่ไม่มีความจำเป็นและใช้หน่วยความจำโดยไม่จำเป็นได้ หากต้องการยกเว้นไดเรกทอรีที่ซ่อน ให้เพิ่มไดเรกทอรีเหล่านั้นลงในอาร์กิวเมนต์รายการ "exclude"
ไวลด์การ์ด "**" มีตัวพิมพ์บริเวณมุม 1 ตัว: รูปแบบ "**" ไม่ตรงกับเส้นทางไดเรกทอรีของแพ็กเกจ ซึ่งหมายความว่า glob(["**"], exclude_directories = 0) จะจับคู่ไฟล์และไดเรกทอรีทั้งหมดภายใต้ไดเรกทอรีของแพ็กเกจปัจจุบันอย่างเคร่งครัด (แต่แน่นอนว่าจะไม่อยู่ในไดเรกทอรีของแพ็กเกจย่อย โปรดดูหมายเหตุก่อนหน้าเกี่ยวกับเรื่องนี้)

โดยทั่วไป คุณควรพยายามระบุส่วนขยายที่เหมาะสม (เช่น *.html) แทนที่จะใช้เครื่องหมาย "*" เปล่าสำหรับรูปแบบ glob ชื่อที่ชัดเจนกว่าคือการบันทึกข้อมูลด้วยตนเองและป้องกันไม่ให้จับคู่ไฟล์สำรองหรือไฟล์ emacs/vi/... ที่บันทึกอัตโนมัติโดยไม่ตั้งใจ

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

ตัวอย่าง Glob

สร้างไลบรารี Java ที่สร้างจากไฟล์ Java ทั้งหมดในไดเรกทอรีนี้ และไฟล์ทั้งหมดที่สร้างโดยกฎ :gen_java_srcs

java_library(
    name = "mylib",
    srcs = glob(["*.java"]) + [":gen_java_srcs"],
    deps = "...",
)

genrule(
    name = "gen_java_srcs",
    outs = [
        "Foo.java",
        "Bar.java",
    ],
    ...
)

รวมไฟล์ txt ทั้งหมดไว้ในไดเรกทอรี testdata ยกเว้น experiment.txt โปรดทราบว่าจะไม่รวมไฟล์ในไดเรกทอรีย่อยของข้อมูลทดสอบ หากต้องการรวมไฟล์เหล่านั้นไว้ ให้ใช้ glob แบบทำซ้ำ (**)

sh_test(
    name = "mytest",
    srcs = ["mytest.sh"],
    data = glob(
        ["testdata/*.txt"],
        exclude = ["testdata/experimental.txt"],
    ),
)

ตัวอย่าง Glob ที่เวียนเกิด

ทำให้การทดสอบขึ้นอยู่กับไฟล์ txt ทั้งหมดในไดเรกทอรี testdata และไดเรกทอรีย่อย (และไดเรกทอรีย่อย และอื่นๆ) ระบบจะละเว้นไดเรกทอรีย่อยที่มีไฟล์ BUILD (ดูข้อจำกัดและคำเตือนด้านบน)

sh_test(
    name = "mytest",
    srcs = ["mytest.sh"],
    data = glob(["testdata/**/*.txt"]),
)

สร้างไลบรารีที่สร้างจากไฟล์ Java ทั้งหมดในไดเรกทอรีนี้และไดเรกทอรีย่อยทั้งหมด ยกเว้นรายการซึ่งมีเส้นทางที่ประกอบด้วยไดเรกทอรีที่ชื่อว่า Testing หากเป็นไปได้ ควรหลีกเลี่ยงการใช้รูปแบบนี้ เนื่องจากจะลดความเพิ่มขึ้นของบิลด์และทำให้ใช้เวลาในการสร้างนานขึ้นได้

java_library(
    name = "mylib",
    srcs = glob(
        ["**/*.java"],
        exclude = ["**/testing/**"],
    ),
)

ตัวอย่าง Glob ที่ขยาย

สร้าง GenRule แยกสำหรับ *_test.cc ในไดเรกทอรีปัจจุบัน ซึ่งนับจำนวนบรรทัดในไฟล์

# Conveniently, the build language supports list comprehensions.
[genrule(
    name = "count_lines_" + f[:-3],  # strip ".cc"
    srcs = [f],
    outs = ["%s-linecount.txt" % f[:-3]],
    cmd = "wc -l $< >$@",
 ) for f in glob(["*_test.cc"])]

หากไฟล์ BUILD ด้านบนอยู่ในแพ็กเกจ //foo และแพ็กเกจมีไฟล์ที่ตรงกัน 3 ไฟล์ ซึ่งได้แก่ a_test.cc, b_test.cc และ c_test.cc การเรียกใช้ bazel query '//foo:all' จะแสดงรายการกฎทั้งหมดที่สร้างขึ้น ดังนี้

$ bazel query '//foo:all' | sort
//foo:count_lines_a_test
//foo:count_lines_b_test
//foo:count_lines_c_test

เลือก

select(
    {conditionA: valuesA, conditionB: valuesB, ...},
    no_match_error = "custom message"
)

select() เป็นฟังก์ชันตัวช่วยที่ทำให้แอตทริบิวต์ของกฎกำหนดค่าได้ โดยสามารถแทนที่ด้านขวามือของ เกือบ การระบุแอตทริบิวต์ เพื่อให้ค่าดังกล่าวขึ้นอยู่กับแฟล็ก Bazel ในบรรทัดคำสั่ง เช่น คุณอาจใช้ตัวเลือกนี้เพื่อกำหนดทรัพยากร Dependency เฉพาะแพลตฟอร์มหรือเพื่อฝังทรัพยากรที่แตกต่างกัน โดยขึ้นอยู่กับว่ากฎสร้างขึ้นในโหมด "นักพัฒนาซอฟต์แวร์" กับโหมด "เผยแพร่"

การใช้งานเบื้องต้นมีดังนี้

sh_binary(
    name = "mytarget",
    srcs = select({
        ":conditionA": ["mytarget_a.sh"],
        ":conditionB": ["mytarget_b.sh"],
        "//conditions:default": ["mytarget_default.sh"]
    })
)

ซึ่งจะทำให้แอตทริบิวต์ srcs ของ sh_binary กำหนดค่าได้โดยแทนที่การกำหนดรายการป้ายกำกับปกติด้วยการเรียก select ที่แมปเงื่อนไขการกำหนดค่ากับค่าที่ตรงกัน เงื่อนไขแต่ละรายการคือการอ้างอิงป้ายกำกับไปยัง config_setting หรือ constraint_value ซึ่งจะ "ตรงกัน" หากการกำหนดค่าของเป้าหมายตรงกับชุดค่าที่คาดไว้ จากนั้นค่าของ mytarget#srcs จะกลายเป็นรายการป้ายกำกับใดก็ได้ที่ตรงกับการเรียกใช้ปัจจุบัน

หมายเหตุ

มีการเลือกเงื่อนไขเดียวเท่านั้นในการเรียกใช้
หากเงื่อนไขหลายรายการตรงกับเงื่อนไขและข้อหนึ่งเป็นความเชี่ยวชาญพิเศษของเงื่อนไขอื่นๆ ความเชี่ยวชาญพิเศษดังกล่าวจะมีผลเหนือกว่า เงื่อนไข B ถือเป็นความเชี่ยวชาญพิเศษของเงื่อนไข A หาก B มีแฟล็กและค่าข้อจํากัดเหมือนกันทั้งหมดกับ A รวมถึงแฟล็กหรือค่าข้อจํากัดเพิ่มเติมบางรายการ และยังหมายความว่าการแก้ปัญหาความเชี่ยวชาญพิเศษไม่ได้ออกแบบมาเพื่อสร้างลำดับดังที่แสดงในตัวอย่างที่ 2 ด้านล่าง
หากเงื่อนไขหลายรายการตรงกับเงื่อนไขหนึ่งและข้อหนึ่งไม่ใช่ความเชี่ยวชาญพิเศษของเงื่อนไขอื่นๆ ทั้งหมด Bazel จะไม่สำเร็จและมีข้อผิดพลาด เว้นแต่เงื่อนไขทั้งหมดจะเปลี่ยนเป็นค่าเดียวกัน
ระบบจะถือว่าป้ายกำกับเทียมพิเศษ //conditions:default ตรงกันหากไม่มีเงื่อนไขอื่นๆ ตรงกัน หากไม่มีเงื่อนไขนี้ กฎอื่นๆ จะต้องตรงกันเพื่อหลีกเลี่ยงข้อผิดพลาด
คุณฝัง select ไว้ภายในการกําหนดแอตทริบิวต์ที่ใหญ่กว่าได้ ดังนั้น srcs = ["common.sh"] + select({ ":conditionA": ["myrule_a.sh"], ...}) และ srcs = select({ ":conditionA": ["a.sh"]}) + select({ ":conditionB": ["b.sh"]}) เป็นนิพจน์ที่ถูกต้อง
select ใช้ได้กับแอตทริบิวต์ส่วนใหญ่ แต่ไม่ใช่ทั้งหมด แอตทริบิวต์ที่ใช้ร่วมกันไม่ได้จะมีเครื่องหมาย nonconfigurable อยู่ในเอกสารประกอบ
แพ็กเกจย่อย
```
subpackages(include, exclude=[], allow_empty=True)
```
subpackages() เป็นฟังก์ชันตัวช่วย ซึ่งคล้ายกับ glob() ที่แสดงแพ็กเกจย่อยแทนไฟล์และไดเรกทอรี โดยจะใช้รูปแบบเส้นทางเดียวกันกับ glob() และจับคู่แพ็กเกจย่อยทั้งหมดที่เป็นรายการสืบทอดโดยตรงของไฟล์ BUILD ที่กำลังโหลดอยู่ได้ ดู glob เพื่อดูคำอธิบายโดยละเอียดและตัวอย่างของรูปแบบการรวมและยกเว้น

รายการผลลัพธ์ของแพ็กเกจย่อยที่แสดงผลจะเรียงลำดับตามลําดับและมีเส้นทางที่สัมพันธ์กับแพ็กเกจการโหลดปัจจุบันที่ตรงกับรูปแบบที่ระบุใน include ไม่ใช่ใน exclude
ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงแพ็กเกจย่อยโดยตรงทั้งหมดสำหรับแพ็กเกจ foo/BUILD
```
# The following BUILD files exist:
# foo/BUILD
# foo/bar/baz/BUILD
# foo/bar/but/bad/BUILD
# foo/sub/BUILD
# foo/sub/deeper/BUILD
#
# In foo/BUILD a call to
subs1 = subpackages(include = ["**"])

# results in subs1 == ["sub", "bar/baz", "bar/but/bad"]
#
# 'sub/deeper' is not included because it is a subpackage of 'foo/sub' not of
# 'foo'

subs2 = subpackages(include = ["bar/*"])
# results in subs2 = ["bar/baz"]
#
# Since 'bar' is not a subpackage itself, this looks for any subpackages under
# all first level subdirectories of 'bar'.

subs3 = subpackages(include = ["bar/**"])
# results in subs3 = ["bar/baz", "bar/but/bad"]
#
# Since bar is not a subpackage itself, this looks for any subpackages which are
# (1) under all subdirectories of 'bar' which can be at any level, (2) not a
# subpackage of another subpackages.

subs4 = subpackages(include = ["sub"])
subs5 = subpackages(include = ["sub/*"])
subs6 = subpackages(include = ["sub/**"])
# results in subs4 and subs6 being ["sub"]
# results in subs5 = [].
#
# In subs4, expression "sub" checks whether 'foo/sub' is a package (i.e. is a
# subpackage of 'foo').
# In subs5, "sub/*" looks for subpackages under directory 'foo/sub'. Since
# 'foo/sub' is already a subpackage itself, the subdirectories will not be
# traversed anymore.
# In subs6, 'foo/sub' is a subpackage itself and matches pattern "sub/**", so it
# is returned. But the subdirectories of 'foo/sub' will not be traversed
# anymore.
```
โดยทั่วไปแล้ว เราแนะนำให้ใช้โมดูล "subpackages" ของ skylib แทนการเรียกใช้ฟังก์ชันนี้โดยตรง