Colección de preguntas de la entrevista técnica de Python (2)

preguntas de la entrevista técnica de Python

1. Describe brevemente django FBV y CBV

FBV是基于函数编程，CBV是基于类编程，本质上也是FBV编程，在Djanog中使用CBV，则需要继承View类，在路由中指定as_view函数，返回的还是一个函数
在DRF中的使用的就是CBV编程

2. El papel de las funciones F y Q en Django

在Django ORM中，F是一个用于数据库查询的特殊对象，用于执行基于数据库字段之间的比较和操作
在Django ORM中，Q对象是用于构建复杂查询条件的工具，它提供了逻辑操作符（如AND、OR、NOT）来组合多个查询条件。

3. La diferencia entre filter, simple_tag e inclusion_tag en las plantillas de Django

在Django模板中，filter、simple_tag和inclusion_tag都是用于自定义模板标签和过滤器的方法，但它们在功能和使用方式上有一些区别：

Filter（过滤器）：参数：1-2个
过滤器是用于在模板中处理变量的函数，可以对变量进行一些简单的处理或转换。
过滤器可以通过管道（|）将其应用于变量，以修改变量的输出结果。
过滤器通常用于对字符串、日期、数字等数据进行格式化或转换。
Django提供了一些内置的过滤器，例如date、lower、upper等，同时也支持自定义过滤器。

Simple Tag（简单标签）：参数：无限制
简单标签是一种自定义模板标签，它是一个Python函数，接受参数并生成一些输出。
简单标签可以在模板中以类似于函数调用的方式使用，并将标签的返回值插入到模板中。
简单标签通常用于执行一些简单的逻辑操作，生成动态内容，并将其嵌入到模板中。

Inclusion Tag（包含标签）：参数：无限制
包含标签也是一种自定义模板标签，它是一个Python函数，用于生成包含其他模板的片段。
包含标签接受参数，并使用指定的参数渲染其他模板。
包含标签通常用于将公共的模板片段（如导航栏、页脚等）封装为可重用的组件，并在多个模板中使用。

4. ¿Cuáles son las diferencias y escenarios de uso entre select_ related y prefetch_ related?

"select_related" 和 "prefetch_related" 都是 Django ORM 提供的用于优化数据库查询的方法，但它们的作用和使用场景略有不同。

1. **select_related**:
   - 作用：通过使用 "select_related" 方法，Django 会在查询时使用 SQL 的 JOIN 操作，将外键关联的对象一并获取，从而在单次查询中获取所有相关数据。
   - 使用场景：适用于 ForeignKey 和 OneToOneField 等外键关联的查询。当你需要在一个查询中获取主对象和关联对象的数据时，可以使用 "select_related" 来避免多次数据库查询，提高性能。
   - 注意事项："select_related" 适合于外键关联，但如果涉及多对多关系或反向关联，性能可能不如 "prefetch_related"，因为 "select_related" 会产生多个 JOIN 操作，可能导致性能下降。

2. **prefetch_related**:
   - 作用："prefetch_related" 用于优化查询涉及多对多关系和反向关联（例如 ManyToManyField 和 Reverse ForeignKey）的情况。它会在单次查询中获取所有相关数据，避免了 N+1 查询问题。
   - 使用场景：适用于优化多对多关系和反向关联的查询。当你需要在查询中获取主对象及其关联对象的数据，并且涉及多对多关系或反向关联时，可以使用 "prefetch_related"。
   - 注意事项："prefetch_related" 可以显著提高性能，但需要注意不要过度使用，以免导致不必要的资源消耗。

综合使用场景和注意事项，可以根据查询需求选择适当的方法：

- 如果查询涉及到外键关联，并且你需要获取主对象和关联对象的数据，可以考虑使用 "select_related"。
- 如果查询涉及到多对多关系或反向关联，并且你需要获取主对象及其关联对象的数据，可以考虑使用 "prefetch_related"。

最佳实践是根据数据模型和具体查询需求来选择使用哪种方法，以达到最佳性能和资源利用。

5. Describa brevemente el mecanismo de recolección de basura en Python.

Python 的垃圾回收机制是自动的，而非强制的，Python 在解释程序执行时，使用了类似于引用计数的技术来实现垃圾回收。Python采用的是一种简单的技术：当程序中的某个变量对象引用计数为0时， Python就会将其释放掉，但这种技术会造成一些问题，比如循环引用等。因此，Python还有其他垃圾回收的方法，比如标记清除、分代回收等。

Python 的垃圾回收机制主要靠引用计数来实现。每个对象有一个引用计数，表示有多少引用指向这个对象。当引用计数降为0时，说明没有任何变量名引用这个对象了，这个对象就可以被垃圾回收器回收。垃圾回收器周期性地执行检查，以确定哪些对象已经过时，然后将它们从内存中删除。

垃圾回收机制的关键在于「引用计数」。Python 中的任何变量都是对某个对象的引用，当变量不再使用一个对象时，Python 就会减少该对象的引用计数，当引用计数降为 0 时，Python 就可以回收这个对象了。

以下是 Python 自动垃圾回收机制的原理：
1.引用计数
Python 中的一个对象对应一个结构体 PyObejct，结构体中保存了对对象所包含的数据的引用，以及引用对象的类型信息。每个对象都会统计这个对象的引用计数，引用计数要求有人来进行维护，Python 需要在代码中将这个对象打上标记，来作为引用 Python 对象的一个位置变量，在对象不再被使用时，引用计数减 1，引用计数为 0 时，释放所占的内存空间。

一般引用计数递增函数如下：
    PyObject *py_incref(PyObject *op) {
        op->ob_refcnt += 1;
        return op;
    }
一般引用计数递减函数如下：
    void py_decref(PyObject *op) {
        op->ob_refcnt -= 1;
        if (op->ob_refcnt == 0) {
            PyObject_GC_Untrack(op);
            op->ob_type->tp_clear(op);
            op->ob_type->tp_free(op);
        }
    }

引用计数的缺陷：如果对象之间存在循环引用，那么这些对象的引用计数永远不会降为 0，垃圾回收器就无法回收它们所占用的内存。对于这种情况，Python 的垃圾回收机制采用了另一个算法——标记清除算法。

2.标记清除
标记清除算法分为两个阶段：

第一阶段：标记
从根对象开始，自上而下地遍历所有对象。标记 根对象。如果一个对象没有标记，就递归地遍历这个对象所有可达的子对象，并标记。这个过程中，被标记的对象的引用计数因为被标记而增加，未被标记的对象引用计数不改变。

第二阶段：
从堆的起始地址开始，依次对每个内存地址进行遍历，对于没有被标记的对象，说明它没有被引用，可以被回收。如果一个对象被回收，那么这个对象所指向的其他对象也会被递归回收。

这样做的好处在于，标记清除算法能够解决循环引用的问题，因为只有可达的对象会被标记，不可达（孤岛）的对象永远不会被访问到，自然就不会被标记，最终被回收。但是，标记清除算法也有缺点，会产生内存碎片。

3.分代回收

Python 的垃圾回收机制中还有一种高级算法：分代回收。这个是因为，Python 中有一些对象被使用较少，有一些对象被使用较多，可以根据对象的历史使用情况把对象划分成几代。一般情况下，新创建的对象会被划分到第一代，第一代对象的存活时间较短，如果一个对象在第一代中存活了一段时间，那么它会被划分到第二代中，第二代对象的存活时间较长，同样地，如果一个对象在第二代中存活了一段时间，那么它会被划分到第三代中，第三代对象的存活时间更长。

Python 的垃圾回收机制主要运用在这三种算法之间，引用计数算法提高了回收垃圾对象的效率，标记清除算法保证了循环引用的完美处理，分代回收算法是为了增加垃圾回收的效率。

在 Python 中，可通过 sys 模块中的 getrefcount 函数来获取对象的引用计数：
    import sys
    variable = 'hello'
    print(sys.getrefcount(variable))  #输出2，因为该函数会隐式引用变量一次
    
可以通过手动打印变量的引用计数来观察垃圾回收机制的工作过程：
    import sys

    class MyClass:
        def __del__(self):
            print("MyClass instance deleted")

    def foo():
        obj = MyClass()
        print(sys.getrefcount(obj))

    foo()
输出结果如下：
    2
	MyClass instance deleted
从上面的输出结果可以看出，在函数执行结束后， MyClass 实例被删除，说明垃圾回收机制已经发现并收回了这个实例对象。

从以上内容可以看出，Python 的自动垃圾回收机制是一种简单和高效的内存管理技术，它通过引用计数、标记清除以及分代回收等多种算法来管理内存分配与回收。内存管理对于编程语言来说非常重要，Python 的内存管理机制优良，使用者可以高效率地进行 Python 编程，同时也可以轻松地避免内存泄漏等不必要的麻烦。

6. Python implementa algoritmos para implementar la disposición completa del código.

# 使用深度优先
def permute(nums):
    def dfs(start):
        if start == len(nums):
            result.append(nums[:])
            return
        for i in range(start, len(nums)):
            nums[start], nums[i] = nums[i], nums[start]
            dfs(start + 1)
            nums[start], nums[i] = nums[i], nums[start]  # 恢复原始状态
    
    result = []
    dfs(0)
    return result

# 测试
nums = [1, 2, 3]
permutations = permute(nums)
for perm in permutations:
    print(perm)

7. Dada una matriz de números que contiene n números enteros, determine si hay tres elementos a, b, c en números tales que a + b + c = 0. Encuentre todos los triples cuya suma sea 0 y no los repita. Nota: Las respuestas no pueden contener triples duplicados. Ejemplo 1: Entrada: nums = [-1,0,1,2,-1,-4] Salida: [[-1,-1,2],[-1,0,1]] Ejemplo 2: Entrada: nums = [] Salida: [] Ejemplo 3: Entrada: nums = [0] Salida: []

def threeSum(nums):
    n = len(nums)
    if n < 3:
        return []

    nums.sort()
    res = []

    for i in range(n-2):
        if i > 0 and nums[i] == nums[i-1]:
            continue

        left = i + 1
        right = n - 1

        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1

    return res

8. Dada una matriz bidimensional arr, los elementos de la matriz son todos 0 o 1. Los elementos adyacentes son todos 1, que es un área conectada, encuentre el área conectada más grande.

# 要找到二维数组 arr 中最大的连通区域，可以使用深度优先搜索（DFS）或广度优先搜索（BFS）的算法来解决
def max_connected_area(arr):
    if not arr:
        return 0

    rows = len(arr)
    cols = len(arr[0])
    max_area = 0

    def dfs(row, col):
        if row < 0 or row >= rows or col < 0 or col >= cols or arr[row][col] != 1:
            return 0

        area = 1
        arr[row][col] = -1  # 标记已访问过的区域为-1

        # 递归搜索上下左右四个方向
        area += dfs(row - 1, col)  # 上
        area += dfs(row + 1, col)  # 下
        area += dfs(row, col - 1)  # 左
        area += dfs(row, col + 1)  # 右

        return area

    for row in range(rows):
        for col in range(cols):
            if arr[row][col] == 1:
                max_area = max(max_area, dfs(row, col))

    return max_area

# 示例用法
arr = [
    [1, 1, 0, 0, 0],
    [1, 1, 0, 0, 1],
    [0, 0, 1, 1, 0],
    [0, 0, 0, 1, 1],
]
max_area = max_connected_area(arr)
print(max_area)  # 输出：5

9. ¿Cuál es la diferencia entre la función lambda y la función ordinaria?

La principal diferencia entre las funciones lambda y las funciones ordinarias es cómo se definen y cómo se utilizan.

Método de definición
Las funciones ordinarias se definen utilizando la palabra clave def, que generalmente puede contener bloques de código de varias líneas y otras declaraciones dentro del cuerpo de la función. La función lambda se define utilizando la palabra clave lambda y solo puede contener una expresión de una sola línea como cuerpo de la función y no puede contener bloques de código de varias líneas.

Escenarios de uso
Las funciones ordinarias se utilizan generalmente para implementar lógica o algoritmos complejos, o funciones que deben llamarse varias veces. Las funciones lambda generalmente se usan para implementar funciones simples, especialmente cuando las funciones deben pasarse como parámetros a otras funciones o métodos, como funciones de orden superior como filter(), map() y reduce(). Además, el uso de funciones lambda también es conveniente cuando necesita escribir algunas funciones temporales rápidas.

Por ejemplo, aquí hay una función de suma implementada usando una función normal:

def add(x, y):
    return x + y

Y así es como se implementa la misma función usando una función lambda:

add = lambda x, y: x + y

Como puede ver, la definición de función lambda es más concisa y adecuada para algunos escenarios simples. Las funciones ordinarias son más flexibles y adecuadas para escenarios más complejos.

10. Tarea, copia superficial, copia profunda

import copy

d = {
    
    '1': [1, 1, 1], '2': 2}
copy1 = d
copy2 = d.copy()
copy3 = copy.copy(d)
copy4 = copy.deepcopy(d)

d['1'][0] = 3 d['2'] = 3  print(copy1, copy2, copy3, copy4)

'''
打印结果分比为

{'1': [3, 1, 1], '2': 3} 

{'1': [3, 1, 1], '2': 2} 

{'1': [3, 1, 1], '2': 2} 

{'1': [1, 1, 1], '2': 2}
'''

Método 1: asignar referencia, copiar1 y d apuntar al mismo objeto

Método 2: copia superficial, copiar para generar un nuevo objeto copy2, pero solo copiar una capa, [1, 1, 1] es el subobjeto común de ambos,

Método 3: copia superficial, llame al método en el módulo de copia, igual que el método 2

Método 3: copia profunda, copia para generar una nueva copia de objeto4 y copia recursivamente todos los subobjetos, de modo que los cambios en d que originalmente apuntaban a [1, 1, 1] no afectarán a los subobjetos [1, 1, 1] generado por copia profunda.

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}

  a = {
    
    '1':1,'2':2,'3':[1,2],4:'abc'}

