What does ":=" do?

I've seen := used in several code samples, but never w开发者_如何转开发ith an accompanying explanation. It's not exactly possible to google its use without knowing the proper name for it.

What does it do?

http://en.wikipedia.org/wiki/Equals_sign#In_computer_programming

In computer programming languages, the equals sign typically denotes either a boolean operator to test equality of values (e.g. as in Pascal or Eiffel), which is consistent with the symbol's usage in mathematics, or an assignment operator (e.g. as in C-like languages). Languages making the former choice often use a colon-equals (:=) or ≔ to denote their assignment operator. Languages making the latter choice often use a double equals sign (==) to denote their boolean equality operator.

Note: I found this by searching for colon equals operator

It's the assignment operator in Pascal and is often used in proofs and pseudo-code. It's the same thing as = in C-dialect languages.

Historically, computer science papers used = for equality comparisons and ← for assignments. Pascal used := to stand in for the hard-to-type left arrow. C went a different direction and instead decided on the = and == operators.

In the statically typed language Go := is initialization and assignment in one step. It is done to allow for interpreted-like creation of variables in a compiled language.

// Creates and assigns
answer := 42

// Creates and assigns
var answer = 42

Another interpretation from outside the world of programming languages comes from Wolfram Mathworld, et al:

If A and B are equal by definition (i.e., A is defined as B), then this is written symbolically as A=B, A:=B, or sometimes A≜B.

■ http://mathworld.wolfram.com/Defined.html

■ https://math.stackexchange.com/questions/182101/appropriate-notation-equiv-versus

Some language uses := to act as the assignment operator.

In a lot of CS books, it's used as the assignment operator, to differentiate from the equality operator =. In a lot of high level languages, though, assignment is = and equality is ==.

This is old (pascal) syntax for the assignment operator. It would be used like so:

a := 45;

It may be in other languages as well, probably in a similar use.

A number of programming languages, most notably Pascal and Ada, use a colon immediately followed by an equals sign (:=) as the assignment operator, to distinguish it from a single equals which is an equality test (C instead used a single equals as assignment, and a double equals as the equality test).

Reference: Colon (punctuation).

In Python:

Named Expressions (NAME := expr) was introduced in Python 3.8. It allows for the assignment of variables within an expression that is currently being evaluated. The colon equals operator := is sometimes called the walrus operator because, well, it looks like a walrus emoticon.

For example:

if any((comment := line).startswith('#') for line in lines):
    print(f"First comment: {comment}")
else:
    print("There are no comments")

This would be invalid if you swapped the := for =. Note the additional parentheses surrounding the named expression. Another example:

# Compute partial sums in a list comprehension
total = 0
values = [1, 2, 3, 4, 5]
partial_sums = [total := total + v for v in values]
# [1, 3, 6, 10, 15]
print(f"Total: {total}")  # Total: 15

Note that the variable total is not local to the comprehension (so too is comment from the first example). The NAME in a named expression cannot be a local variable within an expression, so, for example, [i := 0 for i, j in stuff] would be invalid, because i is local to the list comprehension.

I've taken examples from the PEP 572 document - it's a good read! I for one am looking forward to using Named Expressions, once my company upgrades from Python 3.6. Hope this was helpful!

Sources: Towards Data Science Article and PEP 572.

It's like an arrow without using a less-than symbol <= so like everybody already said "assignment" operator. Bringing clarity to what is being set to where as opposed to the logical operator of equivalence.

In Mathematics it is like equals but A := B means A is defined as B, a triple bar equals can be used to say it's similar and equal by definition but not always the same thing.

Anyway I point to these other references that were probably in the minds of those that invented it, but it's really just that plane equals and less that equals were taken (or potentially easily confused with =<) and something new to define assignment was needed and that made the most sense.

Historical References: I first saw this in SmallTalk the original Object Language, of which SJ of Apple only copied the Windows part of and BG of Microsoft watered down from them further (single threaded). Eventually SJ in NeXT took the second more important lesson from Xerox PARC in, which became Objective C.

Well anyway they just took colon-equals assiment operator from ALGOL 1958 which was later popularized by Pascal

https://en.wikipedia.org/wiki/PARC_(company)

https://en.wikipedia.org/wiki/Assignment_(computer_science)

Assignments typically allow a variable to hold different values at different times during its life-span and scope. However, some languages (primarily strictly functional) do not allow that kind of "destructive" reassignment, as it might imply changes of non-local state. The purpose is to enforce referential transparency, i.e. functions that do not depend on the state of some variable(s), but produce the same results for a given set of parametric inputs at any point in time.

https://en.wikipedia.org/wiki/Referential_transparency

For VB.net,

a constructor (for this case, Me = this in Java):

Public ABC(int A, int B, int C){
Me.A = A;
Me.B = B;
Me.C = C;
}

when you create that object:

new ABC(C:=1, A:=2, B:=3)

Then, regardless of the order of the parameters, that ABC object has A=2, B=3, C=1

So, ya, very good practice for others to read your code effectively

Colon-equals was used in Algol and its descendants such as Pascal and Ada because it is as close as ASCII gets to a left-arrow symbol.

The strange convention of using equals for assignment and double-equals for comparison was started with the C language.

In Prolog, there is no distinction between assignment and the equality test.