### What is this?

This is a collection of questions that come up every now and then about syntax in PHP. This is also a Community Wiki, so everyone is invited to participate in maintaining this list. 

### Why is this?

It used to be hard to find questions about operators and other syntax tokens.&#185;  
The main idea is to have links to existing questions on Stack Overflow, so it&#39;s easier for us to reference them, not to copy over content from the PHP Manual.

Note: Since January 2013, Stack Overflow [does support special characters][1]. Just surround the search terms by quotes, e.g. [`[php] &quot;==&quot; vs &quot;===&quot;`][2]

### **What should I do here?**

If you have been pointed here by someone because you have asked such a question, please find the particular syntax below. The linked pages to the [PHP manual](http://php.net/manual/en/index.php) along with the linked questions will likely answer your question then. If so, you are encouraged to upvote the answer. This list is not meant as a substitute for the help others provided.

## The List

If your particular token is not listed below, you might find it in the [List of Parser Tokens][3].

---

`&amp;` [Bitwise Operators][4] or [References][5]

 - https://stackoverflow.com/questions/1676897
 - https://stackoverflow.com/questions/600202
 - https://stackoverflow.com/questions/2209934/
 - https://stackoverflow.com/questions/2376348
 - https://stackoverflow.com/questions/1006652
 - https://stackoverflow.com/questions/2297592
 - https://stackoverflow.com/questions/2422907
 - https://stackoverflow.com/questions/2478149
 - https://stackoverflow.com/questions/3957584
 - https://stackoverflow.com/questions/4705262
 - https://stackoverflow.com/questions/4705838
 - https://stackoverflow.com/questions/21058439 (&amp;$)

---

`=&amp;` [References][5]

 - https://stackoverflow.com/questions/1768343
 - https://stackoverflow.com/questions/1367454
 - https://stackoverflow.com/questions/3177342
 - https://stackoverflow.com/questions/2081806

---

`&amp;=` [Bitwise Operators][4]

 - https://stackoverflow.com/questions/1367454
 - https://stackoverflow.com/questions/3177342

---

`&amp;&amp;` [Logical Operators][6]

 - https://stackoverflow.com/questions/2803321
 - https://stackoverflow.com/questions/2376348
 - https://stackoverflow.com/questions/4746865
 - https://stackoverflow.com/questions/4502092

---

`%` [Arithmetic Operators][7]

 - https://stackoverflow.com/questions/1934173
 - https://stackoverflow.com/questions/3204919

---

`!!` [Logical Operators][6]

 - https://stackoverflow.com/questions/2127260

---

`@` [Error Control Operators][8]

 - https://stackoverflow.com/questions/1032161
 - https://stackoverflow.com/questions/3551527
 - https://stackoverflow.com/questions/3984864
 - https://stackoverflow.com/questions/4872340
 - https://stackoverflow.com/questions/3621215

---

`?:` [Ternary Operator][9]

 - https://stackoverflow.com/questions/1080247
 - https://stackoverflow.com/questions/1993409
 - https://stackoverflow.com/questions/4055355
 - https://stackoverflow.com/questions/4210187

---

`??` [Null Coalesce Operator][36] (since PHP 7)

 - https://stackoverflow.com/questions/7278835

---

`?string`
`?int`
`?array`
`?bool`
`?float` [Nullable return type declaration][10] (since PHP 7.1)

 - [Nullable return type declaration](https://stackoverflow.com/a/54217328/250259)
 - [Nullable parameter type declaration](https://stackoverflow.com/a/48450841)
 - [php method argument type hinting with question mark (?type)][34]

---

`:` [Alternative syntax for control structures][11], [Ternary Operator][9], [Return Type Declaration](https://www.php.net/manual/en/language.types.declarations.php)

 - https://stackoverflow.com/questions/2908095
 - https://stackoverflow.com/questions/4747761
 - https://stackoverflow.com/questions/40346754

---

`::` [Scope Resolution Operator][12]

 - https://stackoverflow.com/questions/2903564
 - https://stackoverflow.com/questions/2588298
 - https://stackoverflow.com/questions/3173501
 - https://stackoverflow.com/questions/1912902
 - https://stackoverflow.com/questions/4120755
 - https://stackoverflow.com/questions/8734823

---

`\` [Namespaces][13]

 - https://stackoverflow.com/questions/10788400
 - https://stackoverflow.com/questions/4790020

---

`-&gt;` [Classes And Objects][14]

 - https://stackoverflow.com/questions/2588149
 - https://stackoverflow.com/questions/3037526
 - https://stackoverflow.com/questions/3173501
 - https://stackoverflow.com/questions/2316370
 - https://stackoverflow.com/questions/4502587

---

`=&gt;` [Arrays][15]

 - https://stackoverflow.com/questions/1241819
 - https://stackoverflow.com/questions/1655336
 - https://stackoverflow.com/questions/4758791

---

`^` [Bitwise Operators][4]

 - https://stackoverflow.com/questions/2674920
 - https://stackoverflow.com/questions/2724936

---

`&gt;&gt;` [Bitwise Operators][4]

 - https://stackoverflow.com/questions/2790329

---

`&lt;&lt;` [Bitwise Operators][4]

- https://stackoverflow.com/questions/9718689/strange-print-behaviour-in-php

---

`&lt;&lt;&lt;` [Heredoc or Nowdoc][16]

 - https://stackoverflow.com/questions/5539669
 - https://stackoverflow.com/questions/1048481
 - https://stackoverflow.com/questions/3700042
 - https://stackoverflow.com/questions/2090081
 - https://stackoverflow.com/questions/2333779

---

`=` [Assignment Operators][17]

 - https://stackoverflow.com/questions/2063480

---

`==` [Comparison Operators][18]

 - https://stackoverflow.com/questions/80646
 - https://stackoverflow.com/questions/1663451
 - https://stackoverflow.com/questions/2063480
 - https://stackoverflow.com/questions/15813490/

---

`===` [Comparison Operators][18]

 - https://stackoverflow.com/questions/1117967
 - https://stackoverflow.com/questions/80646
 - https://stackoverflow.com/questions/2063480
 - https://stackoverflow.com/questions/15813490/

---

`!==` [Comparison Operators][18]

 - https://stackoverflow.com/questions/1298083
 - https://stackoverflow.com/questions/1139154

---

`!=` [Comparison Operators][18]

 - https://stackoverflow.com/questions/1663451
 - https://stackoverflow.com/questions/1139154
 - https://stackoverflow.com/questions/6356826
 - https://stackoverflow.com/questions/9671785/what-is-the-difference-between-and

---

`&lt;&gt;` [Comparison Operators][18]

 - https://stackoverflow.com/questions/249312
 - https://stackoverflow.com/questions/589391
 - https://stackoverflow.com/questions/9671785
 - https://stackoverflow.com/questions/15813490/

---

`&lt;=&gt;` [Comparison Operators][18] (since PHP 7.0)

 - [Spaceship (three way comparison) operator][19]

---

`|` [Bitwise Operators][4]

 - https://stackoverflow.com/questions/2233835
 - https://stackoverflow.com/questions/13811922

---

`||` [Logical Operators][6]

 - https://stackoverflow.com/questions/2233835
 - https://stackoverflow.com/questions/4502092
 - https://stackoverflow.com/questions/5666741
 - https://stackoverflow.com/questions/12213283

---

`~` [Bitwise Operators][4]

 - https://stackoverflow.com/questions/1967360

---

`+` [Arithmetic Operators][7], [Array Operators][20]

 - https://stackoverflow.com/questions/2140090

---

`+=` and `-=` [Assignment Operators][17]

 - https://stackoverflow.com/questions/542995
 - https://stackoverflow.com/questions/7140158

---

`++` and `--` [Incrementing/Decrementing Operators][21]

 - https://stackoverflow.com/questions/1968371
 - [Answer below][22]

---

`.=` [Assignment Operators][17]

 - https://stackoverflow.com/questions/2202331
 - https://stackoverflow.com/questions/1241432

---

`.` [String Operators][23]

 - https://stackoverflow.com/questions/1466408
 - https://stackoverflow.com/questions/6484968

---

`,` [Function Arguments][24]

 - https://stackoverflow.com/questions/1466408

`,` [Variable Declarations][25]

 - https://stackoverflow.com/questions/41383218

---

`$$` [Variable Variables][26]

 - https://stackoverflow.com/questions/2715654
 - https://stackoverflow.com/questions/4169882
 - https://stackoverflow.com/questions/4891872

---

`` ` `` [Execution Operator][27]

 - https://stackoverflow.com/questions/6002296

---

`&lt;?=` [Short Open Tags][28]

 - https://stackoverflow.com/questions/1963901
 - https://stackoverflow.com/questions/2020445
 - https://stackoverflow.com/questions/1959256/what-does-mean

---

`[]` [Arrays][15] (short syntax since PHP 5.4)

 - https://stackoverflow.com/q/20709055/2758197
 - https://stackoverflow.com/questions/6933345
 - https://stackoverflow.com/questions/2431629
 - https://stackoverflow.com/questions/3908576
 - [Shorthand for arrays: literal `$var = []` empty array](https://stackoverflow.com/questions/4271874)


---

`&lt;?` [Opening and Closing tags][29]

 - https://stackoverflow.com/questions/200640


---

`...` [Argument unpacking][30] (since PHP 5.6)

---
`**` [Exponentiation][31] (since PHP 5.6)

---
`#` [One-line shell-style comment][32]

 - [Can I use hashes for comments in PHP?][33]

---
`?-&gt;` [NullSafe Operator Calls][35] (since PHP 8.0)

- https://stackoverflow.com/questions/62178354/what-does-this-symbol-mean-in-php-within-an-object-or-null-value

---


  [1]: https://meta.stackexchange.com/questions/160100/a-new-search-engine-for-stack-exchange
  [2]: https://stackoverflow.com/search?q=%5Bphp%5D%20%22===%22%20vs%20%22==%22
  [3]: http://secure.php.net/manual/en/tokens.php
  [4]: http://secure.php.net/manual/en/language.operators.bitwise.php
  [5]: http://secure.php.net/manual/en/language.references.php
  [6]: http://secure.php.net/manual/en/language.operators.logical.php
  [7]: http://secure.php.net/manual/en/language.operators.arithmetic.php
  [8]: http://secure.php.net/manual/en/language.operators.errorcontrol.php
  [9]: http://php.net/manual/en/language.operators.comparison.php#language.operators.comparison.ternary
  [10]: https://www.php.net/manual/en/migration71.new-features.php
  [11]: http://secure.php.net/manual/en/control-structures.alternative-syntax.php
  [12]: http://secure.php.net/manual/en/language.oop5.paamayim-nekudotayim.php
  [13]: http://php.net/namespaces
  [14]: http://secure.php.net/manual/en/language.oop5.php
  [15]: http://secure.php.net/manual/en/language.types.array.php
  [16]: http://php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc
  [17]: http://secure.php.net/manual/en/language.operators.assignment.php
  [18]: http://secure.php.net/manual/en/language.operators.comparison.php
  [19]: https://stackoverflow.com/a/31298778
  [20]: http://secure.php.net/manual/en/language.operators.array.php
  [21]: http://secure.php.net/manual/en/language.operators.increment.php
  [22]: https://stackoverflow.com/a/3737177
  [23]: http://secure.php.net/manual/en/language.operators.string.php
  [24]: http://php.net/manual/en/functions.arguments.php
  [25]: http://php.net/manual/en/language.variables.scope.php
  [26]: http://php.net/manual/en/language.variables.variable.php
  [27]: http://php.net/manual/en/language.operators.execution.php
  [28]: http://php.net/manual/en/ini.core.php#ini.short-open-tag
  [29]: http://secure.php.net/manual/en/language.basic-syntax.php
  [30]: http://php.net/manual/en/functions.arguments.php#functions.variable-arg-list
  [31]: http://secure.php.net/manual/en/migration56.new-features.php#migration56.new-features.exponentiation
  [32]: http://php.net/manual/en/language.basic-syntax.comments.php
  [33]: https://stackoverflow.com/questions/9093609/can-i-use-hashes-for-comments-in-php
  [34]: https://stackoverflow.com/questions/48881489/php-method-argument-type-hinting-with-question-mark-type
  [35]: https://stackoverflow.com/a/62178856/250259
  [36]: https://www.php.net/manual/en/migration70.new-features.php#migration70.new-features.null-coalesce-op

Reference — What does this symbol mean in PHP?

I read this word many time &quot;Kitchen sink&quot;, mostly when i download something from github, there is folder with name &quot;Kitchen sink&quot;. but i don&#39;t know exact meaning of this.&lt;br&gt;
Can anybody explain what is the meaning of Kitchen sink? 

What is exact meaning of &quot;kitchen sink&quot; in programming?

Both of them emphasize text. The `&lt;em&gt;` tag shows text as italics, whereas `&lt;strong&gt;` makes it bold. Is this the only difference?

What is the difference between &lt;strong&gt; and &lt;em&gt; tags?

in this [article about boost spirit semantic actions][1] it is mentioned that 

&gt;  There are actually 2 more arguments
&gt; being passed: the parser context and a
&gt; reference to a boolean ‘hit’
&gt; parameter. The parser context is
&gt; meaningful only if the semantic action
&gt; is attached somewhere to the right
&gt; hand side of a rule. We will see more
&gt; information about this shortly. The
&gt; boolean value can be set to false
&gt; inside the semantic action invalidates
&gt; the match in retrospective, making the
&gt; parser fail.

All fine, but i&#39;ve been trying to find an example passing a function object as semantic action that uses the other parameters (parser context and hit boolean) but i haven&#39;t found any. I would love to see an example using regular functions or function objects, as i barely can grok the phoenix voodoo

  [1]: http://boost-spirit.com/home/2010/03/03/the-anatomy-of-semantic-actions-in-qi/

boost spirit semantic action parameters

From using a number of programming languages and libraries I have noticed various terms used for the total number of elements in a collection.

The most common seem to be `length`, `count`, and `size`.

eg.

    array.length
    vector.size()
    collection.count

Is there any preferred term to be used?
Does it depend on what type of collection it is? ie. mutable/immutable

Is there a preference for it being a property instead of a method?


count vs length vs size in a collection

Are both `&lt;h1&gt;&lt;a ...&gt; ... &lt;/a&gt;&lt;/h1&gt;` and `&lt;a ...&gt;&lt;h1&gt; ... &lt;/h1&gt;&lt;/a&gt;` valid HTML, or is only one correct? If they are both correct, do they differ in meaning?

Which is more correct: &lt;h1&gt;&lt;a&gt;...&lt;/a&gt;&lt;/h1&gt; OR &lt;a&gt;&lt;h1&gt;...&lt;/h1&gt;&lt;/a&gt;

Today I&#39;ve gotten a remark about code considering the way I check whether a variable is true or false in a school assignment.

The code which I had written was something like this:

    var booleanValue = true;

    function someFunction(){
        if(booleanValue === true){
            return &quot;something&quot;;
        }
    }

They said it was better/neater to write it like this:

    var booleanValue = true;

    function someFunction(){
        if(booleanValue){
            return &quot;something&quot;;
        }
    }


The remark which I have gotten about the &quot;=== true&quot; part was that it was not needed and could create confusion.

However my idea is that it is better to check whether the variable is a boolean or not, especially since Javascript is a loosetyped language.

In the second example a string would also return &quot;something&quot;;

So my question; Is it neater to loose the &quot;=== true&quot; part in the future, or is it good practise to check the type of the variable as well.


**Edit:**
In my &quot;real&quot; code the boolean represents whether an image has been deleted or not, so the only values boolValue should ever have is true or false.

0 and 1 for example shouldn&#39;t be in that variable.


boolean in an if statement

What is the difference between *syntax* and *semantics* in programming languages (like C, C++)?  

What is the difference between syntax and semantics in programming languages?

Is there a best practice concerning the nesting of `label` and `input` HTML elements?

classic way:

&lt;!-- language: lang-html --&gt;

    &lt;label for=&quot;myinput&quot;&gt;My Text&lt;/label&gt;
    &lt;input type=&quot;text&quot; id=&quot;myinput&quot; /&gt;

or

&lt;!-- language: lang-html --&gt;

    &lt;label for=&quot;myinput&quot;&gt;My Text
       &lt;input type=&quot;text&quot; id=&quot;myinput&quot; /&gt;
    &lt;/label&gt;


Should I put input elements inside a label element?

Ok for the recursive options when deleting files, but what is `rimraf`?
Is it an acronym? Does it come from words combination? 

The word is fairly pleasant, I would like to know where does it come from.



Does anyone knows what &quot;rimraf&quot; means?

I have a function, parseQuery, that parses a SQL query into an abstract representation of that query.

I&#39;m about to write a function that takes an abstract representation of a query and returns a SQL query string.

What should I call the second function?

What is the opposite of &#39;parse&#39;?

My [Google-fu][1] has failed me.

In Python, are the following two tests for equality equivalent?

    n = 5
    # Test one.
    if n == 5:
        print &#39;Yay!&#39;

    # Test two.
    if n is 5:
        print &#39;Yay!&#39;

Does this hold true for objects where you would be comparing instances (a `list` say)?

Okay, so this kind of answers my question:

    L = []
    L.append(1)
    if L == [1]:
        print &#39;Yay!&#39;
    # Holds true, but...

    if L is [1]:
        print &#39;Yay!&#39;
    # Doesn&#39;t.

So `==` tests value where `is` tests to see if they are the same object?

  [1]: https://english.stackexchange.com/questions/19967/what-does-google-fu-mean


Is there a difference between &quot;==&quot; and &quot;is&quot;?

I hear about &#39;sugaring&#39; and &#39;desugaring&#39; more often in Java 8, what does these terms mean ? are they conceptual or syntactical.

Some Example:

&gt; Default iterated loop resugaring to java 
&gt;
&gt; Observations about syntactic sugar in compilation.

What are &quot;sugar&quot;, &quot;desugar&quot; terms in context of Java 8?

In HTML table, what does `td` stand for? I mean literally, what is it an acronym for? Table division? Table data?

HTML table td meaning

I&#39;m trying to find some good examples of semantic diff/merge utilities.  The traditional paradigm of comparing source code files works by comparing lines and characters.. but are there any utilities out there (for any language) that actually consider the *structure* of code when comparing files?

For example, existing diff programs will report &quot;difference found at character 2 of line 125. File x contains v-o-i-d, where file y contains b-o-o-l&quot;.  A specialized tool should be able to report &quot;Return type of method doSomething() changed from void to bool&quot;.

I would argue that this type of semantic information is actually what the user is looking for when comparing code, and should be the goal of next-generation progamming tools.  Are there any examples of this in available tools?

Semantic Diff Utilities

What makes a language a scripting language? I&#39;ve heard some people say &quot;when it gets interpreted instead of compiled&quot;. That would make PHP (for example) a scripting language. Is that the only criterion? Or are there other criteria?

### See also:

* [What’s the difference between a “script” and an “application”?](https://stackoverflow.com/questions/98268/whats-the-difference-between-a-script-and-an-application)


When is a language considered a scripting language?

In the Introduction to Swift WWDC session, a read-only property `description` is demonstrated:

```swift
class Vehicle {
    var numberOfWheels = 0
    var description: String {
        return &quot;\(numberOfWheels) wheels&quot;
    }
}

let vehicle = Vehicle()
println(vehicle.description)
```

Are there any implications to choosing the above approach over using a method instead:

```swift
class Vehicle {
    var numberOfWheels = 0
    func description() -&gt; String {
        return &quot;\(numberOfWheels) wheels&quot;
    }
}

let vehicle = Vehicle()
println(vehicle.description())
```

It seems to me that the most obvious reasons for choosing a read-only computed property are:

 - **Semantics** - in this example it makes sense for `description` to be a property of the class, rather than an action it performs.
 - **Brevity/Clarity** - prevents the need to use empty parentheses when getting the value.

Clearly the above example is overly simple, but are there other good reasons to choose one over the other? For example, are there some features of functions or properties that would guide your decision of which to use?


----------


_N.B. At first glance this seems like quite a common OOP question, but I&#39;m keen to know of any Swift-specific features that would guide best practice when using this language._

Computed read-only property vs function in Swift

This question on &#39;[How to tell if a PHP array is empty][1]&#39; had me thinking of this question

Is there a reason that `count` should be used instead of `empty` when determining if an array is empty or not?

My personal thought would be if the 2 are equivalent for the case of empty arrays you should use `empty` because it gives a boolean answer to a boolean question. From the question linked above, it seems that `count($var) == 0` is the popular method. To me, while technically correct, makes no sense. E.g. **Q: $var, are you empty? A: 7**. Hmmm...

Is there a reason I should use `count == 0` instead or just a matter of personal taste?

As pointed out by others in comments for a now deleted answer, `count` will have performance impacts for large arrays because it will have to count all elements, whereas `empty` can stop as soon as it knows it isn&#39;t empty. So, if they give the same results in this case, but `count` is potentially inefficient, why would we ever use `count($var) == 0`?

  [1]: https://stackoverflow.com/questions/2216052/how-to-tell-if-a-php-array-is-empty/2216062#2216062

Checking for empty arrays: count vs empty

I have some html like this:

    &lt;div id=&quot;1&quot;&gt;
    	&lt;p&gt;
    		Volume = &lt;input type=&quot;text&quot; /&gt;
    		&lt;button rel=&quot;3.93e-6&quot; class=&quot;1&quot; type=&quot;button&quot;&gt;Check answer&lt;/button&gt;
    	&lt;/p&gt;
    	&lt;div&gt;&lt;/div&gt;
    &lt;/div&gt;

and some JS like this:

    $(&quot;button&quot;).click(function () {
        var buttonNo = $(this).attr(&#39;class&#39;);
        var correct = Number($(this).attr(&#39;rel&#39;));
    		
        validate (Number($(&quot;#&quot;+buttonNo+&quot; input&quot;).val()),correct);
        $(&quot;#&quot;+buttonNo+&quot; div&quot;).html(feedback);
    });

What I&#39;d really like is if I didn&#39;t have to have the class=&quot;1&quot; on the button (I know numeric classes aren&#39;t valid, but this is a WIP!), so I could determine buttonNo based on the id of the parent div. In real life there are multiple sections looking like this.

1. How do I find the id of the div parenting the button.

2. What would be a more semantic way to store the answer in the button code. I want to make this as foolproof as possible for a non programmer to copy and paste without breaking things!

Finding the id of a parent div using Jquery

I&#39;ve generally used the `KeyValuePair&lt;TKey,TValue&gt;` type whenever I have data that is pair-related in the sense that one is a key to the other. If the data is unrelated then the `Tuple&lt;T1,T2&gt;` type makes more sense and I&#39;d go with that.

Now I just read [this article][1] about why to generally avoid `KeyValuePair&lt;TKey,TValue&gt;` and prefer `Tuple&lt;T1,T2&gt;`. The primary argument being the performance benefit of `Tuple&lt;T1,T2&gt;`.

Outside performance, is there any reason a KVP would be a better choice than a `Tuple&lt;T1,T2&gt;`?

  [1]: http://www.dotnetperls.com/tuple-keyvaluepair

When is it better to use a Tuple versus a KeyValuePair?

I always stumble upon this (rather simple question) when making e.g. Wordpress blogs. Should I wrap the headline, which should also be a link, in a anchor `&lt;a&gt;` element, or should it be the other way around. And why?

**(1)**:

    &lt;a href=&quot;foo&quot;&gt;
        &lt;h1&gt;bar&lt;/h1&gt;
    &lt;/a&gt;

**(2)**:

    &lt;h1&gt;
        &lt;a href=&quot;foo&quot;&gt;bar&lt;/a&gt;
    &lt;/h1&gt;

I always end up doing **(1)**, as it just seems more logical to me, that the headline is wrapped in a link.

Does it make any difference in e.g. SEO? Will it reflect the SEO ranking?

Anchors inside headers, or vice versa - is there a different in relation to SEO?

quick question: is it actually allowed to use the header tag twice? e.g. i have two important head-sections in my header.php where both could have header tag?



html5: using header or footer tag twice?

I asked [this](https://stackoverflow.com/questions/12664230/is-boolean-expression-statement-the-same-as-ifboolean-expression-stat/) question earlier, and after thinking about the topic some more, I began to wonder where the seemingly fuzzy boundary between the meanings of the terms &quot;statement&quot; and &quot;expression&quot; lies.  Are all statements also expressions?  Where do the return values in a REPL console come from? They don&#39;t always seem to make any intuitive sense.  Of course if you type `1+1`, you&#39;ll get `2`, but other times it isn&#39;t as obvious what the logic is.

Given that anything typed into REPL produces *some* value, does it mean that it can be used in JS source code as both an expression and a standalone statement?

can string of code that could be used for `_X_` in the following snippet also be used for `_Y_` and vice versa? `if(_X_) _Y_` 

Javascript: difference between a statement and an expression?

This is a question I have been struggling with for a while. What is the proper way to mark up name/value pairs?

I&#39;m fond of the &amp;lt;dl&amp;gt; element, but it presents a problem: There is no way to separate one pair from another - they have no unique container. Visually, the code lacks definition. Semantically, though, I think this is the correct markup.

    &lt;dl&gt;
        &lt;dt&gt;Name&lt;/dt&gt;
        &lt;dd&gt;Value&lt;/dd&gt;
        &lt;dt&gt;Name&lt;/dt&gt;
        &lt;dd&gt;Value&lt;/dd&gt;
    &lt;/dl&gt;

In the above code, it is difficult to properly offset the pairs visually, both in code and rendered. If I wanted to, for instance, but a border around each pair, that would be a problem.

We may point to tables. It could be argued that name-value pairs are tabular data. That seems incorrect to me, but I see the argument. However, the HTML does not differentiate the name from the value, except in position, or with the addition of class names.

    &lt;table&gt;
        &lt;tr&gt;
            &lt;td&gt;Name&lt;/td&gt;
            &lt;td&gt;Value&lt;/td&gt;
        &lt;/tr&gt;
        &lt;tr&gt;
            &lt;td&gt;Name&lt;/td&gt;
            &lt;td&gt;Value&lt;/td&gt;
        &lt;/tr&gt;
    &lt;/table&gt;

This makes much more sense from a visual standpoint, both in code and in CSS. Styling the aforementioned border is trivial. However, as mentioned above, the semantics are fuzzy at best.

Thoughts, comments, questions?

**Edit/Update**
Perhaps this was something I should have explicitly mentioned in relation to structure, but a definition list also has the problem of not semantically grouping the pairs. The ordering and implicit border between a `dd` and a `dt` is easily understood,  but they still feel slightly off to me.

Semantics and Structure of Name-Value Pairs

Is there a difference between these two statements inside a function?

    bool returnValue = true;
    // Code that does something
    return(returnValue);

and this?

    bool returnValue = true;
    // Code
    return returnValue;

The former has parentheses around `returnValue`.

Are parentheses around the result significant in a return statement?

What is the difference between **GET** and **POST** for **Ajax** requests?

I don&#39;t see any difference between those two, except that when I use **GET**, the parameters are send in URL, which for me don&#39;t really make any difference, since all requests are made on background and user doesn&#39;t find any difference.

edit:
What are **PUT** and **DELETE** methods used for?

GET vs POST in Ajax

Which of the following is the correct way to structure a page:

**1) `h1` only in `header`**

    &lt;header&gt;
    	&lt;h1&gt;Site title&lt;/h1&gt;
    	&lt;nav&gt;...&lt;/nav&gt;
    &lt;/header&gt;
    &lt;section&gt;
    	&lt;h2&gt;Page title&lt;/h2&gt;
    &lt;/section&gt;

If I use `h1` exclusively inside `header` as the site&#39;s title, every page will have the same content for the `h1` tag. That doesn&#39;t seem very informative.


----------


**2) `h1` in `header` and `section`, for both site and page title**

    &lt;header&gt;
    	&lt;h1&gt;Site title&lt;/h1&gt;
    	&lt;nav&gt;...&lt;/nav&gt;
    &lt;/header&gt;
    &lt;section&gt;
    	&lt;h1&gt;Page title&lt;/h1&gt;
    &lt;/section&gt;

I&#39;ve also seen examples of using `h1` more than once, in both `header` and `section` tags. However, isn&#39;t it wrong to have two titles for the same page? This example shows multiple header and `h1` tags http://orderedlist.com/resources/html-css/structural-tags-in-html5/


----------


**3) `h1` only in `section`, emphasizing the page title**

    &lt;header&gt;
    	&lt;p&gt;Site title&lt;/p&gt;
    	&lt;nav&gt;...&lt;/nav&gt;
    &lt;/header&gt;
    &lt;section&gt;
    	&lt;h1&gt;Page title&lt;/h1&gt;
    &lt;/section&gt;

Lastly, W3 seems to recommend using `h1` within the main `section` element, does that mean I shouldn&#39;t use it in the `header` element?

&gt; Sections may contain headings of any rank, but authors are strongly
&gt; encouraged to either use only h1 elements, or to use elements of the
&gt; appropriate rank for the section&#39;s nesting level.



How to properly use h1 in HTML5

What is the difference in meaning between &#39;semantics&#39; and &#39;syntax&#39;?  What are they?

Also, what&#39;s the difference between things like &quot;semantic website vs. normal website&quot;, &quot;semantic social networking vs. normal social networking&quot; etc.


Are semantics and syntax the same?

when to use UL or OL in html?

The result is the one desired; after a bit of trial and error.  I don&#39;t understand what the &quot;2:-&quot; and &quot;3:-&quot; do/mean.  Can someone explain.

    #!/bin/bash
    pid=$(ps -ef | grep java | awk &#39; NR ==1 {print $2}&#39;)
    
    count=${2:-30}  # defaults to 30 times
    delay=${3:-10} # defaults to 10 second
    mkdir $(date +&quot;%y%m%d&quot;)
    folder=$(date +&quot;%y%m%d&quot;)
    while [ $count -gt 0 ]
    do
        jstack $pid &gt;./&quot;$folder&quot;/jstack.$(date +%H%M%S.%N)
        sleep $delay
        let count--
        echo -n &quot;.&quot;
    done


What does the colon dash &quot;:-&quot; mean in bash

input: phrase 1, phrase 2

output: semantic similarity value (between 0 and 1), or the probability these two phrases are talking about the same thing

Is there an algorithm that tells the semantic similarity of two phrases

I am looking at messing around with creating a functional reactive framework at some point. I have read quite a lot about it and seen a few examples but I wanted to get a clear idea of what this framework would HAVE to do to be considered an FRP extension/dsl. I&#39;m not really concerned with implementation problems or specifics etc but more as to what would be desired in a perfect world situation.

What would be the key operations and qualities of an ideal functional reactive programming language?

Specification for a Functional Reactive Programming language

I&#39;m stuck deciding which to use as both seem to work.

Should I be placing links `&lt;a&gt;` inside of `&lt;h2&gt;` elements?

Or the other way around?

What is the correct standard?

Semantically, which is more correct: a in h2, or h2 in a?

Within an article-oriented page (such as a blog post), the `&lt;h1&gt;` element (level 1 heading) is commonly used to markup either:

  - the blog title (i.e. the often-large site title at the top of the page, _not_ to the `&lt;title&gt;` element), or
  - the article title

What is the best choice and why?

To the site owner, who may want to shout out to the world the name of their site/blog, using a level 1 heading around the site title might seem to make sense.

From the perspective of what you are trying to communicate to the user, the site title is of less relevance - the article content is what you&#39;re trying to communicate and all other site content is secondary. Therefore using `&lt;h1&gt;` for the article title seems best.

I feel the `&lt;h1&gt;` element should focus on the article title, not the site title or other content. This does not appear to be a popular convention by any means.

Examples:

  - [Joel Spolsky][1] uses `&lt;h1&gt;` for the article title, and an anchor for the site title
  - [Jeff Atwood][2] uses _no `&lt;h1&gt;` at all_, `&lt;h2&gt;` for the article title and an anchor for the site title
  - [37 Signals&#39; SVN][3] uses `&lt;h1&gt;` for the site title and an anchor for the article title

That&#39;s three different approaches across three sites where you might expect a strong consideration for correct semantic markup.

I think Joel has it right with Jeff a close second. I&#39;m quite surprised at the markup choices by the 37Signals people.

To me it seems quite a simple decision: what is of greatest relevance to the consumer of the article? The article title. Therefore wrap the article title in an `&lt;h1&gt;` element. Done.

Am I wrong? Are there further considerations I&#39;m missing? Am I right? If so, why is the &#39;`&lt;h1&gt;` for article title&#39; approach not more commonly used?

Is the decision of where to use the `&lt;h1&gt;` element as invariable as I put it? Or are there some subjective considerations to be made as well?

**Update**: Thanks for all the answers so far. I&#39;d really appreciate some angle on how the use of the `&lt;h1&gt;` for the article title instead of site title benefits usability and accessibility (or doesn&#39;t, as the case may or may not be). Answers based on fact instead of just personal supposition will get many bonus points!


  [1]: http://joelonsoftware.com/
  [2]: http://codinghorror.com/
  [3]: http://37signals.com/svn/

H1 in article page - site title or article title?

I wish HTML could do something semantically equivalent to this;

    &lt;dl class=&quot;main-list&quot;&gt;
        &lt;definitionitem&gt;
            &lt;dt&gt;Some Thing&lt;/dt&gt;
                &lt;dd&gt;You know it!&lt;/dd&gt;
            &lt;dt&gt;Another Thing&lt;/dt&gt;
                &lt;dd&gt;Word.&lt;/dd&gt;
        &lt;/definitionitem&gt;
        &lt;definitionitem&gt;
            &lt;dt&gt;Stuff&lt;/dt&gt;
                &lt;dd&gt;Alright!&lt;/dd&gt;
        &lt;/definitionitem&gt;
    &lt;/dl&gt;

However, since the closest I&#39;ve come is something I&#39;m not 100% satisfied with the semantics of;

    &lt;div class=&quot;redundant-wrapper&quot;&gt;
        &lt;dl class=&quot;main-list&quot;&gt;
            &lt;dt&gt;Some Thing&lt;/dt&gt;
                &lt;dd&gt;You know it!&lt;/dd&gt;
            &lt;dt&gt;Another Thing&lt;/dt&gt;
                &lt;dd&gt;Word.&lt;/dd&gt;
        &lt;/dl&gt;
        &lt;dl class=&quot;another-main-list&quot;&gt;
            &lt;dt&gt;Stuff!&lt;/dt&gt;
                &lt;dd&gt;Alright!&lt;/dd&gt;
        &lt;/dl&gt;
    &lt;/div&gt;

I was wondering if anyone has any other ideas of how you might do this?

Also, the reason the items would be grouped is because they are visually grouped in the content that is being marked up. Imagine a dictionary page, with a single definition list, where each definition is in an inset box that is floated left. I run into this situation all the time.

All Semantics Solutions on Gang of Coders

Total of 35 Semantics Solutions