b = a.copy() y b=copy.copy(a) son copias superficiales

Cuando los datos inmutables en a/b: tipo int, tipo de cadena, tipo de tupla cambian, no afecta al otro.

Pero en otros casos, como al cambiar elementos de la lista, se producirán efectos mutuos.

Ejemplo:

①Ejemplos de cambios de datos inmutables

Cambiar a int:

  a = {
    
    '1':1,'2':2,'3':[1,2],'4':'abc'}
 b = a.copy()
 a['1']=250
 print(a)
 print(b)
 out: 
 
 '''
{'1': 250, '2': 2, '3': [1, 2], '4': 'abc'}
{'1': 1, '2': 2, '3': [1, 2], 4: 'abc'}
'''

Cambiar cadena:

  a = {
    
    '1':1,'2':2,'3':[1,2],'4':'abc'}
 b = a.copy()
 a['4']='def'
 print(a)
 print(b)
 out: 
 
 '''
{'1': 1, '2': 2, '3': [1, 2], '4': 'def'}
{'1': 1, '2': 2, '3': [1, 2], '4': 'abc'}
'''

Cambios en tupla:

  a = {
    
    '1':1,'2':2,'3':[1,2],'4':'abc'}
 b = a.copy()
 a['3']=[1,2,3]
 print(a)
 print(b)
 '''
{'1': 1, '2': 2, '3': [1, 2, 3], '4': 'abc'}
{'1': 1, '2': 2, '3': [1, 2], '4': 'abc'}
'''

②Ejemplos de cambios de datos variables

  a = {
    
    '1':1,'2':2,'3':[1,2],'4':'abc'}
 b = a.copy()
 a['3'][0]=2
 print(a)
 print(b)
 '''
{'1': 1, '2': 2, '3': [2, 2], '4': 'abc'}
{'1': 1, '2': 2, '3': [2, 2], '4': 'abc'}
'''

10. ¿Enumerar los métodos de solicitud comunes?

GET     请求指定的页面信息，并返回实体主体。
HEAD     类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
POST     向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
PUT     从客户端向服务器传送的数据取代指定的文档的内容。
DELETE      请求服务器删除指定的页面。
CONNECT     HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
OPTIONS     允许客户端查看服务器的性能。
TRACE     回显服务器收到的请求，主要用于测试或诊断。

11. Lectura de archivos de big data:

①Utilice generador generador;

②El iterador realiza un recorrido iterativo: para línea en archivo;

12. La diferencia entre iteradores y generadores:

Respuesta: (1) Iterador es un concepto más abstracto, cualquier objeto, si su clase tiene el método siguiente y el método iter, se devuelve a sí mismo. Para objetos contenedores como cadenas, listas, dict, tuplas, etc., es muy conveniente utilizar un bucle for para recorrerlos. En segundo plano para la declaración, la función iter() se llama en el objeto contenedor. iter() es una función incorporada de Python. iter() devolverá un objeto iterador que define el método next(), que accede a los elementos del contenedor uno por uno. Next() también es una función integrada de Python. Cuando no hay elementos posteriores, next() generará una excepción StopIteration.

(2) Generator es una herramienta simple y poderosa para crear iteradores. Están escritas como funciones normales, excepto que utilizan la declaración de rendimiento cuando necesitan devolver datos. Cada vez que se llama a next(), el generador devuelve la posición donde lo dejó (recuerda la posición donde se ejecutó la declaración por última vez y todos los valores de datos)

Diferencia: los generadores pueden hacer todo lo que los iteradores pueden hacer, y debido a que los métodos __iter__() y next() se crean automáticamente, los generadores son particularmente concisos y los generadores también son eficientes. Se utilizan expresiones generadoras en lugar de listas. El análisis puede ahorrar memoria en al mismo tiempo. Además de los métodos automáticos para crear y guardar el estado del programa, se lanza automáticamente una excepción StopIteration cuando finaliza el generador.

13. Hablemos brevemente sobre la diferencia entre python2 y python3:

1 Py3 usa codificación utf-8 de forma predeterminada y python2 usa codificación ascill.

2 Se eliminó <> y se reemplazó todo con !=

3 La división entera devuelve un número de coma flotante. Para obtener un resultado entero, utilice //

4 Elimine la declaración de impresión y agregue la función print() para lograr la misma función. Lo mismo ocurre con la declaración exec, que se ha cambiado a la función exec().

5 Se modificó el comportamiento de los operadores secuenciales, como x<y, cuando los tipos x e y no coinciden, se genera un TypeError en lugar de devolver un valor bool aleatorio.

6 La función de entrada ha cambiado, raw_input se ha eliminado y reemplazado con entrada

7 Elimine el descomprimido del parámetro de tupla. No se puede definir una función como def(a, (b, c)):pass『Pythonnote』

8 Py3.X ha eliminado el tipo largo. Ahora solo hay un tipo entero: int, pero se comporta como la versión 2.X de long.

9 Se agregó un nuevo tipo de bytes, correspondiente a la cadena de octetos de la versión 2.X.

10 El método next() del iterador pasa a llamarse __next__() y se agrega la función incorporada next() para llamar al método __next__() del iterador. "Pythonnote" Xiao Yan

11 Se agregaron dos decoradores, @abstractmethod y @abstractproperty, para que sea más conveniente escribir métodos abstractos (propiedades).

12 Todas las excepciones se heredan de BaseException y se elimina StardardError

13 Se eliminó el comportamiento de secuencia y el atributo .message de la clase de excepción.

14 Utilice rise Exception(args) en lugar de rise Exception, sintaxis de argumentos de Xiao Yan

15 El módulo cPickle se ha retirado y puede ser reemplazado por el módulo pickle. Con el tiempo tendremos un módulo transparente y eficiente.

16 Módulo de operación de imagen eliminado

17 Se eliminaron audiodev, Bastion, bsddb185, excepciones, linuxaudiodev, md5, MimeWriter, mimify, popen2,

módulos rexec, sets, sha, stringold, strop, sunaudiodev, timing y xmllib

18 Se eliminó el módulo bsddb (publicado por separado, disponible en)

19 Nuevo módulo eliminado

20 xrange() renombrado a rango()

14. ¿encontrar y grep?:

El comando grep es una poderosa herramienta de búsqueda de texto. La cadena de contenido de búsqueda grep puede ser una expresión regular, lo que permite la búsqueda de patrones en archivos de texto. Si se encuentra un patrón coincidente, grep imprime todas las líneas que contienen el patrón.

buscar generalmente se usa para buscar archivos que cumplan con las condiciones en un directorio específico, o también se puede usar para buscar archivos propiedad de un usuario específico.

15. ¿Cómo utilizar el rendimiento en Python?

Respuesta: Yield es simplemente un generador, de modo que la función recuerda la posición en el cuerpo de la función cuando regresó por última vez. La segunda (o n) llamada al generador salta a esta función.

16. Describe las diferencias entre matrices, listas enlazadas, colas y pilas.

数组与链表是数据存储方式的概念，数组在连续的空间中存储数据，而链表可以在非连续的空间中存储数据；

队列和堆栈是描述数据存取方式的概念，队列是先进先出，而堆栈是后进先出；队列和堆栈可以用数组来实现，也可以用链表实现。

17. En Django, cuando un usuario inicia sesión en el servidor de aplicaciones A (ingresa al estado de inicio de sesión) y luego nginx envía la siguiente solicitud al servidor de aplicaciones B, ¿cuál será el impacto?

Si los datos de la sesión iniciada por el usuario en el servidor de aplicaciones A no se comparten con el servidor de aplicaciones B, se perderá el estado de inicio de sesión anterior.

18. ¿Cuál es la diferencia entre cookie y sesión?

1.cookie:
cookie是保存在浏览器端的键值对,可以用来做用户认证
2.session：
将用户的会话信息保存在服务端,key值是随机产生的自符串,value值时session的内容
依赖于cookie将每个用户的随机字符串保存到用户浏览器上
Django中session默认保存在数据库中：django_session表flask,session默认将加密的数据写在用户的cookie中

1. Los datos de las cookies se almacenan en el navegador del cliente y los datos de la sesión se almacenan en el servidor.

2. Las cookies no son muy seguras. Otros pueden analizar la COOKIE almacenada localmente y realizar engaños de COOKIE. Las sesiones deben usarse por razones de seguridad. Siga la cuenta pública "Selección de tecnología Full Stack"

3. La sesión se guardará en el servidor durante un período de tiempo determinado. Cuando aumenta el acceso, consumirá más rendimiento del servidor. Para reducir el rendimiento del servidor, se debe utilizar COOKIE.

4. Los datos guardados por una sola cookie no pueden exceder los 4 K. Muchos navegadores limitan un sitio para guardar hasta 20 cookies.

5. Sugerencia: almacene información importante, como información de inicio de sesión, como SESIÓN; si es necesario conservar otra información, se puede colocar en COOKIE.

19. El proceso necesario para crear un servidor tcp simple.

1.socket crea un socket

2.bind une ip y puerto

3.listen hace que el socket sea vinculable pasivamente

4.accept espera el enlace del cliente

5.recv/send recibe y envía datos

20. La diferencia entre nuevo inicio

__init__ es el método de inicialización y el método __new__ es el constructor real

__new__ se llama antes de crear la instancia y su tarea es crear y devolver la instancia.

Se llama a __init__ después de crear la instancia y luego establece algunos valores iniciales de las propiedades del objeto.

Resumen: el nuevo método se llama antes que el método init , y el valor de retorno del nuevo método se pasará al método init como primer parámetro y, finalmente, init establece algunos parámetros para esta instancia.

21. Respecto a tipos estáticos, tipos dinámicos y tipos fuertes, tipos débiles:

La distinción entre estático y dinámico depende de si se puede modificar dinámicamente más adelante. El tipo de c posterior no se puede cambiar, por lo que es estático. Los tipos posteriores de Python se pueden modificar, por lo que son tipos dinámicos.

La distinción entre tipos fuertes y débiles depende de si se pueden realizar operaciones entre diferentes tipos. En js, se puede usar "a" +1 = "a1", por lo que es un tipo débil, y en Python, se informará un error directamente. Por tanto, Python es un lenguaje fuertemente tipado.

Resumen: Python es un lenguaje fuertemente tipado y de tipo dinámico.

22. ¿Cuál es la función del pase?

pass  不做任何事情，一般用做占位语句。
pass  空语句，是为了保持程序结构的完整性

23. Escriba una programación de socket de Python simple

python 编写server的步骤：

1第一步是创建socket对象。调用socket构造函数。如：

socket = socket.socket(family, type )

family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信。

type参数代表套接字类型，可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。

2.第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：

socket.bind( address )由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。

3.第三步是使用socket套接字的listen方法接收连接请求。

socket.listen( backlog )

backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。

4.第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。

connection, address =socket.accept()

调用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素address是客户的Internet地址。

