ทำไมเครื่องหมายลบ '-' โดยทั่วไปจะไม่โอเวอร์โหลดในลักษณะเดียวกับเครื่องหมายบวก

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

พิจารณาตัวอย่างต่อไปนี้ใน JavaScript:

var a = "abcdefg";
var b = "efg";

a-b == NaN
// but
a+b == "abcdefgefg"

ในระยะสั้นไม่มีการดำเนินการใด ๆ ที่คล้ายกับการลบในสตริงที่ผู้คนต้องการเขียนอัลกอริทึมด้วย

+ผู้ประกอบการโดยทั่วไปหมายถึงการทำงานของสารเติมแต่งหนังสือ , ที่อยู่, การดำเนินการเชื่อมโยงกับเอกลักษณ์องค์ประกอบ:

• A + (B + C) = (A + B) + C
• A + 0 = 0 + A = A

มันสมเหตุสมผลที่จะใช้ตัวดำเนินการนี้สำหรับสิ่งต่าง ๆ เช่นการบวกจำนวนเต็มการต่อสตริงและตั้งค่าการรวมเนื่องจากพวกเขาทั้งหมดมีโครงสร้างพีชคณิตเดียวกัน:

1 + (2 + 3) == (1 + 2) + 3
1 + 0 == 0 + 1 == 1

"a" + ("b" + "c") == ("a" + "b") + "c"
"a" + "" == "" + "a" == "a"

และเราสามารถใช้มันเพื่อเขียนอัลกอริธึมที่มีประโยชน์เช่นconcatฟังก์ชั่นที่ทำงานตามลำดับของสิ่งที่ "เชื่อมต่อกัน" เช่น:

def concat(sequence):
    return sequence.reduce(+, 0)

เมื่อการลบ-เข้ามาเกี่ยวข้องคุณมักพูดถึงโครงสร้างของกลุ่มซึ่งจะเพิ่มค่าผกผัน −A สำหรับทุกองค์ประกอบ A เพื่อให้:

• A + −A = −A + A = 0

และในขณะนี้ทำให้รู้สึกถึงสิ่งต่าง ๆ เช่นการลบจำนวนเต็มและทศนิยมหรือแม้กระทั่งการตั้งค่าความแตกต่าง แต่ก็ไม่สมเหตุสมผลสำหรับสตริงและรายการ การผกผันของ"foo"คืออะไร?

มีโครงสร้างที่เรียกว่าmonoid cancellativeซึ่งไม่มี inverses แต่มีคุณสมบัติการยกเลิกดังนั้น:

• A - A = 0
• A - 0 = A
• (A + B) - B = A

นี่คือโครงสร้างที่คุณอธิบายที่"ab" - "b" == "a"แต่"ab" - "c"ไม่ได้กำหนดไว้ เป็นเพียงว่าเราไม่มีอัลกอริทึมที่มีประโยชน์มากมายที่ใช้โครงสร้างนี้ ฉันเดาว่าถ้าคุณคิดว่าการต่อข้อมูลเป็นอนุกรมแล้วการลบสามารถใช้ในการแยกวิเคราะห์ได้

เนื่องจากการต่อสตริงที่ใช้ได้สองสตริงนั้นเป็นการดำเนินการที่ถูกต้องเสมอ แต่สิ่งที่ตรงกันข้ามนั้นไม่เป็นความจริง

var a = "Hello";
var b = "World";

สิ่งที่ควรa - bอยู่ที่นี่ ไม่มีวิธีที่ดีที่จะตอบคำถามนี้เพราะคำถามนั้นไม่ถูกต้อง

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

ดังนั้นการเรียกเมธอดจึงเป็นที่ต้องการ:

public string Remove(string source, string toRemove)
public string Replace(string source, string oldValue, string newValue)

ในภาษา C # เราใช้+สำหรับการต่อสตริงเนื่องจากรูปแบบ

var result = string1 + string2 + string3;

