ทำไมโอเปอเรเตอร์ที่ได้รับมอบหมายจึงอยู่ทางซ้ายมือ

ฉันเริ่มสอนการเขียนโปรแกรมเพื่อนเมื่อเร็ว ๆ นี้ (เรากำลังใช้ Python) และเมื่อเราเริ่มพูดคุยเกี่ยวกับการสร้างตัวแปรและผู้ดำเนินการที่ได้รับมอบหมายเธอถามว่าทำไมค่าทางด้านขวาถูกกำหนดให้กับชื่อทางด้านซ้ายไม่ใช่ในทางกลับกัน .

ก่อนหน้านี้ฉันไม่ได้คิดมากเพราะมันดูเป็นธรรมชาติสำหรับฉัน แต่เธอบอกว่าซ้าย - ขวาดูเหมือนจะดูเป็นธรรมชาติมากกว่าสำหรับเธอเพราะนั่นเป็นวิธีที่พวกเราส่วนใหญ่อ่านภาษาธรรมชาติ

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

aligned = 2
on = 'foo' + 'bar' + 'foobar'
the = 5.0 / 2
left = 2 + 5

ตรงข้ามกับ:

2 = aligned 
'foo' + 'bar' + 'foobar' = on
5.0 / 2 = the 
2 + 5 = right 

# What were the names again...?

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

Ditto @paxdiablo นักเขียนโปรแกรมภาษาต้นถูกเขียนขึ้นโดยนักคณิตศาสตร์ - จริง ๆ แล้วพวกเขาทั้งหมดเป็น ในคณิตศาสตร์ตามหลักการของเธอเอง - การอ่านจากซ้ายไปขวา - มันสมเหตุสมผลในการทำงาน

x = 2y - 4

ในคณิตศาสตร์คุณจะพูดว่า: ขอ x เท่ากับ 2y -4

นอกจากนี้แม้ในพีชคณิตคุณก็ทำเช่นนี้ เมื่อคุณแก้สมการสำหรับตัวแปรคุณจะแยกตัวแปรที่คุณกำลังหาอยู่ทางด้านซ้าย เช่น y = mx + b;

นอกจากนี้เมื่อตระกูลทั้งภาษา - เช่นตระกูล C - มีไวยากรณ์บางอย่างมันจะเปลี่ยนค่าใช้จ่ายมากขึ้น

BASICหนึ่งในภาษาคอมพิวเตอร์ที่เก่าแก่ที่สุดมีรูปแบบ "เหมาะสม" ของ:

10 LET AREA = HEIGHT * WIDTH

ซึ่งตรงกับความคิดทางคณิตศาสตร์ของการระบุตัวแปรเช่น "ให้ H เป็นความสูงของวัตถุ"

COBOLก็คล้ายกับCOMPUTEคำสั่งของมัน เช่นเดียวกับหลาย ๆ วิธีในการทำสิ่งต่าง ๆ มันอาจเป็นการตัดสินใจตามอำเภอใจที่ถูกส่งต่อผ่านหลายภาษา

จริงๆแล้วมีภาษาโปรแกรมที่กำหนดทางด้านขวาคือ: TI-BASIC ! ไม่เพียงแค่นั้น แต่ยังไม่ได้ใช้ '=' เป็นผู้ดำเนินการที่ได้รับมอบหมาย แต่ใช้ลูกศรที่รู้จักในฐานะผู้ประกอบการ "STO"

ตัวอย่าง:

5→A
(A + 3)→B
(A - B)→C

ในตัวอย่างข้างต้นมีการประกาศตัวแปรสามตัวและกำหนดค่า A จะเท่ากับ 5, B จะเท่ากับ 8 และ C จะเท่ากับ -3 การประกาศ / การมอบหมายครั้งแรกสามารถอ่านได้ 'store 5 as A'

สำหรับสาเหตุที่ TI-BASIC ใช้ระบบดังกล่าวสำหรับการมอบหมายงานฉันเชื่อว่ามันเป็นเพราะมันเป็นภาษาการเขียนโปรแกรมสำหรับเครื่องคิดเลข ตัวดำเนินการ "STO" ในเครื่องคิดเลข TI มักใช้ในการดำเนินการเครื่องคิดเลขทั่วไปหลังจากคำนวณตัวเลขแล้ว หากเป็นตัวเลขที่ผู้ใช้ต้องการจดจำพวกเขาจะกดปุ่ม "STO" และ caclulator จะขอให้พวกเขาตั้งชื่อ (ให้ล็อคอัลฟ่าโดยอัตโนมัติเพื่อให้การกดแป้นพิมพ์เป็นตัวอักษรแทนตัวเลข):