\5. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv 时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最[大数据](http://lib.csdn.net/base/hadoop)量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符串，用它表示收到的数据。如果发送的数据量超过了recv所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用recv时，多余的数据会从缓冲区删除(以及自上次调用recv以来，客户可能发送的其它任何数据)。

\6. 传输结束，服务器调用socket的close方法关闭连接。

python编写client的步骤：

1. 创建一个socket以连接服务器：socket= socket.socket( family, type )

2.使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下：

socket.connect((host,port) )

host代表服务器主机名或IP，port代表服务器进程所绑定的端口号。如连接成功，客户就可通过套接字与服务器通信，如果连接失败，会引发socket.error异常。

3. 处理阶段，客户和服务器将通过send方法和recv方法通信。

4. 传输结束，客户通过调用socket的close方法关闭连接。

24. ¿Qué es mro orientado a objetos?

En programación orientada a objetos, MRO (Orden de resolución de métodos) se refiere a determinar el orden en el que se resuelven los métodos cuando una clase llama a un método en el caso de herencia múltiple. MRO determina el orden en que se llaman los métodos de cada clase en herencia múltiple y cómo manejar los conflictos de métodos.

El cálculo de MRO se logra utilizando el algoritmo de linealización C3. El algoritmo de linealización C3 crea una nueva lista fusionando las listas de orden de análisis de métodos de todas las clases principales para garantizar que el orden de análisis de métodos no se destruya cuando se llama al método. El algoritmo C3 sigue los siguientes tres principios:

1. Principio del niño primero

Si una clase es una subclase de otra clase, entonces los métodos de la subclase deben llamarse antes que los métodos de la clase principal.

2. Orden de herencia múltiple (Orden de herencia múltiple)

En el caso de herencia múltiple, al seleccionar el método de la siguiente clase, se debe preferir el método de la primera clase base.

3. Consistencia

Si una clase es padre de varias clases, entonces se debe mantener el orden de las clases en la nueva lista.

Al utilizar el algoritmo de linealización C3 para calcular MRO, puede asegurarse de que en el caso de herencia múltiple, el orden de resolución del método sea consistente y siga los principios anteriores. Esto ayuda a evitar posibles conflictos y ambigüedades y proporciona un orden claro de llamadas a métodos.

A continuación se muestra un ejemplo para ilustrar el proceso de cálculo de MRO:

Suponga la siguiente definición de clase:

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

Según el algoritmo de linealización C3, calcule la secuencia MRO de clase D:

1. Primero, agregue la clase D a la lista MRO :D

2. A continuación, combine la lista MRO (B, A) de la clase principal B de D en la lista MRO: D, B, A

3. Fusione la lista MRO (C, A) de la otra clase principal C de D en la lista MRO, siguiendo el principio de prioridad de subclase y el principio de orden de herencia múltiple: D, B, C, A

4. Finalmente, combine la lista MRO de A (A) en la lista MRO: D, B, C, A

Por tanto, la secuencia MRO de clase D es D, B, C, A. Esto significa que al llamar a un método de clase D, primero buscará el método de la clase D, luego el método de la clase B, luego el método de la clase C y finalmente el método de la clase A.

Mediante el cálculo de MRO, se puede garantizar que en el caso de herencia múltiple, el orden de resolución del método sea consistente y siga ciertas prioridades y principios, asegurando así la exactitud y previsibilidad del programa.

25. Enumere los componentes integrados de Django

​Paginador

Forma

modeloForma

orma

​cookie y sesión

​Middleware

Señal

26. Análisis de 5 métodos comunes en middleware y middleware integrado

26.1 El método init llama al método de la clase principal

init方法在启动服务的时候执行一次

26.2 proceso_request(auto,solicitud)

请求进入中间件后，第一个执行的方法
返回值有两个：Response|None
返回Response，不会再执行视图函数，而是调到process_response方法（此处有坑，最后说）
返回None，或者不return，继续运行

26.3 vista_proceso(self,solicitud,func,*args,**kwargs)

运行完process_request后，就运行这个
func是要执行的视图函数，所以：response = func(request) return response，可以得到视图函数的结果
如果调用了func(request)方法，如果不return response的话，视图函数还会执行一次，所以要不就不调用，调用就return
如果手动调用了func(request)方法，视图函数中的异常不会被process_exception(self,request,exception)接收

26.4 proceso_respuesta(auto,solicitud,respuesta)

每次返回response的时候必经的方法
必须return 一个 response，否则页面显示啥？

26.5 proceso_plantilla_respuesta(auto,solicitud,respuesta)

官方说当视图函数的返回结果是return render(request,‘xxx.html’,context)的时候，走process_template_response包装返回的响应，但我测试，发现不会调用这个方法，模板渲染返回的response也会调用process_response这个方法，可能是版本的问题吧，另外这个方法使用的情况真的比较少

26.6 proceso_excepción(auto,solicitud,excepción)

视图函数中出现了异常，接受异常的信息
但如果视图函数时通过上面所说，在process_view中手动调用了func(request)，则process_exception方法不会被调用接收异常信息

27. ¿Cuál es el mecanismo operativo de sesión en Django?

El almacenamiento de sesiones de Django se puede implementar mediante middleware.
Debe registrar la APLICACIÓN y configurar el middleware en el archivo settings.py para el inicio.
Configure el modo de almacenamiento (base de datos/caché/almacenamiento híbrido) y configure el caché de la base de datos para el almacenamiento, y genere el formulario django_session para lectura y escritura.

28. ¿Cómo cargar datos de inicialización en Django?

Después de que Django llama al método save () al crear un objeto, el marco ORM escribirá los atributos del objeto en la base de datos para inicializar la base de datos.

Consulte la base de datos operando objetos, devuelva la consulta configurada a la función de vista y muéstrela en la página de inicio a través del lenguaje de plantilla.

29. Describa brevemente el mecanismo de almacenamiento en caché (integrado) en Django.

De acuerdo con el método de caché establecido por Django, cuando el navegador realiza la primera solicitud, el caché almacenará en caché una sola variable o toda la página web en el disco duro o la memoria y establecerá el encabezado de respuesta al mismo tiempo.

Cuando el navegador inicia una solicitud nuevamente, agrega el tiempo de solicitud f-Modified-Since a Django.

Django descubre que f-Modified-Since primero eliminará los parámetros y los comparará con el tiempo de caducidad en el caché. Si el tiempo de caché es relativamente nuevo, los datos se solicitarán nuevamente, se almacenarán en caché y luego la respuesta se devolverá al cliente. .

Si el caché no ha caducado, los datos se extraen directamente del caché y se devuelven a la respuesta al cliente.

30. ¿Qué se incluye en el sistema de enrutamiento Django?

include se utiliza para el reenvío de rutas. Por lo general, crearemos un módulo de enrutamiento urls.py en cada aplicación, y luego comenzaremos desde la ruta raíz y reenviaremos todas las solicitudes de URL que pertenecen a la aplicación al módulo urls.py correspondiente.

31. ¿Cuál es la diferencia entre el comando y hacer migrar y hacer migraciones? (primario)

realizar migraciones: generar archivos de migración

migrar: realizar la migración

32. Enumere varios métodos para reducir la cantidad de consultas a la base de datos.

• Aprovechando la pereza y el almacenamiento en caché integrado de Django queryset
• Utilice los métodos select_ related y prefetch_ related para realizar operaciones de unión a nivel de base de datos
• usar caché

33. ¿Cuándo se creó el objeto de solicitud de Django?

Cuando se solicita una página, Django crea un objeto HttpRequest que contiene metadatos de la solicitud.
Cuando Django carga la vista correspondiente, el objeto HttpRequest se utilizará como el primer parámetro de la función de vista y cada vista devolverá un objeto HttpResponse.

34. Todos los métodos en Django orm (todos los métodos del objeto QuerySet)

El marco ORM de Django proporciona muchos métodos para consultar datos de tablas de bases de datos. Diferentes métodos devuelven resultados diferentes y diferentes métodos tienen sus propios escenarios de uso correspondientes.

Existen 13 métodos de consulta principales comúnmente utilizados, que se dividen en cuatro categorías según sus características:

El valor de retorno del método es un objeto iterable QuerySet:

todo():

通过ORM框架提供的【all() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都是模型类的对象。

filtrar():

【filter() 】方法的返回值是一个可迭代对象QuerySet类型数据，返回值都是符合查询条件的数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都是模型类的对象。

excluir():

①.【exclude() 】方法的返回值也是一个可迭代对象QuerySet，返回值都是不符合查询条件的数据。

②.【exclude() 】方法在实际开发中基本少用，基本都采用【filter()】方法。

③.【exclude() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都是模型类的对象。

ordenar_por()：

①.【order_by() 】方法的返回值也是一个可迭代对象QuerySet，返回值都是符合排序条件的数据。

②.【order_by() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都是模型类的对象。

③.入参的相关注意点：

参数的字段名要加引号。
如果要实现降序功能，要在字段名前面加个负号【-】。

contrarrestar():

①.【reverse() 】方法的返回值也是一个可迭代对象QuerySet，【reverse() 】方法用于对查询结果进行反转。

②.【reverse() 】方法在实际开发中基本少用，基本都采用【order_by()】方法。

③.【reverse() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都是模型类的对象。

valores():

①.【values() 】方法的返回值也是一个可迭代对象QuerySet，【values() 】方法用于查询部分字段或者全部字段的数据。

②.如果要查询全部字段的数据，【values() 】方法的入参字段数要为0；

③.【values() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都不是模型类的对象而是可迭代的字典噢，字典里的键是表字段，值是表字段对应的数据。

lista_valores()：

①.【values_list() 】方法的返回值也是一个可迭代对象QuerySet，但【values_list() 】方法用于查询部分字段或者全部字段的数据。

②.如果要查询全部字段的数据，【values_list() 】方法的入参字段数要为0；

③.【values_list() 】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都不是模型类的对象而是元祖哦，元组里放的是查询表字段对应的数据。

distinto():

①.【distinct()】方法的返回值也是一个可迭代对象QuerySet。

②.【distinct()】方法的返回值是一个可迭代对象QuerySet类型数据，该类型数据类似于list。这个可迭代对象QuerySet类型数据里面每个数据都不是模型类的对象，而是每个元祖，元组里放的是查询字段对应的数据。

③.【distinct()】方法对模型类的对象去重没有意义，因为每个对象都是一个不一样的存在。所以【distinct()】方法一般是跟 【values】方法 或者 【values_list】方法 一起使用，但如果跟【all()】方法一起使用是产生不了去重的效果。

④.【distinct()】方法的作用：用于对数据进行去重。

El valor de retorno del método es un único objeto:

conseguir():

①.【get()】方法的返回值是一个模型类的对象。

②.【get()】方法用于查询符合条件的返回模型类的对象且符合条件的对象只能为一个，如果符合筛选条件的对象超过了一个或者没有一个都会抛出错误。

primero():

①.【first()】方法返回符合查询条件的结果里的第一条数据且返回的数据是模型类的对象。

último();

①.【last()】方法返回符合查询条件的结果里的最后一条数据且返回的数据是模型类的对象。

El valor de retorno del método es un valor booleano:

existe()：

①.【exists()】方法用于判断查询的结果 QuerySet 列表里是否有数据。

②.【exists()】方法返回值的数据类型是布尔值，有数据则返回值为true，没有数据则返回值为false。

El valor de retorno del método es un número:

contar():

①.【count()】方法用于查询数据的数量且返回的数据是整数。

35. ¿Cuáles son las funciones de F y Q?

Introducción a la función F():

Para operar un determinado valor de columna en la tabla de datos, F() permite a Django tener una referencia al valor del campo de la base de datos sin vincular realmente los datos. No es necesario obtener el objeto en la memoria y luego operar el campo, y Ejecute directamente la instrucción SQL de producción original.

Método Q:

Función: Realiza consultas complejas sobre objetos y admite operadores & (y), | (o), ~ (no).

36. ¿Cuál es la función del parámetro on_delete en el campo ForeignKey en el modelo de Django?

Explicación de on_delete: cuando se elimina un dato en la tabla secundaria, la operación de clave externa asociada.

Al eliminar datos en una tabla asociada, la operación de la tabla actual y sus campos asociados.
Después de Django2.0, cuando la tabla está asociada con otra tabla, se debe escribir el parámetro on_delete; de ​​lo contrario, se informará una excepción.

1. SET_NULL

on_delete = models.SET_NULL

En el modo en blanco, al eliminar, el campo de clave externa se establece en blanco. La premisa es en blanco = Verdadero, nulo = Verdadero. Al definir este campo, se permite estar en blanco.

Elimine los datos asociados (tabla secundaria) y establezca el valor predeterminado asociado a ellos en nulo (en la tabla principal)

2.CASCADA

Indica eliminación en cascada

• Cuando se eliminan los datos de la tabla asociada (tabla secundaria), también se eliminan los datos de la clave externa correspondiente (tabla principal).

on_delete = models.CASCADE

3. Otros

on_delete = Ninguno: Al eliminar datos de la tabla asociada, el comportamiento de los campos entre la tabla actual y la tabla asociada.

on_delete = models.DO_NOTHING: Eliminas el tuyo, el padre (clave externa) no quiere controlarte

on_delete = models.PROTECT: Modo protegido. Si se utiliza este método, se generará un ProtectError al eliminar los datos asociados.

on_delete = models.SET_DEFAULT: establece el valor predeterminado. Al eliminar un campo de subtabla, el campo de clave externa se establece en el valor predeterminado, así que preste atención a agregar un valor predeterminado al definir la clave externa.

on_delete = models.SET (valor): al eliminar datos asociados, personaliza un valor, que solo puede corresponder a la entidad especificada

37. Mecanismo de defensa CSRF bajo Django

La idea general de la defensa simbólica es :

• Paso 1: el backend genera aleatoriamente un token y lo guarda en el estado SESIÓN; al mismo tiempo, el backend entrega el token a la página de inicio;
• Paso 2: la próxima vez que el front-end necesite iniciar una solicitud (como una publicación), agregue este token a los datos de la solicitud o la información del encabezado y páselo al back-end juntos;
• Paso 3: El backend verifica si el token generado por la solicitud del front-end es coherente con el token en la SESIÓN;

1. Mecanismo de prevención CSRF bajo Django

Cuando Django responde a una solicitud de un cliente por primera vez, generará aleatoriamente un token en el lado del servidor y lo colocará en la cookie. Entonces cada solicitud POST traerá este token.

De esta forma podrás evitar ser atacado por CSRF.

En la plantilla, agregue una etiqueta {% csrf_token %} para cada formulario POST. De la siguiente manera:

1. En la cookie de la respuesta HTTP devuelta, Django agregará un campo csrftoken, cuyo valor es un token generado automáticamente.

2. En todas las plantillas de formulario POST, agregue una etiqueta {% csrf_token %}. Su función es en realidad agregar una etiqueta de entrada oculta al formulario, de la siguiente manera

   , y este csrf_token = cookie.csrftoken, al representar la plantilla, hay context['csrf_token'] = request.COOKIES['csrftoken'] en el contexto.

3. Al enviar POST al servidor a través del formulario, el formulario contiene el elemento de entrada crsrmiddlewaretoken oculto arriba. Después de que el servidor lo recibe, Django verificará el valor del campo csrftoken en la cookie de la solicitud y el valor del campo csrfmiddlewaretoken en el formulario enviado ¿Es lo mismo? Si son iguales, indica que se trata de una solicitud legítima; de lo contrario, esta solicitud puede provenir del ataque CSRF de otra persona y se devolverá 403 Forbidden.

4. Al enviar una solicitud POST al servidor a través de ajax, se requiere agregar un encabezado x-csrftoken cuyo valor es el valor del csrftoken en la cookie. Después de que el servidor lo reciba, django verificará el campo csrftoken en la cookie del request y el encabezado del mensaje de publicación ajax ¿Son los encabezados x-csrftoken iguales? Si es así, indica una solicitud legítima.

El método de implementación específico :

Django implementa la función de evitar la falsificación de solicitudes entre sitios para los usuarios , lo cual se logra a través del middleware django.middleware.csrf.CsrfViewMiddleware. La función anti-falsificación de solicitudes entre sitios en Django se divide en global y local.

Global:

Middleware django.middleware.csrf.CsrfViewMiddleware

Parcialmente:

• @csrf_protect, establece a la fuerza la función anti-falsificación de solicitudes entre sitios para la función actual, incluso si no se establece ningún middleware global en la configuración.
• @csrf_exempt, cancele la función de prevención de falsificación de solicitudes entre sitios de la función actual, incluso si el middleware global está configurado en la configuración.

Nota: desde django.views.decorators.csrf importa csrf_exempt,csrf_protect

2. Principio

Agregue csrftoken en la página del cliente y verifíquelo en el lado del servidor. El trabajo de verificación del lado del servidor se completa a través de la capa intermedia de 'django.middleware.csrf.CsrfViewMiddleware'. Hay dos formas de defenderse de los ataques CSRF en Django:

1. Adjunte csrftoken al formulario

2. Agregue el encabezado de solicitud X-CSRFToken a la solicitud de solicitud.

Nota: Django realiza la verificación csrftoken para todas las solicitudes POST de forma predeterminada. Si la verificación falla, se esperará un error 403.

38. ¿Cuáles son las funciones de Form y ModeForm de Django?

Función de forma:

1.在前端生成HTML代码
2.对数据作有效性校验
3.返回校验信息并展示

ModeForm: genera el componente From según la clase del modelo y puede operar la base de datos

39. ¿Cuál es la diferencia entre filtro y simple_tag en la plantilla de Django?

Filtro personalizado: {indefinido {parámetro 1 | nombre de la función de filtro: parámetro 2}}

• Se puede utilizar con la etiqueta if.
• Debe escribir dos parámetros formales al personalizar

simple_tag:{% simple_tag nombre de la función parámetro 1 parámetro 2 %}

• Se pueden pasar múltiples parámetros, no hay límite
• No se puede usar con la etiqueta if

40. ¿Cuáles son las ventajas y desventajas de utilizar ORM y SQL nativo?

1. ORM tiene una velocidad de desarrollo rápida y un funcionamiento sencillo. Hacer que el desarrollo esté más orientado a objetos
y la velocidad de ejecución es lenta. Al procesar operaciones complejas, como consultas de unión de varias tablas, la sintaxis de ORM se volverá complicada
2. La velocidad de desarrollo de SQL es lenta y la velocidad de ejecución es rápida. Fuerte desempeño

41. ¿Qué es RPC?

La llamada a procedimiento remoto (RPC) es un protocolo que un programa puede usar para solicitar un servicio de un programa en otra computadora en la red.
RPC usa el modelo cliente/servidor. El solicitante es un cliente y el proveedor de servicios es un servidor.
2. Primero, el proceso de llamada del cliente envía un mensaje de llamada con parámetros de proceso al proceso de servicio y luego espera el mensaje de respuesta.
3. Del lado del servidor, el proceso permanece inactivo hasta que llega la información de la llamada. Cuando llega un mensaje de llamada, el servidor obtiene los parámetros del proceso, calcula el resultado, envía un mensaje de respuesta y luego espera el siguiente mensaje de llamada 4. Finalmente,
el cliente llama al proceso para recibir el mensaje de respuesta y obtiene el resultado del proceso. y luego continúa la ejecución de la llamada.

42. ¿Qué componentes están incluidos en el marco de descanso de Django?

1.序列化组件:serializers 对queryset序列化以及对请求数据格式校验
2.路由组件routers 进行路由分发
3.视图组件ModelViewSet 帮助开发者提供了一些类，并在类中提供了多个方法
4.认证组件 写一个类并注册到认证类(authentication_classes)，在类的的authticate方法中编写认证逻
5.权限组件 写一个类并注册到权限类(permission_classes)，在类的的has_permission方法中编写认证逻辑。
6.频率限制 写一个类并注册到频率类(throttle_classes)，在类的的allow_request/wait 方法中编写认证逻辑
7.解析器 选择对数据解析的类，在解析器类中注册(parser_classes)
8.渲染器 定义数据如何渲染到到页面上,在渲染器类中注册(renderer_classes)
9.分页 对获取到的数据进行分页处理, pagination_class
10.版本 版本控制用来在不同的客户端使用不同的行为
在url中设置version参数，用户请求时候传入参数。在request.version中获取版本，根据版本不同 做不同处理

43. Describa brevemente el proceso de certificación de Django Rest Framework.

1. Después de que llegue la solicitud del usuario, vaya a APIView e inicialice el método de autenticación predeterminado.
2. Vaya al método de envío de APIView. El método inicial llama a request.user.
3. Si configuramos la clase de autenticación, vaya a autenticación en nuestra propia clase de autenticación.método

44. ¿Cómo implementa Django Rest Framework el control de frecuencia de acceso de los usuarios?

Utilice la cuenta IP/usuario como clave y la marca de tiempo de cada acceso como valor para construir un diccionario de datos y guardarlo. Los elementos de la lista de marcas de tiempo se juzgan para cada acceso, eliminan los de tiempo de espera y luego calculan el resto de la lista. El límite de frecuencia se puede lograr mediante la cantidad de elementos.
Usuarios anónimos: usan el control de IP, pero no pueden controlarlo completamente, porque el usuario puede cambiar la IP del proxy para iniciar sesión. Usuarios: usan el control de cuenta, pero si hay Son muchas cuentas, no hay límite.

45. Qué es el dominio cruzado y su solución:

Dominio cruzado:
cuando el navegador solicita recursos de una página web en un nombre de dominio a otro nombre de dominio, el navegador no permite solicitudes de diferentes fuentes por razones de seguridad.
Política del mismo origen:

• El acuerdo es el mismo.
• Mismo nombre de dominio
• Mismo puerto

Método de procesamiento:
1. Dominio cruzado a través de JSONP
JSON es un formato de intercambio de datos
JSONP es un protocolo no oficial de interacción de datos entre dominios
jsonp es la etiqueta de script json incluida en la llamada de función
y no se ve afectada por la política del mismo origen. manualmente escriba la etiqueta, pase la URL y pase el nombre de una función de devolución de llamada al mismo tiempo.
Después de que el servidor obtenga el nombre, empaquetará los datos con el nombre de la función cuando devuelva los datos. Después de que el cliente obtenga los datos, elimine la etiqueta de secuencia de comandos inmediatamente. 2.cors: el uso
compartido de recursos entre dominios
utiliza encabezados HTTP personalizados para permitir que los navegadores y servidores se comuniquen entre sí
(1. Si se trata de una solicitud simple, configure directamente el nombre de dominio al que se permite acceder:
permita que su nombre de dominio para obtener mi
respuesta de datos ['Access-Control-Allow- Origin'] = "*"
(2. Si se trata de una solicitud compleja, la solicitud de opciones se enviará primero para verificación previa y luego el PUT/ real Se enviará la solicitud POST.... Por lo tanto, si la solicitud compleja
es una solicitud como PUT, el servidor debe configurarse para permitir cierta Solicitud.
Si se establece un encabezado de solicitud para una solicitud compleja, el servidor debe configurar una cierta encabezado de solicitud que se permitirá.
Solicitud simple:
una solicitud.
Solicitud no simple:
dos solicitudes. Antes de enviar datos, se enviará primero una solicitud para "verificación previa",
solo se pasa la "verificación previa" antes de enviar otra solicitud. para la transmisión de datos.
Siempre que se cumplan las dos condiciones siguientes al mismo tiempo, es una solicitud simple.
(1) El método de solicitud es uno de los siguientes tres métodos: HEAD GET POST
(2) Encabezado HTTP La información no exceder los siguientes campos:

Accept                                     
Accept-Language                                     
Content-LanguageLast-Event-ID

Tipo de contenido: limitado a tres valores aplicación/x-www-form-urlencoded, multipart/form-data, texto/plain
JSONP y CORS:
1. JSONP solo puede implementar solicitudes GET, mientras que CORS admite todo tipo de solicitudes HTTP
2.jsonp requiere la cooperación mutua entre el cliente y el servidor
. 3. No es necesario configurar Cors en el lado del cliente, el lado del servidor necesita procesar el encabezado de diferentes solicitudes.

46. ​​​​Cómo implementar la autenticación de inicio de sesión de usuario

1. sesión de cookies
2. el token genera una cadena cifrada después de iniciar sesión correctamente
3.JWT: abreviatura del token json wed. Cifra la información del usuario en el token. El servidor no guarda ninguna información del usuario. El servidor
verifica la exactitud del token mediante el uso la clave guardada.

47. OSI, TCP/IP, arquitectura de protocolo de cinco capas y protocolo de cada capa

Capas OSI (7 capas): capa física, capa de enlace de datos, capa de red, capa de transporte, capa de sesión, capa de presentación y capa de aplicación.

Capas TCP/IP (4 capas): capa de interfaz de red, capa de Internet, capa de transporte y capa de aplicación.

Protocolo de cinco capas (5 capas): capa física, capa de enlace de datos, capa de red, capa de transporte y capa de aplicación.

Los protocolos para cada capa son los siguientes:

Capa física: RJ45, CLOCK, IEEE802.3 (repetidor, hub, gateway)

Enlace de datos: PPP, FR, HDLC, VLAN, MAC (puente, conmutador)

Capa de red: IP, ICMP, ARP, RARP, OSPF, IPX, RIP, IGRP (enrutador)

Capa de transporte: TCP, UDP, SPX

Capa de sesión: NFS, SQL, NETBIOS, RPC

Capa de presentación: JPEG, MPEG, ASII

Capa de aplicación: FTP, DNS, Telnet, SMTP, HTTP, WWW, NFS

Las funciones de cada capa son las siguientes:

Capa física: transmite bits a través de medios y determina especificaciones mecánicas y eléctricas (Bit)

Capa de enlace de datos: ensamblaje de bits en tramas y transmisión punto a punto (trama)

Capa de red: Responsable de la transmisión de paquetes de datos desde el origen al destino y la interconexión a Internet (Paquete)

Capa de transporte: proporciona entrega de mensajes confiable de extremo a extremo y recuperación de errores (segmento)

Capa de sesión: establecimiento, gestión y terminación de sesiones (Unidad de datos de protocolo de sesión SPDU)

Capa de presentación: traduce, cifra y comprime datos (representa la unidad de datos de protocolo PPDU)

Capa de aplicación: medios que permiten el acceso al entorno OSI (Unidad de datos de protocolo de aplicación APDU)

48. ARP es el Protocolo de resolución de direcciones. Explique su principio de funcionamiento en un lenguaje sencillo.

El Protocolo de resolución de direcciones, o ARP (Protocolo de resolución de direcciones), es un protocolo TCP/IP que obtiene direcciones físicas basadas en direcciones IP.

1. Primero, cada host establecerá una lista ARP en su propio búfer ARP para representar la correspondencia entre la dirección IP y la dirección MAC.

2. Cuando el host de origen quiere enviar datos, primero verifica si hay una dirección MAC del host de destino correspondiente a la dirección IP en la lista ARP. Si es así, envía los datos directamente. Si no, envía paquetes ARP. a todos los hosts en este segmento de red. , el paquete de datos incluye: dirección IP del host de origen, dirección MAC del host de origen, dirección IP del host de destino

3. Cuando todos los hosts de esta red reciben el paquete ARP, primero verifican si la dirección IP en el paquete es su propia dirección IP. Si no, ignoran el paquete. Si es así, primero lo sacan del paquete. Las direcciones IP y MAC del host de origen se escriben en la lista ARP. Si ya existen, se sobrescriben y luego su propia dirección MAC se escribe en el paquete de respuesta ARP para indicarle al host de origen que es la dirección MAC que está buscando. .

4. Después de que el host de origen reciba el paquete de respuesta ARP. Escriba la dirección IP y MAC del host de destino en la lista ARP y utilice esta información para enviar datos. Si el host de origen no ha recibido un paquete de respuesta ARP, significa que la consulta ARP falló.

Nota: Las solicitudes ARP se envían por difusión (255.255.255.255) y las respuestas ARP se envían por unidifusión.

49. Sistema de nombres de dominio DNS, describa brevemente su principio de funcionamiento.

Cuando un cliente DNS necesita un nombre para usarlo en un programa, consulta a un servidor DNS para resolver el nombre. Cada mensaje de consulta enviado por el cliente incluye tres datos: el nombre de dominio DNS especificado, el tipo de consulta especificado y la categoría especificada del nombre de dominio DNS. Basado en el servicio UDP, puerto 53. Esta aplicación generalmente no la utilizan directamente los usuarios, pero sirve para otras aplicaciones, como HTTP, SMTP, etc., en las que se debe completar la conversión del nombre de host a la dirección IP.

50. ¿Cuáles son las características de los servicios orientados a la conexión y los no orientados a la conexión?

Para los servicios orientados a la conexión, ambas partes deben establecer un canal de comunicación completo entre las dos partes antes de comunicarse. Durante el proceso de comunicación, toda la conexión se puede monitorear y administrar en tiempo real.

Los servicios no orientados a la conexión no necesitan establecer una conexión entre dos nodos de comunicación por adelantado. Cuando se necesita comunicación, el nodo emisor puede enviar información a la red, permitiendo que la información se transmita de forma independiente en la red. Generalmente, hay no hay necesidad de comunicación durante el proceso de transmisión, luego monitoree.

51. ¿Proceso de protocolo de enlace de tres vías TCP? ¿Por qué se utiliza un protocolo de enlace de tres vías? ¿Está bien utilizar un protocolo de enlace de dos vías?

Respuesta: El proceso de establecimiento de una conexión se basa en el modelo cliente-servidor. Suponga que el host A es el cliente y el host B es el servidor.

(1) Proceso de protocolo de enlace de tres vías TCP: el host A envía una solicitud de conexión a B, el host B confirma el segmento de mensaje recibido del host A y el host A confirma la confirmación del host B nuevamente.

(2) El protocolo de enlace de tres vías se utiliza para evitar que el segmento de solicitud de conexión fallida se transmita repentinamente al host B, provocando así un error. El segmento de solicitud de conexión fallida significa que la solicitud de conexión enviada por el host A no recibe confirmación del host B, por lo que después de un período de tiempo, el host A reenvía la solicitud de conexión al host B, la solicitud de conexión se establece con éxito y los datos La transmisión se completa en secuencia. Considere una situación tan especial: la primera solicitud de conexión enviada por el host A no se perdió, pero el nodo de red provocó un retraso en llegar al host B. El host B pensó que era una nueva conexión iniciada por el host A, por lo que el host B aceptó la conexión. y se envía una confirmación A al host A, pero en este momento el host A simplemente la ignora. El host B ha estado esperando que el host A envíe datos, lo que resulta en un desperdicio de recursos del host B. (Esta es la falta del tercer apretón de manos (A confirma a B nuevamente))

(3) No es posible realizar dos apretones de manos debido a las circunstancias especiales de la solicitud de conexión real mencionadas anteriormente.

就是说如果只进行两次握手，那么就存在以下问题：

1.如果只进行两次握手，那么服务器只能确认客户端的请求，但是客户端无法确认服务器是否已经收到自己的请求，从而无法保证连接的可靠性。

2.可能存在历史连接的延续。假设客户端发送一个连接请求，但是由于某种原因导致服务器没有收到请求，客户端可能会认为连接已经建立，但是服务器并不知道。如果后来有其他客户端向服务器发送请求，而请求中恰好包含了与之前客户端相同的源地址和端口号，那么服务器就会误认为这是之前客户端发送的请求，从而建立连接，这就导致了历史连接的延续，可能会给网络带来安全隐患。

因此，为了保证连接的可靠性和安全性，TCP采用了三次握手的方式建立连接。

52. ¿Qué tipos de cerraduras hay en Mysql?

MyISAM admite bloqueos de tabla e InnoDB admite bloqueos de tabla y bloqueos de fila, el valor predeterminado es el bloqueo de fila.

Bloqueo a nivel de mesa: gastos generales bajos, bloqueo rápido y sin interbloqueos. La granularidad de bloqueo es grande, la probabilidad de conflicto de bloqueo es la más alta y la cantidad de concurrencia es la más baja.

Bloqueo a nivel de fila: puede producirse una gran sobrecarga, un bloqueo lento y un punto muerto. La fuerza del bloqueo es pequeña, la probabilidad de conflicto de bloqueo es pequeña y la concurrencia es la más alta.

53. ¿Mysql admite transacciones?

En el modo predeterminado, MYSQL está en modo de confirmación automática y todas las operaciones de actualización de la base de datos se enviarán inmediatamente, por lo que, de forma predeterminada, MySQL no admite transacciones. Pero si su tipo de tabla MYSQL usa tablas InnoDB o tablas BDB, su MYSQL puede usar el procesamiento de transacciones. Use SET AUTOCOMMIT=0 para permitir que MYSQL permita el modo sin confirmación automática. En el modo sin confirmación automática, debe usar COMMIT para confirmar sus cambios. o utilice ROLLBACK para revertir sus cambios. Para artículos más interesantes, preste atención a la cuenta pública "Pythonnote" o "Selección de tecnología Full Stack"

Los ejemplos son los siguientes:

START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1; 
UPDATE table2 SET summmary=@A WHERE type=1; 
COMMIT;

54. ¿Las consultas de Mysql distinguen entre mayúsculas y minúsculas?

No distingue entre.

55. Cuando la columna se establece en AUTO INCREMENT, ¿qué sucede si se alcanza el valor máximo en la tabla?

Respuesta: Dejará de incrementar y cualquier inserción adicional generará un error porque la clave ya está en uso.

56. Hay una tabla con una clave primaria de incremento automático de ID. Después de insertar 17 registros, elimine los registros 15, 16 y 17. Luego reinicie Mysql e inserte otro registro. ¿La ID de este registro es 18 o 18? ¿15?

Si el tipo de tabla es MyISAM, entonces es 18. Debido a que la tabla MyISAM registrará la ID máxima de la clave primaria incrementada automáticamente en el archivo de datos, la ID máxima de la clave primaria incrementada automáticamente no se perderá cuando se reinicie MySQL.

Si el tipo de tabla es InnoDB, entonces es 15. La tabla InnoDB solo registra la ID máxima de la clave primaria incrementada automáticamente en la memoria, por lo que reiniciar la base de datos o realizar una operación OPTIMIZAR en la tabla hará que se pierda la ID máxima.

57. ¿Cuáles son los tres paradigmas de la base de datos?

Primera forma normal (1NF): los campos son atómicos y no se pueden subdividir. (Todos los sistemas de bases de datos relacionales satisfacen la primera forma normal. Los campos de la tabla de la base de datos tienen un solo atributo y no se pueden dividir más). La
segunda forma normal (2NF) se establece sobre la base de la primera forma normal (1NF), que es decir, satisface la primera forma normal. La segunda forma normal (2NF) primero debe satisfacer la primera forma normal (1NF). Requiere que cada instancia o fila de una tabla de base de datos se pueda distinguir de forma única. Generalmente es necesario agregar una columna a la tabla para almacenar el identificador único de cada instancia. Esta columna de atributos únicos se llama clave primaria o clave primaria.
Para satisfacer la tercera forma normal (3NF), primero debes satisfacer la segunda forma normal (2NF). En resumen, la tercera forma normal (3NF) requiere que una tabla de base de datos no contenga información de clave no primaria que ya esté contenida en otras tablas.

Entonces la tercera forma normal tiene las siguientes características:

1. Cada columna tiene un solo valor.
2. Cada fila se puede distinguir
3. Cada tabla no contiene información de clave no principal que ya contienen otras tablas.

58. ¿Cuál es el principio y el proceso de replicación de mysql?

R: Las capacidades de replicación integradas de MySQL son la base para crear aplicaciones grandes y de alto rendimiento. Distribuir datos de Mysql a múltiples sistemas.Este mecanismo de distribución se logra copiando los datos de un determinado host Mysql a otros hosts (esclavos) y ejecutándolos nuevamente. * Un servidor actúa como servidor maestro durante la replicación, mientras que uno o más servidores actúan como servidores esclavos. El servidor maestro escribe actualizaciones en un archivo de registro binario y mantiene un índice del archivo para realizar un seguimiento de las rotaciones de registros. Estos registros registran las actualizaciones enviadas a los servidores esclavos. Cuando un esclavo se conecta al maestro, notifica al maestro dónde leyó la última actualización exitosa en el registro. El esclavo recibe cualquier actualización que haya ocurrido desde entonces, luego bloquea y espera a que se notifique al maestro sobre las nuevas actualizaciones. El proceso es el siguiente: 1. El servidor maestro registra la actualización en el archivo de registro binario. 2. El servidor esclavo copia el registro binario del servidor maestro en su propio registro de retransmisión (registro de reproducción). 3. Rehaga la hora en el registro de retransmisión del servidor y aplique las actualizaciones a su propia base de datos.

59. ¿Cuál es la diferencia entre myISAM e innodb en mysql?

1. Soporte de transacciones > MyISAM: El énfasis está en el rendimiento, cada consulta es atómica y sus tiempos de ejecución son más rápidos que el tipo InnoDB, pero no se proporciona soporte de transacciones. > InnoDB: proporciona funciones avanzadas de base de datos, como transacciones de soporte de transacciones y claves externas. Tablas seguras para transacciones (compatibles con ACID) con capacidades de transacción (confirmación), reversión (reversión) y recuperación ante fallas.
2. InnoDB admite bloqueos a nivel de fila, mientras que MyISAM admite bloqueos a nivel de tabla. >> Cuando un usuario opera una tabla myisam, las declaraciones de selección, actualización, eliminación e inserción bloquearán automáticamente la tabla. Si la tabla bloqueada satisface la concurrencia de inserción, nuevos datos Se puede insertar al final de la mesa.
3. InnoDB admite MVCC, mientras que MyISAM no.
4. InnoDB admite claves externas, mientras que MyISAM no.
5. Clave primaria de tabla > MyISAM: Permite que existan tablas sin índices ni claves primarias. Los índices son las direcciones donde se guardan las filas. > InnoDB: si no hay una clave principal o un conjunto de índice único no vacío, se generará uno automáticamente.
6. La clave primaria de bytes (no visible para el usuario), los datos son parte del índice principal y el índice adicional guarda el valor del índice principal. 6. InnoDB no admite la indexación de texto completo, pero MyISAM sí la admite.
7. Portabilidad, copia de seguridad y recuperación > MyISAM: Los datos se almacenan en forma de archivos, por lo que es muy conveniente para la transferencia de datos entre plataformas. Puede realizar operaciones en una tabla individualmente durante la copia de seguridad y la recuperación. > InnoDB: las soluciones gratuitas incluyen copiar archivos de datos, hacer copias de seguridad de binlog o usar mysqldump, lo cual es relativamente doloroso cuando el volumen de datos alcanza decenas de gigabytes.
8. Estructura de almacenamiento > MyISAM: Cada MyISAM se almacena como tres archivos en el disco. El nombre del primer archivo comienza con el nombre de la tabla y la extensión indica el tipo de archivo. Los archivos .frm almacenan definiciones de tablas. La extensión del archivo de datos es .MYD (MYData). La extensión del archivo de índice es .MYI (MYIndex). > InnoDB: todas las tablas se almacenan en el mismo archivo de datos (o en varios archivos, o archivos de espacio de tabla independientes). El tamaño de la tabla InnoDB solo está limitado por el tamaño del archivo del sistema operativo, que generalmente es de 2 GB.

60. ¿Cuáles son los nombres de los cuatro niveles de aislamiento de transacciones admitidos por InnoDB en MySQL y las diferencias entre ellos paso a paso?

1. Leer no confirmado (leer contenido no confirmado) >> En este nivel de aislamiento, todas las transacciones pueden ver los resultados de ejecución de otras transacciones no confirmadas. Este nivel de aislamiento rara vez se utiliza en aplicaciones prácticas porque su rendimiento no es mucho mejor que el de otros niveles. La lectura de datos no confirmados también se denomina lectura sucia.
2. Leer confirmado (leer contenido de confirmación) >> Este es el nivel de aislamiento predeterminado de la mayoría de los sistemas de bases de datos (pero no el predeterminado de MySQL). Cumple con la definición simple de aislamiento: una transacción solo puede ver los cambios realizados por transacciones confirmadas. Este nivel de aislamiento también admite la llamada lectura no repetible, porque otras instancias de la misma transacción pueden tener nuevas confirmaciones durante el procesamiento de la instancia, por lo que la misma selección puede devolver resultados diferentes.
3. Lectura repetible (relegible) >> Este es el nivel de aislamiento de transacciones predeterminado de MySQL, que garantiza que varias instancias de la misma transacción verán las mismas filas de datos al leer datos al mismo tiempo. Pero, en teoría, esto conducirá a otro problema espinoso: la lectura fantasma. En pocas palabras, la lectura fantasma significa que cuando el usuario lee un cierto rango de filas de datos, otra transacción inserta una nueva fila en el rango. Cuando el usuario vuelve a leer las filas de datos en el rango, encontrará que hay nuevos "fantasmas". línea. Los motores de almacenamiento InnoDB y Falcon resuelven este problema mediante el mecanismo de control de concurrencia multiversión (MVCC, bloqueo de brecha de control de concurrencia multiversión). Nota: De hecho, la versión múltiple solo resuelve el problema de la lectura no repetible, y agregar un bloqueo de espacio (que aquí es el llamado control de concurrencia) resuelve el problema de la lectura fantasma.
4. Serializable >> Este es el nivel de aislamiento más alto. Resuelve el problema de lectura fantasma al obligar a las transacciones a ordenarse para que no puedan entrar en conflicto entre sí. En resumen, agrega un bloqueo compartido en cada fila de datos leída. En este nivel, pueden producirse muchos tiempos de espera y conflictos de bloqueo.

61. ¿Qué es un índice? Describa brevemente qué tipos de índices de uso común existen.

Un índice es una estructura que ordena los valores de una o más columnas en una tabla de base de datos y permite un acceso rápido a información específica en una tabla de base de datos. Si desea encontrar un empleado específico por su apellido, un índice puede ayudarlo a obtener la información más rápido que buscar en todas las filas de la tabla.

En términos sencillos, un índice es una tabla de contenido de datos, como leer un libro. Si quiero leer el contenido del Capítulo 3, Sección 4, si hay una tabla de contenido, puedo hojear directamente la tabla de contenido y busque el número de página del Capítulo 3, Sección 4. Si no hay un índice, tendría que empezar desde el principio del libro y pasar página por página hasta llegar al contenido del Capítulo 3, Sección 4.

1. Clasificación de índices MySQL

Podemos dividirlos aproximadamente en dos categorías según los índices generados para los atributos de las columnas:

Índice de una sola columna: el árbol de índice generado por una sola columna de la tabla se denomina índice de una sola columna de la tabla.
Índice compuesto: el árbol de índice generado al combinar varias columnas de la tabla se denomina índice combinado de la tabla.

2. Los índices de una sola columna tienen divisiones específicas y detalladas:

Índice de clave principal: el árbol de índice generado en función de la clave principal de la tabla se denomina índice de clave principal de la tabla.
Índice único: el árbol de índice generado por la columna única de la tabla se denomina índice único de la tabla.
Índice ordinario: el árbol de índice generado por las columnas ordinarias (clave no principal, columnas no únicas) de la tabla se denomina índice ordinario de la tabla.
Índice de texto completo

62. ¿Qué tipo de estructura de datos es un índice?

Respuesta: La estructura de datos del índice está relacionada con la implementación del motor de almacenamiento específico. Los índices más utilizados en MySQL incluyen el índice Hash, el índice de árbol B +, etc.

La implementación de índice predeterminada del motor de almacenamiento InnoDB que utilizamos a menudo es: índice de árbol B+.

63. ¿Cuáles son las diferencias o ventajas y desventajas entre el índice Hash y el árbol B+?

Respuesta: En primer lugar, debemos conocer los principios de implementación subyacentes del índice Hash y del índice de árbol B+:

La capa inferior del índice hash es la tabla hash. Al buscar, el valor clave correspondiente se puede obtener llamando a la función hash una vez y luego consultando la tabla nuevamente para obtener los datos reales.
La implementación subyacente del árbol B + es un árbol de búsqueda equilibrado de múltiples rutas. Cada consulta comienza desde el nodo raíz. Solo cuando se encuentra el nodo hoja se puede obtener el valor clave consultado y luego, en función de la consulta, se juzga si es necesario devolver la tabla para consultar los datos.

Luego se puede observar que tienen las siguientes diferencias:

Los índices hash son más rápidos para consultas equivalentes (generalmente), pero no pueden realizar consultas de rango. Porque después de utilizar la función hash para crear el índice en el índice hash, el orden del índice no puede ser coherente con el orden original y no se pueden admitir consultas de rango. Todos los nodos del árbol B + siguen las reglas (el nodo izquierdo es más pequeño que el nodo principal, el nodo derecho es más grande que el nodo principal y el árbol de múltiples bifurcaciones es similar) y el rango de soporte natural es.
El índice hash no admite el uso de índice para ordenar; el principio es el mismo que el anterior.
Los índices hash no admiten consultas difusas ni la coincidencia de prefijos más a la izquierda de índices de varias columnas. El principio también se debe a que la función hash es impredecible y los índices AAAA y AAAAB no tienen correlación.
Los índices hash no pueden evitar consultar datos en ningún momento, mientras que los árboles B + pueden completar consultas solo a través de índices cuando se cumplen ciertas condiciones (índice agrupado, índice de cobertura, etc.).
Aunque los índices hash son más rápidos en consultas equivalentes, son inestables y tienen un rendimiento impredecible. Cuando un determinado valor clave tiene una gran cantidad de duplicados, se produce una colisión de hash y la eficiencia puede ser extremadamente pobre. La eficiencia de las consultas del árbol B + es relativamente estable: todas las consultas se realizan desde el nodo raíz hasta el nodo hoja y la altura del árbol es baja.

Por lo tanto, en la mayoría de los casos, seleccionar directamente el índice del árbol B + puede lograr una velocidad de consulta mejor y estable. No es necesario utilizar el índice hash.

64. Como se mencionó anteriormente, el árbol B + no necesita regresar a la tabla para consultar datos cuando satisface el índice agrupado y el índice de cobertura ¿Qué es un índice agrupado?

Respuesta: En el índice del árbol B +, el nodo hoja puede almacenar el valor clave actual, o puede almacenar el valor clave actual y los datos de toda la fila.Estos son el índice agrupado y el índice no agrupado. En InnoDB, solo el índice de clave principal es un índice agrupado. Si no hay una clave principal, se selecciona una clave única para construir un índice agrupado. Si no hay una clave única, se genera implícitamente una clave para construir un índice agrupado.

Cuando la consulta utiliza un índice agrupado, la fila completa de datos se puede obtener en el nodo hoja correspondiente, por lo que no es necesario volver a consultar la tabla.

65. ¿Los índices no agrupados definitivamente devolverán consultas de tabla?

Respuesta: No necesariamente. Esto implica si todos los campos requeridos por la declaración de consulta llegan al índice. Si todos los campos llegan al índice, entonces no es necesario volver a realizar una consulta en la tabla.

Para dar un ejemplo simple, supongamos que hemos establecido un índice en la edad de la tabla de empleados, luego, cuando se realiza la consulta de selección de edad del empleado donde edad < 20, el nodo hoja del índice ya contiene información de edad y no será realizado de nuevo Consulta de tabla de retorno.

66. ¿Conoces los bloqueos de MySQL?

Respuesta: Cuando la base de datos tiene transacciones concurrentes, pueden ocurrir inconsistencias en los datos. En este momento, se necesitan algunos mecanismos para garantizar el orden de acceso. El mecanismo de bloqueo es uno de esos mecanismos.

Al igual que en una habitación de hotel, si todos van y vienen a voluntad, muchas personas robarán la misma habitación. Si se instala una cerradura en la habitación, solo la persona que solicitó la llave podrá entrar y cerrar la habitación. Los demás pueden hacerlo. Sólo espere a que termine de usarlo antes de poder usarlo nuevamente.

67. ¿Qué tipo de bloqueos tiene MySQL? ¿Un bloqueo como el del ejemplo anterior no obstaculizaría la eficiencia de la concurrencia?

Respuesta: En términos de tipos de bloqueo, existen bloqueos compartidos y bloqueos exclusivos.

Bloqueo compartido: también llamado bloqueo de lectura. Cuando el usuario desea leer datos, se agrega un bloqueo compartido a los datos y se pueden agregar varios bloqueos compartidos al mismo tiempo.
Bloqueo exclusivo: También llamado bloqueo de escritura. Cuando el usuario quiere escribir datos, se agrega un bloqueo exclusivo a los datos. Solo se puede agregar un bloqueo exclusivo. Es exclusivo de otros bloqueos exclusivos y bloqueos compartidos.

Usando el ejemplo anterior, hay dos tipos de comportamiento de usuario. Uno es ver una casa. Es aceptable que varios usuarios vean una casa juntos. Una es quedarse una noche, durante este período ni los que quieran registrarse ni los que quieran ver la habitación podrán hacerlo. La granularidad de los bloqueos depende del motor de almacenamiento específico: InnoDB implementa bloqueos a nivel de fila, bloqueos a nivel de página y bloqueos a nivel de tabla. Sus gastos generales de bloqueo varían de grandes a pequeños, y sus capacidades de concurrencia también varían de grandes a pequeñas.

68. ¿Cuántos formatos de entrada existen para el binlog de MySQL?¿Cuáles son las diferencias?

Respuesta: Hay tres formatos, declaración, fila y mixto.

En el modo de declaración, la unidad de registro es una declaración. Es decir, se registrará el impacto de cada declaración SQL. Dado que la ejecución de las declaraciones SQL es contextual, es necesario guardar información relevante al guardar. Al mismo tiempo, también hay algunas declaraciones que utilizan funciones y similares que no se pueden grabado y copiado.
A nivel de fila, la unidad de registro son los cambios en cada fila. Básicamente, se pueden registrar todos los cambios. Sin embargo, muchas operaciones causarán una gran cantidad de cambios de fila (como alterar la tabla). Por lo tanto, los archivos en este modo se guardan. demasiada información y el volumen de registro es demasiado grande.
mixto, una solución de compromiso. Las operaciones comunes usan registros de declaraciones, y la fila se usa cuando no se pueden usar declaraciones.

Además, la nueva versión de MySQL también ha realizado algunas optimizaciones a nivel de fila: cuando cambia la estructura de la tabla, las declaraciones se registrarán en lugar de fila por fila.

69. Una ejecución de SQL tarda demasiado, ¿cómo se optimiza y desde qué aspectos?

1. Verifique si SQL involucra tablas conjuntas o subconsultas de varias tablas. Si es así, vea si el negocio se puede dividir y los campos relevantes pueden ser redundantes o fusionarse en tablas temporales (optimización del negocio y algoritmos).

2. Para consultas que involucran listas vinculadas, si se pueden realizar consultas de subtablas y los resultados después de consultas de una sola tabla se pueden integrar en campos.

3. Si ninguno de los dos métodos anteriores se puede operar y debe consultar la lista vinculada, considere indexar las condiciones de consulta correspondientes. Agilizar consultas.

4. Separar tablas históricas para un gran número de tablas (como tablas de flujo de transacciones).

5. La separación de la base de datos maestro y esclavo, lectura y escritura, reduce la presión de lectura y escritura simultáneas en la misma tabla.En cuanto a la sincronización maestro-esclavo, mysql tiene su propio binlog para lograr la sincronización maestro-esclavo.

6. Explicar analiza la declaración SQL, verifica el plan de ejecución, analiza si se utiliza el índice, analiza el número de filas escaneadas, etc.

7. Verifique el registro de ejecución de mysql para ver si hay otros problemas.

He puesto en negrita la palabra clave explicar arriba, es decir, muchos entrevistadores no le preguntan directamente sobre la optimización de SQL, sino que le preguntarán si sabe cuál es el plan de ejecución de MySQL. De hecho, solo quiero comprobar si conoce la palabra clave explicar, por lo que si no comprende explicar, debe conectarse en línea y comprobarlo usted mismo.

70. ¿Qué tipos de datos admite Redis?

Respuesta: Redis admite cinco tipos de datos: cadena (cadena), hash (hash), lista (lista), conjunto (conjunto) y zset (conjunto ordenado: conjunto ordenado).

También existen algunas estructuras de datos como HyperLogLog, Geo, Pub/Sub, etc. También debemos saber que, además, al igual que Redis Module, como BloomFilter, RedisSearch, Redis-ML, etc., podemos tener una impresión, incluso Si no sabemos por qué es mejor que no haber escuchado nada mejor.

71. ¿Cuáles son las estrategias de eliminación de Redis?

La estrategia de eliminación de memoria de Redis se refiere a cómo manejar los datos que deben escribirse recientemente y requieren una aplicación de espacio adicional cuando la memoria de Redis para el almacenamiento en caché es insuficiente.

sin desalojo: cuando la memoria no es suficiente para acomodar los datos recién escritos, la nueva operación de escritura informará un error.
allkeys-lru: cuando la memoria no es suficiente para acomodar los datos recién escritos, elimine la clave utilizada menos recientemente en el espacio de claves.
allkeys-random: cuando la memoria no es suficiente para acomodar datos recién escritos, se elimina aleatoriamente una clave del espacio de claves.
volatile-lru: cuando la memoria no es suficiente para acomodar los datos recién escritos, elimine la clave utilizada menos recientemente en el espacio de claves con el tiempo de vencimiento establecido.
volátil-aleatorio: cuando la memoria no es suficiente para acomodar los datos recién escritos, se elimina aleatoriamente una clave del espacio de claves con el tiempo de vencimiento establecido.
volatile-ttl: cuando la memoria no es suficiente para acomodar los datos recién escritos, en el espacio de clave con un tiempo de vencimiento establecido, la clave con un tiempo de vencimiento anterior se elimina primero.

Preste atención a los seis mecanismos aquí. volatile y allkeys especifican si eliminar datos del conjunto de datos con un tiempo de vencimiento establecido o eliminar datos de todos los conjuntos de datos. Los siguientes lru, ttl y random son tres estrategias de eliminación diferentes, más una A no -Estrategia de condena que nunca se recicla.

Utilice reglas de política:

1. Si los datos muestran una distribución de ley de potencia, es decir, algunos datos tienen una frecuencia de acceso alta y otros datos tienen una frecuencia de acceso baja, use allkeys-lru

2. Si los datos están distribuidos equitativamente, es decir, todas las frecuencias de acceso a los datos son iguales, utilice allkeys-random

72. ¿Por qué Redis necesita poner todos los datos en la memoria?

Respuesta: Para lograr la velocidad de lectura y escritura más rápida, Redis lee todos los datos en la memoria y los escribe en el disco de forma asíncrona. Por lo tanto, redis tiene las características de alta velocidad y persistencia de datos. Si los datos no se colocan en la memoria, la velocidad de E / S del disco afectará seriamente el rendimiento de redis.

Hoy en día, cuando la memoria es cada vez más barata, Redis se volverá cada vez más popular. Si se establece el uso máximo de memoria, no se pueden insertar nuevos valores después de que el número de registros de datos alcance el límite de memoria.

73. ¿Cuáles son los escenarios adecuados para Redis?

(1) Caché de sesión

Uno de los escenarios más utilizados para usar Redis es el caché de sesión. La ventaja de usar Redis para almacenar sesiones en caché sobre otro almacenamiento (como Memcached) es que Redis proporciona persistencia. Al mantener un caché que no requiere estrictamente coherencia, la mayoría de las personas no estarían contentas si se perdiera toda la información del carrito de compras del usuario. Ahora bien, ¿seguirían estando así?

Afortunadamente, a medida que Redis ha mejorado a lo largo de los años, es fácil descubrir cómo utilizar Redis correctamente para almacenar en caché los documentos de sesión. Incluso la conocida plataforma comercial Magento proporciona complementos para Redis.

(2) Caché de página completa (FPC)

Además de los tokens de sesión básicos, Redis también proporciona una plataforma FPC muy simple. Volviendo al problema de coherencia, incluso si se reinicia la instancia de Redis, los usuarios no verán una caída en la velocidad de carga de la página debido a la persistencia del disco. Esta es una gran mejora, similar al FPC local de PHP.

Tomando Magento nuevamente como ejemplo, Magento proporciona un complemento para usar Redis como backend de caché de página completa. Además, para los usuarios de WordPress, Pantheon tiene un muy buen complemento wp-redis, que puede ayudarlo a cargar las páginas que ha navegado lo más rápido posible.

(3)Cola

Una de las grandes ventajas de Reids en el campo de los motores de almacenamiento de memoria es que proporciona operaciones de lista y configuración, lo que permite que Redis se utilice como una buena plataforma de cola de mensajes. Las operaciones utilizadas por Redis como cola son similares a las operaciones push/pop de los lenguajes de programación locales (como Python) en listas.

Si busca rápidamente "colas de Redis" en Google, encontrará inmediatamente una gran cantidad de proyectos de código abierto, cuyo propósito es utilizar Redis para crear muy buenas herramientas de back-end para satisfacer diversas necesidades de colas. Por ejemplo, Celery tiene un backend que utiliza Redis como intermediario. Puedes verlo desde aquí.
(4) Clasificación/Contador

Redis hace un excelente trabajo incrementando o disminuyendo números en la memoria. Los conjuntos (Sets) y los conjuntos ordenados (SortedSet) también nos facilitan mucho la realización de estas operaciones. Redis solo proporciona estas dos estructuras de datos. Entonces, para obtener los 10 mejores usuarios del conjunto ordenado, llamémoslos "user_scores", simplemente lo hacemos así: Por supuesto, esto supone que lo estás haciendo en función de las puntuaciones de tus usuarios. Clasificación creciente. Si desea devolver el usuario y la puntuación del usuario, debe hacer esto:

ZRANGE puntuaciones_usuario 0 10 CONPUNTUACIONES

Agora Games es un buen ejemplo, implementado en Ruby, y su tabla de clasificación utiliza Redis para almacenar datos, que puedes ver aquí.
(5) Publicar/Suscribirse

Por último (pero ciertamente no menos importante) está la funcionalidad de publicación/suscripción de Redis. De hecho, existen muchos casos de uso para publicar/suscribir. He visto a personas usarlo en conexiones de redes sociales, como desencadenantes de scripts basados ​​en publicación/suscripción, ¡e incluso para crear sistemas de chat usando la funcionalidad de publicación/suscripción de Redis!

74. ¿Hablar sobre el concepto de ranura hash de Redis?

El clúster de Redis no utiliza hash consistente, pero introduce el concepto de ranuras de hash. El clúster de Redis tiene 16384 ranuras de hash. Cada clave es verificada por CRC16 y el módulo 16384 se utiliza para determinar qué ranura colocar. Cada nodo del clúster es responsable de parte de la ranura hash.

¿Cuál es el modelo de replicación maestro-esclavo del clúster Edis?

Para que el clúster siga disponible cuando algunos nodos fallan o la mayoría de los nodos no pueden comunicarse, el clúster utiliza un modelo de replicación maestro-esclavo y cada nodo tendrá N-1 réplicas.

75. ¿Se perderán las operaciones de escritura en el clúster de Redis?

Redis no garantiza una coherencia sólida de los datos, lo que significa que, en la práctica, el clúster puede perder operaciones de escritura bajo ciertas condiciones.

76. ¿Cómo se replican los clústeres de Redis?

Respuesta: replicación asincrónica

77. ¿Para qué sirven las canalizaciones en Redis?

Un servidor de solicitud/respuesta puede manejar nuevas solicitudes incluso si las solicitudes antiguas aún no han sido respondidas, de modo que se pueden enviar múltiples comandos al servidor sin esperar una respuesta y, finalmente, leer la respuesta en un solo paso. Se trata del pipelining, una técnica que se ha utilizado ampliamente durante décadas. Por ejemplo, se han implementado muchos protocolos POP3 para admitir esta función, lo que acelera enormemente el proceso de descarga de correo nuevo desde el servidor.

78¿Cómo entender las transacciones de Redis?

Una transacción es una operación de aislamiento separada: todos los comandos de la transacción se serializarán y ejecutarán en orden. Durante la ejecución de la transacción, no será interrumpida por solicitudes de comando enviadas por otros clientes.
Una transacción es una operación atómica: o se ejecutan todos los comandos de la transacción o no se ejecuta ninguno de ellos.

79. ¿Cuáles son los comandos relacionados con las transacciones de Redis?

MULTI、EJEC.、DESCARTAR、VER

MULTI: Para iniciar una transacción, redis colocará los comandos posteriores en la cola uno por uno y luego usará el comando EXEC para ejecutar atómicamente esta serie de comandos.

EXEC: ejecuta todos los comandos de operación en la transacción.

DISCARD: Cancela la transacción y abandona la ejecución de todos los comandos en el bloque de transacción.

MIRAR: Monitoree una o más claves. Si esta clave (o claves) es modificada por otros comandos antes de que se ejecute la transacción, la transacción se interrumpirá y no se ejecutará ningún comando en la transacción.

UNWATCH: cancela la monitorización WATCH de todas las claves.

80. ¿Cómo configurar el tiempo de vencimiento y la validez permanente de la clave Redis?

Comandos EXPIRAR y PERSISTIR

81. ¿Cómo realiza Redis la optimización de la memoria?

Utilice hashes tanto como sea posible. Las tablas hash (lo que significa que el número almacenado en una tabla hash es pequeña) utilizan muy poca memoria, por lo que debe abstraer su modelo de datos en una tabla hash tanto como sea posible. Por ejemplo, si hay un objeto de usuario en su sistema web, no establezca una clave separada para el nombre, apellido, correo electrónico y contraseña del usuario, sino que almacene toda la información del usuario en una tabla hash.

82. ¿Cómo funciona el proceso de reciclaje de Redis?

Un cliente ejecutó un nuevo comando y agregó nuevos datos. Redi verifica el uso de la memoria. Si es mayor que el límite máximo de memoria, se reciclará de acuerdo con la política establecida. Se ejecuta un nuevo comando, etc. Por lo tanto, estamos cruzando constantemente el límite del límite de la memoria al alcanzar constantemente el límite y luego reciclarnos constantemente por debajo del límite. Si el resultado de un comando da como resultado el uso de una gran cantidad de memoria (como guardar la intersección de un conjunto grande en una nueva clave), este uso de memoria no tardará mucho en exceder el límite de memoria.

83. ¿Cuál es la cantidad máxima de nodos en un clúster de Redis?

Respuesta: 16.384.

83. ¿Cómo elegir una base de datos para el clúster de Redis?

Respuesta: El clúster de Redis actualmente no puede seleccionar la base de datos y el valor predeterminado es la base de datos 0.

84. ¿Qué sucede cuando Redis se queda sin memoria?

Respuesta: Si se alcanza el límite superior establecido, el comando de escritura de Redis devolverá un mensaje de error (pero el comando de lectura aún puede regresar normalmente). O puede usar Redis como caché para usar el mecanismo de eliminación de configuración. Cuando Redis alcanza la memoria límite superior, se eliminarán los antiguos.

85. Si este redis brinda servicios a empresas en línea, ¿cuáles son los problemas con el uso del comando de teclas?

Respuesta: redis tiene un solo subproceso. La instrucción de claves hará que el hilo se bloquee por un período de tiempo y el servicio en línea se detendrá. El servicio no se puede restaurar hasta que se ejecute la instrucción. En este momento, puede usar el comando de escaneo. El comando de escaneo puede extraer la lista de claves del modo especificado sin bloquear, pero habrá una cierta probabilidad de duplicación. Solo hágalo una vez en el cliente, pero el tiempo total empleado será ser más largo que usarlo directamente. El comando de teclas es largo.

86. Si hay una gran cantidad de claves que deben configurarse para que caduquen al mismo tiempo, ¿a qué debería prestar atención en general?

Respuesta: Si el tiempo de vencimiento de una gran cantidad de claves se establece de manera demasiado concentrada, Redis puede experimentar un breve retraso en el momento del vencimiento. Generalmente, es necesario agregar un valor aleatorio al tiempo para extender el tiempo de vencimiento.

87. ¿Qué se debe hacer con la solución de clúster de Redis? ¿Cuales son los planes?

codis: la solución de clúster más utilizada en la actualidad. Básicamente tiene el mismo efecto que twemproxy, pero admite la recuperación de datos de nodos antiguos en nuevos nodos hash cuando cambia el número de nodos.
La característica del clúster que viene con redis cluster3.0 es que su algoritmo distribuido no es un hash consistente, sino el concepto de ranuras hash, y admite la configuración de nodos esclavos. Consulte la documentación oficial para obtener más detalles.
Implementado en la capa de código comercial, se crean varias instancias de Redis no relacionadas, en la capa de código, el cálculo hash se realiza en la clave y luego los datos se manipulan en la instancia de Redis correspondiente. Este método tiene requisitos relativamente altos para el código de la capa hash. Las consideraciones incluyen soluciones de algoritmos alternativos después de una falla del nodo, recuperación automática de scripts después de una descarga de datos, monitoreo de instancias, etc.

88. ¿Alguna vez ha utilizado el bloqueo distribuido de Redis? ¿Cómo se implementa?

Respuesta: Primero use setnx para competir por el candado. Después de agarrarlo, use expire para agregar un tiempo de vencimiento al candado para evitar que se olvide de liberarlo.

89. ¿Qué pasará si el proceso falla inesperadamente o es necesario reiniciarlo por mantenimiento antes de ejecutarlo y caducar después de setnx?

Respuesta: La instrucción set tiene parámetros muy complejos. ¡Esto debería poder combinar setnx y expirar en una instrucción al mismo tiempo!

90. ¿Alguna vez has usado Redis para colas asincrónicas? ¿Cómo lo usaste? ¿Cuáles son las desventajas?

Generalmente, la estructura de lista se utiliza como cola, rpush produce mensajes y lpop consume mensajes. Cuando no haya ningún mensaje de lpop, duerma un rato y vuelva a intentarlo.

Desventajas: cuando el consumidor se desconecta, los mensajes producidos se perderán, por lo que debe utilizar una cola de mensajes profesional como RabbitMQ.

¿Se puede producir una vez y consumir muchas veces?

Utilizando el modelo de suscriptor de tema pub/sub, se puede implementar una cola de mensajes 1:N.

91. ¿Cuáles son las soluciones para la penetración, la avería y la avalancha de caché?

Penetración de caché: se refiere a consultar datos que no deben existir. Si los datos no se pueden encontrar desde la capa de almacenamiento, no se escribirán en el caché. Esto hará que los datos inexistentes se consulten en la base de datos cada vez que se solicita, lo que puede provocar que la base de datos se cuelgue.

solución:

1. Los datos devueltos por la consulta están vacíos y el resultado vacío aún se almacena en caché, pero el tiempo de vencimiento será más corto;

2. Filtro Bloom: hash todos los datos posibles en un mapa de bits que sea lo suficientemente grande. Los datos que no deben existir serán interceptados por este mapa de bits, evitando así consultas a la base de datos.

Desglose del caché: para una clave con un tiempo de vencimiento establecido, cuando el caché caduca en un momento determinado, habrá una gran cantidad de solicitudes simultáneas para la clave en ese momento. Cuando estas solicitudes descubren que el caché ha caducado Por lo general, cargarán los datos desde la base de datos de back-end y los volverán a almacenar en el caché. En este momento, las solicitudes simultáneas de gran tamaño pueden abrumar instantáneamente la base de datos.

solución:

1. Utilice un bloqueo mutex: cuando el caché falla, no cargue la base de datos inmediatamente. Primero use setnx como Redis para configurar un bloqueo mutex. Cuando la operación regrese exitosamente, realice la operación de carga de base de datos y reinicie el caché. De lo contrario, intente nuevamente .Obtener método de caché.

2. Nunca caduca: lo físico no caduca, pero la lógica caduca (subproceso asincrónico en segundo plano para actualizar).

Avalancha de caché: se utiliza el mismo tiempo de vencimiento al configurar el caché, lo que hace que el caché caduque al mismo tiempo en un momento determinado, todas las solicitudes se reenvían a la base de datos y la base de datos está bajo presión instantánea y provoca una avalancha. La diferencia con el desglose del caché: Avalanche son muchas claves, mientras que el desglose es un caché de claves determinado.

solución:

Distribuya el tiempo de caducidad de la caché. Por ejemplo, puede agregar un valor aleatorio al tiempo de caducidad original, como de 1 a 5 minutos al azar. De esta manera, la tasa de repetición de cada tiempo de caducidad de la caché se reducirá y será difícil para provocar eventos de fracaso colectivo.

92. ¿Por qué Redis es tan rápido con un solo subproceso?

Respuesta: Redis utiliza tecnología de cola para convertir el acceso concurrente en acceso en serie, eliminando la sobrecarga del control en serie de la base de datos tradicional.

93. ¿Cómo diseñar bloqueos distribuidos usando redis? ¿Cuénteme sobre las ideas de implementación? ¿Es posible usar zk? ¿Cómo implementarlo? ¿Cuál es la diferencia entre los dos?

Redis:

1. Hilo Un setnx (objeto bloqueado, marca de tiempo t1 cuando se agota el tiempo de espera), si se devuelve verdadero, se obtiene el bloqueo.

2. El hilo B usa get para obtener t1, lo compara con la marca de tiempo actual y determina si se ha agotado el tiempo de espera. De lo contrario, será falso. Si se agota el tiempo de espera, vaya al paso 3.

3. Calcule el nuevo tiempo de espera t2, use el comando getset para devolver t3 (este valor puede haber sido modificado por otros subprocesos), si t1 == t3, obtenga el bloqueo, si t1! = t3, el bloqueo lo adquieren otros hilos. 4. Después de adquirir el bloqueo, procese la lógica de negocios y luego determine si el tiempo de espera del bloqueo se agotó. Si no se agotó el tiempo de espera, elimine el bloqueo. Si se agotó el tiempo de espera, no lo procese (para evitar la eliminación de otros subprocesos). ' Cerraduras).

zk:

1. Cuando el cliente bloquea un método, se genera un nodo1 ordenado instantáneo único en el directorio del nodo especificado correspondiente al método en zk.

2. El cliente obtiene todos los nodos secundarios que se han creado en la ruta. Si encuentra que el número de secuencia del nodo1 que creó es el más pequeño, se considera que el cliente ha obtenido el bloqueo.

3. Si se descubre que el nodo1 no es el más pequeño, monitoreará el nodo más grande con un número de serie menor que el nodo creado automáticamente y esperará.

4. Después de adquirir el bloqueo, termine de procesar la lógica y elimine el nodo1 que creó.

Diferencia: zk tiene un rendimiento más pobre, una sobrecarga elevada y una implementación simple.

94. ¿Conoce la persistencia de Redis? ¿Cómo se implementa la capa inferior? ¿Cuáles son las ventajas y desventajas?

RDB (Redis DataBase: sincroniza instantáneas generadas por datos de Redis con discos y otros medios en diferentes momentos): instantáneas de la memoria al disco duro, actualizadas periódicamente. Desventajas: requiere mucho tiempo, rendimiento (operaciones fork + io) y es fácil perder datos. AOF (Agregar solo archivo: registra todas las instrucciones ejecutadas por redis. La próxima vez que redis se reinicie, solo necesita ejecutar las instrucciones): escriba el registro. Desventajas: Gran tamaño, velocidad de recuperación lenta.

bgsave realiza persistencia completa de la imagen y aof realiza persistencia incremental. Debido a que bgsave llevará mucho tiempo y no es lo suficientemente en tiempo real, causará una gran pérdida de datos durante el apagado y requiere la cooperación de aof. Cuando se reinicia la instancia de redis, aof se usará primero para restaurar el estado de la memoria. no hay un registro de aof, utilizará archivos rdb para restaurar. Redis reescribirá AOF periódicamente y comprimirá el tamaño del registro del archivo AOF. Después de Redis 4.0, existe una función de persistencia híbrida, que integra la cantidad total de bgsave y el incremento de aof, lo que no solo garantiza la eficiencia de la recuperación sino que también tiene en cuenta la seguridad de los datos. El principio de bgsave, fork y cow, fork significa que redis realiza la operación bgsave creando un proceso hijo, y cow significa copiar al escribir. Una vez creado el proceso hijo, los procesos padre e hijo comparten el segmento de datos y el proceso padre continúa brindando servicios de lectura y escritura, y escribe sucio Los datos de la página se separarán gradualmente del proceso secundario.

95. ¿Por qué necesitas la partición de Redis?

Respuesta: La partición permite a Redis administrar una memoria más grande y Redis podrá usar la memoria de todas las máquinas. Sin particiones, sólo puedes utilizar hasta una memoria de la máquina. La partición permite duplicar la potencia informática de Redis simplemente agregando computadoras, y el ancho de banda de la red de Redis también se duplicará a medida que aumente la cantidad de computadoras y tarjetas de red.

96. ¿Qué soluciones de implementación de particiones de Redis conoces?

Respuesta: La partición del lado del cliente significa que el cliente ya ha decidido en qué nodo de Redis se almacenarán o leerán los datos. La mayoría de los clientes ya implementan la partición del lado del cliente.

1. La partición del proxy significa que el cliente envía la solicitud al proxy y luego el proxy decide a qué nodo ir para escribir o leer datos. El agente decide qué instancias de Redis solicitar según las reglas de partición y luego las devuelve al cliente según los resultados de la respuesta de Redis. Una implementación de proxy para redis y memcached es Twemproxy

2. Enrutamiento de consultas significa que el cliente solicita aleatoriamente cualquier instancia de Redis y luego Redis reenvía la solicitud al nodo de Redis correcto. Redis Cluster implementa una forma híbrida de enrutamiento de consultas, pero en lugar de reenviar solicitudes directamente de un nodo de Redis a otro nodo de Redis, las redirecciona directamente al nodo de Redis correcto con la ayuda del cliente.

97. ¿Cuáles son las desventajas de la partición de Redis?

Por lo general, no se admiten operaciones que impliquen varias claves. Por ejemplo, no puede intersectar dos colecciones porque pueden estar almacenadas en diferentes instancias de Redis (en realidad, hay una manera para esta situación, pero el comando de intersección no se puede usar directamente).

Si se operan varias claves al mismo tiempo, no se pueden utilizar transacciones de Redis.

La granularidad de la partición es la clave, por lo que no es posible fragmentar un conjunto de datos con una única clave enorme como un conjunto ordenado muy grande.

Cuando se utilizan particiones, el procesamiento de datos puede ser muy complejo; por ejemplo, para realizar copias de seguridad debe recopilar archivos RDB/AOF de diferentes instancias y hosts de Redis simultáneamente.

Ampliar o reducir dinámicamente cuando se realiza la partición puede ser complejo. El clúster de Redis agrega o elimina nodos de Redis en tiempo de ejecución, lo que puede lograr un reequilibrio de datos que sea más transparente para los usuarios. Sin embargo, algunos otros métodos de partición de clientes o de partición de proxy no admiten esta función. Sin embargo, existe una tecnología de fragmentación previa que también puede resolver mejor este problema.

98. ¿Cómo ampliar el caché y los datos persistentes de Redis?

Respuesta: Si se usa Redis como caché, use hash consistente para lograr expansión y contracción dinámicas.

Si se utiliza Redis como almacenamiento persistente, se debe utilizar una relación fija de mapeo de claves a nodos y la cantidad de nodos no se puede cambiar una vez determinada. De lo contrario (es decir, cuando los nodos de Redis necesitan cambiar dinámicamente), se debe utilizar un sistema que pueda reequilibrar los datos en tiempo de ejecución y actualmente solo el clúster de Redis puede hacer esto.

99. ¿Cómo resolver el problema de competencia concurrente de redis?

Respuesta: Redis es un modo de proceso único y de un solo subproceso que utiliza el modo de cola para convertir el acceso concurrente en acceso en serie. Redis en sí no tiene concepto de bloqueos. Redis no compite por múltiples conexiones de clientes. Sin embargo, cuando el cliente Jedis accede simultáneamente a Redis, pueden ocurrir problemas como tiempo de espera de conexión, errores de conversión de datos, bloqueo y cierre de la conexión por parte del cliente. Estos problemas Todos son causados ​​por confusión en la conexión del cliente.

Hay 2 soluciones para esto:

1. Desde la perspectiva del cliente, para garantizar que cada cliente se comunique con Redis de manera normal y ordenada, las conexiones se agrupan y los bloqueos internos se sincronizan para las operaciones de lectura y escritura del cliente en Redis. 2. Desde la perspectiva del servidor, utilice setnx para implementar el bloqueo.

Nota: Para el primer tipo, la aplicación necesita manejar la sincronización de recursos por sí misma. El método que se puede usar es relativamente simple, puede usar sincronizado o bloqueado, el segundo tipo requiere el uso del comando setnx de Redis, pero es necesario prestar atención a algunas cuestiones.

100. Describe brevemente el modo centinela de redis.

Respuesta: Sentinel monitorea redis en tiempo real y tiene dos funciones principales.

Supervise si la base de datos maestra y la base de datos esclava se están ejecutando normalmente.

Cuando la base de datos maestra falla, una base de datos esclava se puede convertir automáticamente a la base de datos maestra para lograr el cambio automático.

101. ¿Cuál es el mecanismo de seguimiento de redis Sentinel?

Respuesta: El monitoreo centinela también está agrupado. Habrá varios centinelas para el monitoreo. Cuando el número de centinelas fallidos alcance un cierto número, se reparará. Una implementación sólida requiere al menos tres instancias de Sentinel.

1. Cada Sentinel envía un comando PING al maestro, al esclavo y a otras instancias de Sentinel que conoce una vez por segundo.

2. Si el tiempo entre una instancia (instancia) y la última respuesta efectiva al comando PING excede el valor especificado por la opción down-after-millisegundos, Sentinel marcará la instancia como subjetivamente fuera de línea.

3. Si un Maestro está marcado como subjetivo fuera de línea, todos los Sentinels que están monitoreando al Maestro deben confirmar que el Maestro efectivamente ha entrado en el estado subjetivo fuera de línea una vez por segundo.

4. Cuando un número suficiente de Sentinels (mayor o igual al valor especificado en el archivo de configuración) confirma que el Maestro efectivamente ha entrado en el estado subjetivo fuera de línea dentro del rango de tiempo especificado, el Maestro será marcado como objetivamente fuera de línea.

5. En circunstancias normales, cada Sentinel enviará un comando INFO a todos los Maestros y Esclavos que conozca una vez cada 10 segundos.

6. Cuando Sentinel marca el Maestro como objetivamente fuera de línea, la frecuencia de envío de comandos INFO a todos los esclavos del Maestro fuera de línea por parte de Sentinel cambiará de una vez cada 10 segundos a una vez cada segundo.

7. Si no hay suficientes Centinelas para aceptar que el Maestro se ha desconectado, se eliminará el estado objetivo fuera de línea del Maestro. Si el Maestro devuelve nuevamente una respuesta válida al comando PING del Sentinel, se eliminará el estado subjetivo fuera de línea del Maestro.

102. Nombra algunos atributos de uso común en la solicitud.

a) Argumentos del parámetro de consulta: el último parámetro pasado al servidor en la dirección URL

b) Solicitar datos de datos: los datos originales enviados por el cliente al servidor (datos originales sin procesar)

c) Archivos cargados: ¿Qué archivos carga el front-end al backend?

