ruby面试题

ruby 基础

1、each、map、collect的区别

each: 仅遍历数组，并做相应操作，数组本身不发生改变。

map:遍历数组，并做相应操作后，返回新数组(处理)，原数组不变。

collect: 跟map作用一样。

collect! map!: 多了一个作用，改变原数组。

// 终端打开 irb
// each
a = [ "a", "b", "c", "d" ]
b = a.each { |x| x + "!" } 	// a == b == [ "a", "b", "c", "d" ]// map map!
a = [ "a", "b", "c", "d" ]
b = a.map { |x| x + "!" }	
a	// ["a", "b", "c", "d"]
b	// ["a!", "b!", "c!", "d!"]
c = a.map! { |x| x + "!" }
a	// ["a!", "b!", "c!", "d!"]
c	// ["a!", "b!", "c!", "d!"]// collect collect!
a = [ "a", "b", "c", "d" ]
b = a.collect { |x| x + "!" }	
a	// ["a", "b", "c", "d"]
b	// ["a!", "b!", "c!", "d!"]
c = a.collect! { |x| x + "!" }
a	// ["a!", "b!", "c!", "d!"]
c	// ["a!", "b!", "c!", "d!"]

2、Block, lambda, Proc 的区别

  1. proc和lambda都是对象，而block不是

  2. block是proc的实例，proc可以重复使用，函数参数只能有一个block，但可以有多个proc

    # 说明block是proc的一个实例
def what_am_i(&block)                                                                                 block.class
end
puts what_am_i {}  # =< Procdef multiple_procs(proc1, proc2)proc1.callproc2.call
end
a = Proc.new { puts "First proc" }
b = Proc.new { puts "Second proc" }
multiple_procs(a,b)

  3. lambda会检查参数个数，proc不会。

    lam = lambda { |x| puts x }    # creates a lambda that takes 1 argument
lam.call(2)                    # prints out 2
lam.call                       # ArgumentError: wrong number of arguments
lam.call(1,2,3) 
pro = Proc.new { |x| puts x } # creates a proc that takes 1 argument
pro.call(2)                   # 2
pro.call                      # returns nil
pro.call(1,2,3)       		  # 1

  4. lambda和proc对于return处理方式不同

    lambda：一个函数调用lambda，lambda里return后返回函数接着执行。

    proc: 一个函数调用proc，proc里return后， 函数也会return。

    def lambda_testlam = lambda { return }lam.callputs "Hello world"
end
lambda_test
def proc_testproc = Proc.new { return }proc.callputs "Hello world"
end
proc_test

参考资料：

What Is the Difference Between a Block, a Proc, and a Lambda in Ruby?

浅谈Ruby中的block, proc, lambda, method object的区别

ruby中闭包

在Ruby里，如果该方法返回一个代码块，而该代码块获得了局部变量的引用，则这些局部变量将在方法返回后依然可以访问。

def show(name)count = 1;return proc do |value|puts count +=1;puts name + '我是闭包' + valueend
endsh = show("ruby")
sh.call('213')
sh.call('kkk')

参考：

Ruby的4种闭包：blocks, Procs, lambdas 和 Methods

3、alias 的用法, alias 与 alias_method 的区别

alias: 给已经存在的方法或变量设置一个别名，在重新定义已存在的方法时，还可以通过别名来调用原来的方法。

alias_method: 和alias类似，但只能给方法起别名，是Module的一个私有实例方法。

class Demo def helloputs "old_hell0"end# 给hello方法取别名# alias old_hello helloalias_method :old_hello, :hellodef helloputs "new_hello"end
end
obj = Demo.new
obj.hello
obj.old_hello

参考：

https://www.cnblogs.com/smallbottle/p/3968704.html

https://ruby-china.org/topics/27747

4、Ruby的对象体系

                   +------------+| BasicObject|+------------+^|superclass|+----+-----+   superclass-----------+|  Object  | ^----------|   Module  |+----+-----+------+     +-+---------+^            |       ^|superclass  |       |Superclass|            |       |
+---------+           +-+-------+    +---> +-+-------+
| 'hello' |  class    | String  | class    | Class   |
|         +---------->+         +--------->+         +------>
+---------+           +---------+          +----+----+      |^           ||  class    |<-----------+

