What's the difference between `*.framework`, `*.dylib` and `*.a` libs - ios

Question

I have a project, in the Framework, there have *.framework, *.dylib, *.a libs.
I want to know what's them? and the difference between them.

Answer 1

Dynamic and static libraries
First of all, a library is a collection of resources and the code itself, compiled for one or more architectures.
Static libraries (*.a):
In the case of static libraries (*.a), the code that the app uses is
copied to the generated executable file by a static linker during
compilation time.
Dynamic libraries (*.dylib):
Dynamic libraries (*.dylib) are different from static libraries in the
sense that they are linked with the app’s executable at runtime, but
not copied into it. As a result, the executable is smaller and,
because the code is loaded only when it is needed, the startup time is
typically faster.
Dynamic and static frameworks:
For frameworks, we first need to understand the bundle concept (as a
framework is a specific kind of a bundle). A bundle is a file
directory with subdirectories inside. On iOS, bundles serve to
conveniently ship related files together in one package – for
instance, images, nibs, or compiled code. The system treats it as one
file and you can access bundle resources without knowing its internal
structure.
The library may also have additional resources: headers, localization
files, images, documentation, and examples of usage. We can bundle all
of this together in one bundle – and the name of this is the framework.
Static frameworks contain a static library packaged with its
resources. Dynamic frameworks contain the dynamic library with its
resources. In addition to that, dynamic frameworks may conveniently
include different versions of the same dynamic library in the same
framework!
Other useful references:
Hackernoon
Runtastic
Static library
Software framework
Update:
Thanks for accepting my answer!
Compiled for one or more architectures?
Every architecture requires a different binary, and when you build an
app Xcode will build the correct architecture for whatever you’re
currently working with. For instance, if you’ve asked it to run in the
simulator, then it’ll only build the i386 version (or x86_64 for
64-bit).
This means that builds are as fast as they can be. When you archive an
app or build in release mode, then Xcode will build for all three ARM
architectures, thus allowing the app to run on most devices. What
about the other builds though?
Naturally, when you build your framework, you’ll want developers to be
able to use it for all possible architectures, right? Of course you do
since that’ll mean you can earn the respect and admiration of your
peers.
Therefore you need to make Xcode build for all five architectures.
This process creates a so-called fat binary, which contains a slice
for each of the architectures.
arm7: Used in the oldest iOS 7-supporting devices
arm7s: As used in iPhone 5 and 5C
arm64: For the 64-bit ARM processor in iPhone 5S
i386: For the 32-bit simulator
x86_64: Used in 64-bit simulator
Raywenderlich: Multi-Architecture