d) Formulario: Son los datos del formulario.

e) Cookie: un tipo de retención del estado del navegador

Lenovo respondió:

¿Qué es la solicitud? Solicitud significa solicitud. Los métodos de solicitud más utilizados son obtener y publicar. Obtener solicitud, obtener solicitud en segundo plano, publicar en segundo plano, publicar seguridad, la información de la solicitud no está expuesta en la dirección URL como la solicitud de obtención. , compare Seguridad, la solicitud de publicación predeterminada del protocolo http es segura, por lo que se requiere la verificación csrf (hablando de eso, qué es la verificación csrf, cómo resolverla y cuál es el principio de la solución), y la solicitud también es una tipo de contexto de solicitud de matraz.¿Qué es el contexto? Es un contenedor que guarda el estado de conexión del front-end y el back-end. Lo que se almacena en él, volviendo al tema, son los atributos anteriores (da una vuelta en círculo y luego regresa, el primero El entrevistador cree que puedes chatear, puedes chatear, conocimiento No está mal, más puntos por impresión)

103. Explique el principio de mantenimiento del estado HTTP.

a) Después de que el usuario inicia sesión, el servidor agregará una cookie a la respuesta cuando devuelva la respuesta.

b) El navegador guardará automáticamente la cookie tras recibirla.

