- 在VisualStudio中部署GDAL库的C++版本(包括SQLite、PROJ等依赖)
- Android开机流程介绍
- STM32CubeMX教程31USB_DEVICE-HID外设_模拟键盘或鼠标
- 深入浅出Java多线程(五):线程间通信
大家好,这里是白泽。《Go语言的100个错误以及如何避免》是最近朋友推荐我阅读的书籍,我初步浏览之后,大为惊喜。就像这书中第一章的标题说到的:“Go: Simple to learn but hard to master”,整本书通过分析100个错误使用 Go 语言的场景,带你深入理解 Go 语言.
我的愿景是以这套文章,在保持权威性的基础上,脱离对原文的依赖,对这100个场景进行篇幅合适的中文讲解。所涉内容较多,总计约 8w 字,这是该系列的第一篇文章,对应书中第1-10个错误场景.
🌟 当然,如果您是一位 Go 学习的新手,您可以在我开源的学习仓库中,找到针对《Go 程序设计语言》英文书籍的配套笔记,期待您的 star.
公众号【白泽talk】,聊天交流群:622383022,原书电子版可以加群获取.
🌟 章节概述:
- 为什么 Go 高效、可扩展、富有生产力
- 为什么说 Go 易学难精
- 介绍开发者常犯的几种类型的错误
Go 语言层面通过 goroutines 和 channels 提供了出色的并发编程机制,无需像其他语言一样使用第三方高性能的库,本身就具备高性能,战未来! 。
一位大厂的前辈留下的五字箴言:
简单:易于理解,方便学习(鄙视链大概是从这里来的) 。
容易:不怎么努力就可以全面掌握(这一点每一个语言都是如此) 。
书中这部分举例开源项目 docker、grpc、k8s 论证使用 channel 在 goroutines 间传递 message,经常编码失误导致问题。因为 goroutines 间是并发运行的,执行顺序无法预测。区别于纯流程式的编程,将解决一个问题分成 n 个步骤,然后依次编码,依次调用其他函数,按序执行.
为了发挥 Go 的并发支持能力,知名 Go 项目中大量使用 goroutines & channels 用作控制程序的执行顺序,而不仅仅是代码编写的顺序决定执行顺序。当各种日志、状态、消息需要在你的程序中传递,那免不了需要仔细编排 message 的流转和流程控制.
毕竟,我们都知道解决并发问题的的最好办法:不用并发。使用 Go 可以不用 channel,甚至不用除了主协程之外的 goroutines,那一定十分安全,但这违背了使用 Go 语言的初衷,也就无法发挥它的能力.
🌟 总结:Go 的高性能是建立在合理的编码之上的。给你独步天下的招式,但也需要你修炼内功,简单不等于容易.
因人为使用不当造成的,使用 Go 的100个错误场景可以分成以下几种类型,:
通过对错误使用场景的分析,可以有针对性的加深我们对 Go 语言的理解,让我们开始吧.
🌟 所有标题中使用#number的形式,标明这是第几个错误场景 。
🌟 章节概述:
- 主流的代码组织方式
- 高效的抽象:接口和范型
- 构建项目的最佳实践
Go 语言当中,在一个块作用域中声明的变量,可以在更内部的块中被重新声明.
错误示例:
var client *http.Client
if tracing {
client, err := createClientWithTracing()
if err != nil {
return err
}
log.Println(client)
} else {
client, err := createDefaultClient()
if err != nil {
return err
}
log.Println(client)
}
// 使用 client
client 在内部块中被重新声明,并使用,并不改变外部的 client 的值,所以外部 client 始终为 nil,且由于外部 client 在下文被使用,编译时不会报 “client declared and not used” 的错误.
修正方案:
var client *http.Client
var err error
if tracing {
client, err = createClientWithTracing()
} else {
client, err = createDefaultClient()
}
if err != nil {
// 处理 err
}
// 使用 client
短变量声明符号 := 会重新声明变量,这里替换成赋值操作,并统一处理 err.
错误示例:
func join(s1, s2 string, max int) (string, error) {
if s1 == "" {
return "", errors.New("s1 is empty")
} else {
if s2 == "" {
return "", errors.New("s2 is empty")
} else {
concat, err := concatenate(s1, s2)
if err != nil {
return "", err
} else {
if len(concat) > max {
return concat[:max], nil
} else {
return concat, nil
}
}
}
}
}
func concatenate(s1, s2 string) (string, error) {
// ...
}
由于复杂的嵌套导致无法直观阅读所有的 case 的执行流程.
修正方案:
func join(s1, s2 string, max int) (string, error) {
if s1 == "" {
return "", errors.New("s1 is empty")
}
if s2 == "" {
return "", errors.New("s2 is empty")
}
concat, err := concatenate(s1, s2)
if err != nil {
return "", err
}
if len(concat) > max {
return concat[:max], nil
}
return concat, nil
}
func concatenate(s1, s2 string) (string, error) {
// ...
}
减少 if 之后没有必要的 else 嵌套,使得所有 case 可以一眼明了.
🌟 书中用 happy path 这个概念,表示决定程序执行流程的不同逻辑判断代码.
修正方案中将 happy path 全部放在靠左侧的第一层,使得代码的阅读性很好.
概念介绍:
init 函数用于初始化应用的状态,但不可以被直接调用.
当一个 package 被初始化的时候,所有的定义的常量和变量先初始化,再执行 init 函数。如果依赖了其他 package 的代码,则先初始化依赖方。这个顺序再多层依赖的时候可以继续推广.
而同一个 package 中的 init 函数按照字典序调用。但不要依赖这种顺序,这没有意义.
调用示例:
package main
import (
"redis"
)
// 3️⃣
var a = 1
// 4️⃣
func init() {
// ...
}
// 5️⃣
func main() {
err := redis.Store("foo", "bar")
// ...
}
-------------------------------------------------
package redis
// 1️⃣
var b = 2
// 2️⃣
func init() {
// ...
}
func Store(key, value string) error {
// ...
}
解释:包 B 被导入包 A 时,包 B 的包级别变量(var)会先初始化,然后调用包 B 中的 init 函数。接着,导入包 A 的包级别变量会初始化,最后调用包 A 中的 init 函数.
错误示例:
var db *sql.DB
func init() {
dataSourceName := os.Getenv("MYSQL_DATA_SOURCE_NAME")
d, err := sql.Open("mysql", dataSourceName)
if err != nil {
log.Panic(err)
}
err = d.Ping()
if err != nil {
log.Panic(err)
}
db = d
}
上述代码的三个缺点:
修正方案:
func createClient(dsn string) (*sql.DB, error) {
db, err := sql.Open("mysql", dsn)
if err != nil {
return nil, err
}
if err = db.Ping(); err != nil {
return nil, err
}
return db, nil
}
🌟 在你的使用场景中,如果能够避免上面提到的三个 issue,则可以使用 init 函数。但绝大多数情况下,还是推荐修正方案的写法.
Go 语言并不强制使用 getter 和 setter 方法去设置值.
Go 的标准库 time 使用示例:
timer := time.NewTimer(time.Second)
<-time.C
我们甚至可以直接修改 C,尽管这十分不推荐。因此为了确保 Go 语言的简单性,getter & setter 的使用需要自行把握。封装是有好处的,但使用时确保它对你的程序是有价值的再开始使用.
推荐命名:
currentBalance := customer.Balance() // 不使用 GetBalance 命名
if currentBalance < 0 {
customer.SetBalance(0) // 使用 SetBalance 命名
}
interface 介绍:
使用接口声明可以被多个对象实现的行为(方法),但与其他语言不同,Go 对接口的实现是隐式的,没有类似 implements 这样的关键词.
io 标准库定义的接口以及使用示例:
package io
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
---------------------------------------------------------
func copySourceToDest(source io.Reader, dest io.Writer) error {
// ...
}
func TestCopySourceToDest(t *testing.T) {
const input = "foo"
source := strings.NewReader(input)
dest := bytes.NewBuffer(make([]byte, 0))
err := copySourceToDest(source, dest)
if err != nil {
t.FailNow()
}
got := dest.String()
if got != input {
t.Errorf("expected: %s, got %s", input, got)
}
}
接口中方法越多,抽象程度越低.
🌟 使用 interface 的三个出发点:
sort 标准库中针对所有基于索引的集合的排序接口:
type Interface interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
有了这个排序的接口,则可以针对它进行各种排序函数的实现:快速排序、归并排序... 。
以一个顾客存储服务为例,举两个例子进行对比,说明使用 interface 解耦的好处.
使用具体类型:
type CustomerService struct {
store mysql.Store // 具体的存储实现
}
func (cs CustomerService) CreateNewCustomer(id string) error {
customer := Customer{id: id}
return cs.store.StoreCustomer(customer)
}
使用 interface 解耦:
type customerStorer interface {
StoreCustomer(Customer) error
}
type CustomerService struct {
storer customerStorer // 定义存储的接口
}
func (cs CustomerService) CreateNewCustomer(id string) error {
customer := Customer{id: id}
return cs.storer.StoreCustomer(customer)
}
🌟 好处:
集成测试时可以使用不同的 store 依赖源(之前必须依赖 mysql 做集成测试).
可以使用 mock 进行单元测试.
type IntConfig struct {
}
func (c *IntConfig) Get() int {
return 0
}
func (c *IntConfig) Set(value int) {
}
type intConfigGetter interface {
Get() int
}
type Foo struct {
threshold intConfigGetter
}
func newFoo(threshold intConfigGetter) Foo {
return Foo{
threshold: threshold,
}
}
func main() {
c := &IntConfig{}
f := newFoo(c)
fmt.Println(f.threshold.Get())
}
通过接口限制,即使工厂方法 newFoo 传入的是实现两个接口的 IntConfig 实例,但是 f.threshold 只能够调用 Get 方法。因为 threshold 字段是 intConfigGetter 定义的接口.
🌟 接口污染 。
很多 Java 或者 C# 转换过来的用户,在创建具体类型前自然而然先创建 interface,这在 Go 当中是不必要的。使用 interface 需要遵循上述的三个出发点(声明通用行为、约束行为、解耦依赖),并在需要的时候使用,并获得收益。而不是在当下去预见未来可能需要使用的时,就在此刻声明好 interface,这只会使代码更加难以阅读.
滥用 interface 会使代码难以阅读,因为多增加了一层理解成本。抽象场景应该从业务中被发现被提取,而不是被创造.
生产侧:接口与其实现方定义在同一个 package 中.
消费侧:接口定义在相对其实现方的外部的 package 中.
在生产侧声明接口,并为其提供实现,这种方式是 C# 或 Java 开发者的习惯,但在 Go 当中,不应该这么做。(其隐式的接口实现机制,也是为了开发者灵活选择接口的实现方式) 。
举个例子,假设生产侧的一个顾客存储服务通过接口声明了其所有行为:
package store
type CustomerStorage interface {
StoreCustomer(customer Customer) error
GetCustomer(id string) (Customer, error)
UpdateCustomer(customer Customer) error
GetAllCustomers() ([]Customer, error)
// ...
}
// 一个针对 CustomerStorage 接口的实现
但在消费端开发者使用的时候,可以结合情况对其进一步进行解耦,因为并不一定会用到这个 CustomerStorage 接口定义的所有方法,比如只声明获取所有顾客的方法.
package client
type customerGetter interface {
GetAllCustomers() ([]Customer, error)
}
此时 client 包中的 customerGetter 接口在设计时参考了 store 包中的 CustomerStorage 接口,确保 GetAllCustomers 方法的函数签名相同。使得 store 包中的实现类依旧满足 client 包中新声明的 customerGetter 接口,且它被约束后只能调用这一个方法.
⚠️ 注意点:
🌟 生产侧接口使用最佳实践:在生产侧定义接口,并提供实现。而在消费端使用时,需要结合实际情况,考虑是否要引入新接口,选择需要的实现。(事实上) 。
🌟 生产侧接口定义的方法通常使用在标准库或者为第三方提供支持的 package 当中,设计时需要结合实际,确保一切预先定义的行为都是有意义的。(毕竟 interface 应该在使用是被发现,而不是一开始被创造) 。
Go 当中,返回接口类型而不是 struct 是一种不好的设计,错误示例:
InMemoryStore 结构实现了 client 包的 Store 接口,在调用 NewInMemoryStore 方法的时候返回接口类型.
缺陷:
🌟 设计哲学:对自己做的事保持保守,开放接受他人做的事.
反映出的最佳实践:
🌟 反例:
很多函数都会返回 error 类型,它本身就是一个接口,此外标准库中也有返回接口类型的情景(如下)。但这些场景都是预先设计且确保收益显著才打破的上述最佳实践规则.
package io
// io.Reader 是一个接口
func LimitReader(r Reader, n int64) Reader {
return &LimitReader{r, n}
}
Go 当中,interface{} 类型表示空接口,即没有声明方法的一个接口,因此可以表示 Go 内部所有的对象。从 Go1.18 开始,引入 any 关键字作为空接口的别名,所有 interface{} 可以用 any 替代.
使用 any 丢失了所有的类型信息,放弃了 Go 作为静态编译语言的优势,相关信息必须再通过断言去提取.
package store
type Customer struct {
// ...
}
type Contract struct {
// ...
}
type Store struct {}
func (s *Store) Get(id string) (any, error){
// ...
}
func (s *Store) Set(id string, v any) error {
// ...
}
这段代码通过 Get 和 Set 可以将不同 struct 存入 Store 结构,但调用 Get 后无法直观判断的到的是什么类型,同时 Set 的时候,也没有类型约束,可以 Set 任何内容.
修正示例:
func (s *Store) GetContract(id string) (Contract, error) {
// ...
}
func (s *Store) SetContract(id string, contract Contract) error {
// ...
}
func (s *Store) GetCustomer(id string) (Customer, error) {
// ...
}
func (s *Store) SetCustomer(id string, customer Customer) error {
// ...
}
定义了太多方法这不是问题,结合上文的消费侧的 interface 用法,可以通过接口进行约束,比如只关心合约的存储:
type ContractStorer interface {
GetContract(id string) (Contract, error)
SetContract(id string, contract Contract) error
}
🌟 何时使用 any(在确实可以接受或返回任何类型参数的时候) 。
示例1
func Marshal(v any) ([]byte, error) {
// ...
}
标准库 encoding/json 中的 Marshal 函数用于序列化,自然可以接受所有类型参数.
示例2
func (c *Conn) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
// ...
}
针对查询语句的参数设置,如 SELECT * FROM FOO WHERE ID = ? AND NAME = ?.
场景:针对一个输入的 map 编写一个 getKeys 函数,获取所有的 keys,map 的 key 和 value 可能有多种类型.
不使用范型:
func getKeys(m any) ([]any, error) {
switch t := m.(type) {
default:
return nil, fmt.Errorf("unknown type: %T", t)
case map[string]int:
var keys []any
for k := range t {
keys = append(keys, k)
}
return keys, nil
case map[int]string:
// ...
}
}
缺陷:
🌟 在函数中使用范型:
func getKeys[K comparable, V any](m map[K]V) []K {
var keys []K
for k := range m {
keys = append(keys, k)
}
return keys
}
func main() {
// 外部调用
m := map[string]int{
"one": 1,
"two": 2,
"three": 3,
}
keys := getKeys(m)
fmt.Println(keys)
}
map 的 key 并不是所有数据类型都可以的,要求可以使用 == 进行比较,因此可以使用内置的 comparable 关键字描述一个可比较的类型.
// Go 内置 comparable 接口
type comparable interface{ comparable }
// Go 内置 any 类型(空接口)
type any = interface{}
Go 支持自定义范型类型:
type customConstraint interface {
~int | ~string
}
func getKeys[K customConstraint, V any](m map[K]V) []K {
var keys []K
for k := range m {
keys = append(keys, k)
}
return keys
}
~int 表示任何类型的底层是 int 的类型,而 int 只能表示准确的 int 类型.
举个例子:
type customConstraint interface {
~int
String() string
}
type customInt int
func (c customInt) String() string {
return strconv.Itoa(int(c))
}
func Print[T customConstraint](t T) {
fmt.Println(t.String())
}
func main() {
Print(customInt(1))
}
因为 customInt 的底层是 int 类型,并且实现了 String 方法,因此可以传递给 customConstraint 接口定义的类型.
但如果将 customConstraint 接口中的 ~int 修改为 int,则出现编译错误:Type does not implement constraint 'customConstraint' because type is not included in type set ('int'),换言之这里必须传递 int 类型,但是由于又限制了需要实现 String 方法,int 作为基本类型,是没有实现 String 方法的,此时陷入进退两难.
🌟 在 struct 中使用范型:
type Node[T any] struct {
Val T
next *Node[T]
}
func (n *Node[T]) Add(next *Node[T]) {
n.next = next
}
func main() {
n1 := Node[int]{Val: 1}
n2 := Node[int]{Val: 2}
n1.Add(&n2)
}
⚠️ 不可以使用范型的场景:
type Foo struct {}
func (f Foo) bar[T any](t T) {}
// 报错:method cannot have type parameters
Go 当中,函数和方法的区别在于,是否有接受者,意思是声明了函数的归属,上述代码方法的接受者是一个普通的 struct,不允许使用类型参数(范型).
如果要在方法中使用范型,则要求方法的接受者具有类型参数(范型).
type Foo[T any] struct{}
func (f Foo[T]) bar(t T) {}
🌟 最佳实践:
不要过早使用范型设计,就像不要过早使用 interface,去发现它,而不是创造它.
类型嵌套:结构 A 拥有一个未命名的结构 B 作为字段.
type Foo struct {
Bar
}
type Bar struct {
Baz int
}
foo := Foo{}
foo.Baz = 42
foo.Bar.Baz = 42 // 与前一步等价
通过结构嵌套,定义在 Bar 内的属性或者方法会被提升至 Foo,可以直接调用.
接口嵌套:通过嵌套组合接口 。
type ReadWriter interface { Reader Writer }
🌟 类型嵌套的错误示例:
type InMem struct {
sync.Mutex
m map[string]int
}
func New() *InMem {
return &InMem{m: make(map[string]int)}
}
func (i *InMem) Get(key string) (int, error) {
i.Lock()
v, contains := i.m[key]
i.Unlock()
return v, contains
}
模拟一个基于内存的并发安全的 map 存储,使用类型嵌套,将互斥锁操作提升至 InMem 层直接调用,看似方便,但使得锁操作直接对外暴露:
m := inmem.New()
m.Lock() // ??不应该对外暴露锁操作,应该封装在 Get 操作内
🌟 修正示例:
type InMem struct {
mu sync.Mutex
m map[string]int
}
func (i *InMem) Get(key string) (int, error) {
i.mu.Lock()
v, contains := i.m[key]
i.mu.Unlock()
return v, contains
}
🌟 使用嵌套的一个优秀案例:
type Logger struct {
// 不使用嵌套
writeCloser io.WriteCloser
}
func (l Logger) Write(p []byte) (int, error) {
return l.writeCloser.Write(p)
}
func (l Logger) Close() error {
return l.writeCloser.Close()
}
-------------------------------------------------
type Logger struct {
// 使用嵌套
io.WriteCloser
}
func main() {
l := Logger{WriteCloser: os.Stdout}
_, _ = l.Write([]byte("foo"))
_ = l.Close()
}
io.WriteCloser 是一个接口,声明了 Write 和 Close 两个方法,在不使用嵌套的代码中,必须为 Logger 类重新声明 Write 和 Close 方法,就为了对应去转发调用 io.WriteCloser 的两个方法,十分冗余.
使用嵌套接口之后,io.WriteCloser 类型的两个方法提升至 Logger 结构层,可以直接调用。这样也意味着 Logger 此时可以被视为实现了 io.WriteCloser 接口.
⚠️ 注意:当 Logger 嵌套了 io.WriteCloser,但初始化的时候不传入具体实现类 os.Stdout,在编译 l.Write([]byte("foo")) 的时候会报错.
🌟 嵌套与面向对象编程的子类化的区别 。
下面是 Y 结构获得 X 的 Foo 方法的两种实现:
🌟 总结:嵌套是一种组合的概念,而子类化是一种继承的概念.
Go 示例:
package main
import "fmt"
type X struct{}
func (x X) method() {
fmt.Println("X's method")
}
type Y struct {
X
}
func main() {
y := Y{}
y.method() // 调用 Y 中嵌套的 X 类型的 method,X 仍然是接收者
}
在上述示例中,Y 结构体嵌套了 X 结构体,当调用 Y 类型的实例的 method 方法时,接收者仍然是 X 类型,因此输出为 "X's method".
Java 示例:
class X {
void method() {
System.out.println("X's method");
}
}
class Y extends X {
// Y 没有显式声明 method,但继承了 X 的 method
}
public class Main {
public static void main(String[] args) {
Y y = new Y();
y.method(); // 调用 Y 中继承的 X 类型的 method,Y 成为接收者
}
}
在 Java 中,继承是一种机制,子类(派生类)继承了父类(基类)的方法,但对于方法调用,接收者(receiver)是实际的对象类型。因此,当在 Java 中使用继承时,调用子类的方法会使得子类成为接收者.
🌟 使用嵌套的两个原则:
Foo.Baz
替代 Foo.Bar.Baz
)。⚠️ 注意:如果要嵌套一个频繁迭代的结构,外部结构需要考量这个内嵌结构的变动对外部结构的长远影响。或许不内嵌一个公共的 struct 是一个好的选择.
已完成全书学习进度10/100,再接再厉.
最后此篇关于Go语言的100个错误使用场景(一)|代码和项目组织的文章就讲到这里了,如果你想了解更多关于Go语言的100个错误使用场景(一)|代码和项目组织的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我在网上搜索但没有找到任何合适的文章解释如何使用 javascript 使用 WCF 服务,尤其是 WebScriptEndpoint。 任何人都可以对此给出任何指导吗? 谢谢 最佳答案 这是一篇关于
我正在编写一个将运行 Linux 命令的 C 程序,例如: cat/etc/passwd | grep 列表 |剪切-c 1-5 我没有任何结果 *这里 parent 等待第一个 child (chi
所以我正在尝试处理文件上传,然后将该文件作为二进制文件存储到数据库中。在我存储它之后,我尝试在给定的 URL 上提供文件。我似乎找不到适合这里的方法。我需要使用数据库,因为我使用 Google 应用引
我正在尝试制作一个宏,将下面的公式添加到单元格中,然后将其拖到整个列中并在 H 列中复制相同的公式 我想在 F 和 H 列中输入公式的数据 Range("F1").formula = "=IF(ISE
问题类似于this one ,但我想使用 OperatorPrecedenceParser 解析带有函数应用程序的表达式在 FParsec . 这是我的 AST: type Expression =
我想通过使用 sequelize 和 node.js 将这个查询更改为代码取决于在哪里 select COUNT(gender) as genderCount from customers where
我正在使用GNU bash,版本5.0.3(1)-发行版(x86_64-pc-linux-gnu),我想知道为什么简单的赋值语句会出现语法错误: #/bin/bash var1=/tmp
这里,为什么我的代码在 IE 中不起作用。我的代码适用于所有浏览器。没有问题。但是当我在 IE 上运行我的项目时,它发现错误。 而且我的 jquery 类和 insertadjacentHTMl 也不
我正在尝试更改标签的innerHTML。我无权访问该表单,因此无法编辑 HTML。标签具有的唯一标识符是“for”属性。 这是输入和标签的结构:
我有一个页面,我可以在其中返回用户帖子,可以使用一些 jquery 代码对这些帖子进行即时评论,在发布新评论后,我在帖子下插入新评论以及删除 按钮。问题是 Delete 按钮在新插入的元素上不起作用,
我有一个大约有 20 列的“管道分隔”文件。我只想使用 sha1sum 散列第一列,它是一个数字,如帐号,并按原样返回其余列。 使用 awk 或 sed 执行此操作的最佳方法是什么? Accounti
我需要将以下内容插入到我的表中...我的用户表有五列 id、用户名、密码、名称、条目。 (我还没有提交任何东西到条目中,我稍后会使用 php 来做)但由于某种原因我不断收到这个错误:#1054 - U
所以我试图有一个输入字段,我可以在其中输入任何字符,但然后将输入的值小写,删除任何非字母数字字符,留下“。”而不是空格。 例如,如果我输入: 地球的 70% 是水,-!*#$^^ & 30% 土地 输
我正在尝试做一些我认为非常简单的事情,但出于某种原因我没有得到想要的结果?我是 javascript 的新手,但对 java 有经验,所以我相信我没有使用某种正确的规则。 这是一个获取输入值、检查选择
我想使用 angularjs 从 mysql 数据库加载数据。 这就是应用程序的工作原理;用户登录,他们的用户名存储在 cookie 中。该用户名显示在主页上 我想获取这个值并通过 angularjs
我正在使用 autoLayout,我想在 UITableViewCell 上放置一个 UIlabel,它应该始终位于单元格的右侧和右侧的中心。 这就是我想要实现的目标 所以在这里你可以看到我正在谈论的
我需要与 MySql 等效的 elasticsearch 查询。我的 sql 查询: SELECT DISTINCT t.product_id AS id FROM tbl_sup_price t
我正在实现代码以使用 JSON。 func setup() { if let flickrURL = NSURL(string: "https://api.flickr.com/
我尝试使用for循环声明变量,然后测试cols和rols是否相同。如果是,它将运行递归函数。但是,我在 javascript 中执行 do 时遇到问题。有人可以帮忙吗? 现在,在比较 col.1 和
我举了一个我正在处理的问题的简短示例。 HTML代码: 1 2 3 CSS 代码: .BB a:hover{ color: #000; } .BB > li:after {
我是一名优秀的程序员,十分优秀!