![](https://img-blog.csdn.net/20160413232121267?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

'hello'.class		# String
String.class		# Class
String.superclass	# Object
Class.class			# Class
Class.superclass	# Module
Module.class		# Class
Module.superclass	# Object
Object.class		# Object
Object.superclass	# BasicObject
BasicObject.class	# Class
BasicObject.superclass	# nil

Module是Class的父类，Class和Module的差别是Class是一个增强的Module，它比Module多了一个new，allocate方法，除了这一个区别，当然这个区别特别重要，Class和Module基本是一样的。

参考： https://blog.csdn.net/feigeswjtu/article/details/51040006

5、 Include, Extend, Load, Require 的使用区别

  • include和extend用于在类中引入模块，区别：

include：把模块中的方法作为类的实例方法

extend: 把模块中的方法作为类的类方法

module Adef class_typeputs "This class is of type:#{self.class}"end
end
class B extend A end
class C include A end
B.class_type
C.new.class_type

  • require、load用于加载库，如.rb文件，区别：

    require: 加载一个库，并且只加载一次，如果多次加载会返回false。文件不需要扩展名

    load: 加载一个库，可多次加载。需要指定文件扩展名。

    # 在当前目录中有一个 two.rb文件
require './two';
load './two.rb';

6、yield、yield self

所有的方法(methods)都会隐式的带一个块(block)参数。

  • yield用来执行块参数，也可以通过call()方法执行。

    yield 相当于是 block.call() 方法的调用，所以参数个数也需要对应, method 定义中 &block 参数必须在最后

    def foo1()yield 1,2,3     # 这里的 1 2 3 就是传递的参数
end
def foo2(time, &block)yield 1, 2, 3block.call(5, 6, 7)  puts time
end
foo1 {|x,y,z| puts z}    # => 3
foo2('2018') {|x,y,z| puts z}    # => 3 7 2018

  • yield self

    在一个对象中，self 表示是一个当前对象的引用。

    yield self if block_given? 相当于如果有块参数，那个调用快参数，参数是自己。

    def foo(&block)puts selfyield self if block_given?yield "AAAAAAAAA"
end
foo {|x| puts x}
foo

参考链接：https://www.cnblogs.com/licongyu/p/5522027.html

7、 Ruby中的元编程

Ruby中的元编程，是可以在运行时动态地操作语言结构（如类、模块、实例变量等）的技术。你甚至于可以在不用重启的情况下，在运行时直接键入一段新的Ruby代码，并执行它。

Ruby的元编程，也具有“利用代码来编写代码”的作用。例如，常见的attr_accessor等方法就是如此。

7.1 实例变量、方法、类
  • 同一个类的实例可以有不同的实例变量，因为实例变量只有使用的时候才会被建立。
  • 匿名类：对一个具体对象添加方法是，ruby会插入一个新的匿名类来容纳新建的方法，匿名类不可见。
  • def initialize(*args): 方法可以通过参数不同执行不同的操作
7.2 send、eval、respond_to?

  • send

    send是Object类的实例方法。第一个参数是方法名，后面是方法的参数

    使用send方法，你所想要调用的方法就顺理成章的变成了一个普通的参数。你可以在运行时，直至最后一刻自由决定到底调用哪个方法。

    class Rubyistdef welcome(*args)"Welcome " + args.join(' ')end
end
obj = Rubyist.new
puts(obj.send(:welcome, "hello", "world")) 
eval("obj.welcome('123')")

  • eval

    用于执行一个用字符串表示的代码,eval方法可以计算多行代码，使得将整个程序代码嵌入到字符串中并执行成为了可能。eval方法很慢，在执行字符串前最好对其预先求值。

    str = "Hello"
puts eval("str + ' world'") # => "Hello world"

  • respond_to?

    所有的对象都有此方法，使用respond_to?方法，你可以确定对象是否能使用指定的方法。

    obj = Object.new
if obj.respond_to?(:program)obj.program
elseputs "Sorry, the object doesn't understand the 'program' message."
end

    参考资料：http://deathking.github.io/metaprogramming-in-ruby/chapter04.html

参考资料：

Ruby中的元编程

8、全局变量，实例变量，局部变量，类变量，Symbol

格式名称作用范围举例
$开头全局变量从定义到程序结束$name
@开头实例变量self@name
@@开头类变量内部直接用，外部用类名::变量名@@name
[a-z_]开头局部变量定义的类、模块、方法内部，在类、模块、方法间不能共享name
[A-Z]常量内部、外部均可，外部访问类名::常量名NAME
:开头Symbol内外:name

参考资料：https://blog.csdn.net/emerald0106/article/details/7358766

9、ruby的特点

  • 解释型执行，方便快捷:Ruby是解释型语言，其程序无需编译即可执行
  • 语法简单、优雅:
  • 完全面向对象: Ruby从一开始就被设计成纯粹的面向对象语言，因此所有东西都是对象，例如整数等基本数据类型。
  • 内置正则式引擎，适合文本处理:Ruby支持功能强大的字符串操作和正则表达式检索功能，可以方便的对字符串进行处理。
  • 自动垃圾收集: 具有垃圾回收（Garbage Collect，GC）功能，能自动回收不再使用的对象。不需要用户对内存进行管理。
  • 跨平台和高度可移植性:Ruby支持多种平台，在Windows， Unix， Linux， MacOS上都可以运行。Ruby程序的可移植性非常好，绝大多数程序可以不加修改的在各种平台上加以运行。
  • 有优雅、完善的异常处理机制: Ruby提供了一整套异常处理机制，可以方便优雅地处理代码处理出错的情况。

缺点：

  • 解释型语言，所以速度较慢
  • 静态检查比较少

rails

active record

创建、查询、修改、删除
class Product < ApplicationRecord
end
# 创建
# create 方法会创建一个新记录，并将其存入数据库：
user = User.create(name: "David", occupation: "Code Artist")
# new 方法实例化一个新对象，但不保存：
user = User.new
user.name = "David"# 读取
users = User.all	# 返回所有用户组成的集合
user = User.first	# 返回第一个用户
david = User.find_by(name: 'David')		# 返回第一个名为 David 的用户
# 查找所有名为 David，职业为 Code Artists 的用户，而且按照 created_at 反向排列
users = User.where(name: 'David', occupation: 'Code Artist').order(created_at: :desc)# 更新
user.name = 'Dave'
user.save			# 
user.update(name: 'Dave')# 删除
user.destroy
# https://ruby-china.github.io/rails-guides/active_record_basics.html#create

上面的代码会创建 Product 模型，对应于数据库中的 products 表。同时，products 表中的字段也映射到 Product 模型实例的属性上。

关联模型

关联原因： 操作两个有关系的表时简化操作。

如果两个表有关联，比如一个作者表，一个图书表，一个作者对应多本书，如果此时删除一个作者前要先把作者对应的书删除，然后在删除作者。但是关联后，只需要在模型中删除作者语句即可，删除书的动作active_record会自动完成。

  • belongs_to:一对一关系

    belongs_to 关联创建两个模型之间一对一的关系，声明所在的模型实例属于另一个模型的实例。

    写belongs_to的模型里的一条记录相对于另一个表里有唯一一条记录，叫一对一。

    例如有作者和图书两个模型，而且每本书只能指定给一位作者，在图书表中写上：

    class Book < ApplicationRecordbelongs_to :author
end

  • has_one：一对一关系

    has_one 关联也建立两个模型之间的一对一关系，但语义和结果有点不一样。这种关联表示模型的实例包含或拥有另一个模型的实例。例如，应用中每个供应商只有一个账户，可以这么定义供应商模型：

    class Supplier < ApplicationRecordhas_one :account
end

    has_one与belongs_to的选择：

    ​

  • has_many ：一对多

    has_many 关联表示模型的实例有零个或多个另一模型的实例。例如，对应用中的作者和图书模型来说，作者模型可以这样声明：

    class Author < ApplicationRecordhas_many :books
end

  • :through: 通过第三张表来关联

    has_many :through

    这种关联表示一个模型的实例可以借由第三个模型，拥有零个和多个另一模型的实例。例如，在医疗锻炼中，病人要和医生约定练习时间。这中间的关联声明如下：

    class Physician < ApplicationRecordhas_many :appointmentshas_many :patients, through: :appointments
end
class Appointment < ApplicationRecordbelongs_to :physicianbelongs_to :patient
end
class Patient < ApplicationRecordhas_many :appointmentshas_many :physicians, through: :appointments
end

    has_one :through

    这种关联表示一个模型通过第三个模型拥有另一模型的实例。例如，每个供应商只有一个账户，而且每个账户都有一个账户历史，那么可以这么定义模型：

    
class Supplier < ApplicationRecordhas_one :accounthas_one :account_history, through: :account
endclass Account < ApplicationRecordbelongs_to :supplierhas_one :account_history
endclass AccountHistory < ApplicationRecordbelongs_to :account
end

  • has_and_belongs_to_many

    直接建立两个模型之间的多对多关系，不借由第三个模型。例如，应用中有装配体和零件两个模型，每个装配体有多个零件，每个零件又可用于多个装配体，这时可以按照下面的方式定义模型：

    class Assembly < ApplicationRecordhas_and_belongs_to_many :parts
endclass Part < ApplicationRecordhas_and_belongs_to_many :assemblies
end

参考资料： https://ruby-china.github.io/rails-guides/association_basics.html

查询接口

  • 检索对象

    find	# 检索指定主键对应的对象，没有记录find方法抛出 ActiveRecord::RecordNotFound 异常。
client = Client.find(10)	# 查找主键（ID）为 10 的客户take	# 检索一条记录而不考虑排序，没有记录take方法返回 nil，而不抛出异常。
client = Client.take	# SELECT * FROM clients LIMIT 1first 	# 默认查找按主键排序的第一条记录。如果没有记录，first 方法返回 nil，而不抛出异常
client = Client.first	# SELECT * FROM clients ORDER BY clients.id ASC LIMIT 1last	# 默认查找按主键排序的最后一条记录。没有记录last方法返回nil，而不抛出异常。
client = Client.last	# SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
client = Client.last(3) # 返回不超过指定数量的查询结果。
client = Client.order(:first_name).last # 返回按照指定属性排序的最后一条记录。
client = Client.last!	# 和 last 方法类似,区别是没有记录会抛出 ActiveRecord::RecordNotFound 异常。find_by	# 查找匹配指定条件的第一条记录。
Client.find_by first_name: 'Lifo'	# Client.where(first_name: 'Lifo').takefind_each 	# 批量检索记录，每条记录传入块，
User.find_each do |user|NewsMailer.weekly(user).deliver_now
end

  • 条件查询

    where 方法用于指明限制返回记录所使用的条件，相当于 SQL 语句的 WHERE 部分。条件可以使用字符串、数组或散列指定。

    纯字符串条件:容易受到 SQL 注入攻击的风险。
Client.where("orders_count = '2'")	# 查找所有 orders_count 字段的值为 2 的客户记录。数组条件: 后面的参数会替换前面的问号(？)
Client.where("orders_count = ?", params[:orders])
Client.where("orders_count = ? AND locked = ?", params[:orders], false)条件中的占位符
Client.where("created_at >= :start_date AND created_at <= :end_date",{start_date: params[:start_date], end_date: params[:end_date]})散列条件
Client.where(locked: true)	# SELECT * FROM clients WHERE (clients.locked = 1)NOT 条件：先调用没有参数的 where 方法，然后马上链式调用 not 方法，就可以生成这个查询。
Client.where.not(locked: true)	# SELECT * FROM clients WHERE (clients.locked != 1)

  • 排序

    按 created_at 字段的升序方式取回记录：
Client.order(:created_at)还可以使用 ASC（升序） 或 DESC（降序） 指定排序方式：
Client.order(created_at: :desc)
Client.order(created_at: :asc)
Client.order(orders_count: :asc, created_at: :desc)

    ​

数据库基本操作

  1. 插入数据

    insert into <tablename> (field1,field2,field3..) values (value1,value2,value3);

  2. 查询

    select * from <tablename>;
select  <*/filed> select from <tablename> where <field>=<key>;
select <*/field> form <tablename> where <field> like '%value%';	// 模糊查询

  3. 删除（Delete）

    delete from <tablename> where <条件（和查询时条件类似）>

  4. 更新（update)

    update <tablename> set <field>=<value> where <条件(和查询时类似）>;

参考链接：https://blog.csdn.net/yuanmxiang/article/details/51683232

https://www.cnblogs.com/daxueshan/p/6687521.html

其他面试题

https://www.jianshu.com/p/cc9f521d72ee

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/36127.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

LoadBalance 负载均衡

LoadBalance 负载均衡

什么是负载均衡 负载均衡(Load Balance&#xff0c;简称 LB),是⾼并发,⾼可⽤系统必不可少的关键组件. 当服务流量增⼤时,通常会采⽤增加机器的⽅式进⾏扩容,负载均衡就是⽤来在多个机器或者其他资源中,按照⼀定的规则合理分配负载. 负载均衡的⼀些实现 服务多机部署时,开发⼈…
阅读更多...
专业软件测试公司分享：安全测评对于软件产品的重要性

专业软件测试公司分享：安全测评对于软件产品的重要性

在互联网普及的今天&#xff0c;随着各类软件的大规模使用&#xff0c;安全问题也变得愈发突出。因此&#xff0c;对软件进行全面的安全测评&#xff0c;不仅可以有效保障用户的信息安全&#xff0c;还能提升软件产品的信任度和市场竞争力。 安全测评对于软件产品的重要性就如…
阅读更多...
LLDB 详解

LLDB 详解

LLDB 详解 LLDB 详解编译器集成优势LLDB 的主要功能命令格式原始&#xff08;raw&#xff09;命令选项终止符: -- LLDB 中的变量唯一匹配原则helpexpressionprint、call、po控制流程&#xff1a;continue、next、step、finishregister read / writethread backtracethread retu…
阅读更多...
线性代数|机器学习-P19SVDLUQR分解自由参数计算和鞍点

线性代数|机器学习-P19SVDLUQR分解自由参数计算和鞍点

文章目录 1. 矩阵A分解1.1 A L U ALU ALU 1. 矩阵A分解 对于矩阵A来说&#xff0c;我们有常见矩阵分解&#xff1a; A L U , A Q R , A X Λ X − 1 , A Q Λ Q T ; A Q S , A S V D \begin{equation} ALU,AQR,AX\Lambda X^{-1},AQ\Lambda Q^T;AQS,ASVD \end{equatio…
阅读更多...
React Native优质开源项目推荐与解析

React Native优质开源项目推荐与解析

目录 2. React Native的优势 2.1. 跨平台开发 2.2. 热更新 2.3. 丰富的社区资源 2.4. 优秀的性能 3. 优质开源项目推荐 3.1. React Navigation 3.1.1 项目简介 3.1.2 特点和优势 3.1.3 应用场景 3.2. Redux 3.2.1 项目简介 3.2.2 特点和优势 3.2.3 应用场景 3.3…
阅读更多...
精彩回顾 | 2024高通边缘智能创新应用大赛系列公开课

精彩回顾 | 2024高通边缘智能创新应用大赛系列公开课

5月29日-6月6日&#xff0c;我们陆续开展了四场精彩绝伦的2024高通边缘智能创新应用大赛直播公开课。高通、阿加犀、广翼智联以及美格智能的业务领袖和行业大咖齐聚一堂&#xff0c;聚焦边缘智能&#xff0c;分享前沿技术、探讨创新应用&#xff0c;抢先揭秘比赛设备的核心特性…
阅读更多...
MIT6.s081 2021 Lab System calls

MIT6.s081 2021 Lab System calls

xv6系统调用实现 不同于 Lab1 利用已实现的系统调用来实现一些用户态下的命令行程序&#xff0c;本 Lab 是要在内核层面实现一些系统调用。这其中难免涉及到一些对内核数据结构的操作&#xff0c;以及处理器体系结构&#xff08;本系列 Lab 基于 RISCV&#xff09;相关的内容&…
阅读更多...
什么是慢查询——Java全栈知识（26）

什么是慢查询——Java全栈知识（26）

1、什么是慢查询 慢查询&#xff1a;也就是接口压测响应时间过长&#xff0c;页面加载时间过长的查询 原因可能如下&#xff1a; 1、聚合查询 2、多表查询 3、单表数据量过大 4、深度分页查询&#xff08;limit&#xff09; 如何定位慢查询&#xff1f; 1、Skywalking 我们…
阅读更多...
js url参数转对象类型（对象类型转url参数）支持中文解码编码

js url参数转对象类型（对象类型转url参数）支持中文解码编码

先上代码 后面上函数参数说明以及调用返回结果 /** Author: 夏林* Date: 24.6.27* desc 时间差算法* params params -> 传入数据 String | Object* params _needEncode -> 是否需要编码 默认 true*/ export function dealUrlSearchParams(_params , _needEncode tr…
阅读更多...
IND83081芯片介绍(一)

IND83081芯片介绍(一)

一、芯片介绍 IND83081是indiemicro推出的一款高性能的汽车矩阵LED照明控制器&#xff0c;集成了四个子模块&#xff0c;每个子模块包含三个串联的MOSFET开关&#xff0c;每个开关均可通过12位PWM内部信号控制&#xff0c;可配置的上升和下降速率及相位移以实现精确控制&#x…
阅读更多...
JOSEF约瑟 JOXL-J拉绳开关 整定范围宽

JOSEF约瑟 JOXL-J拉绳开关 整定范围宽

用途 双向拉绳开关的壳体采用金属材料铸造&#xff0c;具有足够的机械强度,抵抗并下工作时脱落的岩石&#xff0c;爆块等物体的撞击不被破坏&#xff0c;当胶带输送机发生紧急事故时&#xff0c;启动拉绳开关,可立即停机报警&#xff0c;防止事故的扩大,保证工作现场的人身安全…
阅读更多...
常用的通信协议有哪些

常用的通信协议有哪些

常用的通信协议有很多种&#xff0c;主要根据其应用领域和通信需求可以分为几类&#xff1a; 网络通信协议&#xff1a; TCP/IP&#xff1a;传输控制协议/互联网协议&#xff0c;用于互联网及局域网通信。 UDP&#xff1a;用户数据报协议&#xff0c;用于实时数据传输&#…
阅读更多...
java 操作 milvus 2.1.4

java 操作 milvus 2.1.4

1. 确认 docker 运行的 milvus容器镜像版本情况&#xff1a; 2. pom 依赖&#xff1a; <dependency><groupId>io.milvus</groupId><artifactId>milvus-sdk-java</artifactId><version>2.1.0</version><exclusions><exclusi…
阅读更多...
Java学习 - Redis慢查询与发布订阅与流水线

Java学习 - Redis慢查询与发布订阅与流水线

慢查询 慢查询是什么 慢查询本质是慢查询日志&#xff0c;它记录了一些执行速度很慢的命令 慢查询与生命周期 生命周期 ------- ------------------------------------------ | | 1.发送请求 | redis服务端 …
阅读更多...
Simulink缓存文件有什么用？

Simulink缓存文件有什么用？

在使用Simulink进行仿真的过程中&#xff0c;经常会发现目录下存在一些后缀为.slxc的文件&#xff0c;这些其实就是Simulink模型的缓存文件&#xff08;.slx cache&#xff09;。 Simulink缓存文件的主要作用是提高仿真和代码生成的效率。 借助缓存文件&#xff0c;可以避免…
阅读更多...
C语言 实现socket服务器客户端通信

C语言 实现socket服务器客户端通信

在socket服务端&#xff0c;当接收到来自客户端的消息后&#xff0c;通常的处理流程如下&#xff1a; 连接建立&#xff1a;服务端首先监听一个预设的网络地址&#xff08;如IP和端口&#xff09;&#xff0c;等待客户端连接。接受连接&#xff1a;当客户端发起连接请求时&…
阅读更多...
中文AI三大顶会：机器之心、量子位与新智元的比较与探讨

中文AI三大顶会：机器之心、量子位与新智元的比较与探讨

在人工智能领域&#xff0c;中文科技媒体扮演着举足轻重的角色&#xff0c;其中机器之心、量子位和新智元被誉为三大顶会&#xff0c;它们以各自独特的定位和特色&#xff0c;在AI领域中散发着不同的光芒。本文将对这三大媒体进行比较与探讨&#xff0c;以期为读者提供更全面的…
阅读更多...
用Python读取Word文件并提取标题

用Python读取Word文件并提取标题

前言 在日常工作中&#xff0c;我们经常需要处理Word文档&#xff0c;特别是从中提取关键信息&#xff0c;如标题、段落等。今天&#xff0c;我们将利用Python来实现这一功能&#xff0c;并为大家提供一段完整的代码示例。 准备工作 首先&#xff0c;你需要安装python-docx库…
阅读更多...
Web浏览器读写NFC Ntag标签

Web浏览器读写NFC Ntag标签

本示例使用的发卡器&#xff1a;RS232串口USB转COM读写器IC卡发卡器WEB浏览器二次开发JS编程SDK-淘宝网 (taobao.com) <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"&g…
阅读更多...
不锈钢氩弧焊丝ER316L

不锈钢氩弧焊丝ER316L

说明&#xff1a;TG316L 是超低碳的不锈钢焊丝。熔敷金属耐蚀、耐热、抗裂性能优良。防腐蚀性能良好。 用途:用于石油化工、化肥设备等。也可用于要求焊接后不进行热处理的高Cr钢的焊接。
阅读更多...
最新文章

Copyright @ 2022~2023