c) Cuando el usuario vuelva a solicitar otras páginas web, el navegador traerá automáticamente la cookie previamente guardada.

d) Después de recibir la solicitud, el servidor puede obtener la cookie del objeto de la solicitud para determinar si el usuario actual ha iniciado sesión.

Lenovo respondió:

HTTP no tiene estado, es decir, los datos se intercambian al conectarse, y será una despedida después del cierre, amnesia permanente, ¿por qué no tiene estado? Debido a que el navegador y el servidor usan comunicación por socket, una vez que se cierra el navegador, cuatro Después del primero onda, toda la información interactiva se destruye (hablando del protocolo de enlace de tres vías TCP, protocolo de enlace de cuatro vías), entonces, ¿cuál es la forma de mantener el estado entre el navegador y el servidor? La diferencia entre cookie y sesión: la cookie se guarda en el Navegador, cada vez que visita el sitio web, todos los valores de cookies guardados localmente (información personal del usuario) se enviarán al sitio web, lo cual no es seguro. Las cookies bajo cada nombre de dominio existen de forma independiente y no interfieren entre sí. Seesion depende de la existencia de cookies, pero se almacena en el servidor, que es más seguro que las cookies. Detalles: los números almacenados en la sesión no se convertirán en cadenas, mientras que los valores almacenados de las cookies se convertirán en instrumentos de cuerda