Sin(7 + Cos(3))
                    -.26979276
Ans→{variable name}
                    -.26979276

และผู้ใช้สามารถตั้งชื่อตัวแปรตามที่พวกเขาเลือก เมื่อต้องเปิดการล็อคอัลฟ่าให้พิมพ์ชื่อแล้วกด "STO" แล้วกดปุ่ม "Ans" จะยุ่งยากเกินไปสำหรับการทำงานปกติ เนื่องจากฟังก์ชันเครื่องคิดเลขทั้งหมดมีให้บริการใน TI-BASIC จึงไม่มีการเพิ่มตัวดำเนินการกำหนดค่าเป็น "STO" ทำหน้าที่เดียวกันแม้ว่าจะย้อนกลับเมื่อเทียบกับภาษาอื่นส่วนใหญ่

(เรื่องเล็ก ๆ น้อย ๆ : TI-BASIC เป็นหนึ่งในภาษาแรกที่ฉันได้เรียนรู้ดังนั้นเมื่อฉันครั้งแรกที่ฉันได้เรียนรู้ Java ในวิทยาลัยฉันรู้สึกเหมือนว่าการมอบหมายให้ LEFT เป็นเรื่องผิดปกติและ 'ย้อนกลับ'!)

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

ทีนี้มันเป็นธรรมชาติมากขึ้น (อย่างน้อยสำหรับผู้พูดภาษาอังกฤษ) ลองดูวิธีที่เราเขียน / พูดภาษาอังกฤษ:

สตีเฟนตอนนี้อายุ 10 ปี (เมื่อเทียบกับสตีเวนตอนนี้อายุ 10 ปี) ฉันมีน้ำหนักมากกว่า 190 ปอนด์ (เมื่อเทียบกับน้ำหนักที่มากกว่า 190 ปอนด์)

ในรหัส:

steven = 10
i > 190

ต่อไปนี้ยังฟังดูเป็นธรรมชาติมากขึ้น:

"ถ้าแมรี่อายุ 18 ปีคุณก็จะได้ขนม" "ถ้าฉันอายุน้อยกว่า 21 ปีแล้วฉันจะขอให้พี่ชายของฉันมาให้ฉันทีกีล่า"

if (mary == 18) { ... }
if (i < 21) { ... }

กว่า:

"ถ้า 18 yo Mary คือ ... " "ถ้า 21 มากกว่าอายุของฉัน ... "

ตอนนี้รหัส:

if (18 == mary) { ... }
if (21 > i) { ... }

โปรดทราบว่านี่ไม่ใช่เรื่องธรรมดาสำหรับโปรแกรมเมอร์หรือผู้พูดภาษาอังกฤษ ประโยคดูเหมือน yoda พูดและรหัสเป็นชื่อเล่น yoda สิ่งเหล่านี้อาจเป็นประโยชน์ใน C ++ แต่ฉันมั่นใจว่าคนส่วนใหญ่จะเห็นด้วย: ถ้าคอมไพเลอร์สามารถทำการยกของหนักและบรรเทาความต้องการสภาพโยดาชีวิตจะง่ายขึ้นเล็กน้อย

แน่นอนว่าคนเราจะชินกับทุกสิ่งได้ ตัวอย่างเช่นหมายเลข 81 ถูกเขียนเป็น:

Eighty One (อังกฤษ) Eighty One และ One (สเปน) One and Eighty (เยอรมัน)

ในที่สุดมี 4! = 24 วิธีที่ถูกต้องในการพูดว่า "แอปเปิ้ลเขียววางอยู่บนโต๊ะ" ในรัสเซีย - คำสั่ง (เกือบ) ไม่สำคัญยกเว้นว่า 'บน' จะต้องมาพร้อมกับ 'ตาราง' ดังนั้นหากคุณเป็นเจ้าของภาษารัสเซีย (เช่น) คุณอาจไม่สนใจว่าจะเขียนa = 10หรือ10 = aเพราะทั้งคู่ดูเหมือนเป็นธรรมชาติ

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

มันเริ่มต้นด้วย FORTRAN ในปี 1950 ที่ FORTRAN เป็นตัวย่อของ FORmula TRANslation - สูตรในคำถามเป็นสมการพีชคณิตแบบง่ายซึ่งโดยการประชุมมักจะกำหนดให้ทางด้านซ้าย

