小编fin*_*nce的帖子

我正在尝试使用 Material-ui 框架创建一个英雄横幅。

到目前为止我所看到的如下：

正如您所看到的，左右填充很烦人。我似乎无法摆脱它。

我的英雄组件如下所示：

import React from 'react'

import Container from '@material-ui/core/Container'

import { makeStyles } from '@material-ui/core'

const useStyles = makeStyles((theme) => ({
    heroContent: {
        backgroundColor: theme.palette.background.paper,
        padding: theme.spacing(8, 0, 6),
    },
    heroButtons: {
        marginTop: theme.spacing(4),
    },
}))

const Hero = () => {
    const classes = useStyles()

    return <Container className={classes.heroContent}></Container>
}

export default Hero

有人可以解释一下如何去掉左侧和右侧的填充并实现全宽度吗？

我尝试在样式中设置填充，如您所见，但这没有效果。任何指导表示赞赏！

我已经使用 Firebase 和 React 构建了应用程序，并且该过程非常无缝。

最近我被要求使用AWS Cognito，由于文档不清楚，设置起来似乎有点痛苦。

首先，如何使用 Cognito 进行用户身份验证？我使用以下应用程序客户端设置设置了一个用户池：

现在，我将授权者添加到我的 API 中，如下所示：

现在我的问题是，如何在我的前端中使用它来登录用户并进行经过身份验证的 API 调用？

似乎有两种不同的工具包可用：

1. https://github.com/aws/aws-sdk-js
2. https://github.com/aws-amplify/amplify-js

对于初学者来说，根本不清楚该使用什么以及如何进行身份验证。理想情况下，我会像 Firebase 一样使用它，只需让我的前端使用电子邮件和密码进行身份验证调用，然后接收某种令牌（仅在成功时），然后可以使用该令牌来制作签名 API来电。

有人可以帮忙提供代码示例吗？

我正在将应用程序从 Firebase 迁移到 AWS Amplify。我想创建一个 React 上下文，如果用户未登录，它将提供路由保护。

例如，我的 Auth.js 文件：

import React, { useEffect, useState, createContext } from 'react'
import fire from './firebase'

export const AuthContext = createContext()

export const AuthProvider = ({ children }) => {
    const [currentUser, setCurrentUser] = useState(null)

    useEffect(() => {
        fire.auth().onAuthStateChanged(setCurrentUser)
    }, [])

    return (
        <AuthContext.Provider value={{ currentUser }}>
            {children}
        </AuthContext.Provider>
    )
}

我的 App.js 文件：

import * as React from 'react'
import { BrowserRouter, Switch, Route } from 'react-router-dom'

import Navbar from './components/navbar/navbar'
import …

我正在自己学习 Scala 并遇到了这个问题。继Link的优秀答案之后，假设我有以下代码：

object Example extends App {
  val x = Seq(1, 2, 3)
  val y = Seq("1", "2", "3")

  class Or[A, B]
  implicit def orA[A, B](implicit ev: A): Or[A, B] = new Or
  implicit def orB[A, B](implicit ev: B): Or[A, B] = new Or

  def f1[T](seq: Seq[T])(implicit ev: Or[T =:= Int, T =:= String]) = {
    println(seq)
  }

  f1(Seq(1, 2, 3))
  f1(Seq("1", "2", "3"))
}

这编译得很好。但是现在让我们假设我更改了函数，以便它需要一个序列列表，而不仅仅是序列，然后尝试以下操作：

object Example extends App {
  val x = Seq(1, 2, 3) …

我正在构建一个 React 应用程序。总的来说，我对 React 和 JS 都很陌生。

我尝试将swiperjs库导入到现有的 React 项目中：

import React, { Component } from "react";
import { Swiper, SwiperSlide } from 'swiper/react';

function HomeBanner(props) {

    return (
        <div >
            <div>
                <img src="img/slider/home-3/home-banner/1.jpg" alt="" />
                <div className="">
                    <h5>Mega Sale Nov 2019</h5>
                    <h3>
                        Double Combo With <br />
                        The Body Shop
                    </h3>
                    <p>Sale up to <strong>50% Off </strong></p>
                    <a className="ps-btn" href="#">Shop Now</a>
                </div>
            </div>
            <div>
                <img src="img/slider/home-3/home-banner/2.jpg" alt="" />
                <div className="">
                    <h5>Mega Sale Nov 2017</h5>
                    <h3>
                        IKEA Minimalist …

我正在做一些我在案例类和类型类上发明的练习。我遇到的问题之一如下：

object Example extends App {

  sealed trait Serializer[T] {
    def serialize(seq: List[T]): String
  }

  implicit object StringSerializer extends Serializer[String] {
    def serialize(seq: List[String]): String = seq.toString()
  }

  implicit object IntSerializer extends Serializer[Int] {
    def serialize(seq: List[Int]): String = seq.toString()
  }

  case class Marker[T: Serializer](lst: Option[List[T]] = None)
  
  Marker() // ambiguous implicit values: here...
}

现在这给出了关于不明确的隐含值的错误。我认为这与我之前问过的一个问题有关（尽管是不同的错误消息）：

在具有给定上下文绑定的嵌套列表中键入擦除

我是否正确，即使错误消息不同，这里的工作过程也是相同的？

我正在尝试清理我的用户 api，以便用户可以整齐地从单个包对象导入，并获取所有内容。我意识到我可以将我的包裹移动到顶部包裹中，但我想知道是否有办法执行以下操作（我知道这可能不是最佳实践）：

我有以下软件包：

package org.Me.packages.packageA

case class A() {
// some implementation
}

package org.Me.packages.packageB

case class B() {
// some implementation
}

现在这将需要导入表单：

import org.Me.packages.packageA.A
import org.Me.packages.packageB.B

我被要求做的是以下内容：

package org.Me.combinedPackages

package object Combined {
   import org.Me.packages.packageA.A
   import org.Me.packages.packageB.B 
}

这样我的最终用户就可以简单地执行以下操作：

import org.Me.combinedPackages._

// access both a and b here

从我在这里读到的，我理解这意味着嵌套导入是不可能的。

那么我想要做的事情是不可能的吗？我意识到存在其他方式。