104. Explique los principios y medidas preventivas de los ataques CSRF.

a) Principio de ataque:

I. El usuario C inicia sesión cuando visita el sitio web normal A y el navegador guarda la cookie de A.

ii. El usuario C luego visita el sitio web del ataque B. Si hay un enlace oculto o una etiqueta de imagen en el sitio web B, solicitará automáticamente la dirección URL del sitio web A, como el envío de formularios, y pasará los parámetros especificados.

iii. Cuando el sitio web atacante B visita el sitio web A, el navegador traerá automáticamente la cookie del sitio web A.

iv. Por lo tanto, el sitio web A puede juzgar que el usuario actual ha iniciado sesión después de recibir la solicitud, por lo que la lógica de operación específica se realiza de acuerdo con la autoridad del usuario, lo que resulta en un ataque exitoso al sitio web.

b) Precauciones:

I. Agregue un valor aleatorio como parámetro en el formulario especificado o encabezado de solicitud.

ii. También establezca el valor aleatorio en la cookie de respuesta.

iii. Luego, el usuario C traerá el valor aleatorio en el formulario de forma predeterminada cuando envíe el formulario normalmente, y el navegador traerá automáticamente el valor aleatorio en la cookie, luego el servidor puede tomar dos valores para verificación después de recibir la solicitud. La próxima vez

