Breno Romeiro obrenoco

## window-quick-explanation.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                obrenoco
                / window-quick-explanation.md
            
            
              Created
              May 4, 2022 02:09
            
          
## pre-load.html
<div id="loading-page" class="loading-page">
  <div class="loader"></div>
</div>
<div class="content">
  <h1>Page loaded!</h1>
</div>

## clipboard.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>Static Template</title>
  </head>
  <body></body>
  <script>

## shuffle-array.js
function shuffle(array) {
  var m = array.length, t, i;
  while (m) {
    i = Math.floor(Math.random() * m--);
    t = array[m];
    array[m] = array[i];
    array[i] = t;
  }
  return array;
}

## fibonacci.ts
// using phi - best performance
// see: https://akuli.github.io/math-tutorial/fib.html
function fibonacciGoldenRation(n: number) {
  const phi = (1 + Math.sqrt(5))/2;
  const asymptotic = Math.pow(phi, n) / Math.sqrt(5);
  return Math.round(asymptotic);
}

// using for() loop
const fibonacciForLoop = (num: number) => {

## package.json
{
  "name": "learn-semver",
  "dependencies": {
    "update-patch": "~0.0.1",
    "update-minor": "^0.1.0"
  },
}

## rebuild-usecallback-usememo.tsx
type CallbackProps = (...args: any[]) => any;
const useCallback2 = <T extends CallbackProps>(
  y: T,
  dependencies: unknown[]
): T => {
  const [myState, setMyState] = useState<T>(() => y);
  useEffect(() => {
    setMyState(() => y);
  }, dependencies);
  return myState;

## html-tags-details-summary.html
<!DOCTYPE html>
<html>
  <head>
    <style>
      summary {
        cursor: pointer;
        list-style: none;
      }
      details[open] summary ~ * {
        animation: toggle 0.1s ease-in-out;

## import.js
// Default importing
import Func from 'utils'

// Entire content importing
import * as Utils from 'utils'

// Selective importing
import {Func} from 'utils'

// Selective importing with alias

## prototypes-classes.js
// Functional Instantiation
// the weakness of this pattern is that whenever we create
// a new person, we have to re-create all the methods in memory,
// which is not cool..
function Person (name, energy) {
  let person = {}
  person.name = name
  person.energy = energy

  person.eat = function (amount) {
	<div id="loading-page" class="loading-page">
	<div class="loader"></div>
	</div>
	<div class="content">
	<h1>Page loaded!</h1>
	</div>
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8" />
	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
	<meta http-equiv="X-UA-Compatible" content="ie=edge" />
	<title>Static Template</title>
	</head>
	<body></body>
	<script>
	function shuffle(array) {
	var m = array.length, t, i;
	while (m) {
	i = Math.floor(Math.random() * m--);
	t = array[m];
	array[m] = array[i];
	array[i] = t;
	}
	return array;
	}
	// using phi - best performance
	// see: https://akuli.github.io/math-tutorial/fib.html
	function fibonacciGoldenRation(n: number) {
	const phi = (1 + Math.sqrt(5))/2;
	const asymptotic = Math.pow(phi, n) / Math.sqrt(5);
	return Math.round(asymptotic);
	}

	// using for() loop
	const fibonacciForLoop = (num: number) => {
	{
	"name": "learn-semver",
	"dependencies": {
	"update-patch": "~0.0.1",
	"update-minor": "^0.1.0"
	},
	}
	type CallbackProps = (...args: any[]) => any;
	const useCallback2 = <T extends CallbackProps>(
	y: T,
	dependencies: unknown[]
	): T => {
	const [myState, setMyState] = useState<T>(() => y);
	useEffect(() => {
	setMyState(() => y);
	}, dependencies);
	return myState;
	<!DOCTYPE html>
	<html>
	<head>
	<style>
	summary {
	cursor: pointer;
	list-style: none;
	}
	details[open] summary ~ * {
	animation: toggle 0.1s ease-in-out;
	// Default importing
	import Func from 'utils'

	// Entire content importing
	import * as Utils from 'utils'

	// Selective importing
	import {Func} from 'utils'

	// Selective importing with alias
	// Functional Instantiation
	// the weakness of this pattern is that whenever we create
	// a new person, we have to re-create all the methods in memory,
	// which is not cool..
	function Person (name, energy) {
	let person = {}
	person.name = name
	person.energy = energy

	person.eat = function (amount) {