แทน

var result = string.Concat(string1, string2, string3);

สะดวกและง่ายต่อการอ่านแม้ว่าการเรียกใช้ฟังก์ชันอาจจะ "ถูกต้อง" มากกว่าจากมุมมองเชิงความหมาย

+ผู้ประกอบการสามารถจริงๆเท่านั้นหมายถึงสิ่งหนึ่งในบริบทนี้ นี้ไม่เป็นความจริงสำหรับ-เนื่องจากความคิดของสตริงลบคลุมเครือ (สายงานReplace(source, oldValue, newValue)ด้วย""เป็นnewValueพารามิเตอร์ขจัดข้อสงสัยทั้งหมดและฟังก์ชั่นที่สามารถใช้ในการปรับเปลี่ยนสตริงไม่เพียง แต่เอาพวกเขา)

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

มีตัวดำเนินการโอเวอร์โหลดที่มีความต่อเนื่องของความหมายที่ดีกว่าตัว+ดำเนินการสำหรับการต่อข้อมูลสตริง นี่คือหมายเลขที่เพิ่มจำนวนเชิงซ้อนสองจำนวน:

public static Complex operator +(Complex c1, Complex c2) 
{
    return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}

ภาษา Groovyไม่อนุญาตให้-:

println('ABC'-'B')

ผลตอบแทน:

AC

และ:

println( 'Hello' - 'World' )

ผลตอบแทน:

Hello

และ:

println('ABABABABAB' - 'B')

ผลตอบแทน:

AABABABAB

เครื่องหมายบวกอาจมีความหมายตามบริบทในบางกรณี แต่ตัวอย่างเคาน์เตอร์ (อาจเป็นข้อยกเว้นที่พิสูจน์กฎ) ใน Python คือชุดวัตถุซึ่งมีให้-แต่ไม่+:

>>> set('abc') - set('bcd')
set(['a'])
>>> set('abc') + set('bcd')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'

มันไม่สมเหตุสมผลที่จะใช้+เครื่องหมายเพราะความตั้งใจอาจคลุมเครือ - มันหมายถึงจุดตัดหรือสหภาพ แต่ใช้|สำหรับสหภาพและ&แยก:

>>> set('abc') | set('bcd')
set(['a', 'c', 'b', 'd'])
>>> set('abc') & set('bcd')
set(['c', 'b'])

" -" ใช้ในคำประสมบางคำ (เช่น "บนเว็บไซต์") สำหรับการรวมส่วนต่าง ๆ เป็นคำเดียวกัน ทำไมเราไม่ใช้ " -" เพื่อรวมสตริงต่างๆเข้าด้วยกันในภาษาการเขียนโปรแกรม? ฉันคิดว่ามันสมเหตุสมผลดี! ตกนรกด้วย+เรื่องไร้สาระนี้!

อย่างไรก็ตามลองดูจากมุมที่เป็นนามธรรมมากกว่านี้

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

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

ตัวอย่างเช่นการเพิ่มหรือลบสองสตริงหมายความว่าอย่างไร

หากคุณเพิ่มสองสาย (ตัวอย่างเช่นให้a = "aa"และb = "bb") คุณจะได้รับaabbเป็นผลมาจากa + b?

แล้วไงb + aล่ะ นั่นจะเป็นbbaaอย่างไร ทำไมไม่aabb? จะเกิดอะไรขึ้นถ้าคุณลบออกaaจากผลการเพิ่มของคุณ สตริงของคุณจะมีแนวคิดเกี่ยวกับจำนวนลบaaหรือไม่?

ตอนนี้กลับไปที่จุดเริ่มต้นของคำตอบนี้และแทนที่spaceshuttleแทนสตริง หากต้องการพูดคุยทั่วไปเหตุใดจึงมีการกำหนดการทำงานหรือไม่ได้กำหนดไว้สำหรับประเภทใด ๆ

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

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