iv. Para el sitio web B, el sitio web B no sabe cuál es el valor aleatorio al enviar el formulario, por lo que no puede realizar un ataque.

Lenovo respondió:

¿Qué es un ataque CSRF? En pocas palabras: visita el sitio web confiable A, luego A guardará su información personal y devolverá una cookie a su navegador. Luego, dentro del tiempo de vencimiento de la cookie, visitará el sitio web malicioso B. Le devolverá algunos códigos de solicitud maliciosos. usted, pidiéndole que visite el sitio web A. Después de recibir esta solicitud maliciosa, su navegador traerá la información de las cookies guardadas en el navegador local para visitar sin su conocimiento. El sitio web A, luego el sitio web A piensa erróneamente que es una operación del propio usuario, lo que provoca que código de ataque del sitio web malicioso C que se ejecutará: enviar correos electrónicos, enviar mensajes, cambiar su contraseña, comprar, transferir dinero, echar un vistazo a su información personal, lo que resulta en información privada. La filtración y la seguridad de la propiedad de la cuenta están amenazadas.

¿Cómo resolver? Al realizar una solicitud psot, agregue csrf_token en el formulario o ajax (es muy simple en el código del proyecto real)

Principio de solución: después de agregar el valor csrf_token, el marco web generará automáticamente información de cookies para nosotros en la respuesta y la devolverá al navegador. Al mismo tiempo, el código de front-end generará un valor csrf_token. Luego, cuando publique en envíe la información, el marco web la comparará automáticamente. El valor csrf_token en la cookie es consistente con el valor csrf_token enviado por el formulario front-end o ajax, lo que significa que el navegador actual inicia una solicitud normal y procesa la lógica empresarial para devolver una respuesta. Entonces, ¿por qué el sitio web de terceros no puede pasar la verificación cuando obtiene el valor de su cookie? Debido a que no tiene el valor del token generado aleatoriamente en su interfaz, no puede ejecutarlo en su computadora para verifique el valor del token generado automática y aleatoriamente en la página de inicio de su navegador.

Nota: Cuando abre un navegador para acceder a una determinada URL (página), el valor predeterminado es una solicitud de obtención, es decir, mientras acceda a la URL, la lógica en la función de vista correspondiente se ejecutará siempre que no es si xx == publicación, por lo que abre la página, primero generará un valor de cookie (token) y lo devolverá al navegador. Luego, cuando envíe el formulario o realice una solicitud ajax, la información de la cookie del navegador (valor simbólico) se enviará al servidor para comparar el token. Este proceso es relativamente Debido a que inició dos solicitudes, la primera vez es obtener y la segunda es publicar. Después de resolver esto, podrá comprender cómo se compara csrf.