修改用户所属组：

const scaleNames = {
  c: 'Celsius',
  f: 'Fahrenheit'
};

function toCelsius(fahrenheit) {
  return (fahrenheit - 32) * 5 / 9;
}

function toFahrenheit(celsius) {
  return (celsius * 9 / 5) + 32;
}

function tryConvert(temperature, convert) {
  const input = parseFloat(temperature);
  if (Number.isNaN(input)) {
    return '';
  }
  const output = convert(input);
  const rounded = Math.round(output * 1000) / 1000;
  return rounded.toString();
}

function BoilingVerdict(props) {
  if (props.celsius >= 100) {
    return <p>The water would boil.</p>;
  }
  return <p>The water would not boil.</p>;
}

class TemperatureInput extends React.Component {
  constructor(props) {
    super(props);
    this.handleChange = this.handleChange.bind(this);
  }

  handleChange(e) {
    this.props.onTemperatureChange(e.target.value);
  }

  render() {
    const temperature = this.props.temperature;
    const scale = this.props.scale;
    return (
      <fieldset>
        <legend>Enter temperature in {scaleNames[scale]}:</legend>
        <input value={temperature}
               onChange={this.handleChange} />
      </fieldset>
    );
  }
}

class Calculator extends React.Component {
  constructor(props) {
    super(props);
    this.handleCelsiusChange = this.handleCelsiusChange.bind(this);
    this.handleFahrenheitChange = this.handleFahrenheitChange.bind(this);
    this.state = {temperature: '', scale: 'c'};
  }

  handleCelsiusChange(temperature) {
    this.setState({scale: 'c', temperature});
  }

  handleFahrenheitChange(temperature) {
    this.setState({scale: 'f', temperature});
  }

  render() {
    const scale = this.state.scale;
    const temperature = this.state.temperature;
    const celsius = scale === 'f' ? tryConvert(temperature, toCelsius) : temperature;
    const fahrenheit = scale === 'c' ? tryConvert(temperature, toFahrenheit) : temperature;

    return (
      <div>
        <TemperatureInput
          scale="c"
          temperature={celsius}
          onTemperatureChange={this.handleCelsiusChange} />
        <TemperatureInput
          scale="f"
          temperature={fahrenheit}
          onTemperatureChange={this.handleFahrenheitChange} />
        <BoilingVerdict
          celsius={parseFloat(celsius)} />
      </div>
    );
  }
}

ReactDOM.render(
  <Calculator />,
  document.getElementById('root')
);

// sub-component
function ListItem(props) {
  // Correct! There is no need to specify the key here:
  return <li>{props.value}</li>;
}

function NumberList(props) {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    // Correct! Key should be specified inside the array.
    <ListItem key={number.toString()}
              value={number} />

  );
  return (
    <ul>
      {listItems}
    </ul>
  );
}

class Clock extends React.Component {
  constructor(props) {
    // 确保 props 能够正确传入；
    super(props);
    // Bind this
    this.handler = this.handler.bind(this);
    this.state = {
      date: new Date(),
      counter: 0,
      showWarning: true
    };
  }
  // 生命周期 Hook 函数；
  componentDidMount() {
    // 不需要在 View 中显示的属性不需要放到 State 中；
    this.timerID = setInterval(
      () => this.tick(),
      1000
    );
  }

  componentWillUnmount() {
    clearInterval(this.timerID);
  }

  tick() {
    this.setState({
      date: new Date()
    });
  }
  
  handler() {
    this.setState({
      counter: this.state.counter + 1
    });
  }

  render() {
    const numbers = [1, 2, 3, 4, 5];
    // JSX 中的 Callback 函数需要在构造函数中绑定 this 指针；
    return (
      <div>
        <NumberList numbers={numbers} />
        <h1 onClick={this.handler}>Hello, {this.props.user.toString()}!</h1>
        <h2>It is {this.state.date.toLocaleTimeString()}.</h2>
        <h2>Counter: {this.state.counter}</h2>
        <p>{this.state.counter > 2 && <WarningBanner warn={this.state.counter} />}

      </div>
    );
  }
}

ReactDOM.render(
  <Clock user="YHSPY"/>,
  document.getElementById('root')
);

var util = require('util')

const wait = (delay, callback) => {
  const id = setInterval(() => {
    const rand = Math.random()
    if (rand > 0.95) {
      callback('Got data successfully!', null)
      clearInterval(id)
    } else if (rand < 0.1) {
      callback(null, 'Sorry, something wrong!') 
      clearInterval(id)
    } else {
      console.log("Waiting...")
    }
  }, Number(delay))
}

/*
  wait(1000, (data, err) => {
    if (err) {
      throw new Error(err)
    }
    console.log(data)
  })
*/

// Use util.promisify
util.promisify(wait)(1000).then(data => {
  console.log(data);
}).catch(err => {
  console.error(err);
})

// Use async/await instead
waitAsync = util.promisify(wait)
let asyncFunc = async () => {
  let result;
  try {
    result = await waitAsync(1000);
  } catch (err) {
    return console.error(err);
  }
  return console.log(result);
};
asyncFunc().then(data => {
  // undefined
  console.log(data)
})

public static int majorityElement(int[] nums) {
    if (nums.length == 0)  // 如果数组长度为0则返回-1
    	return -1;
    
    int arrLen = nums.length;
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0;i < arrLen; i ++) {
    	int currentVal = 0;
    	if (map.containsKey(nums[i]))  // 如果HashMap中存在该值对应的元素则使用该值
    		currentVal = map.get(nums[i]);

    	if (currentVal > arrLen / 2) {  // 如果满足条件则返回该元素
    		return nums[i];
    	} else {
    		map.put(nums[i], currentVal + 1);  // 否则对应元素值加一
    	}
    }
    
    return -1;
}

public static boolean containsDuplicateOptimizeFurther(int[] nums) {
    Set<Integer> set = new HashSet<Integer>();  
    int start = 0, end = 0;  // 定义窗口的首尾指针
    for(int i = 0; i < nums.length; i++) {   // 开始遍历
        if(!set.contains(nums[i])) {    
            set.add(nums[i]);   
            end++;   // 如果Set中没有此元素则加入，尾指针后移
        } else { 
            return true;   // 有则返回True
        }
        
        if(end - start  > k) {  // 保持首尾指针距离不大于k  
            set.remove(nums[start]);    //如果大于则移除首指针元素
            start++;   // 移除后首指针后移
        }  
    }  
    return false;
}