lucasrmagalhaes / homework-issues Goto Github PK

Continuous Integration/Continuous Delivery: uma técnica para integrar, entregar e implantar aplicações de forma contínua.

class

dotnet build

Nem todos os membros são herdados.

É um host Git open source capaz de organizar repositórios em grupos, além de possuir estruturas CI/CD.

Version Control System: sistemas gerenciadores de versões mantém um registro detalhado de modificações do código. Além disso, são importantes para manter o controle de alterações e compartilhamento de código-fonte.

Utilizando a gestão de dependências você é capaz de fazer a configuração do seu Gradle corretamente.

Também podem ser utilizadas outras anotações para auxiliar no mapeamento da classe, tais como: @id, @column, @table, @OneToMany e @manytoone.

@entity

I - <React.Fragment>DIO</React.Fragment>
II - <>React</>
III - <React.Fragment key=”xpto”>Lista</React.Fragment>
IV - <React.useFragment>foo</React.useFragment>
V - <MyContext.Context>Provider</MyContext.Context>

I, II e III estão corretas.

Esses artefatos estão presentes no pacote ________ que ajudam a manter o código independente da implementação utilizada. Lembrando que para persistir dados com JPA, não é preciso escolher uma implementação que irá executar todo o trabalho.

javax.persistence

Um componente com render props recebe uma função, que retorna um elemento React e executa-o ao invés de implementar a sua própria lógica.

Uma tecnologia de versionamento distribuído (cada cópia do repositório mantem o histórico completo de alterações), open source e com alto desempenho.

I - Deve possuir estado
II - Deve possuir dependência externa
III - Não deve possuir estilo próprio (css)
IV - Só pode existir dentro de Containers
V - É criado somente para compartilhar rotas

Todas estão erradas.

ApiException

import React, { memo, useState } from 'react'
import Button from '../Button'

function PhotosGallery(props) {
  const { photos } = props

  const [gallery, setGallery] = useState(photos)
  
  const handleRemove = (key) => {
    const newGallery = gallery.filter((img, index) => index !== key) 
    setGallery(newGallery)
  }

  const renderPhotos = (img, key) => {
    return (
      <div>
        <img src={img} />
        <Button onClick={() => handleRemove(key)}>
          Remover {key}
        </Button>
      </div>
    )
  }

  return (
    <div>
      {gallery.map(renderPhotos)}
    </div>
  )
}

export default memo(PhotosGallery)

Possui Dumb Components, possui estado, manipula dos dados que está recebendo, preocupando-se como as coisas vão funcionar.

I - Preopcupa-se como as coisas vão funcionar.
II - Não possui estado.
III - Deve contar somente Dumb Components.
IV - Na maioria dos casos possui estado e pode chamar outros fluxos da aplicação.

I e IV estão corretas.

Limpar objetos não utilizados da memória.

O termo Render Props é uma técnica de compartilhamento de código entre componentes React passando uma função através de propriedade.

Deve ser utilizado para manipular “focus”, seleção de texto ou mídia, bilbioteca de terceiros e disparar eventos imperativos.

Não versionado, não modificado, modificado e staged.

both static and final

Uma interface define um contrato que pode ser implementado por classes e structs.

mockMvc.perform(
	put("/v1/soldado")
        	.header("meu_header", "")
                .content(jsonInString)
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk());

@PutMapping("/v1/soldado")

Razor é uma View Engine utilizada no ASP.NET MVC.

As structs são tipos de valor e requerem alocação de heap.

mkdir

Preocupa-se com a apresentação e recebe valores via props.

dotnet run

Alta coesão.

function Button(props) {
	const { children, onClick } = props

	return (
		<button className="button" onClick={onClick}>
			{children}
		 </button>
 	)
}

O componente não possui dependência com terceiros, recebendo todos valores via props.

Captura de erros que ocorreram no React.

public class testmeth {
	static int i = 1;
	
	public static void main(String args[]) {
		System.out.println(i+” , “);
		m(i);
		System.out.println(i);
	}

	public void m(int i) {
		i += 2;
	}
}

1 , 1

UserGallery e AccountBank.

Controlar as alterações (versões) de uma determinada estrutura e/ou arquivo, o GitLab é um exemplo de ferramenta de versionamento de código-fonte.

inputRef.current.focus()

persistence.xml

Quando um valor errado é enviado através de uma prop, um warning vai ser apresentado no console JavaScript.

myComponent.propTypes = { name: PropTypes.string.isRequired }

import React from 'react'
import PropType from 'prop-types'

function Calc(props) {
  const { min, max, onChange } = props

  return (
    <div>
      <p>
        Valor mínimo: {min}
      </p>
      <p>
        Valor máximo: {max}
      </p>
      <input type="text" onChange={onChange} />
    </div>
  )
}

Calc.propTypes = {
  min: PropType.number.isRequired,
  max: PropType.number.isRequired,
  onChange: PropType.func.isRequired,
}

export default Calc

Não possui estado, recebe valores via props, preocupa-se somente com a apresentação.

É um padrão do React para um componente retornar múltiplos elementos.

GitTak

Expected Exceptions, Expected Exceptions Rules e Try / Catch Idiom.

Criamos uma propriedade pública que tenha get e set.

I - Button
II - Card
III - UserFilter
VI - UserGallery
V - Modal

I, II e V estão corretos.

Quantos forem necessários, Error Boundary pode ser criado de forma granular.

commit

Esta frase sintetiza qual princípio?

Dependency Inversion Principle.

Grupo de instruções que são executadas em estágios, geralmente relacionados aos processos de CI/CD.

React é somente uma biblioteca e não possui uma forma de estruturar o projeto, existem boas práticas mas a forma de como a arquitetura vai ser construída fica a cargo da equipe de desenvolvedores.

Não há limites para criação de Smart Components.