string is an alias in C# for System.String.
So technically, there is no difference. It's like int vs. System.Int32.

As far as guidelines, it's generally recommended to use string any time you're referring to an object.

e.g.
***
string place = "world";
***
Likewise, I think it's generally recommended to use String if you need to refer specifically to the class.

e.g.
***
string greet = String.Format("Hello {0}!", place);
***

px - Pixels - point per scale corresponds to actual pixels on the screen.

i - Inches - based on the physical size of the screen.

mm - Millimeters - based on the physical size of the screen.

pt - Points - 1/72 of an inch based on the physical size of the screen.

dp - Density-independent Pixels - an abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi screen, so one dp is one pixel on a 160 dpi screen. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Note: The compiler accepts both dip and dp, though dp is more consistent with sp.

sp - scalable pixels - this is like the dp unit, but it is also scaled by the user's font size preference. It is recommended that you use this unit when specifying font sizes, so they will be adjusted for both the screen density and user's preference.

Take the example of two screens that are the same size but one has a screen density of 160 dpi (dots per inch, i.e. pixels per inch) and the other is 240 dpi.
***
Lower resolution screen Higher resolution, same size
Physical Width 1.5 inches 1.5 inches
Dots Per Inch (“dpi”) 160 240
Pixels (=width*dpi) 240 360
Density (factor of baseline 160) 1.0 1.5

Density-independent pixels 240 240
(“dip” or “dp” or “dps”)

Scale-independent pixels
(“sip” or “sp”) Depends on user font size settings same
***

PUT /user/12345 HTTP/1.1 <-- create the user providing the id 12345
Host: mydomain.com

GET /user/12345 HTTP/1.1 <-- return that user
Host: mydomain.com
Otherwise, use POST to initially create the object, and PUT to update the object:

POST /user HTTP/1.1 <--- create the user, server returns 12345
Host: mydomain.com

PUT /user/12345 HTTP/1.1 <--- update the user
Host: mydomain.com

An illustration of when to prefer the first method to the second one is when you need to avoid overriding a function's previous definitions.

With
***
if (condition){
function myfunction(){
// Some code
}
}
***
, this definition of myfunction will override any previous definition, since it will be done at parse-time.

While
***
if (condition){
var myfunction = function (){
// Some code
}
}
***
does the correct job of defining myfunction only when condition is met.

let is interesting, because it allows us to do something like this:
***
(() => {
var count = 0;

for (let i = 0; i < 2; ++i) {
for (let i = 0; i < 2; ++i) {
for (let i = 0; i < 2; ++i) {
console.log(count++);
}
}
}
})();
***
Which results in counting [0, 7].

Whereas
***
(() => {
var count = 0;

for (var i = 0; i < 2; ++i) {
for (var i = 0; i < 2; ++i) {
for (var i = 0; i < 2; ++i) {
console.log(count++);
}
}
}
})();
***
Only counts [0, 1].

URI => Uniform Resource Identifier Identifies a complete address of resource i-e location, name or both.

URL => Uniform Resource Locator Identifies location of the resource.

URN => Uniform Resource Name Identifies the name of the resource

***
import React, { PureComponent, Fragment } from 'react';
import ReactDOM from 'react-dom';

class Select extends PureComponent {
state = {
options: [
{
name: 'Select…',
value: null,
},
{
name: 'A',
value: 'a',
},
{
name: 'B',
value: 'b',
},
{
name: 'C',
value: 'c',
},
],
value: '?',
};

handleChange = (event) => {
this.setState({ value: event.target.value });
};

render() {
const { options, value } = this.state;

return (


{options.map(item => (

{item.name}

))}

Favorite letter: {value}

);
}
}

ReactDOM.render(, window.document.body);
***

4 years ago

Ques:  OnChange event using React JS for drop down

the best way to concat props/variables:
***
var sample = "test";
var result = `this is just a ${sample}`;
//this is just a test
***

4 years ago

Ques:  Concatenating variables and strings in React

useState is one of the hooks available in React v16.8.0. It basically lets you turn your otherwise non-stateful/functional components to one that can have its own state.

At the very basic level, it's used this way:
***
const [isLoading, setLoading] = useState(true);
***
This then lets you call setLoading passing a boolean value. It's a cool way of having "stateful" functional component.

4 years ago

Ques:  What is useState() in React?

To remove an element from an array, just do:
***
array.splice(index, 1);
***
In your case:
***
removePeople(e) {
var array = [...this.state.people]; // make a separate copy of the array
var index = array.indexOf(e.target.value)
if (index !== -1) {
array.splice(index, 1);
this.setState({people: array});
}
},
***

4 years ago

Ques:  Delete item from state array in react

Set the environment variable in the script command:
***
...
"scripts": {
"start": "node app.js",
"test": "NODE_ENV=test mocha --reporter spec"
},
...
***
Then use process.env.NODE_ENV in your app.

Note: This is for Mac & Linux only. For Windows refer to the comments.

4 years ago

Ques:  How to set environment variables from within package.json?

In the file you put in /etc/init.d/ you have to set it executable with:
***
chmod +x /etc/init.d/start_my_app
***
Thanks to @meetamit, if this does not run you have to create a symlink to /etc/rc.d/
***
ln -s /etc/init.d/start_my_app /etc/rc.d/
***
Please note that on latest Debian, this will not work as your script have to be LSB compliant (provide, at least, the following actions: start, stop, restart, force-reload, and status)

As a note, you should put the absolute path of your script instead of a relative one, it may solves unexpected issues:
***
/var/myscripts/start_my_app
***
And don't forget to add on top of that file:
***
#!/bin/sh
***

4 years ago

Ques:  How to run a shell script at startup