Zach Gollwitzer zachgoll

## git-question.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                zachgoll
                / git-question.md
            
            
              Last active
              March 14, 2020 16:13
            
          
    How would another contributor access these branches? To get started I suppose it's git clone, but can you git clone later too when you already have and old version of the repo? Or do you manually create branches locally and then pull those?
Think about this in terms of remote vs. local.  Any branch that is local can only be accessed by the person who has created it.  Once that person pushes it up to the remote repository, it is now accessible by all those who can see the remote repository.
The git clone command should only be done once, at the very beginning.  If you want to grab updates later, you would use the git pull command, which is a combination of git fetch and git merge.
**Why is it that you have to specify what branch you are pushing to? I mean it seems a lot safer to automatically push the current branch to the remote branch with the same name (is there any way to do that, so that when I push my feat1 branch it will be pushed to the remote feat1 branch, without risking pushing master

  
## map-operator.js
const { interval } = Rx;
const { map, take } = RxOperators;

// The input observable will emit the values 1, 2, 3
// in 1 second intervals
function inputObservable() {
  const returnValues = [1, 2, 3];
  return interval(1000)
    .pipe(
    	take(returnValues.length),

## take-operator.js
const { interval } = Rx;
const { map, take } = RxOperators;

// The input observable will emit the values 1, 2, 3
// in 1 second intervals
function inputObservable() {
  const returnValues = [1, 2, 3];
  return interval(1000)
    .pipe(
    	take(returnValues.length),

## switchmap-2.js
obs1$.switchMap(
  (x) => {
    return obs2$.pipe(
      map((y) => {
        return "" + x + y;
      })
    );
  }
);

## switchmap-2.js
// Note: The "$" is a convention that is used to denote an Observable variable type and does nothing than add styling
outerObs$.pipe(switchMap(
  (outerObservableValue) => {
    return innerObservable$.pipe(
      map((innerObservableValue) => {
        return
      })
    );
  }
))

## switchmap-example.js
const { interval, Observable } = Rx;
const { map, take, switchMap, startWith } = RxOperators;

// Emit value 1 at 1 second
// Emit value 3 at 4 seconds
// Emit value 5 at 5.5 seconds
// Complete at 5.5 seconds
function outerObservable() {
  return new Observable(subscriber => {
    setTimeout(() => {

## mergeMapTo-example.js
const { interval, Observable } = Rx;
const { map, take, switchMap, startWith, mergeMapTo } = RxOperators;

function outerObservable() {
  return new Observable(subscriber => {
    setTimeout(() => {
    	subscriber.next("A");
    }, 1000);

    setTimeout(() => {

## correct-date-example.html
<html>
  <head>
    <style>
      body {
        padding: 20px;
      }
    </style>
  </head>
  <body>
    <h2>Date example web app</h2>

## incorrect-date-example.html
<html>
  <head>
    <style>
      body {
        padding: 20px;
      }
    </style>
  </head>
  <body>
    <h2>Date example web app</h2>

## asking-user-timezone.html
<html>
  <head>
    <style>
      body {
        padding: 20px;
      }
    </style>
  </head>
  <body>
    <h2>Date example web app</h2>
	const { interval } = Rx;
	const { map, take } = RxOperators;

	// The input observable will emit the values 1, 2, 3
	// in 1 second intervals
	function inputObservable() {
	const returnValues = [1, 2, 3];
	return interval(1000)
	.pipe(
	take(returnValues.length),
	obs1$.switchMap(
	(x) => {
	return obs2$.pipe(
	map((y) => {
	return "" + x + y;
	})
	);
	}
	);
	// Note: The "$" is a convention that is used to denote an Observable variable type and does nothing than add styling
	outerObs$.pipe(switchMap(
	(outerObservableValue) => {
	return innerObservable$.pipe(
	map((innerObservableValue) => {
	return
	})
	);
	}
	))
	const { interval, Observable } = Rx;
	const { map, take, switchMap, startWith } = RxOperators;

	// Emit value 1 at 1 second
	// Emit value 3 at 4 seconds
	// Emit value 5 at 5.5 seconds
	// Complete at 5.5 seconds
	function outerObservable() {
	return new Observable(subscriber => {
	setTimeout(() => {
	const { interval, Observable } = Rx;
	const { map, take, switchMap, startWith, mergeMapTo } = RxOperators;

	function outerObservable() {
	return new Observable(subscriber => {
	setTimeout(() => {
	subscriber.next("A");
	}, 1000);

	setTimeout(() => {
	<html>
	<head>
	<style>
	body {
	padding: 20px;
	}
	</style>
	</head>
	<body>
	<h2>Date example web app</h2>