COBOL ร่วมสมัยใกล้เคียงกันนั้นหมายถึงว่าเป็นภาษาอังกฤษและได้รับมอบหมายทางด้านขวา (ส่วนใหญ่!)

MOVE 1 TO COUNTER.
ADD +1 TO LINE-CNT.
MULTIPLY QTY BY PRICE GIVING ITEM-PRICE.

ดีที่ @ diceguyd30 ชี้ว่ามีทั้งสัญลักษณ์

• <Identifier> = <Value>หมายถึง "ให้ตัวระบุเป็นค่า " หรือเพื่อขยายที่: กำหนด (หรือสร้างนิยามใหม่) ตัวแปรตัวบ่งชี้ที่จะคุ้มค่า
• <Value> -> <Identifier>หมายถึง "เก็บค่าเพื่อระบุ " หรือเพื่อขยายที่: ใส่ค่าเข้าไปในสถานที่ที่กำหนดโดยตัวบ่งชี้

แน่นอนว่าโดยทั่วไปการพูดตัวบ่งชี้ในความเป็นจริงอาจเป็นค่า L ใด ๆ

วิธีแรกให้เกียรติแนวคิดนามธรรมของตัวแปรวิธีที่สองคือเพิ่มเติมเกี่ยวกับการจัดเก็บจริง

โปรดทราบว่าวิธีแรกก็เหมือนกันในภาษาที่ไม่มีการกำหนด นอกจากนี้ยังทราบว่าคำนิยามตัวแปรและการมอบหมายมีความใกล้ชิดกับ<Type> <Identifier> = <Value><Identifier> = <Value>

ดังที่ได้กล่าวมาแล้วภาษาคอมพิวเตอร์ยุคแรก ๆ ก็ทำงานได้ดี เช่น FORTRAN ซึ่งมาพร้อมหลายปีก่อนหน้า BASIC

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

มันอาจเป็นเศษเล็กเศษน้อยของขั้นตอนวิธีการแยกวิเคราะห์ต้น โปรดจำไว้ว่าการแยกวิเคราะห์ LR ถูกประดิษฐ์ขึ้นในปี 2508 เท่านั้นและอาจเป็นไปได้ว่าตัวแยกวิเคราะห์ LL มีปัญหา (ภายในเวลาและข้อ จำกัด ด้านพื้นที่ของเครื่องจักรในเวลานั้น) ไปทางอื่น พิจารณา:

identifier = function();
function();

ทั้งสองมีความชัดเจนจากโทเค็นที่สองอย่างชัดเจน ในทางกลับกัน,

function() = identifier;
function();

ไม่สนุก. สิ่งนี้แย่ลงเมื่อคุณเริ่มสร้างนิพจน์การมอบหมาย

function(prev_identifier = expression) = identifier;
function(prev_identifier = expression);

แน่นอนว่าง่ายต่อการทำให้คลุมเครือสำหรับเครื่องยังหมายถึงง่ายต่อการ disambiguate สำหรับมนุษย์ อีกตัวอย่างง่ายๆคือการค้นหาการเริ่มต้นของตัวระบุที่กำหนด

identifier1 = expressionOfAnArbitraryLength;
identifier2 = expressionOfAReallyReallyReallyArbitraryLength;
identifier3 = expression;
identifier4 = AlongLineExpressionWithAFunctionCallWithAssignment(
    identifier = expr);

ง่ายเพียงแค่มองทางด้านซ้าย ด้านขวามืออีกข้าง

expressionOfAnArbitraryLength = identifier1;
expressionOfAReallyReallyReallyArbitraryLength = identifier2;
expression = identifier3;
AlongLineExpressionWithAFunctionCallWithAssignment(expr = identifier
    ) = identifier4;

โดยเฉพาะอย่างยิ่งเมื่อคุณไม่สามารถgrepเจาะบัตรได้ยากกว่าการค้นหาตัวระบุที่คุณต้องการ

ภาษา Asssemblyมีปลายทางเป็นส่วนหนึ่งของ opcode ทางซ้าย ภาษาระดับสูงมีแนวโน้มที่จะปฏิบัติตามอนุสัญญาของภาษาก่อน

เมื่อคุณเห็น=(หรือ:=ภาษาปาสคาลิช) คุณสามารถออกเสียงสิ่งเหล่านั้นได้เช่นis assigned the valueกันจากซ้ายไปขวาจะมีเหตุผล (เพราะเราอ่านจากซ้ายไปขวาในภาษาส่วนใหญ่ด้วย) เนื่องจากภาษาการเขียนโปรแกรมได้รับการพัฒนาโดยคนส่วนใหญ่ที่อ่านจากซ้ายไปขวา

มันเป็นประเภทของการพึ่งพาอาศัยเส้นทาง ฉันคิดว่าหากการเขียนโปรแกรมคอมพิวเตอร์ถูกประดิษฐ์โดยคนที่พูดภาษาฮิบรูหรืออารบิก (หรือภาษาอื่นจากขวาไปซ้าย) จากนั้นฉันสงสัยว่าเราจะวางปลายทางไว้ทางขวา

สำหรับสิ่งที่คุ้มค่างบมากที่สุดใน COBOL multiply salary by rate giving taxอ่านจากซ้ายไปขวาดังนั้นทั้งสองตัวถูกดำเนินการถูกตั้งชื่อแรกและปลายทางสุดท้ายเช่น:

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

เธอบอกว่าจากซ้ายไปขวานั้นดูเป็นธรรมชาติมากกว่าสำหรับเธอเพราะนั่นเป็นวิธีที่พวกเราส่วนใหญ่อ่านภาษาธรรมชาติ

ฉันคิดว่านี่เป็นข้อผิดพลาด ในอีกด้านหนึ่งคุณสามารถพูดว่า "กำหนด 10 ถึง x" หรือ "ย้าย 10 ถึง x" ในทางกลับกันคุณสามารถพูดว่า "ตั้งค่า x เป็น 10" หรือ "x กลายเป็น 10"

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

ใน pseudocode ผู้ประกอบการที่ได้รับมอบหมายมักเขียนทางด้านขวา ตัวอย่างเช่น

2*sqrt(x)/(3+y) -> z

ในเครื่องคิดเลข Casio แม้แต่ชุดที่ไม่สามารถตั้งโปรแกรมได้ตัวแปรการกำหนดจะแสดงทางด้านขวา

A+2B → C

ในตัวแปรที่อยู่ทางขวาเช่นกัน

expression variable !

ใน x86 ไวยากรณ์ของ Intel มีปลายทางทางด้านซ้าย แต่ไวยากรณ์ GAS กลับคำสั่งทำให้เกิดความสับสนกับคนจำนวนมากโดยเฉพาะคำแนะนำเกี่ยวกับคำสั่งของพารามิเตอร์เช่นการลบหรือการเปรียบเทียบ คำแนะนำเหล่านี้เหมือนกันใน 2 ภาษาที่แตกต่างกัน

mov rax, rbx    ; Intel syntax
movq %rbx, %rax ; GAS syntax

พวกเขาทั้งสองย้ายค่าใน rbx เพื่อ rax ไม่มีภาษาแอสเซมบลีอื่น ๆ ที่ฉันรู้จักเขียนปลายทางทางด้านขวาเช่น GAS

บางแพลตฟอร์มวางนิพจน์ทางซ้ายและตัวแปรทางด้านขวา:

MOVE expression TO variable      COBOL
expression → variable            TI-BASIC, Casio BASIC
expression -> variable           BETA, R
put expression into variable     LiveCode

https://en.wikipedia.org/wiki/Assignment_%28computer_science%29#Notation

ภาษาส่วนใหญ่กำหนดค่าทางด้านซ้ายซึ่งเป็นหนึ่งในเหตุผลที่ง่ายต่อการจัดตำแหน่งตัวดำเนินการง่ายต่อการอ่านและรับรู้ตัวแปรเนื่องจากตำแหน่งตัวดำเนินการกำหนดค่าและตำแหน่งของตัวแปรจะไม่แตกต่างกันมากในบรรทัดและง่ายต่อการอ่านเป็น "ให้ตัวแปรเป็นค่าบางค่า".

อย่างไรก็ตามบางคนชอบพูดว่า "ย้ายค่า x ไปยัง y" และเขียนตัวแปรทางด้านขวา

ฉันคิดว่ามันเป็นไปตามวิธีคิดอย่างมีเหตุผล
จะต้องมีกล่อง (ตัวแปร) ก่อนจากนั้นคุณใส่วัตถุ (ค่า) ข้างใน
คุณไม่วางวัตถุในอากาศแล้ววางกล่องล้อมรอบ